Update app.py

app.py

@@ -1,111 +1,107 @@
-import time
-import cv2
-import numpy as np
 import streamlit as st
-from streamlit_webrtc import webrtc_streamer, WebRtcMode, VideoTransformerBase
+import cv2
+import time
+import threading
+import os
+from streamlit_autorefresh import st_autorefresh
+
+# Initialize session state for broadcasting if not already set
+if "broadcasting" not in st.session_state:
+    st.session_state.broadcasting = False
+if "broadcaster_thread" not in st.session_state:
+    st.session_state.broadcaster_thread = None
+
+def broadcast_loop(camera_index):
+    """
+    Capture 3-second segments from the selected camera and write them to 'latest.mp4'.
+    This loop runs in a background thread while st.session_state.broadcasting is True.
+    """
+    cap = cv2.VideoCapture(int(camera_index))
+    if not cap.isOpened():
+        st.error("Could not open camera.")
+        return
 
-# Set wide layout and page title
-st.set_page_config(page_title="Live Stream Broadcast", layout="wide")
+    # Try to determine FPS; default to 20 if not available.
+    fps = cap.get(cv2.CAP_PROP_FPS)
+    if fps is None or fps < 1:
+        fps = 20
 
-# -----------------------------------------------------------------------------
-# Custom CSS: Hide the timeline parts of the video controls (works in WebKit‑based browsers)
-st.markdown(
+    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+
+    while st.session_state.broadcasting:
+        # Open a VideoWriter to record a 3-second segment.
+        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+        out = cv2.VideoWriter("latest.mp4", fourcc, fps, (width, height))
+        segment_start = time.time()
+
+        while time.time() - segment_start < 3 and st.session_state.broadcasting:
+            ret, frame = cap.read()
+            if not ret:
+                break
+            out.write(frame)
+            time.sleep(1.0 / fps)
+        out.release()  # Close the file so that it can be served.
+    cap.release()
+
+def start_broadcast(password, camera_index):
+    """
+    Start broadcasting if the correct password is entered.
     """
-    <style>
-    video::-webkit-media-controls-timeline {
-        display: none !important;
-    }
-    video::-webkit-media-controls-current-time-display {
-        display: none !important;
-    }
-    video::-webkit-media-controls-time-remaining-display {
-        display: none !important;
-    }
-    </style>
-    """,
-    unsafe_allow_html=True,
-)
-# -----------------------------------------------------------------------------
-st.title("Live Streaming Space")
+    if password != "test123":
+        return "Incorrect password! Broadcast not started."
+    if not st.session_state.broadcasting:
+        st.session_state.broadcasting = True
+        thread = threading.Thread(target=broadcast_loop, args=(camera_index,), daemon=True)
+        st.session_state.broadcaster_thread = thread
+        thread.start()
+        return "Broadcasting started."
+    else:
+        return "Already broadcasting."
 
-# -----------------------------------------------------------------------------
-# A simple video transformer that “buffers” frames for 3 seconds.
-# (In a more complex app you might encode these frames into a video segment file.)
-class BufferingTransformer(VideoTransformerBase):
-    def __init__(self):
-        self.buffer = []            # List to hold frames
-        self.buffer_duration = 3.0  # Buffer duration in seconds
-        self.last_flush_time = time.time()
+def stop_broadcast():
+    """
+    Stop broadcasting by setting the broadcasting flag to False.
+    """
+    if st.session_state.broadcasting:
+        st.session_state.broadcasting = False
+        return "Broadcast stopped."
+    else:
+        return "Not broadcasting."
 
-    def transform(self, frame):
-        # Convert the frame (a VideoFrame object) into a NumPy array (BGR format)
-        img = frame.to_ndarray(format="bgr24")
-        self.buffer.append(img)
-        now = time.time()
-        if now - self.last_flush_time >= self.buffer_duration:
-            # Here you could (for example) encode/store the buffered frames.
-            # For this demo we just clear the buffer every 3 seconds.
-            self.buffer = []
-            self.last_flush_time = now
-        # Return the image unchanged for display
-        return img
+def get_latest_video_path():
+    """
+    Return the path to the latest video if it exists.
+    """
+    return "latest.mp4" if os.path.exists("latest.mp4") else None
 
-# -----------------------------------------------------------------------------
-# Sidebar: Password input for broadcasting. Only if you enter the correct password
-# ("test123") do you get access to the broadcast controls.
-password = st.sidebar.text_input("Enter broadcasting password", type="password")
-if password == "test123":
-    st.sidebar.success("Authenticated for broadcasting!")
-    broadcast_mode = True
-else:
-    broadcast_mode = False
+# Set page configuration
+st.set_page_config(page_title="Temporary File‑Based Live Stream", layout="wide")
+st.title("Temporary File‑Based Live Stream with Streamlit")
 
-# -----------------------------------------------------------------------------
-if broadcast_mode:
-    st.sidebar.header("Broadcast Settings")
-    # (In a real app you might enumerate the actual connected cameras.
-    # Here we simply provide a dummy list of choices.)
-    camera_options = ["Camera 0", "Camera 1", "Camera 2"]
-    camera_choice = st.sidebar.selectbox("Select Camera", camera_options)
-    camera_index = int(camera_choice.split(" ")[-1])
+# Create two tabs: one for broadcasting and one for viewing.
+tabs = st.tabs(["Broadcast", "View"])
 
-    st.write("### You are in **BROADCASTING** mode")
-    st.write("Your live stream is being sent to all viewers.")
+with tabs[0]:
+    st.header("Broadcasting Controls")
+    password_input = st.text_input("Enter broadcast password:", type="password")
+    camera_index_input = st.number_input("Camera Index", min_value=0, value=0, step=1)
+    col1, col2 = st.columns(2)
+    with col1:
+        if st.button("Start Broadcasting"):
+            status = start_broadcast(password_input, camera_index_input)
+            st.info(status)
+    with col2:
+        if st.button("Stop Broadcasting"):
+            status = stop_broadcast()
+            st.info(status)
 
-    # Start the WebRTC streamer in SENDONLY mode (broadcasting).
-    # The same key ("live_stream") is used so that viewers join the same “room.”
-    webrtc_ctx = webrtc_streamer(
-        key="live_stream",
-        mode=WebRtcMode.SENDONLY,
-        video_device_index=camera_index,
-        media_stream_constraints={"video": True, "audio": False},
-        video_transformer_factory=BufferingTransformer,
-        video_html_attrs={
-            "controls": True,
-            "style": {
-                "width": "100%",
-                "border": "2px solid #ccc",
-                "border-radius": "10px",
-            },
-        },
-        rtc_configuration={"iceServers": [{"urls": ["stun:stun.l.google.com:19302"]}]},
-    )
-else:
-    st.write("### Viewing Broadcast")
-    st.info("If you have the broadcasting password, enter it in the sidebar to broadcast your own stream.")
-    # In viewing mode, join the same “room” in RECVONLY mode so you can see the active stream.
-    webrtc_ctx = webrtc_streamer(
-        key="live_stream",
-        mode=WebRtcMode.RECVONLY,
-        media_stream_constraints={"video": True, "audio": False},
-        video_transformer_factory=BufferingTransformer,
-        video_html_attrs={
-            "controls": True,
-            "style": {
-                "width": "100%",
-                "border": "2px solid #ccc",
-                "border-radius": "10px",
-            },
-        },
-        rtc_configuration={"iceServers": [{"urls": ["stun:stun.l.google.com:19302"]}]},
-    )
+with tabs[1]:
+    st.header("Live View")
+    video_path = get_latest_video_path()
+    if video_path:
+        # Automatically refresh the app every 3 seconds to load the latest file.
+        st_autorefresh(interval=3000, key="video_autorefresh")
+        st.video(video_path)
+    else:
+        st.write("No broadcast available yet.")