stream_server.py

import os
import subprocess
import pathlib
# from fastapi import HTTPException
import asyncio

# Define base directories
BASE_DIR = pathlib.Path('./videos').resolve()
HLS_DIR = pathlib.Path('./hls_videos').resolve()
HLS_DIR.mkdir(exist_ok=True)


# Keep track of video names added to the queue
video_names = []
segment_counter = 1
total_processed_duration = 0
segment_lock = asyncio.Lock()

def is_valid_path(video_name):
    """
    Validates the video path to prevent directory traversal attacks.

    Args:
        video_name (str): Name of the video file.

    Returns:
        bool: True if valid, False otherwise.
    """
    video_path = (BASE_DIR / video_name).resolve()
    return str(video_path).startswith(str(BASE_DIR))

def convert_to_hls(input_file, output_playlist, segment_prefix='segment', segment_duration=10):
    """
    Converts an MP4 file to HLS .ts segments, maintaining continuity characteristics across segments.

    :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.
    """
    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',
        '-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'{HLS_DIR}/{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:
        # 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:
        print(f"Error during conversion: {e}")
    except Exception as e:
        print(f"An unexpected error occurred: {e}")



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):
    """
    Concatenates multiple HLS playlists into a single playlist with unique segment numbering.

    Args:
        video_names (list): List of video names added to the queue.
        base_dir (str): Base directory where HLS files are stored.
        request (Request): FastAPI request object to extract base URL.
    """
    concatenated_playlist_path = os.path.join(base_dir, 'master.m3u8')
    max_segment_duration = 3  # Since we set hls_time to 3
    segment_lines = []  # To store segment lines

    # Construct base URL from the incoming request
    

    for video_name in video_names:
        video_playlist_path = os.path.join(base_dir, f'{video_name}.m3u8')
        if os.path.exists(video_playlist_path):
            with open(video_playlist_path, 'r') as infile:
                lines = infile.readlines()
                for line in lines:
                    line = line.strip()
                    if line.startswith('#EXTINF'):
                        # Append EXTINF line
                        segment_lines.append(line)
                    elif line.endswith('.ts'):
                        segment_file = line
                        # Update segment URI to include full URL
                        segment_path = f'{segment_file}'
                        segment_lines.append(segment_path)
                    elif line.startswith('#EXT-X-BYTERANGE'):
                        # Include byte range if present
                        segment_lines.append(line)
                    elif line.startswith('#EXT-X-ENDLIST'):
                        # Do not include this here; we'll add it at the end
                        continue
                    elif line.startswith('#EXTM3U') or line.startswith('#EXT-X-VERSION') or line.startswith('#EXT-X-PLAYLIST-TYPE') or line.startswith('#EXT-X-TARGETDURATION') or line.startswith('#EXT-X-MEDIA-SEQUENCE'):
                        # Skip these tags; they'll be added in the concatenated playlist
                        continue
                    else:
                        # Include any other necessary tags
                        segment_lines.append(line)

    # Write the concatenated playlist
    with open(concatenated_playlist_path, 'w') as outfile:
        outfile.write('#EXTM3U\n')
        outfile.write('#EXT-X-PLAYLIST-TYPE:VOD\n')
        outfile.write(f'#EXT-X-TARGETDURATION:{max_segment_duration}\n')
        outfile.write('#EXT-X-VERSION:4\n')
        outfile.write(f'#EXT-X-MEDIA-SEQUENCE:{1}\n')  # Starting from segment number 1
        for line in segment_lines:
            outfile.write(f'{line}\n')
        outfile.write('#EXT-X-ENDLIST\n')

def generate_m3u8(video_duration, output_path,segment_duration=3):
    # Initialize playlist content
    m3u8_content = "#EXTM3U\n"
    m3u8_content += "#EXT-X-PLAYLIST-TYPE:VOD\n"
    m3u8_content += f"#EXT-X-TARGETDURATION:{segment_duration}\n"
    m3u8_content += "#EXT-X-VERSION:4\n"
    m3u8_content += "#EXT-X-MEDIA-SEQUENCE:1\n"
    
    # # Calculate the number of full segments and the remaining duration

    # segment_duration = int(segment_duration)
    # full_segments = int(video_duration // segment_duration)
    # remaining_duration = video_duration % segment_duration

    # # Add full segments to the playlist
    # for i in range(full_segments):
    #     m3u8_content += f"#EXTINF:{segment_duration:.6f},\n"
    #     m3u8_content += f"/live_stream/video_stream{i + 1}.ts\n"

    # # Add the remaining segment if there's any leftover duration
    # if remaining_duration > 0:
    #     m3u8_content += f"#EXTINF:{remaining_duration:.6f},\n"
    #     m3u8_content += f"/live_stream/video_stream{full_segments + 1}.ts\n"

    # # End the playlist
    # m3u8_content += "#EXT-X-ENDLIST\n"
    with open(output_path, "w") as file:
        file.write(m3u8_content)    

    print(f"M3U8 playlist saved to {output_path}")