XDSA/one_to_1.py at master · hackabit18/XDSA · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
import cv2
from socket import socket, AF_INET, SOCK_STREAM
from imutils.video import WebcamVideoStream
import pyaudio
from array import array
from threading import Thread
import numpy as np
import zlib
import struct

HOST = input("Enter Server IP\n")
PORT_VIDEO = 3000
PORT_AUDIO = 4000

BufferSize = 4096
CHUNK=1024
lnF = 640*480*3
FORMAT=pyaudio.paInt16
CHANNELS=2
RATE=44100

def SendAudio():
    while True:
        data = stream.read(CHUNK)
        dataChunk = array('h', data)
        vol = max(dataChunk)
        if(vol > 500):
            print("Recording Sound...")
        else:
            print("Silence..")
        clientAudioSocket.sendall(data)

def RecieveAudio():
    while True:
        data = recvallAudio(BufferSize)
        stream.write(data)

def recvallAudio(size):
    databytes = b''
    while len(databytes) != size:
        to_read = size - len(databytes)
        if to_read > (4 * CHUNK):
            databytes += clientAudioSocket.recv(4 * CHUNK)
        else:
            databytes += clientAudioSocket.recv(to_read)
    return databytes

def SendFrame():
    while True:
        frame = wvs.read()
        cv2_im = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
        frame = cv2.resize(frame, (640, 480))
        frame = np.array(frame, dtype = np.uint8).reshape(1, lnF)
        jpg_as_text = bytearray(frame)

        databytes = zlib.compress(jpg_as_text, 9)
        length = struct.pack('!I', len(databytes))
        bytesToBeSend = b''
        clientVideoSocket.sendall(length)
        while len(databytes) > 0:
            if (5000 * CHUNK) <= len(databytes):
                bytesToBeSend = databytes[:(5000 * CHUNK)]
                databytes = databytes[(5000 * CHUNK):]
                clientVideoSocket.sendall(bytesToBeSend)
            else:
                bytesToBeSend = databytes
                clientVideoSocket.sendall(bytesToBeSend)
                databytes = b''
        print("##### Data Sent!! #####")


def RecieveFrame():
    while True:
        lengthbuf = recvallVideo(4)
        length, = struct.unpack('!I', lengthbuf)
        databytes = recvallVideo(length)
        img = zlib.decompress(databytes)
        if len(databytes) == length:
            print("Recieving Media..")
            print("Image Frame Size:- {}".format(len(img)))
            img = np.array(list(img))
            img = np.array(img, dtype = np.uint8).reshape(480, 640, 3)
            cv2.imshow("Stream", img)
            if cv2.waitKey(1) == 27:
                cv2.destroyAllWindows()
        else:
            print("Data CORRUPTED")

def recvallVideo(size):
    databytes = b''
    while len(databytes) != size:
        to_read = size - len(databytes)
        if to_read > (5000 * CHUNK):
            databytes += clientVideoSocket.recv(5000 * CHUNK)
        else:
            databytes += clientVideoSocket.recv(to_read)
    return databytes


clientVideoSocket = socket(family=AF_INET, type=SOCK_STREAM)
clientVideoSocket.connect((HOST, PORT_VIDEO))
wvs = WebcamVideoStream(0).start()

clientAudioSocket = socket(family=AF_INET, type=SOCK_STREAM)
clientAudioSocket.connect((HOST, PORT_AUDIO))

audio=pyaudio.PyAudio()
stream=audio.open(format=FORMAT,channels=CHANNELS, rate=RATE, input=True, output = True,frames_per_buffer=CHUNK)

initiation = clientVideoSocket.recv(5).decode()

if initiation == "start":
    SendFrameThread = Thread(target=SendFrame).start()
    SendAudioThread = Thread(target=SendAudio).start()
    RecieveFrameThread = Thread(target=RecieveFrame).start()
    RecieveAudioThread = Thread(target=RecieveAudio).start()