Add support for response proxy headers & flag to use request proxy via use_request_proxy

mediaflow_proxy/handlers.py

@@ -16,6 +16,7 @@ from .utils.http_utils import (
     download_file_with_retry,
     request_with_retry,
     EnhancedStreamingResponse,
+    ProxyRequestHeaders,
 )
 from .utils.m3u8_processor import M3U8Processor
 from .utils.mpd_utils import pad_base64
@@ -24,7 +25,12 @@ logger = logging.getLogger(__name__)
 
 
 async def handle_hls_stream_proxy(
-    request: Request, destination: str, headers: dict, key_url: HttpUrl = None, verify_ssl: bool = True
+    request: Request,
+    destination: str,
+    proxy_headers: ProxyRequestHeaders,
+    key_url: HttpUrl = None,
+    verify_ssl: bool = True,
+    use_request_proxy: bool = True,
 ):
     """
     Handles the HLS stream proxy request, fetching and processing the m3u8 playlist or streaming the content.
@@ -32,9 +38,10 @@ async def handle_hls_stream_proxy(
     Args:
         request (Request): The incoming HTTP request.
         destination (str): The destination URL to fetch the content from.
-        headers (dict): The headers to include in the request.
+        proxy_headers (ProxyRequestHeaders): The headers to include in the request.
         key_url (str, optional): The HLS Key URL to replace the original key URL. Defaults to None.
         verify_ssl (bool, optional): Whether to verify the SSL certificate of the destination. Defaults to True.
+        use_request_proxy (bool, optional): Whether to use the MediaFlow proxy configuration. Defaults to True.
 
     Returns:
         Response: The HTTP response with the processed m3u8 playlist or streamed content.
@@ -43,19 +50,19 @@ async def handle_hls_stream_proxy(
         follow_redirects=True,
         timeout=httpx.Timeout(30.0),
         limits=httpx.Limits(max_keepalive_connections=10, max_connections=20),
-        proxy=settings.proxy_url,
+        proxy=settings.proxy_url if use_request_proxy else None,
         verify=verify_ssl,
     )
     streamer = Streamer(client)
     try:
         if destination.endswith((".m3u", ".m3u8")):
-            return await fetch_and_process_m3u8(streamer, destination, headers, request, key_url)
+            return await fetch_and_process_m3u8(streamer, destination, proxy_headers, request, key_url)
 
-        response = await streamer.head(destination, headers)
+        response = await streamer.head(destination, proxy_headers.request)
         if "mpegurl" in response.headers.get("content-type", "").lower():
-            return await fetch_and_process_m3u8(streamer, destination, headers, request, key_url)
+            return await fetch_and_process_m3u8(streamer, destination, proxy_headers, request, key_url)
 
-        headers.update({"range": headers.get("range", "bytes=0-")})
+        proxy_headers.request.update({"range": proxy_headers.request.get("range", "bytes=0-")})
         # clean up the headers to only include the necessary headers and remove acl headers
         response_headers = {k: v for k, v in response.headers.multi_items() if k in SUPPORTED_RESPONSE_HEADERS}
 
@@ -65,9 +72,10 @@ async def handle_hls_stream_proxy(
         else:
             transfer_encoding = "chunked"
         response_headers["transfer-encoding"] = transfer_encoding
+        response_headers.update(proxy_headers.response)
 
         return EnhancedStreamingResponse(
-            streamer.stream_content(destination, headers),
+            streamer.stream_content(destination, proxy_headers.request),
             status_code=response.status_code,
             headers=response_headers,
             background=BackgroundTask(streamer.close),
@@ -86,31 +94,45 @@ async def handle_hls_stream_proxy(
         return Response(status_code=502, content=f"Internal server error: {e}")
 
 
-async def proxy_stream(method: str, video_url: str, headers: dict, verify_ssl: bool = True):
+async def proxy_stream(
+    method: str,
+    video_url: str,
+    proxy_headers: ProxyRequestHeaders,
+    verify_ssl: bool = True,
+    use_request_proxy: bool = True,
+):
     """
     Proxies the stream request to the given video URL.
 
     Args:
         method (str): The HTTP method (e.g., GET, HEAD).
         video_url (str): The URL of the video to stream.
-        headers (dict): The headers to include in the request.
+        proxy_headers (ProxyRequestHeaders): The headers to include in the request.
         verify_ssl (bool, optional): Whether to verify the SSL certificate of the destination. Defaults to True.
