Send Receive Images in TCP Python to Unity

fix.cs

// fix
int increment = 0;
while (recieved < fileSize)
{
     byte[] data = new byte[camClient.ReceiveBufferSize];
     increment = dataStream.Read(data, 0, data.Length);
     recieved += increment; 
     ms.Write(data.Take(increment).ToArray(), 0, increment);

}

getVideoStream.cs

using System.Collections;
using UnityEngine;
using System;
using System.Net;
using System.Text;
using System.Net.Sockets;
using System.Threading;
using UnityEngine.UI;
using System.IO;

void getVideoStream()
    {
        byte[] header; 
        int recieved;
        int fileSize;
        NetworkStream dataStream;
        MemoryStream ms;
        while (connectCam)
        {
            fileSize = 0;
            recieved = 0;
            camClient = new TcpClient(camIP, camPort);

            //get header
            dataStream = camClient.GetStream();
            while (!dataStream.DataAvailable)
            {
                //waste time
            }
            header = new byte[1024];
            dataStream.Read(header, 0, header.Length);
            fileSize = Int32.Parse(Encoding.Default.GetString(bytesReducer(header)));
            byte[] result = Encoding.ASCII.GetBytes(fileSize.ToString());

            //send response
            dataStream.Write(result, 0, result.Length);

            ms = new MemoryStream();
            while (!dataStream.DataAvailable)
            {
                //waste time
            }
            while (recieved < fileSize)
            {
                byte[] data = new byte[camClient.ReceiveBufferSize];
                recieved += dataStream.Read(data, 0, data.Length);
                ms.Write(data, 0, data.Length);

            }
            //the below class simply sends function calls from secondary thread back to the main thread
            UnityMainThreadDispatcher.Instance().Enqueue(convertBytesToTexture(ms.ToArray()));
            dataStream.Close();
            camClient.Close();

        }
    }

void convertBytesToTexture(byte[] byteArray) {
        try
        {
            camTexture.LoadImage(byteArray); //Texture2D object
            camImage.texture = camTexture; //RawImage object
        }
        catch (Exception e)
        {
            print(e);
        }
    }

imagestreamer.py

// https://stackoverflow.com/questions/52578146/images-streamed-over-tcp-are-split-in-3-with-middle-missing/52582372#52582372

import cv2
import numpy as np
import socket
from threading import Thread

_continue = True
def imageStreamer4():
    global _continue
    cam = cv2.VideoCapture(0)
    camSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    camSocket.bind(("",8081))
    camSocket.listen(1)
    # set flip image to false if you don't want the image to be flipped
    flipImage = True

    while _continue:
        try:
            client,address = camSocket.accept()
            print("client connected")
            ret,camImage = cam.read()
            if flipImage:
                camImage = cv2.flip(camImage,1)

            #uncomment the below code to view the webcam stream locally
            """
            cv2.imshow('image',camImage)
            if cv2.waitKey(1) == 27: 
                break  # esc to quit
            """
            byteString = bytes(cv2.imencode('.jpg', camImage)[1].tostring())
            fileSize = len(byteString)
            totalSent = 0
            client.send(str(fileSize).encode())

            sizeConfirmation = client.recv(1024)

            totalSent = 0
            while totalSent < fileSize:
                totalSent += client.send(byteString[totalSent:])

            print(str(fileSize), str(totalSent),sizeConfirmation.decode('utf-8'))

        except Exception as e:
            print(e)
            print("shutting down video stream")
            _continue = False

    print("video stream exited.")