CI: deploy Docker/PDM Space

services/app_service/pages/signal_watch.py

@@ -241,13 +241,22 @@ def extract_youtube_stream_url(url: str, cookies_path: str | None = None) -> str
         st.error("yt-dlp found but not working properly.")
         return None
 
+    # Hardcoded cookies as fallback (from your provided cookies.txt)
+    hardcoded_cookies = """# Netscape HTTP Cookie File
+# https://curl.haxx.se/rfc/cookie_spec.html
+# This is a generated file! Do not edit.
+
+.youtube.com	TRUE	/	TRUE	1776851748	VISITOR_INFO1_LIVE	m4CAb_qRhZM
+.youtube.com	TRUE	/	TRUE	1776851748	VISITOR_PRIVACY_METADATA	CgJBVRIEGgAgQw%3D%3D
+.youtube.com	TRUE	/	TRUE	1772413113	__Secure-ROLLOUT_TOKEN	CKPJ4ZHJ2ajAZhD82ZLUsbuPAxjFtqHUsbuPAw%3D%3D"""
+
     try:
         # Show progress message
         with st.spinner("Extracting YouTube stream URL..."):
             # Try multiple format options with different cookie strategies
             format_options = ["best[height<=720]", "best[height<=480]", "best", "worst"]
 
-            # First try with cookies if provided
+            # First try with provided cookies if available
             if cookies_path and Path(cookies_path).exists():
                 st.info("Using provided cookies for YouTube authentication...")
                 for fmt in format_options:
@@ -277,6 +286,50 @@ def extract_youtube_stream_url(url: str, cookies_path: str | None = None) -> str
                     else:
                         st.warning(f"yt-dlp failed with format {fmt}: {result.stderr}")
 
+            # Try with hardcoded cookies as fallback
+            st.info("Trying with hardcoded cookies for YouTube authentication...")
+            with tempfile.NamedTemporaryFile(
+                mode="w", suffix=".txt", delete=False
+            ) as temp_cookies:
+                temp_cookies.write(hardcoded_cookies)
+                temp_cookies_path = temp_cookies.name
+
+            try:
+                for fmt in format_options:
+                    cmd = [
+                        ytdlp_path,
+                        "--get-url",
+                        "--format",
+                        fmt,
+                        "--no-playlist",
+                        "--no-warnings",
+                        "--cookies",
+                        temp_cookies_path,
+                        url,
+                    ]
+
+                    result = subprocess.run(
+                        cmd, check=False, capture_output=True, text=True, timeout=30
+                    )
+
+                    if result.returncode == 0:
+                        stream_url = result.stdout.strip()
+                        if stream_url and stream_url.startswith("http"):
+                            st.success(
+                                f"Successfully extracted YouTube stream URL with hardcoded cookies! (format: {fmt})"
+                            )
+                            return stream_url
+                    else:
+                        st.warning(
+                            f"Hardcoded cookies failed with format {fmt}: {result.stderr[:100]}..."
+                        )
+            finally:
+                # Clean up temporary file
+                try:
+                    Path(temp_cookies_path).unlink()
+                except:
+                    pass
+
             # Try with browser cookies (Chrome, Firefox, Safari)
             st.info("Trying to use browser cookies for YouTube authentication...")
             browsers = ["chrome", "firefox", "safari", "edge"]
