Skip to content

StreamVault is a TV-first free IPTV player for Android TV built with Kotlin, Jetpack Compose, Room, Hilt, and Media3.

10.2 KB
Raw Blame
"""Private Xtream-style V12 bandwidth fixture.

The media files are supplied outside the repository.  This server only exposes
the controlled catalogue/media routes needed by the opt-in normal UI test,
applies one aggregate delivery rate to every response, and records request
bytes/timing so the measured delivery can be compared with player telemetry.
"""

from __future__ import annotations

import argparse
import json
import pathlib
import re
import threading
import time
import urllib.parse
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer


parser = argparse.ArgumentParser()
parser.add_argument("--hls-root", type=pathlib.Path, required=True)
parser.add_argument("--progressive", type=pathlib.Path, required=True)
parser.add_argument("--state-dir", type=pathlib.Path, required=True)
parser.add_argument("--port", type=int, default=18786)
args = parser.parse_args()

HLS_ROOT = args.hls_root.resolve()
PROGRESSIVE = args.progressive.resolve()
STATE = args.state_dir.resolve()
STATE.mkdir(parents=True, exist_ok=True)
if not (HLS_ROOT / "long-master.m3u8").is_file():
    parser.error("--hls-root must contain long-master.m3u8")
if not PROGRESSIVE.is_file():
    parser.error("--progressive file is missing")


def extend_variant(name: str, copies: int = 480) -> None:
    """Create a long finite VOD playlist by repeating real fixture segments."""
    source = HLS_ROOT / name / "long.m3u8"
    target = HLS_ROOT / name / "v12.m3u8"
    lines = source.read_text(encoding="utf-8").splitlines()
    segment_names = [line for line in lines if line.endswith(".ts")]
    if not segment_names:
        raise SystemExit(f"no segments in {source}")
    header = [line for line in lines if not line.endswith(".ts") and line != "#EXT-X-ENDLIST"]
    output = header[:]
    for index in range(copies):
        if index and index % len(segment_names) == 0:
            output.append("#EXT-X-DISCONTINUITY")
        output.extend(["#EXTINF:2.000000,", segment_names[index % len(segment_names)]])
    output.append("#EXT-X-ENDLIST")
    target.write_text("\n".join(output) + "\n", encoding="utf-8")


for _variant in ("v0", "v1", "v2"):
    extend_variant(_variant)
(HLS_ROOT / "v12-master.m3u8").write_text(
    "\n".join([
        "#EXTM3U", "#EXT-X-VERSION:3", "#EXT-X-INDEPENDENT-SEGMENTS",
        '#EXT-X-STREAM-INF:BANDWIDTH=15075344,AVERAGE-BANDWIDTH=14439089,RESOLUTION=3840x2160,CODECS="avc1.42c033"',
        "v0/v12.m3u8",
        '#EXT-X-STREAM-INF:BANDWIDTH=5441472,AVERAGE-BANDWIDTH=5177833,RESOLUTION=1920x1080,CODECS="avc1.42c028"',
        "v1/v12.m3u8",
        '#EXT-X-STREAM-INF:BANDWIDTH=2675616,AVERAGE-BANDWIDTH=2614515,RESOLUTION=1280x720,CODECS="avc1.42c01f"',
        "v2/v12.m3u8", "",
    ]), encoding="utf-8")

MOVIES = {
    1201: ("V12 Adaptive Sustainable", "v12-master.m3u8", "m3u8"),
    1202: ("V12 Adaptive Unsustainable", "v12-master.m3u8", "m3u8"),
    1203: ("V12 Progressive Control", "progressive.mp4", "mp4"),
}

lock = threading.Lock()
rate_bps = 120_000_000
next_slot = 0.0
sequence = 0
events: list[dict[str, object]] = []


def record(event: str, **data: object) -> None:
    row = {"time": time.time(), "event": event, **data}
    with lock:
        events.append(row)
        (STATE / "events.jsonl").open("a", encoding="utf-8").write(json.dumps(row) + "\n")


def status() -> dict[str, object]:
    with lock:
        return {"rateBps": rate_bps, "nextSlot": next_slot, "eventCount": len(events)}


def shape(byte_count: int) -> None:
    global next_slot
    with lock:
        now = time.monotonic()
        due = max(now, next_slot) + byte_count * 8 / max(1, rate_bps)
        next_slot = due
    delay = due - time.monotonic()
    if delay > 0:
        time.sleep(delay)


def media_path(route: str) -> pathlib.Path | None:
    if route == "/asset/progressive.mp4":
        return PROGRESSIVE
    movie_match = re.fullmatch(r"/movie/validation/validation/(1201|1202|1203)\.(?:m3u8|mp4)", route)
    if movie_match:
        stream_id = int(movie_match.group(1))
        return HLS_ROOT / "v12-master.m3u8" if stream_id in (1201, 1202) else PROGRESSIVE
    if route.startswith("/asset/"):
        rel = pathlib.PurePosixPath(urllib.parse.unquote(route.removeprefix("/asset/")))
        target = (HLS_ROOT / pathlib.Path(*rel.parts)).resolve()
        if target.is_relative_to(HLS_ROOT) and target.is_file():
            return target
    return None