+        use_request_proxy (bool, optional): Whether to use the MediaFlow proxy configuration. Defaults to True.
 
     Returns:
         Response: The HTTP response with the streamed content.
     """
-    return await handle_stream_request(method, video_url, headers, verify_ssl)
+    return await handle_stream_request(method, video_url, proxy_headers, verify_ssl, use_request_proxy)
 
 
-async def handle_stream_request(method: str, video_url: str, headers: dict, verify_ssl: bool = True):
+async def handle_stream_request(
+    method: str,
+    video_url: str,
+    proxy_headers: ProxyRequestHeaders,
+    verify_ssl: bool = True,
+    use_request_proxy: bool = True,
+):
     """
     Handles the stream request, fetching the content from the video URL and streaming it.
 
     Args:
         method (str): The HTTP method (e.g., GET, HEAD).
         video_url (str): The URL of the video to stream.
-        headers (dict): The headers to include in the request.
+        proxy_headers (ProxyRequestHeaders): The headers to include in the request.
         verify_ssl (bool, optional): Whether to verify the SSL certificate of the destination. Defaults to True.
+        use_request_proxy (bool, optional): Whether to use the MediaFlow proxy configuration. Defaults to True.
 
     Returns:
         Response: The HTTP response with the streamed content.
@@ -119,12 +141,12 @@ async def handle_stream_request(method: str, video_url: str, headers: dict, veri
         follow_redirects=True,
         timeout=httpx.Timeout(30.0),
         limits=httpx.Limits(max_keepalive_connections=10, max_connections=20),
-        proxy=settings.proxy_url,
+        proxy=settings.proxy_url if use_request_proxy else None,
         verify=verify_ssl,
     )
     streamer = Streamer(client)
     try:
-        response = await streamer.head(video_url, headers)
+        response = await streamer.head(video_url, proxy_headers.request)
         # clean up the headers to only include the necessary headers and remove acl headers
         response_headers = {k: v for k, v in response.headers.multi_items() if k in SUPPORTED_RESPONSE_HEADERS}
         if transfer_encoding := response_headers.get("transfer-encoding"):
