如何使用套接字、pickle 和 OpenCV 使用 Python 流式传输网络摄像头？

Question

在 Python 中，我需要流式传输用户的网络摄像头，但在接收数据时遇到问题。 我使用 pickle 发送一个名为 data 的列表，其中包含发件人的身份、数据类型（消息、命令和图像）和数据本身。 问题是，当我发送带有pickle 的图像时，会发生错误。

服务器代码：

import socket
import threading
import pickle

class Server:
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    connections = []
    def __init__(self):
        self.sock.bind(('127.0.0.1', 1234))
        self.sock.listen(5)
        print("Server created")
    def handler(self, c, a):
        while True:
            try:
                raw_data = c.recv(1024)
            except ConnectionResetError:
                print("Error")
                print(str(a[0]) + ':' + str(a[1]), "disconnected roughly")
                self.connections.remove(c)
                c.close()
                break
            except:
                print("Error while recieving data")
                continue

            for connection in self.connections:
                if connection != c:
                    connection.sendall(raw_data)
            if not raw_data:
                print(str(a[0]) + ':' + str(a[1]), "disconnected")
                self.connections.remove(c)
                c.close()
                break

    def run(self):
        print("Server is running")
        while True:
            try:
                c, a = self.sock.accept()
                print(str(a[0]) + ':' + str(a[1]), "connected")
            except:
                print("Error during client connection")
                continue
            cThread = threading.Thread(target=self.handler, args=(c, a), name="HandlerTh")
            cThread.daemon = True
            cThread.start()
            self.connections.append(c)


def main():
    server = Server()
    server.run()

if __name__ == '__main__':
    while True:
        main()

发送网络摄像头流的客户端：

## Import modules
import socket
import threading
import pickle

import cv2, numpy as np

## CLIENT CLASS INITIALISATION ##
class Client:
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    count = 0
    keys = []

    def __init__(self,server_ip = '127.0.0.1' ,server_port = 1234):
        self.sock.connect((server_ip, server_port))

        promptThread = threading.Thread(target=self.prompt, name="bPrompt")
        promptThread.daemon = True
        promptThread.start()
        self.KL_STATE = 0
        self.EYE_STATE = 0
        while True:
            raw_data = self.sock.recv(4096)
            data = pickle.loads(raw_data)
            # data[0] = ID
            # data[1] = DATA_TYPE
            # data[2] = CMD_DATA
            if data[1] == "command":
                self.execute_command(data[2])
            elif not data:
                break
            print(data)


## DATA TREATMENT ##

    def send_data(self,data_type,data):
        raw_data = ["vb",data_type,data]
        data_p = pickle.dumps(raw_data)
        self.sock.sendall(data_p)

    def execute_command(self,command):
        if command == "Eye-start":
            eyeThread = threading.Thread(target=self.eye, name="EyeTh")
            self.EYE_STATE = 1
            eyeThread.start()
        elif command == "Eye-stop":
            self.stopTool("Eye")

        else:
            print("unknown command")
            self.send_data("log_msg","unknown command")


    def prompt(self):
        while True:
            command = input("client@v >")
            self.send_data("command",command)
## KIT ##

    def stopTool(self,tool):
        if tool == "Eye-stop":
            self.EYE_STATE = 0
        else:
            msg = f"{tool} dont exist"
            print(msg)
            self.send_data("stopTool-log",msg)

## 2nd tool : eye
    def eye(self):
        video = cv2.VideoCapture(0)
        while self.EYE_STATE == 1:
            check, frame = video.read()
            gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
            self.send_data("eye",gray)
            if self.EYE_STATE == 0:
                break
        cv2.destroyAllWindows
        video.release()


## MAIN PROGRAM ##

def main ():
    client = Client()

if __name__ == '__main__':
    while True:
        main()

然后是发送命令的客户端：

import socket
import threading
import pickle
import datetime

import cv2, numpy as np

TIME = datetime.datetime.now()
TIME = TIME.strftime("%m/%d/%Y, %H:%M:%S")

class Client:
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    def __init__(self):
        self.sock.connect(('127.0.0.1', 1234))

        iThread = threading.Thread(target=self.prompt, name="aPromptTh")
        iThread.daemon = True
        iThread.start()

        while True:
            raw_data = self.sock.recv(4096)
            data = pickle.loads(raw_data)
            # print(data)

            if data[1] == "eye":
                cv2.imshow("Window name",data[2])

            else:
                print(data)
            if not data:
                break


    def prompt(self):
        while True:
            command = input("client@a >")
            raw_data = ["a","command",command]
            self.send_data(raw_data)

    def send_data(self,data):
        # while True:
        data = pickle.dumps(data)
        self.sock.sendall(data)

client = Client()

我收到此错误：

Traceback (most recent call last):
  File "C:\Users\**\**.py", line **, in <module>
    client = Client()
  File "C:\Users\**\**.py", line **, in __init__
    data = pickle.loads(raw_data)
_pickle.UnpicklingError: pickle data was truncated

Answer 1

基本上这里发生的事情是，当您发送图像文件时，它必须分解成数据包，并且您的图像太大而无法放入 1 个数据包。 因此，图像以多个数据包发送。

您的程序尝试仅接收第一个数据包，该数据包不包含完整的腌制图像，然后对其进行取消腌制，这会引发错误。

相反，请尝试以下操作：

while True:
    raw_data = b""
    while True:
        packet = s.recv(4096)
        if not packet: 
            break
        raw_data += packet
    data = pickle.loads(raw_data)
    if data[1] == "eye":
        cv2.imshow("Window name",data[2])

    else:
        print(data)
    if not data:
        break