Work for the srubbing for the Tesla

Author: MrDesjardins

routes/stream.py

@@ -11,6 +11,7 @@
 from services.background_tasks import get_transcription_queue, TranscriptionJob
 from services.database import add_to_history, get_history, clear_history
 from services.path_utils import expand_path
+from services.streaming import get_audio_duration
 from services.youtube import get_video_metadata, extract_video_id
 
 logger = logging.getLogger(__name__)
@@ -181,19 +182,24 @@ def get_audio_file(video_id: str):
 
     if _audio_is_ready(video_id):
         file_size = audio_path.stat().st_size
+        headers = {
+            "Accept-Ranges": "bytes",
+            "Cache-Control": "public, max-age=3600",
+            "Content-Length": str(file_size),
+            "Access-Control-Allow-Origin": "*",
+            "Access-Control-Expose-Headers": "X-Audio-Duration",
+            "Connection": "keep-alive",
+        }
+        duration = get_audio_duration(video_id)
+        if duration is not None:
+            headers["X-Audio-Duration"] = str(duration)
 
         # FileResponse automatically handles streaming, chunking, and seeking (Range headers)
         return FileResponse(
             path=audio_path,
             media_type="audio/mpeg",
             filename=f"{video_id}.mp3",
-            headers={
-                "Accept-Ranges": "bytes",
-                "Cache-Control": "public, max-age=3600",
-                "Content-Length": str(file_size),
-                "Access-Control-Allow-Origin": "*",
-                "Connection": "keep-alive",
-            },
+            headers=headers,
         )
 
     return JSONResponse(
@@ -210,17 +216,18 @@ def check_audio_file(video_id: str):
 
     if _audio_is_ready(video_id):
         file_size = audio_path.stat().st_size
-        return JSONResponse(
-            status_code=200,
-            content={},
-            headers={
-                "Accept-Ranges": "bytes",
-                "Cache-Control": "public, max-age=3600",
-                "Content-Length": str(file_size),
-                "Content-Type": "audio/mpeg",
-                "Access-Control-Allow-Origin": "*",
-            },
-        )
+        headers = {
+            "Accept-Ranges": "bytes",
+            "Cache-Control": "public, max-age=3600",
+            "Content-Length": str(file_size),
+            "Content-Type": "audio/mpeg",
+            "Access-Control-Allow-Origin": "*",
+            "Access-Control-Expose-Headers": "X-Audio-Duration",
+        }
+        duration = get_audio_duration(video_id)
+        if duration is not None:
+            headers["X-Audio-Duration"] = str(duration)
+        return JSONResponse(status_code=200, content={}, headers=headers)
 
     return JSONResponse(status_code=404, content={}, headers={"Retry-After": "2"})
 

services/streaming.py

@@ -4,9 +4,11 @@
 Downloads audio from YouTube using yt-dlp and saves as MP3.
 """
 
+import json
 import logging
 import os
 import subprocess
+from typing import Optional
 
 from services.cache import get_audio_cache
 from services.path_utils import expand_path, expand_path_str
@@ -15,6 +17,41 @@
 logger = logging.getLogger(__name__)
 config = get_config()
 
+_audio_duration_cache: dict[str, float] = {}
+
+
+def get_audio_duration(youtube_video_id: str) -> Optional[float]:
+    """Return duration in seconds from ffprobe. Cached per session."""
+    if youtube_video_id in _audio_duration_cache:
+        return _audio_duration_cache[youtube_video_id]
+
+    audio_path = expand_path(config.get_audio_path(youtube_video_id))
+    if not audio_path.exists():
+        return None
+
+    try:
+        result = subprocess.run(
+            [
+                "ffprobe",
+                "-v",
+                "quiet",
+                "-print_format",
+                "json",
+                "-show_format",
+                str(audio_path),
+            ],
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+        data = json.loads(result.stdout)
+        duration = float(data["format"]["duration"])
+        _audio_duration_cache[youtube_video_id] = duration
+        return duration
+    except Exception as e:
+        logger.warning(f"ffprobe failed for {youtube_video_id}: {e}")
+        return None
+
 
 def _get_download_marker(youtube_video_id: str) -> str:
     """Get the path for the download-in-progress marker file."""

static/app.js

@@ -12,6 +12,7 @@ let currentVideoId = null;
 let currentQueueId = null;
 let isPlaying = false;
 let currentTrackTitle = null;
+let serverAudioDuration = null; // Authoritative duration from server (ffprobe)
 const defaultTitle = 'YouTube Radio';
 
 // Prefetch configuration
@@ -176,6 +177,11 @@ async function waitForAudioFile(videoId, maxWaitSeconds = 60) {
 
             if (response.ok) {
                 console.log(`Audio file ready after ${attemptCount} attempts (${Date.now() - startTime}ms)`);
+                const durationHeader = response.headers.get('X-Audio-Duration');
+                if (durationHeader) {
+                    serverAudioDuration = parseFloat(durationHeader);
+                    remoteLog('log', '[MediaSession] Server audio duration', { duration: serverAudioDuration });
+                }
                 return true;
             }
 
@@ -513,25 +519,27 @@ function updatePositionState() {
         return;
     }
 
-    // Validate that we have a valid duration
-    if (!player.duration || isNaN(player.duration) || !isFinite(player.duration) || player.duration <= 0) {
-        return;
-    }
+    // Use server duration as authoritative fallback when browser reports NaN/Infinity
+    const duration = (player.duration && !isNaN(player.duration) && isFinite(player.duration) && player.duration > 0)
+        ? player.duration
+        : serverAudioDuration;
+
+    if (!duration) return;
 
     try {
         // Clamp position to be within valid range [0, duration]
-        const position = Math.min(Math.max(0, player.currentTime || 0), player.duration);
+        const position = Math.min(Math.max(0, player.currentTime || 0), duration);
         const playbackRate = player.playbackRate || 1.0;
 
         // All parameters must be valid: duration > 0, position >= 0 && position <= duration, playbackRate != 0
         navigator.mediaSession.setPositionState({
-            duration: player.duration,
+            duration: duration,
             playbackRate: playbackRate,
             position: position
         });
 
         remoteLog('log', '[MediaSession] Position state updated', {
-            duration: player.duration,
+            duration: duration,
             position: position,
             playbackRate: playbackRate
         });
@@ -889,6 +897,7 @@ async function startStreamFromQueue(youtube_video_id, queue_id) {
 
             // Wait for audio file to be ready before playing
             showStreamStatus('Starting download from YouTube...');
+            serverAudioDuration = null; // Reset for new track
             const fileReady = await waitForAudioFile(data.youtube_video_id, 60);
 
             if (!fileReady) {
@@ -1582,6 +1591,7 @@ async function startStream() {
 
             // Wait for audio file to be ready before playing
             showStreamStatus('Starting download from YouTube...');
+            serverAudioDuration = null; // Reset for new track
             const fileReady = await waitForAudioFile(youtube_video_id, 60);
 
             if (!fileReady) {

templates/index.html

@@ -218,7 +218,7 @@ <h2>
     <script src="/static/update-checker.js?v=1737842302"></script>
 
     <!-- Main Application Script -->
-    <script src="/static/app.js?v=1770739501"></script>
+    <script src="/static/app.js?v=1770739502"></script>
 </body>
 
 </html>