Create a version that works with Picamera2

[woutersf]

I attempted to run this on my Raspberry pi 4 with Picamera2 and coultn't get it to work.
the picamera2 docs only have a mjpeg server example and a seperate H264 quantiser example

Is there another branch/version of this repo where this works with picamera2 ?

I suspect the changes are something like the following however I don't speak python fluently.

To be added:

from picamera2 import Picamera2
from picamera2.encoders import H264Encoder
from picamera2.outputs import CircularOutput  # (or FileOutput?)

and then the camera references should be removed or replaced by picam2
where picam2 iis intialised and starts streaming.

Also in the try:

    picam2 = Picamera2()
    fps = 30
    dur = 5
    micro = int((1 / fps) * 1000000)
    vconfig = picam2.create_video_configuration()
    vconfig['controls']['FrameDurationLimits'] = (micro, micro)
    picam2.configure(vconfig)
    encoder = H264Encoder()
    output = CircularOutput(buffersize=int(fps * (dur + 0.2)), outputtofile=False)
    output.fileoutput = "file.h264"
    picam2.start_recording(encoder, output)
    application = tornado.web.Application(requestHandlers)
    application.listen(serverPort)
    streamBuffer.setLoop(loop)
    loop.start()

If anyone has any hints on getting this to work, I'm willing to give it some attempts but it's not familiar to me, I would need some guidance.

[dans98]

Honestly, You would be better to start from scratch. the picamera2 module is completely different, and I'm not sure it can be made to work in the same fashion.

[nikola-j]

Here is a picamera2 version:

import io
import os
import socket
from string import Template
from threading import Condition

import tornado.ioloop
import tornado.web
import tornado.websocket
from picamera2 import Picamera2
from picamera2.encoders import H264Encoder
from picamera2.outputs import Output

# start configuration
serverPort = 8000

picam2 = Picamera2()
picam2.configure(picam2.create_video_configuration(main={"size": (640, 480)}))

framerate = 10

s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.connect(('8.8.8.8', 0))
serverIp = s.getsockname()[0]

abspath = os.path.abspath(__file__)
dname = os.path.dirname(abspath)
os.chdir(dname)


def getFile(filePath):
    file = open(filePath, 'r')
    content = file.read()
    file.close()
    return content


def templatize(content, replacements):
    tmpl = Template(content)
    return tmpl.substitute(replacements)


indexHtml = templatize(getFile('index.html'), {'ip': serverIp, 'port': serverPort, 'fps': framerate})
jmuxerJs = getFile('jmuxer.min.js')


class StreamingOutput(Output):
    def __init__(self):
        super().__init__()
        self.loop = None
        self.buffer = io.BytesIO()

    def setLoop(self, loop):
        self.loop = loop

    def outputframe(self, frame, keyframe=True, timestamp=None):
        self.buffer.write(frame)
        if self.loop is not None and wsHandler.hasConnections():
            self.loop.add_callback(callback=wsHandler.broadcast, message=self.buffer.getvalue())
        self.buffer.seek(0)
        self.buffer.truncate()


class wsHandler(tornado.websocket.WebSocketHandler):
    connections = []

    def open(self):
        self.connections.append(self)

    def on_close(self):
        self.connections.remove(self)

    def on_message(self, message):
        pass

    @classmethod
    def hasConnections(cl):
        if len(cl.connections) == 0:
            return False
        return True

    @classmethod
    async def broadcast(cl, message):
        for connection in cl.connections:
            try:
                await connection.write_message(message, True)
            except tornado.websocket.WebSocketClosedError:
                pass
            except tornado.iostream.StreamClosedError:
                pass

    def check_origin(self, origin):
        return True


class indexHandler(tornado.web.RequestHandler):
    def get(self):
        self.write(indexHtml)


class jmuxerHandler(tornado.web.RequestHandler):
    def get(self):
        self.set_header('Content-Type', 'text/javascript')
        self.write(jmuxerJs)


requestHandlers = [
    (r"/ws/", wsHandler),
    (r"/", indexHandler),
    (r"/jmuxer.min.js", jmuxerHandler)
]

try:
    output = StreamingOutput()
    encoder = H264Encoder(repeat=True, framerate=framerate, qp=20)
    encoder.output = output
    picam2.start_recording(encoder, output)

    application = tornado.web.Application(requestHandlers)
    application.listen(serverPort)
    loop = tornado.ioloop.IOLoop.current()
    output.setLoop(loop)
    loop.start()
except KeyboardInterrupt:
    picam2.stop_recording()
    loop.stop()

[chradev]

Hi guys,

I have just forked @nikola-j and @kroketio repository pi-h264-to-browser and make some changes to stream video from both RPi 5 cameras to a browser and setup the range-of-interest by picamera2 property ScalerCrop. My code is on pi-h264-to-browser-stramer but my experience in Python is very weak so I will be extremely grateful for a little help to solve following problems in server.py:

• avoiding duplication of the StreamingOutput and wsHandler classes
• using of {OffsetX, OffsetY, Width, Height} values in the StreamingOutput class but calculated by another application (independent process) - maybe by using of Unix sockets or something alike

I am working on RPi 5 & bookworm RPi official OS with 2x RPi cameras v.2.

Best regards
Christo