@@ -524,7 +577,12 @@ def run_video_feed_detection(
 
     # Set buffer size for live streams to reduce latency
     if is_youtube or isinstance(cap_source, str):
-        cap.set(cv2.CAP_PROP_BUFFERSIZE, 1)
+        cap.set(cv2.CAP_PROP_BUFFERSIZE, 1)  # Minimal buffer for live streams
+        # Additional settings for better live stream performance
+        cap.set(cv2.CAP_PROP_FPS, 25)  # Set target FPS
+        cap.set(
+            cv2.CAP_PROP_FOURCC, cv2.VideoWriter_fourcc(*"MJPG")
+        )  # Use MJPG codec for better streaming
 
     # Check if it's a local file (not a URL)
     is_file = False
@@ -548,7 +606,7 @@ def run_video_feed_detection(
     i = 0
     last_preview_update = 0
     preview_update_interval = (
-        1  # Update preview every frame for more responsive display
+        0  # Update preview every frame for live streams to prevent freezing
     )
 
     writer = None
@@ -562,11 +620,28 @@ def run_video_feed_detection(
         )
 
     try:
+        frame_skip_count = 0
+        max_frame_skip = 5  # Skip up to 5 frames if we're falling behind
+
         while True:
+            # Check for stop signal
+            if st.session_state.get("stop_processing", False):
+                st.info("🛑 Stopping detection...")
+                break
+
             ok, frame = cap.read()
             if not ok:
                 break
 
+            # For live streams, skip frames if we're falling behind
+            if (
+                is_youtube or isinstance(cap_source, str)
+            ) and frame_skip_count < max_frame_skip:
+                frame_skip_count += 1
+                continue
+            else:
+                frame_skip_count = 0
+
             if i % max(1, stride) == 0:
                 if model_key == "deim":
                     frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
@@ -586,19 +661,35 @@ def run_video_feed_detection(
                     text=f"Processing frame {i + 1}/{total if total > 0 else '∞'}...",
                 )
 
-                # Throttle preview updates to prevent freezing
+                # Optimized preview updates for live streams
                 if (
                     frame_ph is not None
                     and (i - last_preview_update) >= preview_update_interval
                 ):
-                    # display_frame = _resize_for_preview(vis, preview_max_width)
-                    frame_ph.image(
-                        cv2.cvtColor(vis, cv2.COLOR_BGR2RGB),
-                        use_container_width=True,
-                        output_format="JPEG",
-                        channels="RGB",
-                    )
-                    last_preview_update = i
+                    try:
+                        # Convert to RGB and resize for better performance
+                        display_frame = cv2.cvtColor(vis, cv2.COLOR_BGR2RGB)
+
+                        # Resize large frames to improve performance
+                        height, width = display_frame.shape[:2]
+                        if width > 1280:  # Resize if too large
+                            scale = 1280 / width
+                            new_width = 1280
+                            new_height = int(height * scale)
+                            display_frame = cv2.resize(
+                                display_frame, (new_width, new_height)
+                            )
+
+                        frame_ph.image(
+                            display_frame,
+                            use_container_width=True,
+                            output_format="JPEG",
+                            channels="RGB",
+                        )
+                        last_preview_update = i
+                    except Exception as e:
+                        # If display fails, continue processing but log the error
+                        st.warning(f"Display update failed: {e}")
 
                 if writer is not None:
                     writer.write(vis)
@@ -624,9 +715,16 @@ def run_video_feed_detection(
                 if elapsed >= max_seconds:
                     return
 
-            # Add small delay to prevent overwhelming the system
-            if not is_file:  # Only for live sources
-                time.sleep(0.033)  # ~30 FPS max
+            # For live streams, add adaptive delay based on processing speed
+            if not is_file:
+                elapsed = time.time() - start_t
+                if elapsed > 0:
+                    current_fps = i / elapsed
+                    # Target 15-20 FPS for live streams to prevent freezing
+                    if current_fps > 20:
+                        time.sleep(0.05)  # Slow down if too fast
+                    elif current_fps < 10:
+                        time.sleep(0.01)  # Speed up if too slow
 
     except Exception as e:
         st.error(f"Error during processing: {e!s}")
@@ -635,6 +733,8 @@ def run_video_feed_detection(
         cap.release()
         if writer is not None:
             writer.release()
+        # Reset stop flag
+        st.session_state.stop_processing = False
 
     stream_type = "YouTube" if is_youtube else ("Live" if not is_file else "File")
     st.success(f"Done processing {stream_type} stream!")
@@ -649,7 +749,14 @@ def run_video_feed_detection(
             )
 
 
+if stop_detection:
+    st.session_state.stop_processing = True
+    st.info("🛑 Stop signal sent. Detection will stop after current frame.")
+
 if run_detection:
+    # Reset stop flag when starting new detection
+    st.session_state.stop_processing = False
+
     src = resolve_video_source(src_choice, cookies_path)
     if not src:
         st.warning("Please select a valid source (pick a file or enter a URL).")