import asyncio import logging import re from typing import Annotated from urllib.parse import quote, unquote import aiohttp from fastapi import Request, Depends, APIRouter, Query, HTTPException, Response from fastapi.datastructures import QueryParams from mediaflow_proxy.configs import settings from mediaflow_proxy.handlers import ( handle_hls_stream_proxy, handle_stream_request, proxy_stream, get_manifest, get_playlist, get_segment, get_init_segment, get_public_ip, ) from mediaflow_proxy.schemas import ( MPDSegmentParams, MPDPlaylistParams, HLSManifestParams, MPDManifestParams, MPDInitParams, ) from mediaflow_proxy.utils.base64_utils import process_potential_base64_url from mediaflow_proxy.utils.extractor_helpers import ( check_and_extract_dlhd_stream, check_and_extract_sportsonline_stream, ) from mediaflow_proxy.utils.hls_prebuffer import hls_prebuffer from mediaflow_proxy.utils.hls_utils import parse_hls_playlist, find_stream_by_resolution from mediaflow_proxy.utils.http_utils import ( get_proxy_headers, ProxyRequestHeaders, apply_header_manipulation, ) from mediaflow_proxy.utils.http_client import create_aiohttp_session from mediaflow_proxy.utils.m3u8_processor import M3U8Processor from mediaflow_proxy.utils.stream_transformers import apply_transformer_to_bytes from mediaflow_proxy.remuxer.media_source import HTTPMediaSource from mediaflow_proxy.remuxer.transcode_handler import ( handle_transcode, handle_transcode_hls_init, handle_transcode_hls_playlist, handle_transcode_hls_segment, ) logger = logging.getLogger(__name__) proxy_router = APIRouter() def sanitize_url(url: str) -> str: """ Sanitize URL to fix common encoding issues and handle base64 encoded URLs. Args: url (str): The URL to sanitize. Returns: str: The sanitized URL. """ original_url = url # First, try to process potential base64 encoded URLs url = process_potential_base64_url(url) # Fix malformed URLs where https%22// should be https:// url = re.sub(r"https%22//", "https://", url) url = re.sub(r"http%22//", "http://", url) # Fix malformed URLs where https%3A%22// should be https:// url = re.sub(r"https%3A%22//", "https://", url) url = re.sub(r"http%3A%22//", "http://", url) # Fix malformed URLs where https:"// should be https:// (after partial decoding) url = re.sub(r'https:"//', "https://", url) url = re.sub(r'http:"//', "http://", url) # Fix URLs where key_id and key parameters are incorrectly appended to the base URL # This happens when the URL contains &key_id= and &key= which should be handled as proxy parameters if "&key_id=" in url and "&key=" in url: # Split the URL at the first occurrence of &key_id= to separate the base URL from the incorrectly appended parameters base_url = url.split("&key_id=")[0] logger.info(f"Removed incorrectly appended key parameters from URL: '{url}' -> '{base_url}'") url = base_url # Log if URL was changed if url != original_url: logger.info(f"URL sanitized: '{original_url}' -> '{url}'") # Also try URL decoding to see what we get try: decoded_url = unquote(url) if decoded_url != url: logger.info(f"URL after decoding: '{decoded_url}'") # If after decoding we still have malformed protocol, fix it if ':"/' in decoded_url: # Fix https:"// or http:"// patterns fixed_decoded = re.sub(r'([a-z]+):"//', r"\1://", decoded_url) logger.info(f"Fixed decoded URL: '{fixed_decoded}'") return fixed_decoded except Exception as e: logger.warning(f"Error decoding URL '{url}': {e}") return url def extract_drm_params_from_url(url: str) -> tuple[str, str, str]: """ Extract DRM parameters (key_id and key) from a URL if they are incorrectly appended. Args: url (str): The URL that may contain appended DRM parameters. Returns: tuple: (clean_url, key_id, key) where clean_url has the parameters removed, and key_id/key are the extracted values (or None if not found). """ key_id = None key = None clean_url = url # Check if URL contains incorrectly appended key_id and key parameters if "&key_id=" in url and "&key=" in url: # Extract key_id key_id_match = re.search(r"&key_id=([^&]+)", url) if key_id_match: key_id = key_id_match.group(1) # Extract key key_match = re.search(r"&key=([^&]+)", url) if key_match: key = key_match.group(1) # Remove the parameters from the URL clean_url = re.sub(r"&key_id=[^&]*", "", url) clean_url = re.sub(r"&key=[^&]*", "", clean_url) logger.info(f"Extracted DRM parameters from URL: key_id={key_id}, key={key}") logger.info(f"Cleaned URL: '{url}' -> '{clean_url}'") return clean_url, key_id, key @proxy_router.head("/hls/manifest.m3u8") @proxy_router.get("/hls/manifest.m3u8") async def hls_manifest_proxy( request: Request, hls_params: Annotated[HLSManifestParams, Query()], proxy_headers: Annotated[ProxyRequestHeaders, Depends(get_proxy_headers)], ): """ Proxify HLS stream requests, fetching and processing the m3u8 playlist or streaming the content. Args: request (Request): The incoming HTTP request. hls_params (HLSPlaylistParams): The parameters for the HLS stream request. proxy_headers (ProxyRequestHeaders): The headers to include in the request. Returns: Response: The HTTP response with the processed m3u8 playlist or streamed content. """ # Sanitize destination URL to fix common encoding issues hls_params.destination = sanitize_url(hls_params.destination) # Check if this is a retry after 403 error (dlhd_retry parameter) force_refresh = request.query_params.get("dlhd_retry") == "1" # Check if destination contains DLHD pattern and extract stream directly dlhd_result = await check_and_extract_dlhd_stream( request, hls_params.destination, proxy_headers, force_refresh=force_refresh ) dlhd_original_url = None if dlhd_result: # Store original DLHD URL for cache invalidation on 403 errors dlhd_original_url = hls_params.destination # Update destination and headers with extracted stream data hls_params.destination = dlhd_result["destination_url"] extracted_headers = dlhd_result.get("request_headers", {}) proxy_headers.request.update(extracted_headers) # Check if extractor wants key-only proxy (DLHD uses hls_key_proxy endpoint) if dlhd_result.get("mediaflow_endpoint") == "hls_key_proxy": hls_params.key_only_proxy = True # Check if extractor wants to force playlist proxy (needed for .css disguised m3u8) if dlhd_result.get("force_playlist_proxy"): hls_params.force_playlist_proxy = True # Also add headers to query params so they propagate to key/segment requests # This is necessary because M3U8Processor encodes headers as h_* query params query_dict = dict(request.query_params) for header_name, header_value in extracted_headers.items(): # Add header with h_ prefix to query params query_dict[f"h_{header_name}"] = header_value # Add DLHD original URL to track for cache invalidation if dlhd_original_url: query_dict["dlhd_original"] = dlhd_original_url # Add DLHD key params if present (for dynamic key header computation) if dlhd_result.get("dlhd_channel_salt"): query_dict["dlhd_salt"] = dlhd_result["dlhd_channel_salt"] if dlhd_result.get("dlhd_auth_token"): query_dict["dlhd_token"] = dlhd_result["dlhd_auth_token"] if dlhd_result.get("dlhd_iframe_url"): query_dict["dlhd_iframe"] = dlhd_result["dlhd_iframe_url"] # Remove retry flag from subsequent requests query_dict.pop("dlhd_retry", None) # Update request query params request._query_params = QueryParams(query_dict) # Check if destination contains Sportsonline pattern and extract stream directly sportsonline_result = await check_and_extract_sportsonline_stream(request, hls_params.destination, proxy_headers) if sportsonline_result: # Update destination and headers with extracted stream data hls_params.destination = sportsonline_result["destination_url"] extracted_headers = sportsonline_result.get("request_headers", {}) proxy_headers.request.update(extracted_headers) # Check if extractor wants key-only proxy if sportsonline_result.get("mediaflow_endpoint") == "hls_key_proxy": hls_params.key_only_proxy = True # Also add headers to query params so they propagate to key/segment requests query_dict = dict(request.query_params) for header_name, header_value in extracted_headers.items(): # Add header with h_ prefix to query params query_dict[f"h_{header_name}"] = header_value # Remove retry flag from subsequent requests query_dict.pop("dlhd_retry", None) # Update request query params request._query_params = QueryParams(query_dict) # Wrap the handler to catch 403 errors and retry with cache invalidation try: result = await _handle_hls_with_dlhd_retry(request, hls_params, proxy_headers, dlhd_original_url) return result except HTTPException: raise except Exception as e: logger.exception(f"Unexpected error in hls_manifest_proxy: {e}") raise HTTPException(status_code=500, detail=str(e)) async def _handle_hls_with_dlhd_retry( request: Request, hls_params: HLSManifestParams, proxy_headers: ProxyRequestHeaders, dlhd_original_url: str | None ): """ Handle HLS request with automatic retry on 403 errors for DLHD streams. """ # Check if resolution selection is needed (either max_res or specific resolution) if hls_params.max_res or hls_params.resolution: async with create_aiohttp_session(hls_params.destination) as (session, proxy_url): try: response = await session.get( hls_params.destination, headers=proxy_headers.request, proxy=proxy_url, ) response.raise_for_status() playlist_content = await response.text() except aiohttp.ClientResponseError as e: raise HTTPException( status_code=502, detail=f"Failed to fetch HLS manifest from origin: {e.status}", ) from e except asyncio.TimeoutError as e: raise HTTPException( status_code=504, detail=f"Timeout while fetching HLS manifest: {e}", ) from e except aiohttp.ClientError as e: raise HTTPException(status_code=502, detail=f"Network error fetching HLS manifest: {e}") from e streams = parse_hls_playlist(playlist_content, base_url=hls_params.destination) if not streams: raise HTTPException(status_code=404, detail="No streams found in the manifest.") # Select stream based on resolution parameter or max_res if hls_params.resolution: selected_stream = find_stream_by_resolution(streams, hls_params.resolution) if not selected_stream: raise HTTPException( status_code=404, detail=f"No suitable stream found for resolution {hls_params.resolution}." ) else: # max_res: select highest resolution selected_stream = max( streams, key=lambda s: s.get("resolution", (0, 0))[0] * s.get("resolution", (0, 0))[1], ) if selected_stream.get("resolution", (0, 0)) == (0, 0): logger.warning( "Selected stream has resolution (0, 0); resolution parsing may have failed or not be available in the manifest." ) # Rebuild the manifest preserving master-level directives # but removing non-selected variant blocks lines = playlist_content.splitlines() selected_variant_index = streams.index(selected_stream) variant_index = -1 new_manifest_lines = [] i = 0 while i < len(lines): line = lines[i] if line.startswith("#EXT-X-STREAM-INF"): variant_index += 1 next_line = "" if i + 1 < len(lines) and not lines[i + 1].startswith("#"): next_line = lines[i + 1] # Only keep the selected variant if variant_index == selected_variant_index: new_manifest_lines.append(line) if next_line: new_manifest_lines.append(next_line) # Skip variant block (stream-inf + optional url) i += 2 if next_line else 1 continue # Preserve all other lines (master directives, media tags, etc.) new_manifest_lines.append(line) i += 1 new_manifest = "\n".join(new_manifest_lines) # Parse skip segments (already returns list of dicts with 'start' and 'end' keys) skip_segments_list = hls_params.get_skip_segments() # Process the new manifest to proxy all URLs within it processor = M3U8Processor( request, hls_params.key_url, hls_params.force_playlist_proxy, hls_params.key_only_proxy, hls_params.no_proxy, skip_segments_list, hls_params.start_offset, ) processed_manifest = await processor.process_m3u8(new_manifest, base_url=hls_params.destination) return Response(content=processed_manifest, media_type="application/vnd.apple.mpegurl") return await handle_hls_stream_proxy(request, hls_params, proxy_headers, hls_params.transformer) @proxy_router.head("/hls/key_proxy/manifest.m3u8", name="hls_key_proxy") @proxy_router.get("/hls/key_proxy/manifest.m3u8", name="hls_key_proxy") async def hls_key_proxy( request: Request, hls_params: Annotated[HLSManifestParams, Query()], proxy_headers: Annotated[ProxyRequestHeaders, Depends(get_proxy_headers)], ): """ Proxify HLS stream requests, but only proxy the key URL, leaving segment URLs direct. Args: request (Request): The incoming HTTP request. hls_params (HLSManifestParams): The parameters for the HLS stream request. proxy_headers (ProxyRequestHeaders): The headers to include in the request. Returns: Response: The HTTP response with the processed m3u8 playlist. """ # Sanitize destination URL to fix common encoding issues hls_params.destination = sanitize_url(hls_params.destination) # Set the key_only_proxy flag to True hls_params.key_only_proxy = True return await handle_hls_stream_proxy(request, hls_params, proxy_headers, hls_params.transformer) # Map file extensions to MIME types for HLS segments HLS_SEGMENT_MIME_TYPES = { "ts": "video/mp2t", # MPEG-TS (traditional HLS) "m4s": "video/mp4", # fMP4 segment (modern HLS/CMAF) "mp4": "video/mp4", # fMP4 segment (alternative extension) "m4a": "audio/mp4", # Audio-only fMP4 segment "m4v": "video/mp4", # Video fMP4 segment (alternative) "aac": "audio/aac", # AAC audio segment } @proxy_router.get("/hls/segment.{ext}", name="hls_segment_proxy") async def hls_segment_proxy( request: Request, proxy_headers: Annotated[ProxyRequestHeaders, Depends(get_proxy_headers)], ext: str, segment_url: str = Query(..., description="URL of the HLS segment", alias="d"), transformer: str = Query(None, description="Stream transformer ID for content manipulation"), ): """ Proxy HLS segments with pre-buffering support. This endpoint supports multiple segment formats: - /hls/segment.ts - MPEG-TS segments (traditional HLS) - /hls/segment.m4s - fMP4 segments (modern HLS/CMAF) - /hls/segment.mp4 - fMP4 segments (alternative) - /hls/segment.m4a - Audio fMP4 segments - /hls/segment.aac - AAC audio segments Uses event-based coordination to prevent duplicate downloads between player requests and background prebuffering. Args: request (Request): The incoming HTTP request. ext (str): File extension determining the segment format. segment_url (str): URL of the HLS segment to proxy. proxy_headers (ProxyRequestHeaders): The headers to include in the request. transformer (str, optional): Stream transformer ID for content manipulation. Returns: Response: The HTTP response with the segment content. """ # Get MIME type for this extension mime_type = HLS_SEGMENT_MIME_TYPES.get(ext.lower(), "application/octet-stream") # Sanitize segment URL to fix common encoding issues original_url = segment_url segment_url = sanitize_url(segment_url) logger.info(f"[hls_segment_proxy] Request for: {segment_url}") if original_url != segment_url: logger.warning(f"[hls_segment_proxy] URL was sanitized! Original: {original_url}") # Extract headers for pre-buffering headers = {} for key, value in request.query_params.items(): if key.startswith("h_"): headers[key[2:]] = value if settings.enable_hls_prebuffer: # Notify the prefetcher that this segment is needed (priority download) # This ensures the player's segment is downloaded first, then prefetcher # continues with sequential prefetch of remaining segments await hls_prebuffer.request_segment(segment_url) # Use cross-process coordination to get the segment segment_data = await hls_prebuffer.get_or_download(segment_url, headers) if segment_data: logger.info(f"[hls_segment_proxy] Serving from prebuffer ({len(segment_data)} bytes): {segment_url}") # Apply transformer if specified (e.g., PNG wrapper stripping) if transformer: segment_data = await apply_transformer_to_bytes(segment_data, transformer) # Return cached/downloaded segment base_headers = { "content-type": mime_type, "cache-control": "public, max-age=3600", "access-control-allow-origin": "*", } response_headers = apply_header_manipulation(base_headers, proxy_headers) return Response(content=segment_data, media_type=mime_type, headers=response_headers) # get_or_download returned None (timeout or error) - fall through to streaming logger.warning(f"[hls_segment_proxy] Prebuffer timeout, using direct streaming: {segment_url}") # Fallback to direct streaming return await handle_stream_request("GET", segment_url, proxy_headers, transformer) # ============================================================================= # HLS Transcode endpoints (VOD playlist + init segment + media segments) # ============================================================================= @proxy_router.head("/transcode/playlist.m3u8") @proxy_router.get("/transcode/playlist.m3u8") async def transcode_hls_playlist( request: Request, proxy_headers: Annotated[ProxyRequestHeaders, Depends(get_proxy_headers)], destination: str = Query(..., description="The URL of the source media.", alias="d"), ): """ Generate an HLS VOD M3U8 playlist for on-the-fly transcoded content. Probes the source file's keyframe index and generates a playlist where each segment corresponds to one or more keyframe intervals. The playlist references the init segment and media segment endpoints below. The generated playlist uses ``#EXT-X-VERSION:7`` with fMP4 (CMAF) segments for universal browser and player compatibility. Args: request: The incoming HTTP request. proxy_headers: Headers to forward to the source. destination: URL of the source media file. """ if not settings.enable_transcode: raise HTTPException(status_code=503, detail="Transcoding support is disabled") destination = sanitize_url(destination) source = HTTPMediaSource(url=destination, headers=dict(proxy_headers.request)) await source.resolve_file_size() # Build URLs for init and segment endpoints that preserve query params # (api_password, headers, etc.) from the current request. base_params = _build_hls_query_params(request, destination) init_url = f"/proxy/transcode/init.mp4?{base_params}" segment_url_template = ( f"/proxy/transcode/segment.m4s?{base_params}&seg={{seg}}&start_ms={{start_ms}}&end_ms={{end_ms}}" ) return await handle_transcode_hls_playlist( request, source, init_url=init_url, segment_url_template=segment_url_template, ) @proxy_router.head("/transcode/init.mp4") @proxy_router.get("/transcode/init.mp4") async def transcode_hls_init( request: Request, proxy_headers: Annotated[ProxyRequestHeaders, Depends(get_proxy_headers)], destination: str = Query(..., description="The URL of the source media.", alias="d"), ): """ Serve the fMP4 init segment (ftyp + moov) for HLS transcode playback. The init segment is built from probed track metadata without running the full transcode pipeline. Args: request: The incoming HTTP request. proxy_headers: Headers to forward to the source. destination: URL of the source media file. """ if not settings.enable_transcode: raise HTTPException(status_code=503, detail="Transcoding support is disabled") destination = sanitize_url(destination) source = HTTPMediaSource(url=destination, headers=dict(proxy_headers.request)) await source.resolve_file_size() return await handle_transcode_hls_init(request, source) @proxy_router.get("/transcode/segment.m4s") async def transcode_hls_segment( request: Request, proxy_headers: Annotated[ProxyRequestHeaders, Depends(get_proxy_headers)], destination: str = Query(..., description="The URL of the source media.", alias="d"), start_ms: float = Query(..., description="Segment start time in milliseconds."), end_ms: float = Query(..., description="Segment end time in milliseconds."), seg: int | None = Query(None, description="Segment number (informational, for logging)."), ): """ Serve a single HLS fMP4 media segment (moof + mdat). Each segment corresponds to a merged keyframe interval in the source file. The time range is self-describing (from the playlist URL) so no cue-point re-derivation is needed. Args: request: The incoming HTTP request. proxy_headers: Headers to forward to the source. destination: URL of the source media file. start_ms: Segment start time in milliseconds. end_ms: Segment end time in milliseconds. """ if not settings.enable_transcode: raise HTTPException(status_code=503, detail="Transcoding support is disabled") destination = sanitize_url(destination) source = HTTPMediaSource(url=destination, headers=dict(proxy_headers.request)) await source.resolve_file_size() return await handle_transcode_hls_segment( request, source, start_time_ms=start_ms, end_time_ms=end_ms, segment_number=seg ) def _build_hls_query_params(request: Request, destination: str) -> str: """ Build query string for HLS sub-requests, preserving auth and header params. Copies ``api_password``, header manipulation params (``h_*``), and the destination URL from the original request. """ params = [f"d={quote(destination, safe='')}"] original = request.query_params if "api_password" in original: params.append(f"api_password={quote(original['api_password'], safe='')}") # Preserve header overrides (h_referer, h_origin, etc.) for key in original: if key.startswith("h_"): params.append(f"{key}={quote(original[key], safe='')}") return "&".join(params) @proxy_router.head("/stream") @proxy_router.get("/stream") @proxy_router.head("/stream/{filename:path}") @proxy_router.get("/stream/{filename:path}") async def proxy_stream_endpoint( request: Request, proxy_headers: Annotated[ProxyRequestHeaders, Depends(get_proxy_headers)], destination: str = Query(..., description="The URL of the stream.", alias="d"), filename: str | None = None, transformer: str = Query(None, description="Stream transformer ID for content manipulation"), ratelimit: str = Query( None, description="Rate limit handler ID for host-specific rate limiting (e.g., 'vidoza', 'aggressive'). " "If not specified, auto-detects based on destination URL hostname. " "Set to 'none' to explicitly disable rate limiting.", ), transcode: bool = Query( False, description="Transcode to browser-compatible fMP4 (re-encode video/audio as needed)" ), start: float | None = Query(None, description="Seek start time in seconds (used with transcode=true)"), ): """ Proxify stream requests to the given video URL. This is a general-purpose stream proxy endpoint. For HLS segments with prebuffer support, use the dedicated /hls/segment.ts endpoint instead. When transcode=true, the media is transcoded on-the-fly to browser-compatible fMP4 (H.264 video + AAC audio). Video is re-encoded only if the source codec is not browser-compatible (e.g. H.265, MPEG-2). Audio is transcoded to AAC when needed (e.g. EAC3, AC3, DTS). GPU acceleration is used when available. Rate limiting can be controlled via the `ratelimit` parameter: - Not specified: Auto-detects based on destination URL (e.g., Vidoza is auto-detected) - "vidoza": Explicitly enable Vidoza rate limiting (5s cooldown between connections) - "aggressive": Generic aggressive rate limiting (3s cooldown) - "none": Explicitly disable all rate limiting Args: request (Request): The incoming HTTP request. proxy_headers (ProxyRequestHeaders): The headers to include in the request. destination (str): The URL of the stream to be proxied. filename (str | None): The filename to be used in the response headers. transformer (str, optional): Stream transformer ID for content manipulation. ratelimit (str, optional): Rate limit handler ID for host-specific rate limiting. transcode (bool): Transcode to browser-compatible format. start (float, optional): Seek start time in seconds (transcode mode only). Returns: Response: The HTTP response with the streamed content. """ # Log incoming request details for debugging seek issues range_header = proxy_headers.request.get("range", "not set") logger.info( f"[proxy_stream] Request received - filename: {filename}, range: {range_header}, " f"method: {request.method}, transcode: {transcode}" ) # Sanitize destination URL to fix common encoding issues destination = sanitize_url(destination) # Check if this is a DLHD key URL request with key params in query dlhd_salt = request.query_params.get("dlhd_salt") dlhd_token = request.query_params.get("dlhd_token") if dlhd_salt and "/key/" in destination: # This is a DLHD key URL - compute dynamic headers via executor to avoid blocking from mediaflow_proxy.extractors.dlhd import compute_key_headers key_headers = await asyncio.to_thread(compute_key_headers, destination, dlhd_salt) if key_headers: ts, nonce, key_path, fingerprint = key_headers proxy_headers.request.update( { "X-Key-Timestamp": str(ts), "X-Key-Nonce": str(nonce), "X-Fingerprint": fingerprint, "X-Key-Path": key_path, } ) if dlhd_token: proxy_headers.request["Authorization"] = f"Bearer {dlhd_token}" logger.info(f"[proxy_stream] Computed DLHD key headers for: {destination}") # Check if destination contains DLHD pattern and extract stream directly dlhd_result = await check_and_extract_dlhd_stream(request, destination, proxy_headers) if dlhd_result: # Update destination and headers with extracted stream data destination = dlhd_result["destination_url"] proxy_headers.request.update(dlhd_result.get("request_headers", {})) # Handle transcode mode — transcode uses time-based seeking, not byte ranges if transcode: if not settings.enable_transcode: raise HTTPException(status_code=503, detail="Transcoding support is disabled") transcode_headers = dict(proxy_headers.request) transcode_headers.pop("range", None) transcode_headers.pop("if-range", None) source = HTTPMediaSource(url=destination, headers=transcode_headers) await source.resolve_file_size() return await handle_transcode(request, source, start_time=start) if proxy_headers.request.get("range", "").strip() == "": proxy_headers.request.pop("range", None) if proxy_headers.request.get("if-range", "").strip() == "": proxy_headers.request.pop("if-range", None) if "range" not in proxy_headers.request: proxy_headers.request["range"] = "bytes=0-" if filename: # If a filename is provided (not a segment), set it in the headers using RFC 6266 format try: # Try to encode with latin-1 first (simple case) filename.encode("latin-1") content_disposition = f'attachment; filename="{filename}"' except UnicodeEncodeError: # For filenames with non-latin-1 characters, use RFC 6266 format with UTF-8 encoded_filename = quote(filename.encode("utf-8")) content_disposition = f"attachment; filename*=UTF-8''{encoded_filename}" proxy_headers.response.update({"content-disposition": content_disposition}) # Handle "none" as explicit disable rate_limit_handler_id = None if ratelimit == "none" else ratelimit return await proxy_stream(request.method, destination, proxy_headers, transformer, rate_limit_handler_id) @proxy_router.head("/mpd/manifest.m3u8") @proxy_router.get("/mpd/manifest.m3u8") async def mpd_manifest_proxy( request: Request, manifest_params: Annotated[MPDManifestParams, Query()], proxy_headers: Annotated[ProxyRequestHeaders, Depends(get_proxy_headers)], ): """ Retrieves and processes the MPD manifest, converting it to an HLS manifest. Args: request (Request): The incoming HTTP request. manifest_params (MPDManifestParams): The parameters for the manifest request. proxy_headers (ProxyRequestHeaders): The headers to include in the request. Returns: Response: The HTTP response with the HLS manifest. """ # Extract DRM parameters from destination URL if they are incorrectly appended clean_url, extracted_key_id, extracted_key = extract_drm_params_from_url(manifest_params.destination) # Update the destination with the cleaned URL manifest_params.destination = clean_url # Use extracted parameters if they exist and the manifest params don't already have them if extracted_key_id and not manifest_params.key_id: manifest_params.key_id = extracted_key_id if extracted_key and not manifest_params.key: manifest_params.key = extracted_key # Sanitize destination URL to fix common encoding issues manifest_params.destination = sanitize_url(manifest_params.destination) return await get_manifest(request, manifest_params, proxy_headers) @proxy_router.head("/mpd/playlist.m3u8") @proxy_router.get("/mpd/playlist.m3u8") async def playlist_endpoint( request: Request, playlist_params: Annotated[MPDPlaylistParams, Query()], proxy_headers: Annotated[ProxyRequestHeaders, Depends(get_proxy_headers)], ): """ Retrieves and processes the MPD manifest, converting it to an HLS playlist for a specific profile. Args: request (Request): The incoming HTTP request. playlist_params (MPDPlaylistParams): The parameters for the playlist request. proxy_headers (ProxyRequestHeaders): The headers to include in the request. Returns: Response: The HTTP response with the HLS playlist. """ # Extract DRM parameters from destination URL if they are incorrectly appended clean_url, extracted_key_id, extracted_key = extract_drm_params_from_url(playlist_params.destination) # Update the destination with the cleaned URL playlist_params.destination = clean_url # Use extracted parameters if they exist and the playlist params don't already have them if extracted_key_id and not playlist_params.key_id: playlist_params.key_id = extracted_key_id if extracted_key and not playlist_params.key: playlist_params.key = extracted_key # Sanitize destination URL to fix common encoding issues playlist_params.destination = sanitize_url(playlist_params.destination) return await get_playlist(request, playlist_params, proxy_headers) @proxy_router.get("/mpd/segment.mp4") async def segment_endpoint( segment_params: Annotated[MPDSegmentParams, Query()], proxy_headers: Annotated[ProxyRequestHeaders, Depends(get_proxy_headers)], ): """ Retrieves and processes a media segment, decrypting it if necessary. This endpoint serves fMP4 segments without TS remuxing. The playlist generator already selects /segment.mp4 vs /segment.ts based on the resolved remux mode, so this endpoint explicitly disables remuxing regardless of global settings. Args: segment_params (MPDSegmentParams): The parameters for the segment request. proxy_headers (ProxyRequestHeaders): The headers to include in the request. Returns: Response: The HTTP response with the processed segment. """ return await get_segment(segment_params, proxy_headers, force_remux_ts=False) @proxy_router.get("/mpd/segment.ts") async def segment_ts_endpoint( segment_params: Annotated[MPDSegmentParams, Query()], proxy_headers: Annotated[ProxyRequestHeaders, Depends(get_proxy_headers)], ): """ Retrieves and processes a media segment, remuxing fMP4 to MPEG-TS. This endpoint is used for HLS playlists when remux_to_ts is enabled. Unlike /mpd/segment.mp4, this forces TS remuxing regardless of global settings. Args: segment_params (MPDSegmentParams): The parameters for the segment request. proxy_headers (ProxyRequestHeaders): The headers to include in the request. Returns: Response: The HTTP response with the MPEG-TS segment. """ return await get_segment(segment_params, proxy_headers, force_remux_ts=True) @proxy_router.get("/mpd/init.mp4") async def init_endpoint( init_params: Annotated[MPDInitParams, Query()], proxy_headers: Annotated[ProxyRequestHeaders, Depends(get_proxy_headers)], ): """ Retrieves and processes an initialization segment for use with EXT-X-MAP. Args: init_params (MPDInitParams): The parameters for the init segment request. proxy_headers (ProxyRequestHeaders): The headers to include in the request. Returns: Response: The HTTP response with the processed init segment. """ return await get_init_segment(init_params, proxy_headers) @proxy_router.get("/ip") async def get_mediaflow_proxy_public_ip(): """ Retrieves the public IP address of the MediaFlow proxy server. Returns: Response: The HTTP response with the public IP address in the form of a JSON object. {"ip": "xxx.xxx.xxx.xxx"} """ return await get_public_ip()