Video Streaming using Python

Python OpenCV

OpenCV-Python is a library of Python bindings designed to solve computer vision problems. OpenCV-Python is a Python wrapper for the original OpenCV C++ implementation.

Socket Programming in Python

Socket programming is a way of connecting two nodes on a network to communicate with each other. One socket(node) listens on a particular port at an IP, while the other socket reaches out to the other to form a connection. The server forms the listener socket while the client reaches out to the server.

import socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

Here we have created a socket with two parameters. The first parameter is AF_INET and the second one is SOCK_STREAM. AF_INET refers to the address-family ipv4 and SOCK_STREAM means connection-oriented TCP protocol.

What is a Network Socket?

A network socket is a software structure within a network node that serves as an endpoint to send and receive data. Its properties are defined by the network API. It exists during the process of application and externally identified by its socket address.

Types of Internet Sockets:

  • Stream sockets: Stream sockets allow processes to communicate using TCP. A stream socket provides a bidirectional, reliable, sequenced, and unduplicated flow of data with no record boundaries.
  • Datagram sockets: Datagram sockets allow processes to use UDP to communicate. A datagram socket supports a bidirectional flow of messages. A process on a datagram socket can receive messages in a different order from the sending sequence and can receive duplicate messages.
  • Raw sockets: Raw sockets provide access to ICMP. These sockets are normally datagram-oriented, although their exact characteristics are dependent on the interface provided by the protocol. Raw sockets are not for most applications.

Client-Server Model in Network Programming

Video Chat App using Python

Just like text chat apps, video chat app provides a way for users to communicate via live video streaming. Video Chat App helps users to communicate with the face-to-face connection between two users via the internet.

Server-side Python Code:

First, we will create the socket by specifying the address family and address type to the socket.socket() function.

server_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

Then I am going to bind the socket with the Host Ip address and with some port number. The port should be an integer value between 1000 to 6265535.


Then I am going to use listen to function to accept the connection. Here I am giving backlog as 5 which means five connections the system will allow. Also, I am using accept function the accept the connection and getting the client socket and the address.

client_socket,addr = server_socket.accept()

After that, it can handle the client socket to accept and send the message using send function, and finally, we can close the socket with the close function.




At the server-side I am using OpenCV to get the frames of the webcam then each frame data will be serialized to bytes data using the pickle module and then it will be packed using the struck module.

# This code is for the server 
# Lets import the libraries
import socket, cv2, pickle,struct,imutils

# Socket Create
server_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
host_name = socket.gethostname()
host_ip = socket.gethostbyname(host_name)
print('HOST IP:',host_ip)
port = 9999
socket_address = (host_ip,port)

# Socket Bind

# Socket Listen
print("LISTENING AT:",socket_address)

# Socket Accept
while True:
client_socket,addr = server_socket.accept()
print('GOT CONNECTION FROM:',addr)
if client_socket:
vid = cv2.VideoCapture(0)

img,frame =
frame = imutils.resize(frame,width=320)
a = pickle.dumps(frame)
message = struct.pack("Q",len(a))+a

cv2.imshow('TRANSMITTING VIDEO',frame)
if cv2.waitKey(1) == '13':

Client-side Python Code:

First, we will create the socket by specifying the address family and address type to the socket.socket() function.

server_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

Now I will use the connect function to connect to the server socket. The host IP address and the port number will be the same as the server.


Now we can send and receive the information using send() and recv() function. Here we will use 1024 as buffer size as TCP is a streaming protocol which means there are no message boundaries it is just the stream of message bytes. It is like FIFO and when the server will send 1024 bytes then 1024 bytes will be received by the client.

packet = client_socket.recv(1024)


The socket can be close the socket with the close function.


Here at the client-side first, we will unpack the received packet data using struct module and then will load the frame using pickle, and finally, we will display the received video.

import socket,cv2, pickle,struct

# create socket
client_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
host_ip = '' # paste your server ip address here
port = 9999
client_socket.connect((host_ip,port)) # a tuple
data = b""
payload_size = struct.calcsize("Q")
while True:
while len(data) < payload_size:
packet = client_socket.recv(4*1024) # 4K
if not packet: break
packed_msg_size = data[:payload_size]
data = data[payload_size:]
msg_size = struct.unpack("Q",packed_msg_size)[0]

while len(data) < msg_size:
data += client_socket.recv(4*1024)
frame_data = data[:msg_size]
data = data[msg_size:]
frame = pickle.loads(frame_data)
cv2.imshow("RECEIVING VIDEO",frame)
if cv2.waitKey(1) == '13':

Thank You for reading!! 😇😇



Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store