@@ -133,13 +155,14 @@ async def handle_stream_request(method: str, video_url: str, headers: dict, veri
         else:
             transfer_encoding = "chunked"
         response_headers["transfer-encoding"] = transfer_encoding
+        response_headers.update(proxy_headers.response)
 
         if method == "HEAD":
             await streamer.close()
             return Response(headers=response_headers, status_code=response.status_code)
         else:
             return EnhancedStreamingResponse(
-                streamer.stream_content(video_url, headers),
+                streamer.stream_content(video_url, proxy_headers.request),
                 headers=response_headers,
                 status_code=response.status_code,
                 background=BackgroundTask(streamer.close),
@@ -159,7 +182,7 @@ async def handle_stream_request(method: str, video_url: str, headers: dict, veri
 
 
 async def fetch_and_process_m3u8(
-    streamer: Streamer, url: str, headers: dict, request: Request, key_url: HttpUrl = None
+    streamer: Streamer, url: str, proxy_headers: ProxyRequestHeaders, request: Request, key_url: HttpUrl = None
 ):
     """
     Fetches and processes the m3u8 playlist, converting it to an HLS playlist.
@@ -167,7 +190,7 @@ async def fetch_and_process_m3u8(
     Args:
         streamer (Streamer): The HTTP client to use for streaming.
         url (str): The URL of the m3u8 playlist.
-        headers (dict): The headers to include in the request.
+        proxy_headers (ProxyRequestHeaders): The headers to include in the request.
         request (Request): The incoming HTTP request.
         key_url (HttpUrl, optional): The HLS Key URL to replace the original key URL. Defaults to None.
 
@@ -175,16 +198,15 @@ async def fetch_and_process_m3u8(
         Response: The HTTP response with the processed m3u8 playlist.
     """
     try:
-        content = await streamer.get_text(url, headers)
+        content = await streamer.get_text(url, proxy_headers.request)
         processor = M3U8Processor(request, key_url)
         processed_content = await processor.process_m3u8(content, str(streamer.response.url))
+        response_headers = {"Content-Disposition": "inline", "Accept-Ranges": "none"}
+        response_headers.update(proxy_headers.response)
         return Response(
             content=processed_content,
             media_type="application/vnd.apple.mpegurl",
-            headers={
-                "Content-Disposition": "inline",
-                "Accept-Ranges": "none",
-            },
+            headers=response_headers,
         )
     except httpx.HTTPStatusError as e:
         logger.error(f"HTTP error while fetching m3u8: {e}")
@@ -229,7 +251,13 @@ async def handle_drm_key_data(key_id, key, drm_info):
 
 
 async def get_manifest(
-    request: Request, mpd_url: str, headers: dict, key_id: str = None, key: str = None, verify_ssl: bool = True
+    request: Request,
+    mpd_url: str,
+    proxy_headers: ProxyRequestHeaders,
+    key_id: str = None,
+    key: str = None,
+    verify_ssl: bool = True,
+    use_request_proxy: bool = True,
 ):
     """
     Retrieves and processes the MPD manifest, converting it to an HLS manifest.
@@ -237,17 +265,22 @@ async def get_manifest(
     Args:
         request (Request): The incoming HTTP request.
         mpd_url (str): The URL of the MPD manifest.
-        headers (dict): The headers to include in the request.
+        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.
         verify_ssl (bool, optional): Whether to verify the SSL certificate of the destination. Defaults to True.
+        use_request_proxy (bool, optional): Whether to use the MediaFlow proxy configuration. Defaults to True.
 
     Returns:
         Response: The HTTP response with the HLS manifest.
     """
     try:
         mpd_dict = await get_cached_mpd(
-            mpd_url, headers=headers, parse_drm=not key_id and not key, verify_ssl=verify_ssl
+            mpd_url,
+            headers=proxy_headers.request,
+            parse_drm=not key_id and not key,
+            verify_ssl=verify_ssl,
+            use_request_proxy=use_request_proxy,
         )
     except DownloadError as e:
         raise HTTPException(status_code=e.status_code, detail=f"Failed to download MPD: {e.message}")
@@ -255,7 +288,7 @@ async def get_manifest(
 
     if drm_info and not drm_info.get("isDrmProtected"):
         # For non-DRM protected MPD, we still create an HLS manifest
-        return await process_manifest(request, mpd_dict, None, None)
+        return await process_manifest(request, mpd_dict, proxy_headers, None, None)
 
     key_id, key = await handle_drm_key_data(key_id, key, drm_info)
 
@@ -265,17 +298,18 @@ async def get_manifest(
     if key and len(key) != 32:
         key = base64.urlsafe_b64decode(pad_base64(key)).hex()
 
-    return await process_manifest(request, mpd_dict, key_id, key)
+    return await process_manifest(request, mpd_dict, proxy_headers, key_id, key)
 
 
 async def get_playlist(
     request: Request,
     mpd_url: str,
     profile_id: str,
-    headers: dict,
+    proxy_headers: ProxyRequestHeaders,
     key_id: str = None,
     key: str = None,
     verify_ssl: bool = True,
+    use_request_proxy: bool = True,
 ):
     """
     Retrieves and processes the MPD manifest, converting it to an HLS playlist for a specific profile.
@@ -284,32 +318,35 @@ async def get_playlist(
         request (Request): The incoming HTTP request.
         mpd_url (str): The URL of the MPD manifest.
         profile_id (str): The profile ID to generate the playlist for.
-        headers (dict): The headers to include in the request.
+        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.
         verify_ssl (bool, optional): Whether to verify the SSL certificate of the destination. Defaults to True.
+        use_request_proxy (bool, optional): Whether to use the MediaFlow proxy configuration. Defaults to True.
 
     Returns:
         Response: The HTTP response with the HLS playlist.
     """
     mpd_dict = await get_cached_mpd(
         mpd_url,
-        headers=headers,
+        headers=proxy_headers.request,
         parse_drm=not key_id and not key,
         parse_segment_profile_id=profile_id,
         verify_ssl=verify_ssl,
+        use_request_proxy=use_request_proxy,
     )
-    return await process_playlist(request, mpd_dict, profile_id)
+    return await process_playlist(request, mpd_dict, profile_id, proxy_headers)
 
 
 async def get_segment(
     init_url: str,
     segment_url: str,
     mimetype: str,
-    headers: dict,
+    proxy_headers: ProxyRequestHeaders,
     key_id: str = None,
     key: str = None,
     verify_ssl: bool = True,
+    use_request_proxy: bool = True,
 ):
     """
     Retrieves and processes a media segment, decrypting it if necessary.
@@ -318,28 +355,36 @@ async def get_segment(
         init_url (str): The URL of the initialization segment.
         segment_url (str): The URL of the media segment.
         mimetype (str): The MIME type of the segment.
-        headers (dict): The headers to include in the request.
+        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.
         verify_ssl (bool, optional): Whether to verify the SSL certificate of the destination. Defaults to True.
+        use_request_proxy (bool, optional): Whether to use the MediaFlow proxy configuration. Defaults to True.
 
     Returns:
         Response: The HTTP response with the processed segment.
     """
     try:
-        init_content = await get_cached_init_segment(init_url, headers, verify_ssl)
-        segment_content = await download_file_with_retry(segment_url, headers, verify_ssl=verify_ssl)
+        init_content = await get_cached_init_segment(init_url, proxy_headers.request, verify_ssl, use_request_proxy)
+        segment_content = await download_file_with_retry(
+            segment_url, proxy_headers.request, verify_ssl=verify_ssl, use_request_proxy=use_request_proxy
+        )
     except DownloadError as e:
         raise HTTPException(status_code=e.status_code, detail=f"Failed to download segment: {e.message}")
-    return await process_segment(init_content, segment_content, mimetype, key_id, key)
+    return await process_segment(init_content, segment_content, mimetype, proxy_headers, key_id, key)
 
 
-async def get_public_ip():
+async def get_public_ip(use_request_proxy: bool = True):
     """
     Retrieves the public IP address of the MediaFlow proxy.
 
+    Args:
+        use_request_proxy (bool, optional): Whether to use the proxy configuration from the user's MediaFlow config. Defaults to True.
+
     Returns:
         Response: The HTTP response with the public IP address.
     """
-    ip_address_data = await request_with_retry("GET", "https://api.ipify.org?format=json", {})
+    ip_address_data = await request_with_retry(
+        "GET", "https://api.ipify.org?format=json", {}, use_request_proxy=use_request_proxy
+    )
     return ip_address_data.json()

mediaflow_proxy/main.py

@@ -3,6 +3,7 @@ from importlib import resources
 
 from fastapi import FastAPI, Depends, Security, HTTPException
 from fastapi.security import APIKeyQuery, APIKeyHeader
+from starlette.middleware.cors import CORSMiddleware
 from starlette.responses import RedirectResponse
 from starlette.staticfiles import StaticFiles
 
@@ -13,6 +14,13 @@ logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(name)s - %(level
 app = FastAPI()
 api_password_query = APIKeyQuery(name="api_password", auto_error=False)
 api_password_header = APIKeyHeader(name="api_password", auto_error=False)
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
 
 
 async def verify_api_key(api_key: str = Security(api_password_query), api_key_alt: str = Security(api_password_header)):

mediaflow_proxy/mpd_processor.py

@@ -7,18 +7,21 @@ from fastapi import Request, Response, HTTPException
 
 from mediaflow_proxy.configs import settings
 from mediaflow_proxy.drm.decrypter import decrypt_segment
-from mediaflow_proxy.utils.http_utils import encode_mediaflow_proxy_url, get_original_scheme
+from mediaflow_proxy.utils.http_utils import encode_mediaflow_proxy_url, get_original_scheme, ProxyRequestHeaders
 
 logger = logging.getLogger(__name__)
 
 
-async def process_manifest(request: Request, mpd_dict: dict, key_id: str = None, key: str = None) -> Response:
+async def process_manifest(
+    request: Request, mpd_dict: dict, proxy_headers: ProxyRequestHeaders, key_id: str = None, key: str = None
+) -> Response:
     """
     Processes the MPD manifest and converts it to an HLS manifest.
 
     Args:
         request (Request): The incoming HTTP request.
         mpd_dict (dict): The MPD manifest data.
+        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.
 
@@ -26,10 +29,12 @@ async def process_manifest(request: Request, mpd_dict: dict, key_id: str = None,
         Response: The HLS manifest as an HTTP response.
     """
     hls_content = build_hls(mpd_dict, request, key_id, key)
-    return Response(content=hls_content, media_type="application/vnd.apple.mpegurl")
+    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) -> Response:
+async def process_playlist(
+    request: Request, mpd_dict: dict, profile_id: str, proxy_headers: ProxyRequestHeaders
+) -> Response:
     """
     Processes the MPD manifest and converts it to an HLS playlist for a specific profile.
 
@@ -37,6 +42,7 @@ async def process_playlist(request: Request, mpd_dict: dict, profile_id: str) ->
         request (Request): The incoming HTTP request.
         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.
 
     Returns:
         Response: The HLS playlist as an HTTP response.
@@ -49,13 +55,14 @@ async def process_playlist(request: Request, mpd_dict: dict, profile_id: str) ->
         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")
+    return Response(content=hls_content, media_type="application/vnd.apple.mpegurl", headers=proxy_headers.response)
 
 
 async def process_segment(
     init_content: bytes,
     segment_content: bytes,
     mimetype: str,
+    proxy_headers: ProxyRequestHeaders,
     key_id: str = None,
     key: str = None,
 ) -> Response:
@@ -66,6 +73,7 @@ async def process_segment(
         init_content (bytes): The initialization segment content.
         segment_content (bytes): The media 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.
 
@@ -81,7 +89,7 @@ async def process_segment(
         # For non-DRM protected content, we just concatenate init and segment content
         decrypted_content = init_content + segment_content
 
-    return Response(content=decrypted_content, media_type=mimetype)
+    return Response(content=decrypted_content, media_type=mimetype, headers=proxy_headers.response)
 
 
 def build_hls(mpd_dict: dict, request: Request, key_id: str = None, key: str = None) -> str:

mediaflow_proxy/routes.py

@@ -2,7 +2,7 @@ from fastapi import Request, Depends, APIRouter
 from pydantic import HttpUrl
 
 from .handlers import handle_hls_stream_proxy, proxy_stream, get_manifest, get_playlist, get_segment, get_public_ip
-from .utils.http_utils import get_proxy_headers
+from .utils.http_utils import get_proxy_headers, ProxyRequestHeaders
 
 proxy_router = APIRouter()
 
@@ -12,9 +12,10 @@ proxy_router = APIRouter()
 async def hls_stream_proxy(
     request: Request,
     d: HttpUrl,
-    headers: dict = Depends(get_proxy_headers),
+    proxy_headers: ProxyRequestHeaders = Depends(get_proxy_headers),
     key_url: HttpUrl | None = None,
     verify_ssl: bool = False,
+    use_request_proxy: bool = True,
 ):
     """
     Proxify HLS stream requests, fetching and processing the m3u8 playlist or streaming the content.
@@ -23,20 +24,25 @@ async def hls_stream_proxy(
         request (Request): The incoming HTTP request.
         d (HttpUrl): The destination URL to fetch the content from.
         key_url (HttpUrl, optional): The HLS Key URL to replace the original key URL. Defaults to None. (Useful for bypassing some sneaky protection)
-        headers (dict): The headers to include in the request.
+        proxy_headers (ProxyRequestHeaders): The headers to include in the request.
         verify_ssl (bool, optional): Whether to verify the SSL certificate of the destination. Defaults to False.
+        use_request_proxy (bool, optional): Whether to use the MediaFlow proxy configuration. Defaults to True.
 
     Returns:
         Response: The HTTP response with the processed m3u8 playlist or streamed content.
     """
     destination = str(d)
-    return await handle_hls_stream_proxy(request, destination, headers, key_url, verify_ssl)
+    return await handle_hls_stream_proxy(request, destination, proxy_headers, key_url, verify_ssl, use_request_proxy)
 
 
 @proxy_router.head("/stream")
 @proxy_router.get("/stream")
 async def proxy_stream_endpoint(
-    request: Request, d: HttpUrl, headers: dict = Depends(get_proxy_headers), verify_ssl: bool = False
+    request: Request,
+    d: HttpUrl,
+    proxy_headers: ProxyRequestHeaders = Depends(get_proxy_headers),
+    verify_ssl: bool = False,
+    use_request_proxy: bool = True,
 ):
     """
     Proxies stream requests to the given video URL.
@@ -44,24 +50,26 @@ async def proxy_stream_endpoint(
     Args:
         request (Request): The incoming HTTP request.
         d (HttpUrl): The URL of the video to stream.
-        headers (dict): The headers to include in the request.
+        proxy_headers (ProxyRequestHeaders): The headers to include in the request.
         verify_ssl (bool, optional): Whether to verify the SSL certificate of the destination. Defaults to False.
+        use_request_proxy (bool, optional): Whether to use the MediaFlow proxy configuration. Defaults to True.
 
     Returns:
         Response: The HTTP response with the streamed content.
     """
-    headers.update({"range": headers.get("range", "bytes=0-")})
-    return await proxy_stream(request.method, str(d), headers, verify_ssl)
+    proxy_headers.request.update({"range": proxy_headers.request.get("range", "bytes=0-")})
+    return await proxy_stream(request.method, str(d), proxy_headers, verify_ssl, use_request_proxy)
 
 
 @proxy_router.get("/mpd/manifest")
 async def manifest_endpoint(
     request: Request,
     d: HttpUrl,
-    headers: dict = Depends(get_proxy_headers),
+    proxy_headers: ProxyRequestHeaders = Depends(get_proxy_headers),
     key_id: str = None,
     key: str = None,
     verify_ssl: bool = False,
+    use_request_proxy: bool = True,
 ):
     """
     Retrieves and processes the MPD manifest, converting it to an HLS manifest.
@@ -69,15 +77,16 @@ async def manifest_endpoint(
     Args:
         request (Request): The incoming HTTP request.
         d (HttpUrl): The URL of the MPD manifest.
-        headers (dict): The headers to include in the request.
+        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.
         verify_ssl (bool, optional): Whether to verify the SSL certificate of the destination. Defaults to False.
+        use_request_proxy (bool, optional): Whether to use the MediaFlow proxy configuration. Defaults to True.
 
     Returns:
         Response: The HTTP response with the HLS manifest.
     """
-    return await get_manifest(request, str(d), headers, key_id, key, verify_ssl)
+    return await get_manifest(request, str(d), proxy_headers, key_id, key, verify_ssl, use_request_proxy)
 
 
 @proxy_router.get("/mpd/playlist")
@@ -85,10 +94,11 @@ async def playlist_endpoint(
     request: Request,
     d: HttpUrl,
     profile_id: str,
-    headers: dict = Depends(get_proxy_headers),
+    proxy_headers: ProxyRequestHeaders = Depends(get_proxy_headers),
     key_id: str = None,
     key: str = None,
     verify_ssl: bool = False,
+    use_request_proxy: bool = True,
 ):
     """
     Retrieves and processes the MPD manifest, converting it to an HLS playlist for a specific profile.
@@ -97,15 +107,16 @@ async def playlist_endpoint(
         request (Request): The incoming HTTP request.
         d (HttpUrl): The URL of the MPD manifest.
         profile_id (str): The profile ID to generate the playlist for.
-        headers (dict): The headers to include in the request.
+        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.
         verify_ssl (bool, optional): Whether to verify the SSL certificate of the destination. Defaults to False.
+        use_request_proxy (bool, optional): Whether to use the MediaFlow proxy configuration. Defaults to True.
 
     Returns:
         Response: The HTTP response with the HLS playlist.
     """
-    return await get_playlist(request, str(d), profile_id, headers, key_id, key, verify_ssl)
+    return await get_playlist(request, str(d), profile_id, proxy_headers, key_id, key, verify_ssl, use_request_proxy)
 
 
 @proxy_router.get("/mpd/segment")
@@ -113,10 +124,11 @@ async def segment_endpoint(
     init_url: HttpUrl,
     segment_url: HttpUrl,
     mime_type: str,
-    headers: dict = Depends(get_proxy_headers),
+    proxy_headers: ProxyRequestHeaders = Depends(get_proxy_headers),
     key_id: str = None,
     key: str = None,
     verify_ssl: bool = False,
+    use_request_proxy: bool = True,
 ):
     """
     Retrieves and processes a media segment, decrypting it if necessary.
@@ -125,23 +137,28 @@ async def segment_endpoint(
         init_url (HttpUrl): The URL of the initialization segment.
         segment_url (HttpUrl): The URL of the media segment.
         mime_type (str): The MIME type of the segment.
-        headers (dict): The headers to include in the request.
+        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.
         verify_ssl (bool, optional): Whether to verify the SSL certificate of the destination. Defaults to False.
+        use_request_proxy (bool, optional): Whether to use the MediaFlow proxy configuration. Defaults to True.
 
     Returns:
         Response: The HTTP response with the processed segment.
     """
-    return await get_segment(str(init_url), str(segment_url), mime_type, headers, key_id, key, verify_ssl)
+    return await get_segment(
+        str(init_url), str(segment_url), mime_type, proxy_headers, key_id, key, verify_ssl, use_request_proxy
+    )
 
 
 @proxy_router.get("/ip")
-async def get_mediaflow_proxy_public_ip():
+async def get_mediaflow_proxy_public_ip(
+    use_request_proxy: bool = True,
+):
     """
     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()
+    return await get_public_ip(use_request_proxy)

mediaflow_proxy/utils/cache_utils.py

@@ -14,7 +14,12 @@ init_segment_cache = TTLCache(maxsize=100, ttl=3600)  # 1 hour default TTL
 
 
 async def get_cached_mpd(
-    mpd_url: str, headers: dict, parse_drm: bool, parse_segment_profile_id: str | None = None, verify_ssl: bool = True
+    mpd_url: str,
+    headers: dict,
+    parse_drm: bool,
+    parse_segment_profile_id: str | None = None,
+    verify_ssl: bool = True,
+    use_request_proxy: bool = True,
 ) -> dict:
     """
     Retrieves and caches the MPD manifest, parsing it if not already cached.
@@ -25,6 +30,7 @@ async def get_cached_mpd(
         parse_drm (bool): Whether to parse DRM information.
         parse_segment_profile_id (str, optional): The profile ID to parse segments for. Defaults to None.
         verify_ssl (bool, optional): Whether to verify the SSL certificate of the destination. Defaults to True.
+        use_request_proxy (bool, optional): Whether to use the proxy configuration from the user's MediaFlow config. Defaults to True.
 
     Returns:
         dict: The parsed MPD manifest data.
@@ -34,7 +40,9 @@ async def get_cached_mpd(
         logger.info(f"Using cached MPD for {mpd_url}")
         return parse_mpd_dict(mpd_cache[mpd_url]["mpd"], mpd_url, parse_drm, parse_segment_profile_id)
 
-    mpd_dict = parse_mpd(await download_file_with_retry(mpd_url, headers, verify_ssl=verify_ssl))
+    mpd_dict = parse_mpd(
+        await download_file_with_retry(mpd_url, headers, verify_ssl=verify_ssl, use_request_proxy=use_request_proxy)
+    )
     parsed_mpd_dict = parse_mpd_dict(mpd_dict, mpd_url, parse_drm, parse_segment_profile_id)
     current_time = datetime.datetime.now(datetime.UTC)
     expiration_time = current_time + datetime.timedelta(seconds=parsed_mpd_dict.get("minimumUpdatePeriod", 300))
@@ -42,7 +50,9 @@ async def get_cached_mpd(
     return parsed_mpd_dict
 
 
-async def get_cached_init_segment(init_url: str, headers: dict, verify_ssl: bool = True) -> bytes:
+async def get_cached_init_segment(
+    init_url: str, headers: dict, verify_ssl: bool = True, use_request_proxy: bool = True
+) -> bytes:
     """
     Retrieves and caches the initialization segment.
 
@@ -50,11 +60,14 @@ async def get_cached_init_segment(init_url: str, headers: dict, verify_ssl: bool
         init_url (str): The URL of the initialization segment.
         headers (dict): The headers to include in the request.
         verify_ssl (bool, optional): Whether to verify the SSL certificate of the destination. Defaults to True.
+        use_request_proxy (bool, optional): Whether to use the proxy configuration from the user's MediaFlow config. Defaults to True.
 
     Returns:
         bytes: The initialization segment content.
     """
     if init_url not in init_segment_cache:
-        init_content = await download_file_with_retry(init_url, headers, verify_ssl=verify_ssl)
+        init_content = await download_file_with_retry(
+            init_url, headers, verify_ssl=verify_ssl, use_request_proxy=use_request_proxy
+        )
         init_segment_cache[init_url] = init_content
     return init_segment_cache[init_url]

mediaflow_proxy/utils/http_utils.py

@@ -1,5 +1,6 @@
 import logging
 import typing
+from dataclasses import dataclass
 from functools import partial
 from urllib import parse
 
@@ -137,7 +138,13 @@ class Streamer:
         await self.client.aclose()
 
 
-async def download_file_with_retry(url: str, headers: dict, timeout: float = 10.0, verify_ssl: bool = True):
+async def download_file_with_retry(
+    url: str,
+    headers: dict,
+    timeout: float = 10.0,
+    verify_ssl: bool = True,
+    use_request_proxy: bool = True,
+):
     """
     Downloads a file with retry logic.
 
@@ -146,6 +153,7 @@ async def download_file_with_retry(url: str, headers: dict, timeout: float = 10.
         headers (dict): The headers to include in the request.
         timeout (float, optional): The request timeout. Defaults to 10.0.
         verify_ssl (bool, optional): Whether to verify the SSL certificate of the destination. Defaults to True.
+        use_request_proxy (bool, optional): Whether to use the proxy configuration from the user's MediaFlow config. Defaults to True.
 
     Returns:
         bytes: The downloaded file content.
@@ -154,7 +162,10 @@ async def download_file_with_retry(url: str, headers: dict, timeout: float = 10.
         DownloadError: If the download fails after retries.
     """
     async with httpx.AsyncClient(
-        follow_redirects=True, timeout=timeout, proxy=settings.proxy_url, verify=verify_ssl
+        follow_redirects=True,
+        timeout=timeout,
+        proxy=settings.proxy_url if use_request_proxy else None,
+        verify=verify_ssl,
     ) as client:
         try:
             response = await fetch_with_retry(client, "GET", url, headers)
@@ -166,7 +177,9 @@ async def download_file_with_retry(url: str, headers: dict, timeout: float = 10.
             raise DownloadError(502, f"Failed to download file: {e.last_attempt.result()}")
 
 
-async def request_with_retry(method: str, url: str, headers: dict, timeout: float = 10.0, **kwargs):
+async def request_with_retry(
+    method: str, url: str, headers: dict, timeout: float = 10.0, use_request_proxy: bool = True, **kwargs
+):
     """
     Sends an HTTP request with retry logic.
 
@@ -175,6 +188,7 @@ async def request_with_retry(method: str, url: str, headers: dict, timeout: floa
         url (str): The URL to send the request to.
         headers (dict): The headers to include in the request.
         timeout (float, optional): The request timeout. Defaults to 10.0.
+        use_request_proxy (bool, optional): Whether to use the proxy configuration from the user's MediaFlow config. Defaults to True.
         **kwargs: Additional arguments to pass to the request.
 
     Returns:
@@ -183,7 +197,9 @@ async def request_with_retry(method: str, url: str, headers: dict, timeout: floa
     Raises:
         DownloadError: If the request fails after retries.
     """
-    async with httpx.AsyncClient(follow_redirects=True, timeout=timeout, proxy=settings.proxy_url) as client:
+    async with httpx.AsyncClient(
+        follow_redirects=True, timeout=timeout, proxy=settings.proxy_url if use_request_proxy else None
+    ) as client:
         try:
             response = await fetch_with_retry(client, method, url, headers, **kwargs)
             return response
@@ -198,6 +214,7 @@ def encode_mediaflow_proxy_url(
     destination_url: str | None = None,
     query_params: dict | None = None,
     request_headers: dict | None = None,
+    response_headers: dict | None = None,
 ) -> str:
     """
     Encodes a MediaFlow proxy URL with query parameters and headers.
@@ -208,6 +225,7 @@ def encode_mediaflow_proxy_url(
         destination_url (str, optional): The destination URL to include in the query parameters. Defaults to None.
         query_params (dict, optional): Additional query parameters to include. Defaults to None.
         request_headers (dict, optional): Headers to include as query parameters. Defaults to None.
+        response_headers (dict, optional): Headers to include as query parameters. Defaults to None.
 
     Returns:
         str: The encoded MediaFlow proxy URL.
@@ -221,6 +239,10 @@ def encode_mediaflow_proxy_url(
         query_params.update(
             {key if key.startswith("h_") else f"h_{key}": value for key, value in request_headers.items()}
         )
+    if response_headers:
+        query_params.update(
+            {key if key.startswith("r_") else f"r_{key}": value for key, value in response_headers.items()}
+        )
     # Encode the query parameters
     encoded_params = parse.urlencode(query_params, quote_via=parse.quote)
 
@@ -263,7 +285,13 @@ def get_original_scheme(request: Request) -> str:
     return "http"
 
 
-def get_proxy_headers(request: Request) -> dict:
+@dataclass
+class ProxyRequestHeaders:
+    request: dict
+    response: dict
+
+
+def get_proxy_headers(request: Request) -> ProxyRequestHeaders:
     """
     Extracts proxy headers from the request query parameters.
 
@@ -271,11 +299,12 @@ def get_proxy_headers(request: Request) -> dict:
         request (Request): The incoming HTTP request.
 
     Returns:
-        dict: A dictionary of proxy headers.
+        ProxyRequest: A named tuple containing the request headers and response headers.
     """
     request_headers = {k: v for k, v in request.headers.items() if k in SUPPORTED_REQUEST_HEADERS}
     request_headers.update({k[2:].lower(): v for k, v in request.query_params.items() if k.startswith("h_")})
-    return request_headers
+    response_headers = {k[2:].lower(): v for k, v in request.query_params.items() if k.startswith("r_")}
+    return ProxyRequestHeaders(request_headers, response_headers)
 
 
 class EnhancedStreamingResponse(Response):