update

mediaflow_proxy/mpd_processor.py

@@ -5,17 +5,39 @@ import time
 
 from fastapi import Request, Response, HTTPException
 
-from mediaflow_proxy.drm.decrypter import decrypt_segment
+from mediaflow_proxy.drm.decrypter import decrypt_segment, process_drm_init_segment
 from mediaflow_proxy.utils.crypto_utils import encryption_handler
-from mediaflow_proxy.utils.http_utils import encode_mediaflow_proxy_url, get_original_scheme, ProxyRequestHeaders
+from mediaflow_proxy.utils.http_utils import (
+    encode_mediaflow_proxy_url,
+    get_original_scheme,
+    ProxyRequestHeaders,
+    apply_header_manipulation,
+)
 from mediaflow_proxy.utils.dash_prebuffer import dash_prebuffer
+from mediaflow_proxy.utils.cache_utils import get_cached_processed_init, set_cached_processed_init
+from mediaflow_proxy.utils.m3u8_processor import SkipSegmentFilter
+from mediaflow_proxy.remuxer.ts_muxer import remux_fmp4_to_ts
 from mediaflow_proxy.configs import settings
 
 logger = logging.getLogger(__name__)
 
 
+def _resolve_ts_mode(request: Request) -> bool:
+    """Resolve the effective TS remux mode from the request query params, falling back to settings."""
+    override = request.query_params.get("remux_to_ts")
+    if override is not None:
+        return override.lower() in ("true", "1", "yes")
+    return settings.remux_to_ts
+
+
 async def process_manifest(
-    request: Request, mpd_dict: dict, proxy_headers: ProxyRequestHeaders, key_id: str = None, key: str = None
+    request: Request,
+    mpd_dict: dict,
+    proxy_headers: ProxyRequestHeaders,
+    key_id: str = None,
+    key: str = None,
+    resolution: str = None,
+    skip_segments: list = None,
 ) -> Response:
     """
     Processes the MPD manifest and converts it to an HLS manifest.
@@ -26,12 +48,14 @@ async def process_manifest(
         proxy_headers (ProxyRequestHeaders): The headers to include in the request.
         key_id (str, optional): The DRM key ID. Defaults to None.
         key (str, optional): The DRM key. Defaults to None.
+        resolution (str, optional): Target resolution (e.g., '1080p', '720p'). Defaults to None.
+        skip_segments (list, optional): List of time segments to skip. Each item should have 'start' and 'end' keys.
 
     Returns:
         Response: The HLS manifest as an HTTP response.
     """
-    hls_content = build_hls(mpd_dict, request, key_id, key)
-    
+    hls_content = build_hls(mpd_dict, request, key_id, key, resolution, skip_segments)
+
     # Start DASH pre-buffering in background if enabled
     if settings.enable_dash_prebuffer:
         # Extract headers for pre-buffering