class Handler(BaseHTTPRequestHandler):
    protocol_version = "HTTP/1.1"

    def log_message(self, *_args: object) -> None:
        pass

    def reply(self, body: bytes | dict[str, object], content_type: str = "application/json", status: int = 200) -> None:
        payload = body if isinstance(body, bytes) else json.dumps(body).encode("utf-8")
        self.send_response(status)
        self.send_header("Content-Type", content_type)
        self.send_header("Content-Length", str(len(payload)))
        self.send_header("Cache-Control", "no-store")
        self.end_headers()
        try:
            self.wfile.write(payload)
        except (BrokenPipeError, ConnectionResetError):
            pass

    def do_GET(self) -> None:
        global rate_bps, next_slot, sequence
        parsed = urllib.parse.urlsplit(self.path)
        query = urllib.parse.parse_qs(parsed.query)
        route = parsed.path

        if route == "/control":
            if "rate" in query:
                rate_bps = max(1, int(query["rate"][0]))
                with lock:
                    next_slot = time.monotonic()
            if query.get("reset", ["0"])[0] == "1":
                with lock:
                    events.clear()
                (STATE / "events.jsonl").write_text("", encoding="utf-8")
            row = {"event": "control", "rateBps": rate_bps, "label": query.get("label", [""])[0]}
            record(**row)
            return self.reply({"rateBps": rate_bps})

        if route == "/status":
            return self.reply(status())
        if route == "/events":
            with lock:
                snapshot = {
                    "events": list(events),
                    "status": {"rateBps": rate_bps, "nextSlot": next_slot, "eventCount": len(events)},
                }
            return self.reply(snapshot)

        if route == "/player_api.php":
            action = query.get("action", [""])[0]
            if not action:
                body = {"user_info": {"username": "validation", "password": "validation", "auth": 1,
                                      "status": "Active", "max_connections": "5"},
                        "server_info": {"url": "10.0.2.2", "port": str(args.port),
                                        "server_protocol": "http", "timezone": "UTC",
                                        "timestamp_now": int(time.time())}}
            elif action == "get_vod_categories":
                body = [{"category_id": "1", "category_name": "V12 Bandwidth", "parent_id": 0}]
            elif action == "get_vod_streams":
                body = [self.movie(stream_id) for stream_id in MOVIES]
            elif action == "get_vod_info":
                stream_id = int(query.get("vod_id", ["0"])[0])
                body = {"info": {"name": MOVIES[stream_id][0], "duration_secs": 384,
                                  "duration": "00:06:24", "tmdb_id": 99999000 + stream_id},
                        "movie_data": self.movie(stream_id)}
            else:
                body = []
            record("api", action=action)
            return self.reply(body)

        target = media_path(route)
        if target is None:
            return self.reply(b"not found", "text/plain", 404)
        return self.stream(target, route)

    @staticmethod
    def movie(stream_id: int) -> dict[str, object]:
        name, _asset, extension = MOVIES[stream_id]
        direct = f"http://10.0.2.2:{args.port}/asset/{_asset}?expires={int(time.time()) + 7200}"
        return {"stream_id": stream_id, "name": name, "category_id": "1", "container_extension": extension,
                "rating": "8", "tmdb": str(99999000 + stream_id), "direct_source": direct}

    def stream(self, target: pathlib.Path, route: str) -> None:
        global sequence
        size = target.stat().st_size
        start, end, response_status = 0, size - 1, 200
        range_value = self.headers.get("Range")
        if range_value:
            match = re.fullmatch(r"bytes=(\d+)-(\d*)", range_value)
            if not match:
                return self.reply(b"invalid range", "text/plain", 416)
            start = int(match.group(1))
            end = min(int(match.group(2)) if match.group(2) else end, end)
            if start > end or start >= size:
                return self.reply(b"invalid range", "text/plain", 416)
            response_status = 206
        content_type = "application/vnd.apple.mpegurl" if target.suffix == ".m3u8" else (
            "video/mp4" if target.suffix == ".mp4" else "video/mp2t")
        self.send_response(response_status)
        self.send_header("Content-Type", content_type)
        self.send_header("Content-Length", str(end - start + 1))
        self.send_header("Accept-Ranges", "bytes")
        self.send_header("Cache-Control", "no-store")
        if response_status == 206:
            self.send_header("Content-Range", f"bytes {start}-{end}/{size}")
        self.end_headers()
        began = time.monotonic()
        sent = 0
        try:
            with target.open("rb") as stream:
                stream.seek(start)
                remaining = end - start + 1
                while remaining:
                    block = stream.read(min(64 * 1024, remaining))
                    if not block:
                        break
                    shape(len(block))
                    self.wfile.write(block)
                    sent += len(block)
                    remaining -= len(block)
        except (BrokenPipeError, ConnectionResetError, OSError):
            pass
        with lock:
            sequence += 1
            request_id = sequence
        elapsed = max(0.001, time.monotonic() - began)
        record("media", id=request_id, path=route, status=response_status, range=range_value,
               bytes=sent, elapsedMs=round(elapsed * 1000, 1), measuredBps=round(sent * 8 / elapsed))


if __name__ == "__main__":
    record("started", port=args.port, hlsRoot=str(HLS_ROOT), progressive=str(PROGRESSIVE))
    ThreadingHTTPServer(("0.0.0.0", args.port), Handler).serve_forever()