Skip to content

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

22.9 KB
Raw Blame
from __future__ import annotations

import json
import pathlib
import re
import sys
import tempfile
import threading
import time
import unittest
import urllib.request
from http.server import ThreadingHTTPServer

sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))

from split_hls_timestamp_fixture_server import (  # noqa: E402
    FixtureState,
    Handler,
    PACKET_SIZE,
    build_prefix_and_suffix,
    find_program_packets,
    null_packet,
    ts_packets,
)


def _ts_packet(pid: int, payload: bytes, *, start: bool = False, cc: int = 0) -> bytes:
    header = bytes((0x47, ((0x40 if start else 0) | ((pid >> 8) & 0x1F)), pid & 0xFF,
                    0x10 | (cc & 0x0F)))
    if len(payload) > PACKET_SIZE - 4:
        raise ValueError("payload too long")
    return header + payload + b"\xff" * (PACKET_SIZE - 4 - len(payload))


def _test_avc_ts() -> bytes:
    # PAT: program 1 -> PMT PID 0x100.
    pat = bytes.fromhex("00 b0 0d 00 01 c1 00 00 00 01 e1 00 00 00 00 00")
    # PMT: program 1, PCR/video PID 0x101, AVC stream type 0x1b.
    pmt = bytes.fromhex("02 b0 12 00 01 c1 00 00 e1 01 f0 00 1b e1 01 f0 00 00 00 00 00")
    pts = bytes((0x21, 0x00, 0x01, 0x00, 0x01))
    pes = b"\x00\x00\x01\xe0\x00\x00\x80\x80\x05" + pts + b"\x00\x00\x01\x65\xaa\xbb"
    return b"".join((
        _ts_packet(0, b"\x00" + pat, start=True),
        _ts_packet(0x100, b"\x00" + pmt, start=True),
        _ts_packet(0x101, pes, start=True),
    ))