@@ -39,20 +63,23 @@ async def process_manifest(
         for key, value in request.query_params.items():
             if key.startswith("h_"):
                 headers[key[2:]] = value
-        
+
         # Get the original MPD URL from the request
         mpd_url = request.query_params.get("d", "")
         if mpd_url:
             # Start pre-buffering in background
-            asyncio.create_task(
-                dash_prebuffer.prebuffer_dash_manifest(mpd_url, headers)
-            )
-    
+            asyncio.create_task(dash_prebuffer.prebuffer_dash_manifest(mpd_url, headers))
+
     return Response(content=hls_content, media_type="application/vnd.apple.mpegurl", headers=proxy_headers.response)
 
 
 async def process_playlist(
-    request: Request, mpd_dict: dict, profile_id: str, proxy_headers: ProxyRequestHeaders
+    request: Request,
+    mpd_dict: dict,
+    profile_id: str,
+    proxy_headers: ProxyRequestHeaders,
+    skip_segments: list = None,
+    start_offset: float = None,
 ) -> Response:
     """
     Processes the MPD manifest and converts it to an HLS playlist for a specific profile.
@@ -62,6 +89,8 @@ async def process_playlist(
         mpd_dict (dict): The MPD manifest data.
         profile_id (str): The profile ID to generate the playlist for.
         proxy_headers (ProxyRequestHeaders): The headers to include in the request.
+        skip_segments (list, optional): List of time segments to skip. Each item should have 'start' and 'end' keys.
+        start_offset (float, optional): Start offset in seconds for live streams.
 
     Returns:
         Response: The HLS playlist as an HTTP response.
@@ -73,8 +102,22 @@ async def process_playlist(
     if not matching_profiles:
         raise HTTPException(status_code=404, detail="Profile not found")
 
-    hls_content = build_hls_playlist(mpd_dict, matching_profiles, request)
-    return Response(content=hls_content, media_type="application/vnd.apple.mpegurl", headers=proxy_headers.response)
+    hls_content = build_hls_playlist(mpd_dict, matching_profiles, request, skip_segments, start_offset)
+
+    # Trigger prebuffering of upcoming segments for live streams
+    if settings.enable_dash_prebuffer and mpd_dict.get("isLive", False):
+        # Extract headers for pre-buffering
+        headers = {}
+        for key, value in request.query_params.items():
+            if key.startswith("h_"):
+                headers[key[2:]] = value
+
+        # Use the new prefetch method for live playlists
+        asyncio.create_task(dash_prebuffer.prefetch_for_live_playlist(matching_profiles, headers))
+
+    # Don't include propagate headers for playlists - they should only apply to segments
+    response_headers = apply_header_manipulation({}, proxy_headers, include_propagate=False)
+    return Response(content=hls_content, media_type="application/vnd.apple.mpegurl", headers=response_headers)
 
 
 async def process_segment(
@@ -84,9 +127,11 @@ async def process_segment(
     proxy_headers: ProxyRequestHeaders,
     key_id: str = None,
     key: str = None,
+    use_map: bool = False,
+    remux_ts: bool = None,
 ) -> Response:
     """
-    Processes and decrypts a media segment.
+    Processes and decrypts a media segment, optionally remuxing to MPEG-TS.
 
     Args:
         init_content (bytes): The initialization segment content.
@@ -95,23 +140,110 @@ async def process_segment(
         proxy_headers (ProxyRequestHeaders): The headers to include in the request.
         key_id (str, optional): The DRM key ID. Defaults to None.
         key (str, optional): The DRM key. Defaults to None.
+        use_map (bool, optional): If True, init segment is served separately via EXT-X-MAP,
+            so don't concatenate init with segment. Defaults to False.
+        remux_ts (bool, optional): If True, remux fMP4 to MPEG-TS. Defaults to settings.remux_to_ts.
 
     Returns:
-        Response: The decrypted segment as an HTTP response.
+        Response: The processed segment as an HTTP response.
     """
     if key_id and key:
         # For DRM protected content
         now = time.time()
-        decrypted_content = decrypt_segment(init_content, segment_content, key_id, key)
+        decrypted_content = decrypt_segment(init_content, segment_content, key_id, key, include_init=not use_map)
         logger.info(f"Decryption of {mimetype} segment took {time.time() - now:.4f} seconds")
     else:
-        # For non-DRM protected content, we just concatenate init and segment content
-        decrypted_content = init_content + segment_content
+        # For non-DRM protected content
+        if use_map:
+            # Init is served separately via EXT-X-MAP
+            decrypted_content = segment_content
+        else:
+            # Concatenate init and segment content
+            decrypted_content = init_content + segment_content
 
-    return Response(content=decrypted_content, media_type=mimetype, headers=proxy_headers.response)
+    # Check if we should remux to TS
+    should_remux = remux_ts if remux_ts is not None else settings.remux_to_ts
+
+    # Remux both video and audio to MPEG-TS for proper HLS TS playback
+    if should_remux and ("video" in mimetype or "audio" in mimetype):
+        # Remux fMP4 to MPEG-TS for ExoPlayer/VLC compatibility
+        now = time.time()
+        try:
+            # For TS remuxing, we always need init_content for codec config
+            # preserve_timestamps=True keeps the original tfdt timestamps from the
+            # fMP4 segment, ensuring continuous playback across HLS segments
+            ts_content = remux_fmp4_to_ts(
+                init_content,
+                decrypted_content,
+                preserve_timestamps=True,
+            )
+            decrypted_content = ts_content
+            mimetype = "video/mp2t"  # Update MIME type for TS (same for audio-only TS)
+            logger.info(f"TS remuxing took {time.time() - now:.4f} seconds")
+        except Exception as e:
+            logger.warning(f"TS remuxing failed, returning fMP4: {e}")
+            # Fall through to return original content
+
+    response_headers = apply_header_manipulation({}, proxy_headers)
+    return Response(content=decrypted_content, media_type=mimetype, headers=response_headers)
 
 
-def build_hls(mpd_dict: dict, request: Request, key_id: str = None, key: str = None) -> str:
+async def process_init_segment(
+    init_content: bytes,
+    mimetype: str,
+    proxy_headers: ProxyRequestHeaders,
+    key_id: str = None,
+    key: str = None,
+    init_url: str = None,
+) -> Response:
+    """
+    Processes an initialization segment for EXT-X-MAP.
+
+    Args:
+        init_content (bytes): The initialization segment content.
+        mimetype (str): The MIME type of the segment.
+        proxy_headers (ProxyRequestHeaders): The headers to include in the request.
+        key_id (str, optional): The DRM key ID. Defaults to None.
+        key (str, optional): The DRM key. Defaults to None.
+        init_url (str, optional): The init URL for caching. Defaults to None.
+
+    Returns:
+        Response: The processed init segment as an HTTP response.
+    """
+    if key_id and key:
+        # Check if we have a cached processed version
+        if init_url:
+            cached_processed = await get_cached_processed_init(init_url, key_id)
+            if cached_processed:
+                logger.debug(f"Using cached processed init segment for {init_url}")
+                response_headers = apply_header_manipulation({}, proxy_headers)
+                return Response(content=cached_processed, media_type=mimetype, headers=response_headers)
+
+        # For DRM protected content, we need to process the init segment
+        # to remove encryption-related boxes but keep the moov structure
+        now = time.time()
+        processed_content = process_drm_init_segment(init_content, key_id, key)
+        logger.info(f"Processing of {mimetype} init segment took {time.time() - now:.4f} seconds")
+
+        # Cache the processed init segment
+        if init_url:
+            await set_cached_processed_init(init_url, key_id, processed_content, ttl=3600)
+    else:
+        # For non-DRM protected content, just return the init segment as-is
+        processed_content = init_content
+
+    response_headers = apply_header_manipulation({}, proxy_headers)
+    return Response(content=processed_content, media_type=mimetype, headers=response_headers)
+
+
+def build_hls(
+    mpd_dict: dict,
+    request: Request,
+    key_id: str = None,
+    key: str = None,
+    resolution: str = None,
+    skip_segments: list = None,
+) -> str:
     """
     Builds an HLS manifest from the MPD manifest.
 
@@ -120,12 +252,23 @@ def build_hls(mpd_dict: dict, request: Request, key_id: str = None, key: str = N
         request (Request): The incoming HTTP request.
         key_id (str, optional): The DRM key ID. Defaults to None.
         key (str, optional): The DRM key. Defaults to None.
+        resolution (str, optional): Target resolution (e.g., '1080p', '720p'). Defaults to None.
+        skip_segments (list, optional): List of time segments to skip. Each item should have 'start' and 'end' keys.
 
     Returns:
         str: The HLS manifest as a string.
     """
-    hls = ["#EXTM3U", "#EXT-X-VERSION:6"]
+    is_ts_mode = _resolve_ts_mode(request)
+    # Use HLS v3 for TS (ExoPlayer compatibility), v6 for fMP4
+    version = 3 if is_ts_mode else 6
+    hls = ["#EXTM3U", f"#EXT-X-VERSION:{version}"]
     query_params = dict(request.query_params)
+
+    # Preserve skip parameter in query params so it propagates to playlists
+    if skip_segments:
+        # Convert back to compact format for URL
+        skip_str = ",".join(f"{s['start']}-{s['end']}" for s in skip_segments)
+        query_params["skip"] = skip_str
     has_encrypted = query_params.pop("has_encrypted", False)
 
     video_profiles = {}
@@ -148,26 +291,113 @@ def build_hls(mpd_dict: dict, request: Request, key_id: str = None, key: str = N
         elif "audio" in profile["mimeType"]:
             audio_profiles[profile["id"]] = (profile, playlist_url)
 
+    # Filter video profiles by resolution if specified
+    if resolution and video_profiles:
+        video_profiles = _filter_video_profiles_by_resolution(video_profiles, resolution)
+
+    # For TS mode, only expose the highest quality video variant
+    # ExoPlayer handles adaptive switching poorly with TS remuxing
+    if is_ts_mode and video_profiles:
+        max_height = max(p[0].get("height", 0) for p in video_profiles.values())
+        video_profiles = {k: v for k, v in video_profiles.items() if v[0].get("height", 0) >= max_height}
+
     # Add audio streams
     for i, (profile, playlist_url) in enumerate(audio_profiles.values()):
         is_default = "YES" if i == 0 else "NO"  # Set the first audio track as default
+        lang = profile.get("lang", "und")
+        bandwidth = profile.get("bandwidth", "128000")
+        name = f"Audio {lang} ({bandwidth})" if lang != "und" else f"Audio {i + 1} ({bandwidth})"
         hls.append(
-            f'#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="audio",NAME="{profile["id"]}",DEFAULT={is_default},AUTOSELECT={is_default},LANGUAGE="{profile.get("lang", "und")}",URI="{playlist_url}"'
+            f'#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="audio",NAME="{name}",DEFAULT={is_default},AUTOSELECT=YES,LANGUAGE="{lang}",URI="{playlist_url}"'
         )
 
+    # Build combined codecs string (video + audio) for EXT-X-STREAM-INF
+    # ExoPlayer requires CODECS to list all codecs when AUDIO group is referenced
+    first_audio_codec = None
+    if audio_profiles:
+        first_audio_profile = next(iter(audio_profiles.values()))[0]
+        first_audio_codec = first_audio_profile.get("codecs", "")
+
     # Add video streams
     for profile, playlist_url in video_profiles.values():
         # Only add AUDIO attribute if there are audio profiles available
         audio_attr = ',AUDIO="audio"' if audio_profiles else ""
-        hls.append(
-            f'#EXT-X-STREAM-INF:BANDWIDTH={profile["bandwidth"]},RESOLUTION={profile["width"]}x{profile["height"]},CODECS="{profile["codecs"]}",FRAME-RATE={profile["frameRate"]}{audio_attr}'
-        )
+
+        # Build combined codecs: video + audio
+        video_codec = profile["codecs"]
+        if first_audio_codec and audio_attr:
+            combined_codecs = f"{video_codec},{first_audio_codec}"
+        else:
+            combined_codecs = video_codec
+
+        # Keep full codec strings (e.g., avc1.42C01F, mp4a.40.2) for ALL modes.
+        # ExoPlayer's CodecSpecificDataUtil rejects simplified strings like "avc1" or "mp4a"
+        # as malformed, which prevents proper codec initialization.
+
+        # Omit FRAME-RATE for TS mode (ExoPlayer compatibility)
+        if is_ts_mode:
+            hls.append(
+                f'#EXT-X-STREAM-INF:BANDWIDTH={profile["bandwidth"]},RESOLUTION={profile["width"]}x{profile["height"]},CODECS="{combined_codecs}"{audio_attr}'
+            )
+        else:
+            hls.append(
+                f'#EXT-X-STREAM-INF:BANDWIDTH={profile["bandwidth"]},RESOLUTION={profile["width"]}x{profile["height"]},CODECS="{combined_codecs}",FRAME-RATE={profile["frameRate"]}{audio_attr}'
+            )
         hls.append(playlist_url)
 
     return "\n".join(hls)
 
 
-def build_hls_playlist(mpd_dict: dict, profiles: list[dict], request: Request) -> str:
+def _filter_video_profiles_by_resolution(video_profiles: dict, target_resolution: str) -> dict:
+    """
+    Filter video profiles to select the one matching the target resolution.
+    Falls back to closest lower resolution if exact match not found.
+
+    Args:
+        video_profiles: Dictionary of profile_id -> (profile, playlist_url).
+        target_resolution: Target resolution string (e.g., '1080p', '720p').
+
+    Returns:
+        Filtered dictionary with only the selected profile.
+    """
+    # Parse target height from "1080p" -> 1080
+    target_height = int(target_resolution.rstrip("p"))
+
+    # Convert to list and sort by height descending
+    profiles_list = [
+        (profile_id, profile, playlist_url)
+        for profile_id, (profile, playlist_url) in video_profiles.items()
+        if profile.get("height", 0) > 0
+    ]
+
+    if not profiles_list:
+        logger.warning("No video profiles with valid height found, returning all profiles")
+        return video_profiles
+
+    sorted_profiles = sorted(profiles_list, key=lambda x: x[1]["height"], reverse=True)
+
+    # Find exact match or closest lower
+    selected = None
+    for profile_id, profile, playlist_url in sorted_profiles:
+        if profile["height"] <= target_height:
+            selected = (profile_id, profile, playlist_url)
+            break
+
+    # If all profiles are higher than target, use lowest available
+    if selected is None:
+        selected = sorted_profiles[-1]
+
+    profile_id, profile, playlist_url = selected
+    logger.info(
+        f"Selected MPD video profile with resolution {profile['width']}x{profile['height']} for target {target_resolution}"
+    )
+
+    return {profile_id: (profile, playlist_url)}
+
+
+def build_hls_playlist(
+    mpd_dict: dict, profiles: list[dict], request: Request, skip_segments: list = None, start_offset: float = None
+) -> str:
     """
     Builds an HLS playlist from the MPD manifest for specific profiles.
 
@@ -175,25 +405,65 @@ def build_hls_playlist(mpd_dict: dict, profiles: list[dict], request: Request) -
         mpd_dict (dict): The MPD manifest data.
         profiles (list[dict]): The profiles to include in the playlist.
         request (Request): The incoming HTTP request.
+        skip_segments (list, optional): List of time segments to skip. Each item should have 'start' and 'end' keys.
+        start_offset (float, optional): Start offset in seconds for live streams. Defaults to settings.livestream_start_offset for live.
 
     Returns:
         str: The HLS playlist as a string.
     """
-    hls = ["#EXTM3U", "#EXT-X-VERSION:6"]
+    # Determine if we're in TS remux mode (per-request override > global setting)
+    is_ts_mode = _resolve_ts_mode(request)
+
+    # Use HLS v3 for TS (ExoPlayer compatibility), v6 for fMP4
+    version = 3 if is_ts_mode else 6
+    hls = ["#EXTM3U", f"#EXT-X-VERSION:{version}"]
 
     added_segments = 0
+    skipped_segments = 0
+    is_live = mpd_dict.get("isLive", False)
 
-    proxy_url = request.url_for("segment_endpoint")
+    # Inject EXT-X-START for live streams (enables prebuffering by starting behind live edge)
+    # User-provided start_offset always takes precedence; otherwise use default for live streams only
+    if is_ts_mode and is_live and start_offset is None:
+        # TS mode needs a larger buffer for ExoPlayer
+        effective_start_offset = -30.0
+    else:
+        effective_start_offset = (
+            start_offset if start_offset is not None else (settings.livestream_start_offset if is_live else None)
+        )
+    if effective_start_offset is not None:
+        # ExoPlayer doesn't handle PRECISE=YES well with TS
+        precise = "NO" if is_ts_mode else "YES"
+        hls.append(f"#EXT-X-START:TIME-OFFSET={effective_start_offset:.1f},PRECISE={precise}")
+
+    # Initialize skip filter if skip_segments provided
+    skip_filter = SkipSegmentFilter(skip_segments) if skip_segments else None
+
+    # In TS mode, we don't use EXT-X-MAP because TS segments are self-contained
+    # (PAT/PMT/VPS/SPS/PPS are embedded in each segment)
+    # Use EXT-X-MAP for live streams, but only for fMP4 (not TS)
+    use_map = is_live and not is_ts_mode
+
+    # Select appropriate endpoint based on remux mode
+    if is_ts_mode:
+        proxy_url = request.url_for("segment_ts_endpoint")  # /mpd/segment.ts
+    else:
+        proxy_url = request.url_for("segment_endpoint")  # /mpd/segment.mp4
     proxy_url = str(proxy_url.replace(scheme=get_original_scheme(request)))
 
+    # Get init endpoint URL for EXT-X-MAP (only used for fMP4 mode)
+    init_proxy_url = request.url_for("init_endpoint")
+    init_proxy_url = str(init_proxy_url.replace(scheme=get_original_scheme(request)))
+
     for index, profile in enumerate(profiles):
         segments = profile["segments"]
         if not segments:
             logger.warning(f"No segments found for profile {profile['id']}")
             continue
 
-        if mpd_dict["isLive"]:
-            depth = max(settings.mpd_live_playlist_depth, 1)
+        if is_live:
+            # TS mode uses deeper playlist for ExoPlayer buffering
+            depth = 20 if is_ts_mode else max(settings.mpd_live_playlist_depth, 1)
             trimmed_segments = segments[-depth:]
         else:
             trimmed_segments = segments
@@ -202,24 +472,38 @@ def build_hls_playlist(mpd_dict: dict, profiles: list[dict], request: Request) -
         if index == 0:
             first_segment = trimmed_segments[0]
             extinf_values = [f["extinf"] for f in trimmed_segments if "extinf" in f]
-            target_duration = math.ceil(max(extinf_values)) if extinf_values else 3
+
+            # TS mode uses int(max)+1 to reduce buffer underruns in ExoPlayer
+            if is_ts_mode:
+                target_duration = int(max(extinf_values)) + 1 if extinf_values else 10
+            else:
+                target_duration = math.ceil(max(extinf_values)) if extinf_values else 3
 
             # Align HLS media sequence with MPD-provided numbering when available
-            mpd_start_number = profile.get("segment_template_start_number")
-            sequence = first_segment.get("number")
-
-            if sequence is None:
-                # Fallback to MPD template start number
-                if mpd_start_number is not None:
-                    sequence = mpd_start_number
+            if is_ts_mode and is_live:
+                # For live TS, derive sequence from timeline first for stable continuity
+                time_val = first_segment.get("time")
+                duration_val = first_segment.get("duration_mpd_timescale")
+                if time_val is not None and duration_val and duration_val > 0:
+                    sequence = math.floor(time_val / duration_val)
                 else:
-                    # As a last resort, derive from timeline information
-                    time_val = first_segment.get("time")
-                    duration_val = first_segment.get("duration_mpd_timescale")
-                    if time_val is not None and duration_val and duration_val > 0:
-                        sequence = math.floor(time_val / duration_val)
+                    sequence = first_segment.get("number") or profile.get("segment_template_start_number") or 1
+            else:
+                mpd_start_number = profile.get("segment_template_start_number")
+                sequence = first_segment.get("number")
+
+                if sequence is None:
+                    # Fallback to MPD template start number
+                    if mpd_start_number is not None:
+                        sequence = mpd_start_number
                     else:
-                        sequence = 1
+                        # As a last resort, derive from timeline information
+                        time_val = first_segment.get("time")
+                        duration_val = first_segment.get("duration_mpd_timescale")
+                        if time_val is not None and duration_val and duration_val > 0:
+                            sequence = math.floor(time_val / duration_val)
+                        else:
+                            sequence = 1
 
             hls.extend(
                 [
@@ -227,31 +511,91 @@ def build_hls_playlist(mpd_dict: dict, profiles: list[dict], request: Request) -
                     f"#EXT-X-MEDIA-SEQUENCE:{sequence}",
                 ]
             )
-            if mpd_dict["isLive"]:
-                hls.append("#EXT-X-PLAYLIST-TYPE:EVENT")
-            else:
+            # For live streams, don't set PLAYLIST-TYPE to allow sliding window
+            if not is_live:
                 hls.append("#EXT-X-PLAYLIST-TYPE:VOD")
 
         init_url = profile["initUrl"]
+        # For SegmentBase profiles, we may have byte range for initialization segment
+        init_range = profile.get("initRange")
 
         query_params = dict(request.query_params)
         query_params.pop("profile_id", None)
         query_params.pop("d", None)
+        query_params.pop("remux_to_ts", None)  # per-request override; already resolved into endpoint choice
         has_encrypted = query_params.pop("has_encrypted", False)
 
-        for segment in trimmed_segments:
-            program_date_time = segment.get("program_date_time")
-            if program_date_time:
-                hls.append(f"#EXT-X-PROGRAM-DATE-TIME:{program_date_time}")
-            hls.append(f'#EXTINF:{segment["extinf"]:.3f},')
-            query_params.update(
-                {
-                    "init_url": init_url,
-                    "segment_url": segment["media"],
-                    "mime_type": profile["mimeType"],
-                    "is_live": "true" if mpd_dict.get("isLive") else "false",
-                }
+        # Add EXT-X-MAP for init segment (for live streams or when beneficial)
+        if use_map:
+            init_query_params = {
+                "init_url": init_url,
+                "mime_type": profile["mimeType"],
+                "is_live": "true" if is_live else "false",
+            }
+            if init_range:
+                init_query_params["init_range"] = init_range
+            # Add key parameters
+            if query_params.get("key_id"):
+                init_query_params["key_id"] = query_params["key_id"]
+            if query_params.get("key"):
+                init_query_params["key"] = query_params["key"]
+            # Add api_password for authentication
+            if query_params.get("api_password"):
+                init_query_params["api_password"] = query_params["api_password"]
+
+            init_map_url = encode_mediaflow_proxy_url(
+                init_proxy_url,
+                query_params=init_query_params,
+                encryption_handler=encryption_handler if has_encrypted else None,
             )
+            hls.append(f'#EXT-X-MAP:URI="{init_map_url}"')
+
+        need_discontinuity = False
+        for segment in trimmed_segments:
+            duration = segment["extinf"]
+
+            # Check if this segment should be skipped
+            if skip_filter:
+                if skip_filter.should_skip_segment(duration):
+                    skip_filter.advance_time(duration)
+                    skipped_segments += 1
+                    need_discontinuity = True
+                    continue
+                skip_filter.advance_time(duration)
+
+            # Add discontinuity marker after skipped segments
+            if need_discontinuity:
+                hls.append("#EXT-X-DISCONTINUITY")
+                need_discontinuity = False
+
+            # Emit EXT-X-PROGRAM-DATE-TIME only for fMP4 (not TS)
+            program_date_time = segment.get("program_date_time")
+            if program_date_time and not is_ts_mode:
+                hls.append(f"#EXT-X-PROGRAM-DATE-TIME:{program_date_time}")
+            hls.append(f"#EXTINF:{duration:.3f},")
+
+            segment_query_params = {
+                "init_url": init_url,
+                "segment_url": segment["media"],
+                "mime_type": profile["mimeType"],
+                "is_live": "true" if is_live else "false",
+            }
+
+            # Add use_map flag so segment endpoint knows not to include init
+            if use_map and not is_ts_mode:
+                segment_query_params["use_map"] = "true"
+            elif is_ts_mode:
+                # TS segments are self-contained; init is always embedded by remuxer
+                segment_query_params["use_map"] = "false"
+
+            # Add byte range parameters for SegmentBase
+            if init_range:
+                segment_query_params["init_range"] = init_range
+            # Segment may also have its own range (for SegmentBase)
+            if "initRange" in segment:
+                segment_query_params["init_range"] = segment["initRange"]
+
+            query_params.update(segment_query_params)
             hls.append(
                 encode_mediaflow_proxy_url(
                     proxy_url,
@@ -264,5 +608,8 @@ def build_hls_playlist(mpd_dict: dict, profiles: list[dict], request: Request) -
     if not mpd_dict["isLive"]:
         hls.append("#EXT-X-ENDLIST")
 
-    logger.info(f"Added {added_segments} segments to HLS playlist")
+    if skip_filter and skipped_segments > 0:
+        logger.info(f"Added {added_segments} segments to HLS playlist (skipped {skipped_segments} segments)")
+    else:
+        logger.info(f"Added {added_segments} segments to HLS playlist")
     return "\n".join(hls)