feature: implement session management

src/app.py

@@ -1,89 +1,107 @@
-from flask import Flask, Response, stream_with_context
+from flask import Flask, Response, stream_with_context, request
 import cv2
+from cv2.typing import MatLike
 import threading
 import time
 import os
 
+class Session:
+    def __init__(self, id: str, latest_frame: MatLike, measured_fps: float, show_fps: bool):
+        self.id = id
+        self.latest_frame: MatLike = latest_frame
+        self.measured_fps = measured_fps
+        self.show_fps = show_fps
+
 app = Flask(__name__)
 PORT = int(os.environ.get("PORT", 5000))
 
-instantiated = False
-
-latest_frame = None
 lock = threading.Lock()
-measured_fps = 0
-show_fps = True
-
-def video_reader():
-    global latest_frame, lock, measured_fps
-
-    cap = cv2.VideoCapture("videos/classroom.mp4")
-    framerate = cap.get(cv2.CAP_PROP_FPS)
-    frame_duration = 1 / framerate
-
-    # variables to measure FPS
-    frame_count = 0
-    last_time = time.time()
-    rolling_duration = 0.5
-
-    # variables to control framerate
-    next_frame_time = time.time()
-    
-    while True:
-        ret, frame = cap.read()
-
-        if not ret:
-            cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
-            continue
-        else:
+
+sessions: set[Session] = set()
+
+def frame_processor(session_id: str):
+    global sessions
+
+    session: Session = next((s for s in sessions if s.id == session_id), None)
+
+    if session is not None:
+        cap = cv2.VideoCapture("videos/classroom.mp4")
+        framerate = cap.get(cv2.CAP_PROP_FPS)
+        frame_duration = 1 / framerate
+
+        # variables to measure FPS
+        frame_count = 0
+        last_time = time.time()
+        rolling_duration = 0.5
+
+        # variables to control framerate
+        next_frame_time = time.time()
+        
+        while True:
+            ret, frame = cap.read()
+
+            if not ret:
+                cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
+                continue
+            else:
+                with lock:
+                    if session.show_fps:
+                        text = f"{session_id}: {session.measured_fps:.0f}"
+                        font = cv2.FONT_HERSHEY_SIMPLEX
+                        font_scale = 1
+                        thickness = 2
+                        color = (0, 255, 0)
+                        (text_width, text_height), _ = cv2.getTextSize(text, font, font_scale, thickness)
+                        x = frame.shape[1] - text_width - 10
+                        y = 30
+                        cv2.putText(frame, text, (x, y), font, font_scale, color, thickness, cv2.LINE_AA)
+                    session.latest_frame = frame
+
+            # measure FPS
+            frame_count += 1
+            now = time.time()
+            if now - last_time >= rolling_duration:
+                session.measured_fps = frame_count / (now - last_time)
+                frame_count = 0
+                last_time = now
+
+            # control framerate
+            next_frame_time += frame_duration
+            sleep_time = next_frame_time - time.time()
+            if sleep_time > 0:
+                time.sleep(sleep_time)
+            else:
+                next_frame_time = time.time()
+
+def stream_mjpeg(session_id: str):
+    global sessions
+
+    session: Session = next((s for s in sessions if s.id == session_id), None)
+
+    if session is not None:
+        while True:
+            if session.latest_frame is None:
+                continue
             with lock:
-                if show_fps:
-                    cv2.putText(frame, f"{measured_fps: .0f}", (frame.shape[1] - 70, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2, cv2.LINE_AA)
-                latest_frame = frame
-
-        # measure FPS
-        frame_count += 1
-        now = time.time()
-        if now - last_time >= rolling_duration:
-            measured_fps = frame_count / (now - last_time)
-            frame_count = 0
-            last_time = now
-
-        # control framerate
-        next_frame_time += frame_duration
-        sleep_time = next_frame_time - time.time()
-        if sleep_time > 0:
-            time.sleep(sleep_time)
-        else:
-            next_frame_time = time.time()
-
-def generate():
-    while True:
-        if latest_frame is None:
-            continue
-        with lock:
-            encode_param = [int(cv2.IMWRITE_JPEG_QUALITY), 50]
-            ret, jpeg = cv2.imencode(".jpg", latest_frame, encode_param)
-            frame_bytes = jpeg.tobytes() if ret else None
-            # print(f"frame filesize: {len(frame_bytes) / (1024 * 1024):.4f} MB")
-        if frame_bytes is not None:
-            yield (b"--frame\r\n"b"Content-Type: image/jpeg\r\n\r\n" + frame_bytes + b"\r\n")
+                encode_param = [int(cv2.IMWRITE_JPEG_QUALITY), 50]
+                ret, jpeg = cv2.imencode(".jpg", session.latest_frame, encode_param)
+                frame_bytes = jpeg.tobytes() if ret else None
+                # print(f"frame filesize: {len(frame_bytes) / (1024 * 1024):.4f} MB")
+            if frame_bytes is not None:
+                yield (b"--frame\r\n"b"Content-Type: image/jpeg\r\n\r\n" + frame_bytes + b"\r\n")
             
 @app.route("/")
 def video_feed():
-    global instantiated
+    global sessions
 
-    if not instantiated:
-        instantiated = True
-        threading.Thread(target=video_reader, daemon=True).start()
-        
-    return Response(stream_with_context(generate()), mimetype="multipart/x-mixed-replace; boundary=frame")
+    session_id = request.args.get("id", "default")
 
-@app.route("/toggle_fps")
-def toggle_fps():
-    global show_fps
-    show_fps = not show_fps
-    return f"fps counter: {"on" if show_fps else "off"}", 200
+    if session_id not in [s.id for s in sessions]:
+        session = Session(session_id, None, 0, True)
+        sessions.add(session)
+        threading.Thread(target=frame_processor, args=[session_id], daemon=True).start()
+        
+    return Response(stream_with_context(stream_mjpeg(session_id)), mimetype="multipart/x-mixed-replace; boundary=frame")
 
 if __name__ == "__main__":
     app.run(host="0.0.0.0", port=PORT, threaded=True)