Revision history [back]

Video be freeze over Socket

I find the following code for streaming video over a socket. When I run it, the video will be freeze at the beginning in the server-side. I traced the code and understood that in the streamer.py, the third while loop condition creates an infinite loop because of the condition while len(data) < msg_size: is always satisfied. In other words, len(data) is always less than msg_size.
Could anyone help me to solve this issue?

from flask import Flask, render_template, Response
from streamer import Streamer

app = Flask(__name__)

def gen():
 streamer = Streamer('localhost', 8089)
 streamer.start()

 while True:
     if streamer.client_connected():
         yield (b'--frame\r\n'b'Content-Type: image/jpeg\r\n\r\n' + streamer.get_jpeg() + b'\r\n\r\n')

@app.route('/')
def index():
   return render_template('index.html')

@app.route('/video_feed')
 def video_feed():
    return Response(gen(), mimetype='multipart/x-mixed-replace; boundary=frame')

 if __name__ == '__main__':
    app.run(host='localhost', threaded=True)

and the streamer.py is:

import cv2
import threading
import socket
import struct
import StringIO
import json
import numpy
class Streamer (threading.Thread):
   def __init__(self, hostname, port):
       threading.Thread.__init__(self)

       self.hostname = hostname
       self.port = port
       self.connected = False
       self.jpeg = None

   def run(self):

        self.isRunning = True

        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        print 'Socket created'

       s.bind((self.hostname, self.port))
       print 'Socket bind complete'

       data = ""
       payload_size = struct.calcsize("L")

       s.listen(10)
       print 'Socket now listening'

      while self.isRunning:

        conn, addr = s.accept()
        print 'while 1...'

     while True:

         data = conn.recv(4096)

         print 'while 2...'
         if data:
            packed_msg_size = data[:payload_size]
            data = data[payload_size:]
           msg_size = struct.unpack("L", packed_msg_size)[0]

           while len(data) < msg_size: # here is the infinite loop
           data += conn.recv(4096)
           print ("lenght of data is " , len(data) )
           print ("message size is  " ,  msg_size )

      frame_data = data[:msg_size]
      #frame_data = data[:len(data)]
      memfile = StringIO.StringIO()
      memfile.write(json.loads(frame_data).encode('latin-1'))
      memfile.seek(0)
      frame = numpy.load(memfile)

      ret, jpeg = cv2.imencode('.jpg', frame)
      self.jpeg = jpeg

      self.connected = True
      print 'recieving...'

    else:
      conn.close()
      self.connected = False
      print 'connected=false...'
      break

 self.connected = False

def stop(self):
    self.isRunning = False

def client_connected(self):
   return self.connected

def get_jpeg(self):
   return self.jpeg.tobytes()

and the client.py is:

import cv2
import numpy as np
import socket 
import sys
import pickle
import struct
import StringIO
import json
import time

cap=cv2.VideoCapture(0)
clientsocket=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
clientsocket.connect(('localhost',8089))

while(cap.isOpened()):
   ret,frame=cap.read()

   memfile = StringIO.StringIO()
   np.save(memfile, frame)
   memfile.seek(0)
   data = json.dumps(memfile.read().decode('latin-1'))

  clientsocket.sendall(struct.pack("L", len(data))+data)
  if cv2.waitKey(1) & 0xFF == ord('q'):
    break

cap.release()

and the javascript is:

<html>
      <head>
         <title>Video Streaming Demonstration</title>
    </head>
    <body>
        <h1>Video Streaming Demonstration</h1>
        <img src="{{ url_for('video_feed') }}">
   </body>
</html>