class SplitHlsTimestampFixtureServerTest(unittest.TestCase):
    def test_extracts_program_psi_and_first_playable_video_pes(self) -> None:
        payload = _test_avc_ts()
        details = find_program_packets(payload)
        self.assertEqual(0x100, details["pmtPid"])
        self.assertEqual(0x101, details["videoPid"])
        self.assertEqual(2, details["firstVideoPesPacketIndex"])
        prefix, suffix, _ = build_prefix_and_suffix(payload)
        self.assertEqual(payload[:2 * PACKET_SIZE], prefix)
        self.assertEqual(payload[2 * PACKET_SIZE:], suffix)

    def test_null_packet_uses_null_pid_and_is_well_formed_ts(self) -> None:
        packet = null_packet(7)
        self.assertEqual(PACKET_SIZE, len(packet))
        self.assertEqual(0x1FFF, ((packet[1] & 0x1F) << 8) | packet[2])
        self.assertEqual([packet], ts_packets(packet))

    def test_master_and_renditions_are_separate_and_aligned(self) -> None:
        with tempfile.TemporaryDirectory() as temporary:
            root = pathlib.Path(temporary)
            for role in ("video", "audio"):
                (root / role).mkdir()
                for index in range(6):
                    (root / role / f"segment_{index:03d}.ts").write_bytes(_test_avc_ts())
            metadata = {
                "video": {"codecString": "avc1.42C01E",
                          "segments": [{"file": f"segment_{i:03d}.ts", "durationSeconds": 2.0}
                                       for i in range(6)]},
                "audio": {"codecString": "mp4a.40.2",
                          "segments": [{"file": f"segment_{i:03d}.ts", "durationSeconds": 2.0}
                                       for i in range(6)]},
            }
            (root / "media.json").write_text(json.dumps(metadata), encoding="utf-8")
            state = FixtureState(root, "off", 0.1, 20.0, 6)
            server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
            server.fixture_state = state
            thread = threading.Thread(target=server.serve_forever, daemon=True)
            thread.start()
            try:
                base = f"http://127.0.0.1:{server.server_port}"
                master = urllib.request.urlopen(base + "/master.m3u8", timeout=2).read().decode()
                video = urllib.request.urlopen(base + "/video/index.m3u8", timeout=2).read().decode()
                audio = urllib.request.urlopen(base + "/audio/index.m3u8", timeout=2).read().decode()
                self.assertIn('CODECS="avc1.42C01E,mp4a.40.2"', master)
                self.assertIn('URI="audio/index.m3u8"', master)
                self.assertIn("video/index.m3u8", master)
                video_sequence, video_rows = self._playlist_rows(video, "video", "ts")
                audio_sequence, audio_rows = self._playlist_rows(audio, "audio", "ts")
                self.assertEqual(6, len(video_rows))
                self.assertEqual(6, len(audio_rows))
                self.assertEqual(video_sequence, video_rows[0][0])
                self.assertEqual(audio_sequence, audio_rows[0][0])
                self.assertEqual(
                    list(range(video_sequence, video_sequence + len(video_rows))),
                    [row[0] for row in video_rows],
                )
                self.assertEqual(
                    list(range(audio_sequence, audio_sequence + len(audio_rows))),
                    [row[0] for row in audio_rows],
                )
                common_sequences = set(row[0] for row in video_rows) & set(row[0] for row in audio_rows)
                self.assertGreaterEqual(len(common_sequences), 5)
                video_program_dates = {sequence: program_date for sequence, program_date, _ in video_rows}
                audio_program_dates = {sequence: program_date for sequence, program_date, _ in audio_rows}
                video_durations = {sequence: duration for sequence, _, duration in video_rows}
                audio_durations = {sequence: duration for sequence, _, duration in audio_rows}
                for sequence in common_sequences:
                    self.assertEqual(video_program_dates[sequence], audio_program_dates[sequence])
                    self.assertEqual(video_durations[sequence], audio_durations[sequence])
            finally:
                server.shutdown()
                server.server_close()
                thread.join(1)

    @staticmethod
    def _playlist_rows(playlist: str, role: str, extension: str) -> tuple[int, list[tuple[int, str, str]]]:
        rows = playlist.splitlines()
        media_sequence = next(
            int(line.split(":", 1)[1]) for line in rows
            if line.startswith("#EXT-X-MEDIA-SEQUENCE:")
        )
        segments: list[tuple[int, str, str]] = []
        program_date: str | None = None
        duration: str | None = None
        for line in rows:
            if line.startswith("#EXT-X-PROGRAM-DATE-TIME:"):
                program_date = line.split(":", 1)[1]
            elif line.startswith("#EXTINF:"):
                duration = line.split(":", 1)[1].split(",", 1)[0]
            elif line.startswith(f"/{role}/segment/"):
                match = re.fullmatch(rf"/{role}/segment/(\d+)\.{extension}", line)
                if match is None or program_date is None or duration is None:
                    raise AssertionError(f"Malformed {role} playlist segment row: {line}")
                segments.append((int(match.group(1)), program_date, duration))
                program_date = None
                duration = None
        return media_sequence, segments

    def test_delayed_valid_sends_psi_then_paced_nulls_then_original_pes(self) -> None:
        with tempfile.TemporaryDirectory() as temporary:
            root = pathlib.Path(temporary)
            for role in ("video", "audio"):
                (root / role).mkdir()
                for index in range(6):
                    (root / role / f"segment_{index:03d}.ts").write_bytes(_test_avc_ts())
            rows = [{"file": f"segment_{i:03d}.ts", "durationSeconds": 2.0} for i in range(6)]
            (root / "media.json").write_text(json.dumps({"video": {"codecString": "avc1.42C01E", "segments": rows},
                                                          "audio": {"codecString": "mp4a.40.2", "segments": rows}}), encoding="utf-8")
            state = FixtureState(root, "delayed-valid", 0.12, 25.0, 6)
            server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
            server.fixture_state = state
            thread = threading.Thread(target=server.serve_forever, daemon=True)
            thread.start()
            try:
                base = f"http://127.0.0.1:{server.server_port}"
                request_started = time.monotonic()
                with urllib.request.urlopen(base + "/video/segment/5.ts", timeout=2) as response:
                    body = response.read()
                    self.assertEqual(200, response.status)
                elapsed = time.monotonic() - request_started
                self.assertGreaterEqual(elapsed, 0.10)
                prefix, suffix, _ = build_prefix_and_suffix(_test_avc_ts())
                self.assertEqual(prefix, body[:len(prefix)])
                expected_null_count = math_floor(0.12 * 25.0)
                null_start = len(prefix)
                nulls = body[null_start:null_start + expected_null_count * PACKET_SIZE]
                self.assertEqual(expected_null_count * PACKET_SIZE, len(nulls))
                self.assertTrue(all(((packet[1] & 0x1F) << 8 | packet[2]) == 0x1FFF
                                    for packet in ts_packets(nulls)))
                self.assertEqual(suffix, body[null_start + len(nulls):])
                events = state.events
                self.assertEqual(1, sum(row["event"] == "primary-delay-target-selected" for row in events))
                sent = next(row for row in events if row["event"] == "primary-playable-pes-sent")
                self.assertGreaterEqual(sent["firstPlayablePesAfterMs"], 100)
                self.assertEqual(expected_null_count, sent["nullPackets"])
            finally:
                server.shutdown()
                server.server_close()
                thread.join(1)

    def test_video_subtitle_profile_uses_non_audio_text_rendition(self) -> None:
        with tempfile.TemporaryDirectory() as temporary:
            root = pathlib.Path(temporary)
            for role in ("video", "audio"):
                (root / role).mkdir()
                for index in range(6):
                    (root / role / f"segment_{index:03d}.ts").write_bytes(_test_avc_ts())
            rows = [{"file": f"segment_{i:03d}.ts", "durationSeconds": 2.0} for i in range(6)]
            (root / "media.json").write_text(json.dumps({
                "video": {"codecString": "avc1.42C01E", "segments": rows},
                "audio": {"codecString": "mp4a.40.2", "segments": rows},
            }), encoding="utf-8")
            state = FixtureState(root, "missing-primary", 0.1, 20.0, 6,
                                 rendition_profile="video-subtitles")
            server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
            server.fixture_state = state
            thread = threading.Thread(target=server.serve_forever, daemon=True)
            thread.start()
            try:
                base = f"http://127.0.0.1:{server.server_port}"
                master = urllib.request.urlopen(base + "/master.m3u8", timeout=2).read().decode()
                subtitle = urllib.request.urlopen(base + "/subtitle/index.m3u8", timeout=2).read().decode()
                video = urllib.request.urlopen(base + "/video/index.m3u8", timeout=2).read().decode()
                vtt = urllib.request.urlopen(base + "/subtitle/segment/5.vtt", timeout=2).read().decode()
                self.assertIn("TYPE=SUBTITLES", master)
                self.assertIn('SUBTITLES="subs"', master)
                self.assertNotIn("TYPE=AUDIO", master)
                self.assertIn("/subtitle/segment/", subtitle)
                self.assertNotIn("#EXT-X-DISCONTINUITY-SEQUENCE:", subtitle)
                self.assertNotIn("#EXT-X-DISCONTINUITY-SEQUENCE:", video)
                self.assertIn("X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:1026000", vtt)
                self.assertIn("Fixture subtitle 5", vtt)
            finally:
                server.shutdown()
                server.server_close()
                thread.join(1)

    def test_subtitle_discontinuity_sequence_offset_is_rendition_scoped(self) -> None:
        with tempfile.TemporaryDirectory() as temporary:
            root = pathlib.Path(temporary)
            for role in ("video", "audio"):
                (root / role).mkdir()
                for index in range(6):
                    (root / role / f"segment_{index:03d}.ts").write_bytes(_test_avc_ts())
            rows = [{"file": f"segment_{i:03d}.ts", "durationSeconds": 2.0} for i in range(6)]
            (root / "media.json").write_text(json.dumps({
                "video": {"codecString": "avc1.42C01E", "segments": rows},
                "audio": {"codecString": "mp4a.40.2", "segments": rows},
            }), encoding="utf-8")
            state = FixtureState(root, "off", 0.1, 20.0, 6,
                                 rendition_profile="video-subtitles",
                                 subtitle_discontinuity_sequence_offset=1)
            server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
            server.fixture_state = state
            thread = threading.Thread(target=server.serve_forever, daemon=True)
            thread.start()
            try:
                base = f"http://127.0.0.1:{server.server_port}"
                subtitle = urllib.request.urlopen(base + "/subtitle/index.m3u8", timeout=2).read().decode()
                video = urllib.request.urlopen(base + "/video/index.m3u8", timeout=2).read().decode()
                status = json.loads(urllib.request.urlopen(base + "/status", timeout=2).read())
                events = json.loads(urllib.request.urlopen(base + "/events", timeout=2).read())
                self.assertIn("#EXT-X-DISCONTINUITY-SEQUENCE:1", subtitle)
                self.assertNotIn("#EXT-X-DISCONTINUITY-SEQUENCE:", video)
                self.assertEqual(1, status["subtitleDiscontinuitySequenceOffset"])
                self.assertEqual(1, events["settings"]["subtitleDiscontinuitySequenceOffset"])
            finally:
                server.shutdown()
                server.server_close()
                thread.join(1)

    def test_missing_primary_keeps_chunked_stream_without_video_pes(self) -> None:
        with tempfile.TemporaryDirectory() as temporary:
            root = pathlib.Path(temporary)
            for role in ("video", "audio"):
                (root / role).mkdir()
                for index in range(6):
                    (root / role / f"segment_{index:03d}.ts").write_bytes(_test_avc_ts())
            rows = [{"file": f"segment_{i:03d}.ts", "durationSeconds": 2.0} for i in range(6)]
            (root / "media.json").write_text(json.dumps({"video": {"codecString": "avc1.42C01E", "segments": rows},
                                                          "audio": {"codecString": "mp4a.40.2", "segments": rows}}), encoding="utf-8")
            state = FixtureState(root, "missing-primary", 0.1, 40.0, 6)
            server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
            server.fixture_state = state
            thread = threading.Thread(target=server.serve_forever, daemon=True)
            thread.start()
            response = None
            try:
                response = urllib.request.urlopen(
                    f"http://127.0.0.1:{server.server_port}/video/segment/5.ts", timeout=2)
                self.assertEqual(200, response.status)
                prefix_size = len(build_prefix_and_suffix(_test_avc_ts())[0])
                prefix = response.read(prefix_size)
                self.assertEqual(prefix_size, len(prefix))
                filler = response.read(5 * PACKET_SIZE)
                self.assertTrue(filler)
                self.assertTrue(all(((packet[1] & 0x1F) << 8 | packet[2]) == 0x1FFF
                                    for packet in ts_packets(filler[:len(filler) // PACKET_SIZE * PACKET_SIZE])))
                self.assertTrue(any(row["event"] == "primary-headers-and-psi-sent" and
                                    row.get("bodyMode") == "indefinite-chunked" for row in state.events))
            finally:
                if response is not None:
                    response.close()
                server.shutdown()
                server.server_close()
                thread.join(1)

    def test_missing_primary_retries_remain_invalid_but_later_sequence_is_playable(self) -> None:
        with tempfile.TemporaryDirectory() as temporary:
            root = pathlib.Path(temporary)
            for role in ("video", "audio"):
                (root / role).mkdir()
                for index in range(6):
                    (root / role / f"segment_{index:03d}.ts").write_bytes(_test_avc_ts())
            rows = [{"file": f"segment_{i:03d}.ts", "durationSeconds": 2.0} for i in range(6)]
            (root / "media.json").write_text(json.dumps({
                "video": {"codecString": "avc1.42C01E", "segments": rows},
                "audio": {"codecString": "mp4a.40.2", "segments": rows},
            }), encoding="utf-8")
            state = FixtureState(root, "missing-primary", 0.1, 40.0, 6)
            server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
            server.fixture_state = state
            thread = threading.Thread(target=server.serve_forever, daemon=True)
            thread.start()
            responses = []
            try:
                base = f"http://127.0.0.1:{server.server_port}/video/segment"
                prefix_size = len(build_prefix_and_suffix(_test_avc_ts())[0])
                for _ in range(2):
                    response = urllib.request.urlopen(f"{base}/5.ts", timeout=2)
                    responses.append(response)
                    self.assertEqual(200, response.status)
                    self.assertEqual(prefix_size, len(response.read(prefix_size)))
                    filler = response.read(5 * PACKET_SIZE)
                    self.assertTrue(filler)
                    complete_packets = len(filler) // PACKET_SIZE
                    self.assertGreater(complete_packets, 0)
                    self.assertTrue(all(
                        ((packet[1] & 0x1F) << 8 | packet[2]) == 0x1FFF
                        for packet in ts_packets(filler[:complete_packets * PACKET_SIZE])
                    ))
                    response.close()
                    responses.remove(response)

                next_sequence = urllib.request.urlopen(f"{base}/6.ts", timeout=2)
                responses.append(next_sequence)
                playable = next_sequence.read()
                self.assertEqual(_test_avc_ts(), playable)
                next_sequence.close()
                responses.remove(next_sequence)

                events = state.events
                self.assertEqual(1, sum(
                    row["event"] == "primary-delay-target-selected" and row["sequence"] == 5
                    for row in events
                ))
                self.assertEqual(2, sum(
                    row["event"] == "primary-headers-and-psi-sent" and row["sequence"] == 5
                    for row in events
                ))
                self.assertTrue(any(
                    row["event"] == "stream-close" and row["sequence"] == 6 and
                    row.get("closeReason") == "body-complete"
                    for row in events
                ))
            finally:
                for response in responses:
                    response.close()
                server.shutdown()
                server.server_close()
                thread.join(1)

    def test_missing_primary_all_keeps_every_video_sequence_invalid_and_audio_valid(self) -> None:
        with tempfile.TemporaryDirectory() as temporary:
            root = pathlib.Path(temporary)
            for role in ("video", "audio"):
                (root / role).mkdir()
                for index in range(6):
                    (root / role / f"segment_{index:03d}.ts").write_bytes(_test_avc_ts())
            rows = [{"file": f"segment_{i:03d}.ts", "durationSeconds": 2.0} for i in range(6)]
            (root / "media.json").write_text(json.dumps({
                "video": {"codecString": "avc1.42C01E", "segments": rows},
                "audio": {"codecString": "mp4a.40.2", "segments": rows},
            }), encoding="utf-8")
            state = FixtureState(root, "missing-primary-all", 0.1, 40.0, 6)
            server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
            server.fixture_state = state
            thread = threading.Thread(target=server.serve_forever, daemon=True)
            thread.start()
            responses = []
            try:
                base = f"http://127.0.0.1:{server.server_port}"
                prefix_size = len(build_prefix_and_suffix(_test_avc_ts())[0])
                for sequence in (5, 6):
                    response = urllib.request.urlopen(
                        f"{base}/video/segment/{sequence}.ts", timeout=2)
                    responses.append(response)
                    self.assertEqual(200, response.status)
                    self.assertEqual(prefix_size, len(response.read(prefix_size)))
                    filler = response.read(5 * PACKET_SIZE)
                    packet_bytes = len(filler) // PACKET_SIZE * PACKET_SIZE
                    self.assertGreater(packet_bytes, 0)
                    self.assertTrue(all(
                        ((packet[1] & 0x1F) << 8 | packet[2]) == 0x1FFF
                        for packet in ts_packets(filler[:packet_bytes])
                    ))
                    response.close()
                    responses.remove(response)

                audio = urllib.request.urlopen(f"{base}/audio/segment/6.ts", timeout=2)
                responses.append(audio)
                self.assertEqual(_test_avc_ts(), audio.read())
                audio.close()
                responses.remove(audio)
                before_reset_events = state.events
                self.assertTrue(any(
                    row["event"] == "stream-close" and row["role"] == "audio" and
                    row["sequence"] == 6 and row.get("closeReason") == "body-complete"
                    for row in before_reset_events
                ))

                # Reset re-anchors the live window, but must not change the
                # selected failure mode or make a later video sequence valid.
                reset_status = state.reset()
                self.assertEqual("missing-primary-all", reset_status["mode"])
                later = urllib.request.urlopen(f"{base}/video/segment/7.ts", timeout=2)
                responses.append(later)
                self.assertEqual(200, later.status)
                self.assertEqual(prefix_size, len(later.read(prefix_size)))
                filler = later.read(5 * PACKET_SIZE)
                self.assertGreater(len(filler) // PACKET_SIZE, 0)
                later.close()
                responses.remove(later)

                events = state.events
                self.assertEqual(1, sum(
                    row["event"] == "primary-delay-target-selected" for row in events
                ))
                self.assertTrue(all(
                    row.get("bodyMode") == "indefinite-chunked"
                    for row in events if row["event"] == "primary-headers-and-psi-sent"
                ), events)
            finally:
                for response in responses:
                    response.close()
                server.shutdown()
                server.server_close()
                thread.join(1)


def math_floor(value: float) -> int:
    return int(value // 1)


if __name__ == "__main__":
    unittest.main()