Update stream_server.py

stream_server.py

@@ -29,114 +29,51 @@ def is_valid_path(video_name):
     video_path = (BASE_DIR / video_name).resolve()
     return str(video_path).startswith(str(BASE_DIR))
 
-def convert_to_hls(input_path, output_dir, video_name, start_number):
+def convert_to_hls(input_file, output_playlist, segment_prefix='segment', segment_duration=10):
     """
-    Converts an MP4 video to HLS format with 3-second segments starting from `start_number`.
+    Converts an MP4 file to HLS .ts segments, maintaining continuity characteristics across segments.
 
-    Args:
-        input_path (str): Path to the input MP4 video.
-        output_dir (str): Directory where HLS files will be stored.
-        video_name (str): Name of the video (used for playlist naming).
-        start_number (int): The starting number for HLS segments.
-
-    Returns:
-        int: Number of segments generated.
+    :param input_file: Path to the input MP4 file.
+    :param output_playlist: Path to the output .m3u8 playlist file.
+    :param segment_prefix: Prefix for naming the .ts segments. Default is 'segment'.
+    :param segment_duration: Duration of each segment in seconds. Default is 10 seconds.
     """
-    # FFmpeg command to convert MP4 to HLS with 3-second segments
-    cmd = [
+    if not os.path.exists(input_file):
+        raise FileNotFoundError(f"Input file '{input_file}' does not exist.")
+
+    # FFmpeg command to convert MP4 to HLS segments
+    os.chmod(input_file, 0o644)  # Change permission to read/write for the user
+    
+    command = [
         'ffmpeg',
-        '-y',  # Overwrite output files without asking
-        '-i', input_path,  # Input file
-        #'-codec', 'copy',  # Audio codec-vf scale=1280:720 -r 30 -c:v libx264 -b:v 1500k -c:a aac -b:a 128k
-        '-vf','scale=1280:720',
-        '-r','30',
-        '-c:v','libx264',
-        '-b:v','1500k',
-        '-c:a','aac',
-        '-b:a','128k',
-        '-hls_time', '3',  # Segment duration in seconds
-        '-hls_playlist_type', 'vod',  # Video on Demand playlist type
-        '-start_number', str(start_number),  # Starting segment number
-        '-hls_segment_filename', os.path.join(output_dir, 'video_stream%d.ts'),  # Segment file naming
-        os.path.join(output_dir, f'{video_name}.m3u8')  # Output playlist
+        '-i', input_file,                    # Input MP4 file
+        '-c:v', 'libx264',                   # Video codec, consistent across all segments
+        '-c:a', 'aac',                       # Audio codec, consistent across all segments
+        '-strict', '-2',                     # Strict flag for AAC codec
+        '-flags', '-global_header',          # Set global header flag for consistency
+        '-hls_time', str(segment_duration),  # Segment duration in seconds
+        '-hls_list_size', '0',               # Keep all segments in the playlist
+        '-hls_flags', 'append_list+omit_endlist+program_date_time',  # Flags to maintain continuity
+        '-hls_segment_type', 'mpegts',       # Ensure the segment type is TS
+        '-hls_segment_filename', f'{segment_prefix}%d.ts',  # Naming pattern for the .ts segments
+        '-force_key_frames', f'expr:gte(t,n_forced*{segment_duration})',  # Force keyframes for segment duration consistency
+        '-avoid_negative_ts', 'make_zero',   # Avoid negative timestamps
+        output_playlist                      # Output .m3u8 playlist file
     ]
 
     try:
-        # Execute the FFmpeg command
-        subprocess.run(cmd, check=True, stderr=subprocess.PIPE)
+        # Run the FFmpeg command
+        subprocess.run(command, check=True)
+        print(f"Successfully converted '{input_file}' to HLS segments with playlist '{output_playlist}'.")
     except subprocess.CalledProcessError as e:
-        # Log FFmpeg errors and raise an HTTP exception
-        error_message = e.stderr.decode()
-        print(f"FFmpeg error: {error_message}")
-        raise HTTPException(status_code=500, detail="Video conversion failed")
-
-
-
-async def add_video(video_name, output_path, audio_duration):
-    """
-    Endpoint to add a video to the streaming queue.
-
-    Args:
-        video_name (str): Name of the video file to add.
-        request (Request): FastAPI request object to extract base URL.
+        print(f"Error during conversion: {e}")
+    except Exception as e:
+        print(f"An unexpected error occurred: {e}")
 
-    Returns:
-        dict: Success message.
-    """
-    global total_processed_duration
-    print((HLS_DIR / f'{video_name}.m3u8').exists())
-    if not (HLS_DIR / f'{video_name}.m3u8').exists():
-        async with segment_lock:
-            global segment_counter
-            current_start_number = segment_counter
-            num_segments_before = len([f for f in os.listdir(HLS_DIR) if f.startswith('video_stream') and f.endswith('.ts')])
-            await asyncio.get_event_loop().run_in_executor(
-                None, convert_to_hls, str(video_name), str(HLS_DIR), video_name, current_start_number
-            )
-            num_segments_after = len([f for f in os.listdir(HLS_DIR) if f.startswith('video_stream') and f.endswith('.ts')])
-            num_new_segments = num_segments_after - num_segments_before
-            # Update the global segment counter
-            segment_counter += num_new_segments
-
-    video_names.append(video_name)
-    segment_duration = 3
-    full_segments = int(audio_duration // segment_duration)
-    remaining_duration = audio_duration % segment_duration
-    
-    existing_segments = set()
-    if output_path:
-        with open(output_path, 'r') as m3u8_file:
-            for line in m3u8_file:
-                if line.startswith('/live_stream/video_stream'):
-                    existing_segments.add(line.strip())
-
-    new_segments = []
-    # Generate new segment paths
-    for i in range(1, full_segments + 1):
-        new_segment_path = f"/live_stream/video_stream{i}.ts"
-        if new_segment_path not in existing_segments:
-            new_segments.append(new_segment_path)
-            total_processed_duration += segment_duration
 
-    
-    with open(output_path, 'a') as m3u8_file:
-        for segment in new_segments:
-            m3u8_file.write(f"#EXTINF:{segment_duration:.3f},\n")
-            m3u8_file.write(f"{segment}\n")
-
-        if remaining_duration > 0:
-            remaining_segment_path = f"/live_stream/video_stream{full_segments + 1}.ts"
-            if remaining_segment_path not in existing_segments:
-                m3u8_file.write(f"#EXTINF:{remaining_duration:.3f},\n")
-                m3u8_file.write(f"{remaining_segment_path}\n")
-                total_processed_duration += remaining_duration          
-
-    # Add #EXT-X-ENDLIST only once after all segments have been added
-    if total_processed_duration == audio_duration:
-        with open(output_path, 'a') as m3u8_file:
-            m3u8_file.write("#EXT-X-ENDLIST\n")
-            total_processed_duration = 0
 
+def add_video(video_name, output_path, audio_duration):
+    convert_to_hls(video_name, output_path, segment_duration=audio_duration)
     return {"message": f'"{video_name}" added to the streaming queue.'}
 
 async def concatenate_playlists(video_names, base_dir):