def __init__(self):
self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#self.server_socket.bind(("", 6000))
self.server_socket.bind((socket.gethostname(), 1243))
self.server_socket.listen(5)
self.videofeed = VideoFeed(1, "server", 1)
print("TCPServer Waiting for client on port 5000")
def __init__(self):
self.client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#self.client_socket.connect(("10.3.42.55", 6000))
#self.client_socket.connect(("127.0.0.1", 6000))
self.client_socket.connect((socket.gethostname(), 1243))
self.vsock = videosocket.videosocket(self.client_socket)
self.videofeed = VideoFeed(1, "client", 1)
def __init__(self, ip_addr="172.20.10.10"):
self.client_socket = socket.socket(socket.AF_INET,
socket.SOCK_STREAM)
self.client_socket.connect((ip_addr, 6000))
self.vsock = videosocket.videosocket(self.client_socket)
self.videofeed = VideoFeed(1, "client", 1)
self.data = StringIO.StringIO()
def __init__(self):
self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
ip = getMyIP()
print 'Your IP is ' + ip
self.server_socket.bind((ip, 6000))
self.server_socket.listen(5)
self.videofeed = VideoFeed(1, "server", 1)
print "TCPServer Waiting for client on port 6000"
def receive(self):
while self.connected:
if self.is_video_call:
if not self.videofeed:
self.videofeed = VideoFeed("client_cam", 1)
frame = self.videofeed.get_frame()
self.vsock.vsend(frame)
rcvd_frame = self.vsock.vreceive()
try:
if rcvd_frame == 2:
self.is_video_call = False
self.vsock.vsend(bytes("-2", ENCODING))
self.videofeed.destroy()
continue
except:
pass
quit = self.videofeed.set_frame(rcvd_frame)
if quit:
# inform other party that user wants to quit
self.vsock.vsend(bytes("-1", ENCODING))
self.is_video_call = False
else:
# free up webcam in case not in use
if self.videofeed:
self.videofeed = None
msg = self.socket.recv(self.buffer_size)
try:
decoded_msg = msg.decode(ENCODING)
except:
continue
if decoded_msg == "VIDEO_CALL_START":
self.send(bytes("READY_FOR_VIDEO_CALL", ENCODING))
self.is_video_call = True
elif decoded_msg == "READY_FOR_VIDEO_CALL":
self.is_video_call = True
elif decoded_msg == "VIDEO_CALL_INITIATE":
self.initiate_video_call()
elif decoded_msg == "VIDEO_CALL_ACCEPT" or decoded_msg == "VIDEO_CALL_REJECTED":
self.send(msg)
elif "VIDEO_CALL_REQUEST" in decoded_msg:
# someone wants to videochat with you
from_uname = decoded_msg.split('$')[-1]
self.receive_vcall(from_uname)
else:
self.update_gui(msg, False)
class Client:
def __init__(self, ip_addr = "127.0.0.1"):
self.client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.client_socket.connect((ip_addr, 6000))
self.vsock = videosocket.videosocket (self.client_socket)
self.videofeed = VideoFeed(1,"client",1)
self.data = StringIO.StringIO()
def connect(self):
while True:
frame=self.videofeed.get_frame()
self.vsock.vsend(frame)
frame = self.vsock.vreceive()
self.videofeed.set_frame(frame)
class Client:
def __init__(self, ip_addr="192.168.2.1"):
self.client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.client_socket.connect((ip_addr, 6000))
self.vsock = videosocket.videosocket(self.client_socket)
self.videofeed = VideoFeed(1, "client", 1)
self.data = StringIO.StringIO()
def connect(self):
while True:
frame = self.videofeed.get_frame()
self.vsock.vsend(frame)
frame = self.vsock.vreceive()
self.videofeed.set_frame(frame)
class Client:
def __init__(self, ip_addr="169.254.162.107"):
self.client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.client_socket.connect((ip_addr, 6000))
self.vsock = videosocket.videosocket(self.client_socket)
self.videofeed = VideoFeed(1, "client", 1)
self.data = io.StringIO()
def mysend(self):
reFrameCnt = 0
fps = 0
tt = 0
while True:
reFrameCnt = reFrameCnt + 1
if reFrameCnt % 10 == 0:
t1 = time.time()
fps = int(10 / (t1 - tt))
tt = t1
print("send fps = ", fps)
#print(1111)
frame1 = self.videofeed.get_frame()
self.vsock.vsend(frame1)
def myreceive(self):
reFrameCnt = 0
fps = 0
tt = 0
while True:
reFrameCnt = reFrameCnt + 1
if reFrameCnt % 10 == 0:
t1 = time.time()
fps = int(10 / (t1 - tt))
tt = t1
print("receive fps = ", fps)
frame = self.vsock.vreceive()
my_img = self.videofeed.set_frame(frame)
my_img = cv2.resize(my_img, (1280, 960),
interpolation=cv2.INTER_AREA)
#cv2.putText(my_img, str(fps), (200, 50), cv2.FONT_HERSHEY_SIMPLEX, 2, (0, 0, 255), 2)
cv2.imshow("aaa", my_img)
cv2.waitKey(1)
#myqueue.put(my_img)
#A = show_img
#print(2222)
'''
class Client:
def __init__(self):
self.client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.client_socket.connect(("10.3.42.55", 6000))
self.vsock = videosocket.videosocket(self.client_socket)
self.videofeed = VideoFeed(1, "client", 1)
self.data = StringIO.StringIO()
def connect(self):
while True:
frame = self.videofeed.get_frame()
self.vsock.vsend(frame)
frame = self.vsock.vreceive()
self.videofeed.set_frame(frame)
# print "RECIEVED:" , frame
"""if (data <> 'Q' and data <> 'q'):
class Client:
def __init__(self):
self.client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.client_socket.connect(("127.0.0.1", 6000))
self.vsock = videosocket.videosocket(self.client_socket)
self.videofeed = VideoFeed(1, "client", 1)
self.data = StringIO.StringIO()
def connect(self):
while True:
frame = self.videofeed.get_frame()
self.vsock.vsend(frame)
frame = self.vsock.vreceive()
self.videofeed.set_frame(frame)
# print "RECIEVED:" , frame
"""if (data <> 'Q' and data <> 'q'):
def onClose(self):
self.videofeed.cam.release()
del self.videofeed
self.videofeed = VideoFeed(1, "ZAMZAM", 1)
self.vidWindow.destroy()
self.vidWindow = tk.Toplevel()
self.vidWindow.withdraw()
self.vidPanel = None
class Server:
def __init__(self):
self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.server_socket.bind(("", 6000))
self.server_socket.listen(5)
self.videofeed = VideoFeed(1, "server", 1)
print "TCP server waiting for client on port 6000"
def start(self):
while 1:
client_socket, address = self.server_socket.accept()
print "I got a connection from " + address
vsock = videosocket.videosocket(client_socket)
while True:
frame = vsock.vreceive()
self.videofeed.set_frame(frame)
frame = self.videofeed.get_frame()
vsock.vsend(frame)
class Server:
def __init__(self):
self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.server_socket.bind(("", 6000))
self.server_socket.listen(5)
self.videofeed = VideoFeed(1,"server",1)
print "TCPServer Waiting for client on port 6000"
def start(self):
while 1:
client_socket, address = self.server_socket.accept()
print "I got a connection from ", address
vsock = videosocket.videosocket(client_socket)
while True:
frame=vsock.vreceive()
self.videofeed.set_frame(frame)
frame=self.videofeed.get_frame()
vsock.vsend(frame)
def connect(self, ip_addr="127.0.0.1"):
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
client_socket.connect((ip_addr, 6000))
except:
return ('Unavailable'
) # if Client can't get a connection to that IP
win.withdraw() # Hide the Connect To window
self.vsock = videosocket.videosocket(
client_socket) # establish a video connection
self.videofeed = VideoFeed(1, "A2", 1)
def __init__(self):
self.server_socket = socket.socket(
socket.AF_INET, socket.SOCK_STREAM) #create socket object
port = 5000
self.server_socket.bind(("", port)) #bind socket to port
self.server_socket.listen(0) #enable server to accept connections
self.videofeed = VideoFeed("server", 0) #create videofeed object
print("Waiting for client on port: %d",
port) #display port that the socket is listening on
client_socket, address = self.server_socket.accept()
print("I got a connection from ",
address) #display ip address of connected client
self.vsock = videosocket.videosocket(
client_socket) #create videosocket object
self.p1 = threading.Thread(target=self.display_video)
self.p2 = threading.Thread(target=self.vidSend)
def receive(self):
while True:
if self.is_video_call:
if not self.videofeed:
self.videofeed = VideoFeed("client_cam", 1)
frame = self.videofeed.get_frame()
self.vsock.vsend(frame)
rcvd_frame = self.vsock.vreceive()
self.videofeed.set_frame(rcvd_frame)
else:
# free up webcam in case not in use
if self.videofeed:
del self.videofeed
msg = self.socket.recv(self.buffer_size)
if msg == bytes("VIDEO_CALL_START", ENCODING):
self.is_video_call = True
elif msg == bytes("VIDEO_CALL_REQUEST", ENCODING):
# someone wants to videochat with you
self.receive_vcall()
else:
self.update_gui(msg, False)
class Client:
def __init__(self):
self.client_socket = socket.socket(
socket.AF_INET, socket.SOCK_STREAM) #create socket object
try:
self.client_socket.connect(
("127.0.0.1", 5000)) #local machine address
# self.client_socket.connect(("192.168.43.41", 5000))#chris's address address
except socket.error, exc: #catch socket exception
print("Caught exception socket.error: %s" % exc)
sys.exit()
print("Connected to server\n")
self.vsock = videosocket.videosocket(
self.client_socket) #create videosocket object
self.videofeed = VideoFeed("client", 1) #create videofeed object
def __init__(self, sIP, sPort):
self.videoMode = 0
self.videofeed = VideoFeed(1, "ZAMZAM", 1)
self.vidPanel = None
self.dummyIP = sIP
self.dummySocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
self.dummySocket.connect((self.dummyIP, sPort))
pass
except:
tkMessageBox.showerror("Error",
"Server Port/IP unavailable/incorrect")
self.root.destroy()
# Tk Stuff
self.root = tk.Tk() # Declares root as the tkinter main window
self.root.title("Chat Client")
self.haveConnection = False
self.videoRunning = True
self.U_client_socket = None
self.U_address = None
self.var = tk.IntVar()
def __init__(self, ip_addr, port):
self.client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.client_socket.connect((ip_addr, port))
self.vsock = videosocket.videosocket(self.client_socket)
self.videofeed = VideoFeed(1, "client", 1)
def connect(ip, port, my_username, error_callback):
global client_socket_video_send
global client_socket_video_recv
#global vsock
global videofeed
global self_username
global pill_to_kill_send_thread
global pill_to_kill_listen_thread
global stop_connection
# Create a socket
# socket.AF_INET - address family, IPv4, some otehr possible are AF_INET6, AF_BLUETOOTH, AF_UNIX
# socket.SOCK_STREAM - TCP, conection-based, socket.SOCK_DGRAM - UDP, connectionless, datagrams, socket.SOCK_RAW - raw IP packets
stop_connection = False
try:
client_socket_video_send = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# Connect to a given ip and port
client_socket_video_send.connect((ip, port))
#vsock = videosocket.videosocket (client_socket_video_send)
except Exception as e:
# Connection error
#error_callback('Connection error: {}'.format(str(e)), False)
close_connection()
return -1
# Prepare username and header and send them
# We need to encode username to bytes, then count number of bytes and prepare header of fixed size, that we encode to bytes as well
try:
self_username = my_username
username = my_username.encode('utf-8')
keyword = 'SEND_SOCKET'.encode('utf-8')
sep_bytes = ':'.encode('utf-8')
username_header = f"{len(keyword+sep_bytes+username):<{HEADER_LENGTH}}".encode('utf-8')
#print('before client_socket_video_send.send(username_header + username)')
ret = client_socket_video_send.send(username_header + keyword+sep_bytes+username)
if(ret <= 0):
close_connection()
return -2
#print('after client_socket_video_send.send(username_header + username)')
except Exception as e:
# Connection error
#error_callback('Connection error: {}'.format(str(e)), False)
close_connection()
return -2
try:
client_socket_video_recv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# Connect to a given ip and port
client_socket_video_recv.connect((ip, port))
#vsock = videosocket.videosocket (client_socket_video_send)
except Exception as e:
# Connection error
#error_callback('Connection error: {}'.format(str(e)), False)
close_connection()
return -1
# Prepare username and header and send them
# We need to encode username to bytes, then count number of bytes and prepare header of fixed size, that we encode to bytes as well
try:
keyword = 'READ_SOCKET'.encode('utf-8')
username_header = f"{len(keyword+sep_bytes+username):<{HEADER_LENGTH}}".encode('utf-8')
#print('before client_socket_video_send.send(username_header + username)')
ret = client_socket_video_recv.send(username_header + keyword+sep_bytes+username)
if(ret <= 0):
close_connection()
return -2
#print('after client_socket_video_send.send(username_header + username)')
except Exception as e:
# Connection error
#error_callback('Connection error: {}'.format(str(e)), False)
close_connection()
return -2
try:
videofeed = VideoFeed(1,my_username,1)
if not (videofeed.capture.isOpened()):
videofeed = None
print('Can not open self capture camera')
pill_to_kill_listen_thread = Event()
return -3
except Exception as e:
# Connection error
#error_callback('Connection error: {}'.format(str(e)), False)
return -3
pill_to_kill_listen_thread = Event()
pill_to_kill_send_thread = Event()
return 1
def __init__(self):
self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.server_socket.bind(("", 6000))
self.server_socket.listen(5)
self.videofeed = VideoFeed(1, "server", 1)
print "TCP server waiting for client on port 6000"
class Server:
def __init__(self):
self.server_socket = socket.socket(
socket.AF_INET, socket.SOCK_STREAM) #create socket object
port = 5000
self.server_socket.bind(("", port)) #bind socket to port
self.server_socket.listen(0) #enable server to accept connections
self.videofeed = VideoFeed("server", 0) #create videofeed object
print("Waiting for client on port: %d",
port) #display port that the socket is listening on
client_socket, address = self.server_socket.accept()
print("I got a connection from ",
address) #display ip address of connected client
self.vsock = videosocket.videosocket(
client_socket) #create videosocket object
self.p1 = threading.Thread(target=self.display_video)
self.p2 = threading.Thread(target=self.vidSend)
# self.p1.p1Alive = True
def display_video(self): #multiprocessing/threading
while (True):
frame = self.vsock.vreceive() #receive frame data through socket
setFrame = self.videofeed.set_frame(frame) #unmarshal frame data
cv.imshow('Server', setFrame) #display on window
key = cv.waitKey(1)
if key in [27, 81, 113]: #quit when q/esc is pressed
print("Exiting program. . . .")
cv.destroyAllWindows()
# self.p1Alive = False
# sys.exit()
break
def vidSend(self): #multiprocessing
while (True):
# if(self.p1.p1Alive):
frame = self.videofeed.get_frame() #get frame from camera
self.vsock.vsend(frame) #send frame data through socket
# else:
# print("breaking")
# break
def start(self):
# p1 = Process(target = self.display_video) #receive
# p2 = Process(target = self.vidSend) #send
# p1 = threading.Thread(target = self.display_video)
# p2 = threading.Thread(target = self.vidSend)
self.p1.start()
self.p2.start()
self.p1.join()
self.p2.join()
sys.exit()
def __init__(self):
self.client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.client_socket.connect(("10.3.42.55", 6000))
self.vsock = videosocket.videosocket(self.client_socket)
self.videofeed = VideoFeed(1, "client", 1)
self.data = StringIO.StringIO()
def connect(self):
client_socket, address = U_client_socket, U_address # retrieve info from global variables (changes made by Daemon)
self.vsock = videosocket.videosocket(
client_socket) # establish a video
self.videofeed = VideoFeed(1, "A1", 1)
self.show()
def __init__(self):
self.client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.client_socket.connect(("127.0.0.1", 6000))
self.vsock = videosocket.videosocket(self.client_socket)
self.videofeed = VideoFeed(1, "client", 1)
self.data = StringIO.StringIO()
class Server:
def __init__(self):
self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.server_socket.bind(("", 6000))
self.server_socket.listen(5)
self.videofeed = VideoFeed(1, "server", 1)
print("TCPServer Waiting for client on port 6000")
def keyBoard(self):
global out
global qflag
global wflag
global startflag
while True:
if keyboard.is_pressed('q') and qflag:
print("q is pressed")
timestr = time.strftime('%Y%m%d-%H%M%S')
out = cv2.VideoWriter('testVideo\\' + timestr + '.mp4', fourcc,
20.0, (640, 480))
startflag = True
#print("frame count start write: ", +frameCnt)
qflag = False
if keyboard.is_pressed('w') and wflag:
out.release()
print("w is pressed")
classface = threading.Thread(target=MyClass.my_main,
args=(
timestr,
hahaha,
))
classface.start()
startflag = False
wflag = False
if not hahaha.empty():
hahaha.get()
qflag = True
wflag = True
print("finish")
def mysend(self, vsock):
global out
global qflag
global wflag
global startflag
sendCnt = 0
while True:
sendCnt = sendCnt + 1
frame1 = self.videofeed.get_frame(sendCnt, startflag)
vsock.vsend(frame1)
if keyboard.is_pressed('q') and qflag:
print("q is pressed")
timestr = time.strftime('%Y%m%d-%H%M%S')
out = cv2.VideoWriter('testVideo\\' + timestr + '.mp4', fourcc,
30.0, (640, 480))
startflag = True
#print("frame count start write: ", +frameCnt)
qflag = False
if keyboard.is_pressed('w') and wflag:
out.release()
print("w is pressed")
classface = threading.Thread(target=MyClass.my_main,
args=(
timestr,
hahaha,
))
classface.start()
startflag = False
wflag = False
if not hahaha.empty():
hahaha.get()
qflag = True
wflag = True
print("finish")
#print(1111)
def myreceive(self, vsock):
while True:
#print(2222)
frame = vsock.vreceive()
self.videofeed.set_frame(frame, startflag, out)
def __init__(self):
self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.server_socket.bind(("", 6000))
self.server_socket.listen(5)
self.videofeed = VideoFeed(1, "server", 1)
print("TCPServer Waiting for client on port 5000")
class Client:
def __init__(self):
self.socket = socket.socket()
self.socket.settimeout(5)
self.buffer_size = 2048
self.vsock = videosocket.VideoSocket(self.socket)
self.is_video_call = False
self.videofeed = None
def receive(self):
while True:
if self.is_video_call:
if not self.videofeed:
self.videofeed = VideoFeed("client_cam", 1)
frame = self.videofeed.get_frame()
self.vsock.vsend(frame)
rcvd_frame = self.vsock.vreceive()
self.videofeed.set_frame(rcvd_frame)
else:
# free up webcam in case not in use
if self.videofeed:
del self.videofeed
msg = self.socket.recv(self.buffer_size)
if msg == bytes("VIDEO_CALL_START", ENCODING):
self.is_video_call = True
elif msg == bytes("VIDEO_CALL_REQUEST", ENCODING):
# someone wants to videochat with you
self.receive_vcall()
else:
self.update_gui(msg, False)
def send(self, msg=None):
if msg is None:
msg = msg_box.get()
msg_box.delete(0, tk.END)
self.socket.send(bytes(msg, ENCODING))
else:
self.socket.send(msg)
def initiate_video_call(self):
self.send(bytes("VIDEO_CALL_START", ENCODING))
usernames = self.socket.recv(self.buffer_size).decode(ENCODING)
names = usernames.split("$")[:-1]
num_online = len(names)
root = tk.Tk()
root.geometry("300x%s" %(str((2 + num_online) * 100)))
if num_online == 0:
l = tk.Label(root, text="No users online, try again later!!", padx=20, pady=10)
l.pack()
else:
l = tk.Label(root, text="Select the person whose face you want to see!!")
l.pack()
for n in names:
b = tk.Button(root, text=n, command=lambda: self.decide_target(root, n))
b.pack()
qb = tk.Button(root, text="Quit", command=lambda: self.decide_target(root, None))
qb.pack()
root.mainloop()
def decide_target(self, root, target):
if target:
self.send(bytes(target, ENCODING))
else:
self.send(bytes("VIDEO_CALL_ABORT", ENCODING))
root.destroy()
def update_gui(self, msg, is_sent=False):
display_listbox.insert("end", msg.decode(ENCODING))
def receive_vcall(self):
# get username of who wants to talk with you
from_uname = self.socket.recv(self.buffer_size).decode(ENCODING)
root = tk.Tk()
root.geometry("300x300")
l = tk.Label(root, text="Your beloved %s wants to see your face !!" %(from_uname),
padx=20, pady=20)
l.pack()
b1 = tk.Button(root, text="Accept", command=lambda: self.send_confirmation(root, from_uname, True))
b1.pack()
b2 = tk.Button(root, text="Reject", command=lambda: self.send_confirmation(root, from_uname, False))
b2.pack()
root.mainloop()
def send_confirmation(self, root, accept_from, decision):
if decision:
msg = bytes("VIDEO_CALL_ACCEPT", ENCODING)
else:
msg = bytes("VIDEO_CALL_REJECTED", ENCODING)
self.send(msg)
self.send(bytes(accept_from, ENCODING))
root.destroy()
