Upload 25 files

Dockerfile

@@ -3,7 +3,7 @@ FROM python:3.12-slim
 # Set environment variables
 ENV PYTHONDONTWRITEBYTECODE="1"
 ENV PYTHONUNBUFFERED="1"
-ENV PORT="8080"
+ENV PORT="8888"
 
 # Set work directory
 WORKDIR /mediaflow_proxy
@@ -22,6 +22,8 @@ USER mediaflow_proxy
 RUN pip install --user --no-cache-dir poetry
 
 # Copy only requirements to cache them in docker layer
+COPY --chown=mediaflow_proxy:mediaflow_proxy pyproject.toml poetry.lock* /mediaflow_proxy/
+
 # Project initialization:
 RUN poetry config virtualenvs.in-project true \
     && poetry install --no-interaction --no-ansi --no-dev
@@ -30,7 +32,7 @@ RUN poetry config virtualenvs.in-project true \
 COPY --chown=mediaflow_proxy:mediaflow_proxy . /mediaflow_proxy
 
 # Expose the port the app runs on
-EXPOSE 8080
+EXPOSE 8888
 
 # Activate virtual environment and run the application with Gunicorn
-CMD ["poetry", "run", "gunicorn", "mediaflow_proxy.main:app", "-w", "4", "-k", "uvicorn.workers.UvicornWorker", "--bind", "0.0.0.0:8080", "--timeout", "120", "--max-requests", "500", "--max-requests-jitter", "200"]
+CMD ["poetry", "run", "gunicorn", "mediaflow_proxy.main:app", "-w", "4", "-k", "uvicorn.workers.UvicornWorker", "--bind", "0.0.0.0:8888", "--timeout", "120", "--max-requests", "500", "--max-requests-jitter", "200"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [2024] [Mohamed Zumair]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,13 +1,215 @@
----
-title: MediaProxy
-emoji: 💻
-colorFrom: indigo
-colorTo: green
-sdk: docker
-pinned: false
-app_port: 8080
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
-
-Test
+# MediaFlow Proxy
+
+<div style="text-align: center;">
+  <img src="https://cdn.githubraw.com/mhdzumair/mediaflow-proxy/main/static/logo.png" alt="MediaFlow Proxy Logo" width="200" style="border-radius: 15px;">
+</div>
+
+MediaFlow Proxy is a powerful and flexible solution for proxifying various types of media streams. It supports HTTP(S) links, HLS (M3U8) streams, and MPEG-DASH streams, including DRM-protected content. This proxy can convert MPEG-DASH DRM-protected streams to decrypted HLS live streams in real-time, making it one of the fastest live decrypter servers available.
+
+## Features
+
+- Convert MPEG-DASH streams (DRM-protected and non-protected) to HLS
+- Support for Clear Key DRM-protected MPD DASH streams
+- Support for non-DRM protected DASH live and VOD streams
+- Proxy HTTP/HTTPS links with custom headers
+- Proxy and modify HLS (M3U8) streams in real-time with custom headers and key URL modifications for bypassing some sneaky restrictions.
+- Retrieve public IP address of the MediaFlow Proxy server for use with Debrid services
+- Support for HTTP/HTTPS/SOCKS5 proxy forwarding
+- Protect against unauthorized access and network bandwidth abuses
+
+## Installation
+
+
+### Option 1: Self-Hosted Deployment
+
+#### Using Docker from Docker Hub
+
+1. Pull & Run the Docker image:
+   ```
+   docker run -p 8888:8888 -e API_PASSWORD=your_password mhdzumair/mediaflow-proxy
+   ```
+
+#### Using Poetry
+
+1. Clone the repository:
+   ```
+   git clone https://github.com/mhdzumair/mediaflow-proxy.git
+   cd mediaflow-proxy
+   ```
+
+2. Install dependencies using Poetry:
+   ```
+   poetry install
+   ```
+
+3. Set the `API_PASSWORD` environment variable in `.env`:
+   ```
+   echo "API_PASSWORD=your_password" > .env
+   ```
+
+4. Run the FastAPI server:
+   ```
+   poetry run uvicorn mediaflow_proxy.main:app --host 0.0.0.0 --port 8888
+   ```
+
+
+#### Build and Run Docker Image Locally
+
+1. Build the Docker image:
+   ```
+   docker build -t mediaflow-proxy .
+   ```
+
+2. Run the Docker container:
+   ```
+   docker run -p 8888:8888 -e API_PASSWORD=your_password mediaflow-proxy
+   ```
+
+#### Configuration
+
+Set the following environment variables:
+
+- `API_PASSWORD`: Required. Protects against unauthorized access and API network abuses.
+- `PROXY_URL`: Optional. HTTP/HTTPS/SOCKS5 proxy URL for forwarding network requests.
+- `MPD_LIVE_STREAM_DELAY`: Optional. Delay in seconds for live DASH streams. This is useful to prevent buffering issues with live streams. Default is `30` seconds.
+
+
+### Option 2: Premium Hosted Service (ElfHosted)
+<div style="text-align: center;">
+  <img src="https://store.elfhosted.com/wp-content/uploads/2024/08/mediaflow-proxy.jpg" alt="ElfHosted Logo" width="200" style="border-radius: 15px;">
+</div>
+For a hassle-free, high-performance deployment of MediaFlow Proxy, consider the premium hosted service through ElfHosted.
+
+To purchase:
+1. Visit [https://store.elfhosted.com/product/mediaflow-proxy](https://store.elfhosted.com/product/mediaflow-proxy)
+2. Follow ElfHosted's setup instructions
+
+Benefits:
+- Instant setup and automatic updates
+- High performance and 24/7 availability
+- No server maintenance required
+
+Ideal for users who want a reliable, plug-and-play solution without the technical overhead of self-hosting.
+
+## Usage
+
+### Endpoints
+
+1. `/proxy/hls`: Proxify HLS streams
+2. `/proxy/stream`: Proxy generic http video streams
+3. `/proxy/mpd/manifest`: Process MPD manifests
+4. `/proxy/mpd/playlist`: Generate HLS playlists from MPD
+5. `/proxy/mpd/segment`: Process and decrypt media segments
+6. `/proxy/ip`: Get the public IP address of the MediaFlow Proxy server
+
+Once the server is running, for more details on the available endpoints and their parameters, visit the Swagger UI at `http://localhost:8888/docs`.
+
+### Examples
+
+#### Proxy HTTPS Stream
+
+```bash
+mpv "http://localhost:8888/proxy/stream?d=https://jsoncompare.org/LearningContainer/SampleFiles/Video/MP4/sample-mp4-file.mp4&api_password=your_password"
+```
+
+#### Proxy HLS Stream with Headers
+
+```bash
+mpv "http://localhost:8888/proxy/hls?d=https://devstreaming-cdn.apple.com/videos/streaming/examples/img_bipbop_adv_example_fmp4/master.m3u8&h_referer=https://apple.com/&h_origin=https://apple.com&h_user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.0.0 Safari/537.36&api_password=your_password"
+```
+
+#### Live DASH Stream (Non-DRM Protected)
+
+```bash
+mpv -v "http://localhost:8888/proxy/mpd/manifest?d=https://livesim.dashif.org/livesim/chunkdur_1/ato_7/testpic4_8s/Manifest.mpd&api_password=your_password"
+```
+
+#### VOD DASH Stream (DRM Protected)
+
+```bash
+mpv -v "http://localhost:8888/proxy/mpd/manifest?d=https://media.axprod.net/TestVectors/v7-MultiDRM-SingleKey/Manifest_1080p_ClearKey.mpd&key_id=nrQFDeRLSAKTLifXUIPiZg&key=FmY0xnWCPCNaSpRG-tUuTQ&api_password=your_password"
+```
+
+Note: The `key` and `key_id` parameters are automatically processed if they're not in the correct format.
+
+### URL Encoding
+
+For players like VLC that require properly encoded URLs, use the `encode_mediaflow_proxy_url` function:
+
+```python
+from mediaflow_proxy.utils.http_utils import encode_mediaflow_proxy_url
+
+encoded_url = encode_mediaflow_proxy_url(
+    mediaflow_proxy_url="http://127.0.0.1:8888",
+    endpoint="/proxy/mpd/manifest",
+    destination_url="https://media.axprod.net/TestVectors/v7-MultiDRM-SingleKey/Manifest_1080p_ClearKey.mpd",
+    query_params={
+        "key_id": "nrQFDeRLSAKTLifXUIPiZg",
+        "key": "FmY0xnWCPCNaSpRG-tUuTQ",
+        "api_password": "your_password"
+    },
+    request_headers={
+        "referer": "https://media.axprod.net/",
+        "origin": "https://media.axprod.net",
+    }
+)
+
+print(encoded_url)
+
+# http://127.0.0.1:8888/proxy/mpd/manifest?key_id=nrQFDeRLSAKTLifXUIPiZg&key=FmY0xnWCPCNaSpRG-tUuTQ&api_password=your_password&d=https%3A%2F%2Fmedia.axprod.net%2FTestVectors%2Fv7-MultiDRM-SingleKey%2FManifest_1080p_ClearKey.mpd&h_referer=https%3A%2F%2Fmedia.axprod.net%2F&h_origin=https%3A%2F%2Fmedia.axprod.net
+```
+
+This will output a properly encoded URL that can be used with players like VLC.
+
+```bash
+vlc "http://127.0.0.1:8888/proxy/mpd/manifest?key_id=nrQFDeRLSAKTLifXUIPiZg&key=FmY0xnWCPCNaSpRG-tUuTQ&api_password=dedsec&d=https%3A%2F%2Fmedia.axprod.net%2FTestVectors%2Fv7-MultiDRM-SingleKey%2FManifest_1080p_ClearKey.mpd"
+```
+
+### Using MediaFlow Proxy with Debrid Services and Stremio Addons
+
+MediaFlow Proxy can be particularly useful when working with Debrid services (like Real-Debrid, AllDebrid) and Stremio addons. The `/proxy/ip` endpoint allows you to retrieve the public IP address of the MediaFlow Proxy server, which is crucial for routing Debrid streams correctly.
+
+When a Stremio addon needs to create a video URL for a Debrid service, it typically needs to provide the user's public IP address. However, when routing the Debrid stream through MediaFlow Proxy, you should use the IP address of the MediaFlow Proxy server instead.
+
+Here's how to utilize MediaFlow Proxy in this scenario:
+
+1. If MediaFlow Proxy is accessible over the internet:
+   - Use the `/proxy/ip` endpoint to get the MediaFlow Proxy server's public IP.
+   - Use this IP when creating Debrid service URLs in your Stremio addon.
+
+2. If MediaFlow Proxy is set up locally:
+   - Stremio addons can directly use the client's IP address.
+
+
+## Future Development
+
+- Add support for Widevine and PlayReady decryption
+
+## Acknowledgements and Inspirations
+
+MediaFlow Proxy was developed with inspiration from various projects and resources:
+
+- [Stremio Server](https://github.com/Stremio/stremio-server) for HLS Proxify implementation, which inspired our HLS M3u8 Manifest parsing and redirection proxify support.
+- [Comet Debrid proxy](https://github.com/g0ldyy/comet) for the idea of proxifying HTTPS video streams.
+- [mp4decrypt](https://www.bento4.com/developers/dash/encryption_and_drm/), [mp4box](https://wiki.gpac.io/xmlformats/Common-Encryption/), and [devine](https://github.com/devine-dl/devine) for insights on parsing MPD and decrypting Clear Key DRM protected content.
+- Test URLs were sourced from:
+  - [OTTVerse MPEG-DASH MPD Examples](https://ottverse.com/free-mpeg-dash-mpd-manifest-example-test-urls/)
+  - [OTTVerse HLS M3U8 Examples](https://ottverse.com/free-hls-m3u8-test-urls/)
+  - [Bitmovin Stream Test](https://bitmovin.com/demos/stream-test)
+  - [Bitmovin DRM Demo](https://bitmovin.com/demos/drm)
+  - [DASH-IF Reference Player](http://reference.dashif.org/dash.js/nightly/samples/)
+- [HLS Protocol RFC](https://www.rfc-editor.org/rfc/rfc8216) for understanding the HLS protocol specifications.
+- Claude 3.5 Sonnet for code assistance and brainstorming.
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+[MIT License](LICENSE)
+
+
+## Disclaimer
+
+This project is for educational purposes only. The developers of MediaFlow Proxy are not responsible for any misuse of this software. Please ensure that you have the necessary permissions to access and use the media streams you are proxying.

mediaflow_proxy/handlers.py

@@ -31,17 +31,43 @@ async def handle_hls_stream_proxy(request: Request, destination: str, headers: d
     Returns:
         Response: The HTTP response with the processed m3u8 playlist or streamed content.
     """
+    client = httpx.AsyncClient(
+        follow_redirects=True,
+        timeout=httpx.Timeout(30.0),
+        limits=httpx.Limits(max_keepalive_connections=10, max_connections=20),
+        proxy=settings.proxy_url,
+    )
+    streamer = Streamer(client)
     try:
-        if destination.endswith((".m3u", ".m3u8")) or "mpegurl" in headers.get("accept", "").lower():
-            return await fetch_and_process_m3u8(destination, headers, request, key_url)
-
-        return await handle_stream_request(request.method, destination, headers)
+        if destination.endswith((".m3u", ".m3u8")):
+            return await fetch_and_process_m3u8(streamer, destination, headers, request, key_url)
+
+        response = await streamer.head(destination, headers)
+        if "mpegurl" in response.headers.get("content-type", "").lower():
+            return await fetch_and_process_m3u8(streamer, destination, headers, request, key_url)
+
+        headers.update({"accept-ranges": headers.get("range", "bytes=0-")})
+        # handle the encoding response header, since decompression is handled by the httpx
+        if "content-encoding" in response.headers:
+            del response.headers["content-encoding"]
+
+        return StreamingResponse(
+            streamer.stream_content(destination, headers),
+            headers=response.headers,
+            background=BackgroundTask(streamer.close),
+        )
     except httpx.HTTPStatusError as e:
-        logger.error(f"HTTP error while fetching m3u8: {e}")
-        return Response(status_code=e.response.status_code, content=str(e))
+        await client.aclose()
+        logger.error(f"Upstream service error while handling request: {e}")
+        return Response(status_code=e.response.status_code, content=f"Upstream service error: {e}")
+    except DownloadError as e:
+        await client.aclose()
+        logger.error(f"Error downloading {destination}: {e}")
+        return Response(status_code=e.status_code, content=str(e))
     except Exception as e:
-        logger.exception(f"Error in live_stream_proxy: {str(e)}")
-        return Response(status_code=500, content=f"Internal server error: {str(e)}")
+        await client.aclose()
+        logger.error(f"Internal server error while handling request: {e}")
+        return Response(status_code=502, content=f"Internal server error: {e}")
 
 
 async def proxy_stream(method: str, video_url: str, headers: dict):
@@ -90,23 +116,27 @@ async def handle_stream_request(method: str, video_url: str, headers: dict):
                 background=BackgroundTask(streamer.close),
             )
     except httpx.HTTPStatusError as e:
-        logger.error(f"Upstream service error while handling {method} request: {e}")
         await client.aclose()
+        logger.error(f"Upstream service error while handling {method} request: {e}")
         return Response(status_code=e.response.status_code, content=f"Upstream service error: {e}")
     except DownloadError as e:
+        await client.aclose()
         logger.error(f"Error downloading {video_url}: {e}")
-        return Response(status_code=502, content=str(e))
+        return Response(status_code=e.status_code, content=str(e))
     except Exception as e:
-        logger.error(f"Internal server error while handling {method} request: {e}")
         await client.aclose()
+        logger.error(f"Internal server error while handling {method} request: {e}")
         return Response(status_code=502, content=f"Internal server error: {e}")
 
 
-async def fetch_and_process_m3u8(url: str, headers: dict, request: Request, key_url: HttpUrl = None):
+async def fetch_and_process_m3u8(
+    streamer: Streamer, url: str, headers: dict, request: Request, key_url: HttpUrl = None
+):
     """
     Fetches and processes the m3u8 playlist, converting it to an HLS playlist.
 
     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.
         request (Request): The incoming HTTP request.
@@ -115,34 +145,29 @@ async def fetch_and_process_m3u8(url: str, headers: dict, request: Request, key_
     Returns:
         Response: The HTTP response with the processed m3u8 playlist.
     """
-    async with httpx.AsyncClient(
-        follow_redirects=True,
-        timeout=httpx.Timeout(30.0),
-        limits=httpx.Limits(max_keepalive_connections=10, max_connections=20),
-        proxy=settings.proxy_url,
-    ) as client:
-        try:
-            streamer = Streamer(client)
-            content = await streamer.get_text(url, headers)
-            processor = M3U8Processor(request, key_url)
-            processed_content = await processor.process_m3u8(content, str(streamer.response.url))
-            return Response(
-                content=processed_content,
-                media_type="application/vnd.apple.mpegurl",
-                headers={
-                    "Content-Disposition": "inline",
-                    "Accept-Ranges": "none",
-                },
-            )
-        except httpx.HTTPStatusError as e:
-            logger.error(f"HTTP error while fetching m3u8: {e}")
-            return Response(status_code=e.response.status_code, content=str(e))
-        except DownloadError as e:
-            logger.error(f"Error downloading m3u8: {url}")
-            return Response(status_code=502, content=str(e))
-        except Exception as e:
-            logger.exception(f"Unexpected error while processing m3u8: {e}")
-            return Response(status_code=502, content=str(e))
+    try:
+        content = await streamer.get_text(url, headers)
+        processor = M3U8Processor(request, key_url)
+        processed_content = await processor.process_m3u8(content, str(streamer.response.url))
+        return Response(
+            content=processed_content,
+            media_type="application/vnd.apple.mpegurl",
+            headers={
+                "Content-Disposition": "inline",
+                "Accept-Ranges": "none",
+            },
+        )
+    except httpx.HTTPStatusError as e:
+        logger.error(f"HTTP error while fetching m3u8: {e}")
+        return Response(status_code=e.response.status_code, content=str(e))
+    except DownloadError as e:
+        logger.error(f"Error downloading m3u8: {url}")
+        return Response(status_code=502, content=str(e))
+    except Exception as e:
+        logger.exception(f"Unexpected error while processing m3u8: {e}")
+        return Response(status_code=502, content=str(e))
+    finally:
+        await streamer.close()
 
 
 async def handle_drm_key_data(key_id, key, drm_info):