Aufgeräumt

scripts/video_delay_proxy.py

@@ -0,0 +1,161 @@
+#!/usr/bin/env python3
+"""
+MJPEG Video Delay Proxy
+Puffert Frames vom Kamerastream (Port 8081) und liefert sie
+mit einstellbarer Verzögerung auf Port 8083.
+Delay wird aus /tmp/exomy_delay.txt gelesen (Sekunden als float).
+"""
+import collections
+import http.server
+import os
+import socketserver
+import threading
+import time
+import urllib.parse
+import urllib.request
+
+DELAY_FILE = '/tmp/exomy_delay.txt'
+SOURCE_URL = 'http://localhost:8081/stream.mjpg'
+PORT = 8083
+BOUNDARY = b'--frame'
+
+# Deque: (timestamp_float, jpeg_bytes)
+frame_buffer = collections.deque()
+buffer_lock = threading.Lock()
+latest_frame = None
+latest_lock = threading.Lock()
+
+
+def read_delay():
+    try:
+        with open(DELAY_FILE) as f:
+            return max(0.0, float(f.read().strip()))
+    except Exception:
+        return 0.0
+
+
+def camera_reader():
+    global latest_frame
+    while True:
+        try:
+            req = urllib.request.urlopen(SOURCE_URL, timeout=5)
+            buf = bytearray()
+            while True:
+                chunk = req.read(4096)
+                if not chunk:
+                    break
+                buf.extend(chunk)
+                while True:
+                    start = buf.find(b'\xff\xd8')
+                    if start == -1:
+                        if len(buf) > 1024 * 1024:
+                            del buf[:-2]
+                        break
+                    end = buf.find(b'\xff\xd9', start + 2)
+                    if end == -1:
+                        if start > 0:
+                            del buf[:start]
+                        break
+                    jpeg = bytes(buf[start:end + 2])
+                    del buf[:end + 2]
+                    ts = time.monotonic()
+                    with buffer_lock:
+                        frame_buffer.append((ts, jpeg))
+                        # Puffer auf 12 Sekunden begrenzen
+                        cutoff = ts - 12.0
+                        while frame_buffer and frame_buffer[0][0] < cutoff:
+                            frame_buffer.popleft()
+                    with latest_lock:
+                        latest_frame = jpeg
+        except Exception:
+            time.sleep(1)
+
+
+def get_delayed_frame():
+    delay = read_delay()
+    if delay <= 0:
+        with latest_lock:
+            return latest_frame
+    target_ts = time.monotonic() - delay
+    with buffer_lock:
+        if not frame_buffer:
+            return None
+        best = frame_buffer[0][1]
+        for ts, jpeg in frame_buffer:
+            if ts <= target_ts:
+                best = jpeg
+            else:
+                break
+        return best
+
+
+class ReusableTCPServer(socketserver.ThreadingTCPServer):
+    allow_reuse_address = True
+
+
+class Handler(http.server.BaseHTTPRequestHandler):
+    def normalized_path(self):
+        return urllib.parse.urlsplit(self.path).path
+
+    def do_GET(self):
+        path = self.normalized_path()
+        if path == '/snapshot.jpg':
+            frame = get_delayed_frame()
+            if frame is None:
+                self.send_error(503)
+                return
+            self.send_response(200)
+            self.send_header('Cache-Control', 'no-cache, private')
+            self.send_header('Pragma', 'no-cache')
+            self.send_header('Access-Control-Allow-Origin', '*')
+            self.send_header('Content-Type', 'image/jpeg')
+            self.send_header('Content-Length', str(len(frame)))
+            self.end_headers()
+            self.wfile.write(frame)
+            return
+
+        if path != '/stream.mjpg':
+            self.send_error(404)
+            return
+        self.send_response(200)
+        self.send_header('Age', '0')
+        self.send_header('Cache-Control', 'no-cache, private')
+        self.send_header('Pragma', 'no-cache')
+        self.send_header('Access-Control-Allow-Origin', '*')
+        self.send_header('Content-Type', 'multipart/x-mixed-replace; boundary=frame')
+        self.end_headers()
+        fps = 10
+        while True:
+            frame = get_delayed_frame()
+            if frame is None:
+                time.sleep(0.1)
+                continue
+            try:
+                self.wfile.write(BOUNDARY + b'\r\n')
+                self.wfile.write(b'Content-Type: image/jpeg\r\n')
+                self.wfile.write(f'Content-Length: {len(frame)}\r\n\r\n'.encode())
+                self.wfile.write(frame)
+                self.wfile.write(b'\r\n')
+                self.wfile.flush()
+                time.sleep(1.0 / fps)
+            except (BrokenPipeError, ConnectionResetError):
+                break
+
+    def log_message(self, fmt, *args):
+        return
+
+
+if __name__ == '__main__':
+    # Delay-Datei initialisieren (world-writable damit Admin-API schreiben kann)
+    try:
+        fd = os.open(DELAY_FILE, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o666)
+        os.write(fd, b'0.0')
+        os.close(fd)
+    except Exception:
+        pass
+
+    threading.Thread(target=camera_reader, daemon=True).start()
+    with ReusableTCPServer(('0.0.0.0', PORT), Handler) as server:
+        server.daemon_threads = True
+        print(f'Video-Delay-Proxy läuft auf Port {PORT}')
+        server.serve_forever()