Skip to content

Bring PS5 GTA6 to 120FPS with DLSS 5. An advanced Windows video player and capture enhancement tool featuring real-time preview for videos, images, and capture card sources. Combine AI-powered Super Resolution, DLSS5 image enhancement, and Frame Generation to deliver a next-generation visual experience.

C++
19.6 KB
Raw Blame
#!/usr/bin/env python3
"""Local media server for the #48 network-playback tests (Python standard library only).

It stands in for the slow / unreliable servers the user does not have:

  * serves files below --root with HTTP Range support (progressive MP4/MKV, HLS playlists + segments);
  * --rate-mbps R        one shared link of R megabytes per second for every connection;
  * --stall-at S1,S2     at server second S every transfer freezes for --stall-seconds (connection stays open);
  * --outage-at S        at server second S active transfers are reset and new connections are reset for
                         --outage-seconds (a cable pulled out);
  * --drop-after-mb M    every response is cut off (reset) after M megabytes of body;
  * --ts-flip RATIO      damages RATIO of the 188-byte packets of *.ts files (size preserved, so Range
                         requests stay consistent): transport-error bit + garbled payload;
  * --live NAME=FILE     /NAME is an endless real-time MPEG-TS stream relayed from ffmpeg looping FILE
                         (no Content-Length); --ts-drop RATIO removes that fraction of its TS packets
                         (IPTV-style packet loss, produces continuity errors);
  * --ts-drop-file RATIO a *.ts file is served like a live stream (200, no Content-Length, no Range, closes at
                         the end) from its start with RATIO of its TS packets removed, as fast as the link allows;
  * /__stats             JSON: connections, in-flight requests, bytes sent, per-request log.

Everything is logged to --log (one JSON object per line) and summarised at /__stats.
"""
import argparse
import http.server
import json
import mimetypes
import os
import queue
import random
import socket
import socketserver
import struct
import subprocess
import sys
import threading
import time
from urllib.parse import unquote, urlparse

TS = 188
CHUNK = 64 * 1024


class Shaper:
    """One shared link: global rate limit, scheduled stalls and an outage window."""

    def __init__(self, args):
        self.rate = args.rate_mbps * 1048576.0 if args.rate_mbps > 0 else 0.0
        self.stalls = [(float(s), float(args.stall_seconds)) for s in args.stall_at.split(',') if s]
        self.outage = (float(args.outage_at), float(args.outage_seconds)) if args.outage_at >= 0 else None
        self.t0 = time.monotonic()
        self.lock = threading.Lock()
        self.tokens = 0.0
        self.last = time.monotonic()
        self.generation = 0          # bumped when an outage starts: in-flight transfers see it and reset
        self._outage_started = False

    def now(self):
        return time.monotonic() - self.t0

    def stalled(self):
        t = self.now()
        return any(start <= t < start + length for start, length in self.stalls)

    def in_outage(self):
        if not self.outage:
            return False
        t = self.now()
        active = self.outage[0] <= t < self.outage[0] + self.outage[1]
        if active and not self._outage_started:
            self._outage_started = True
            self.generation += 1
        return active

    def wait(self, nbytes, stop):
        """Blocks until nbytes may go out. Returns False when the transfer must be reset."""
        gen = self.generation
        while not stop.is_set():
            if self.in_outage() or self.generation != gen:
                return False
            if self.stalled():
                time.sleep(0.05)
                continue
            if not self.rate:
                return True
            with self.lock:
                now = time.monotonic()
                self.tokens = min(self.tokens + (now - self.last) * self.rate, max(self.rate * 0.05, CHUNK))
                self.last = now
                if self.tokens >= nbytes:
                    self.tokens -= nbytes
                    return True
                need = (nbytes - self.tokens) / self.rate
            time.sleep(min(max(need, 0.001), 0.05))
        return False


class Stats:
    def __init__(self):
        self.lock = threading.Lock()
        self.connections = 0
        self.refused = 0
        self.in_flight = 0
        self.max_in_flight = 0
        self.bytes_sent = 0
        self.requests = []

    def begin(self, path, rng, client):
        with self.lock:
            rec = {'id': len(self.requests) + 1, 't': round(time.monotonic() - T0, 3), 'path': path, 'range': rng,
                   'client': client, 'bytes': 0, 'endT': None, 'result': 'open'}
            self.requests.append(rec)
            self.in_flight += 1
            self.max_in_flight = max(self.max_in_flight, self.in_flight)
            return rec

    def add(self, rec, n):
        with self.lock:
            rec['bytes'] += n
            self.bytes_sent += n

    def end(self, rec, result):
        with self.lock:
            rec['endT'] = round(time.monotonic() - T0, 3)
            rec['result'] = result
            self.in_flight -= 1
        log(dict(event='request-end', id=rec['id'], path=rec['path'], range=rec['range'], bytes=rec['bytes'], result=result))

    def snapshot(self):
        with self.lock:
            return dict(connections=self.connections, refused=self.refused, inFlight=self.in_flight,
                        maxInFlight=self.max_in_flight, bytesSent=self.bytes_sent,
                        requestCount=len(self.requests), requests=list(self.requests[-200:]),
                        serverSeconds=round(time.monotonic() - T0, 3))


T0 = time.monotonic()
ARGS = None
SHAPER = None
STATS = Stats()
LOG = None
LOG_LOCK = threading.Lock()
STOP = threading.Event()
LIVE = {}
ACTIVE = set()
ACTIVE_LOCK = threading.Lock()


def reset_all():
    """A cable pulled out: every open connection dies with a reset, even one blocked in a write."""
    with ACTIVE_LOCK:
        sockets = list(ACTIVE)
    for sock in sockets:
        try:
            sock.setsockopt(socket.SOL_SOCKET, socket.SO_LINGER, struct.pack('ii', 1, 0))
            sock.close()
        except OSError:
            pass


def outage_watcher():
    started = False
    while not STOP.is_set():
        if SHAPER.in_outage() and not started:
            started = True
            log(dict(event='outage-start'))
            reset_all()
        elif started and not SHAPER.in_outage():
            started = False
            log(dict(event='outage-end'))
        time.sleep(0.02)


def log(obj):
    obj['t'] = round(time.monotonic() - T0, 3)
    if LOG:
        with LOG_LOCK:
            LOG.write(json.dumps(obj, ensure_ascii=False) + '\n')
            LOG.flush()


def flip_ts(buf, base, ratio, seed):
    """Deterministically damages ratio of the TS packets in buf (which starts at absolute offset base)."""
    if ratio <= 0:
        return buf
    data = bytearray(buf)
    first = -(-base // TS) * TS            # first packet boundary at or after base
    for off in range(first - base, len(data) - TS + 1, TS):
        index = (base + off) // TS
        h = ((index * 2654435761) ^ seed) & 0xFFFFFFFF
        if h / 4294967296.0 < ratio:
            data[off + 1] |= 0x80          # transport_error_indicator
            for i in range(off + 12, off + TS, 7):
                data[i] ^= 0x5A
    return bytes(data)


class Handler(http.server.BaseHTTPRequestHandler):
    protocol_version = 'HTTP/1.1'
    server_version = 'veyra-test/1'

    def log_message(self, fmt, *a):
        pass

    def send_response(self, code, message=None):
        log(dict(event='response', conn=getattr(self, 'conn_id', 0), code=code, path=self.path, range=self.headers.get('Range')))
        super().send_response(code, message)

    def setup(self):
        super().setup()
        with STATS.lock:
            STATS.connections += 1
            self.conn_id = STATS.connections
        log(dict(event='connection-open', conn=self.conn_id, peer=self.client_address[1]))
        with ACTIVE_LOCK:
            ACTIVE.add(self.connection)
        if SHAPER.in_outage():
            with STATS.lock:
                STATS.refused += 1
            self.reset()

    def finish(self):
        log(dict(event='connection-close', conn=getattr(self, 'conn_id', 0)))
        with ACTIVE_LOCK:
            ACTIVE.discard(self.connection)
        try:
            super().finish()
        except OSError:
            pass

    def reset(self):
        try:
            self.connection.setsockopt(socket.SOL_SOCKET, socket.SO_LINGER, struct.pack('ii', 1, 0))
            self.connection.close()
        except OSError:
            pass
        self.close_connection = True

    def do_HEAD(self):
        self.serve(True)

    def do_GET(self):
        self.serve(False)

    def serve(self, head):
        path = unquote(urlparse(self.path).path)
        if path == '/__stats':
            body = json.dumps(STATS.snapshot()).encode()
            self.send_response(200)
            self.send_header('Content-Type', 'application/json')
            self.send_header('Content-Length', str(len(body)))
            self.end_headers()
            self.wfile.write(body)
            return
        if path.lstrip('/') in LIVE:
            return self.serve_live(path.lstrip('/'))
        full = os.path.normpath(os.path.join(ARGS.root, path.lstrip('/')))
        if not full.startswith(os.path.normpath(ARGS.root)) or not os.path.isfile(full):
            self.send_response(404)
            self.send_header('Content-Length', '0')
            self.end_headers()
            return
        if ARGS.ts_drop_file > 0 and full.lower().endswith('.ts') and not head:
            return self.serve_lossy_file(path, full)
        size = os.path.getsize(full)
        start, end, status = 0, size - 1, 200
        rng = self.headers.get('Range')
        if rng and rng.startswith('bytes='):
            a, _, b = rng[6:].partition('-')
            try:
                start = int(a) if a else max(0, size - int(b))
                end = min(int(b), size - 1) if (a and b) else size - 1
            except ValueError:
                start, end = 0, size - 1
            if start >= size:
                self.send_response(416)
                self.send_header('Content-Range', f'bytes */{size}')
                self.send_header('Content-Length', '0')
                self.end_headers()
                return
            status = 206
        ctype = {'.m3u8': 'application/vnd.apple.mpegurl', '.ts': 'video/mp2t', '.mkv': 'video/x-matroska'}.get(
            os.path.splitext(full)[1].lower()) or mimetypes.guess_type(full)[0] or 'application/octet-stream'
        self.send_response(status)
        self.send_header('Content-Type', ctype)
        self.send_header('Accept-Ranges', 'bytes')
        self.send_header('Content-Length', str(end - start + 1))
        if status == 206:
            self.send_header('Content-Range', f'bytes {start}-{end}/{size}')
        self.end_headers()
        rec = STATS.begin(path, [start, end], self.client_address[1])
        if head:
            STATS.end(rec, 'head')
            return
        result = 'done'
        is_ts = full.lower().endswith('.ts')
        try:
            with open(full, 'rb') as f:
                f.seek(start)
                pos = start
                limit = ARGS.drop_after_mb * 1048576 if ARGS.drop_after_mb > 0 else None
                sent = 0
                while pos <= end:
                    n = min(CHUNK, end - pos + 1)
                    if limit is not None and sent + n > limit:
                        n = int(limit - sent)
                        if n <= 0:
                            result = 'dropped'
                            self.reset()
                            break
                    chunk = f.read(n)
                    if not chunk:
                        break
                    if is_ts and ARGS.ts_flip > 0:
                        chunk = flip_ts(chunk, pos, ARGS.ts_flip, ARGS.seed)
                    if not SHAPER.wait(len(chunk), STOP):
                        result = 'reset'
                        self.reset()
                        break
                    self.wfile.write(chunk)
                    pos += len(chunk)
                    sent += len(chunk)
                    STATS.add(rec, len(chunk))
        except (BrokenPipeError, ConnectionResetError, ConnectionAbortedError, OSError):
            result = 'client-closed'
            self.close_connection = True
        STATS.end(rec, result)

    def serve_lossy_file(self, path, full):
        """The file as a live-style stream with packet loss (no length, no ranges), at link speed."""
        self.send_response(200)
        self.send_header('Content-Type', 'video/mp2t')
        self.send_header('Cache-Control', 'no-cache')
        self.send_header('Connection', 'close')
        self.end_headers()
        self.close_connection = True
        rec = STATS.begin(path, None, self.client_address[1])
        rnd = random.Random(ARGS.seed + rec['id'])
        result = 'done'
        try:
            with open(full, 'rb') as f:
                while True:
                    chunk = f.read(CHUNK - CHUNK % TS)
                    if not chunk:
                        break
                    kept = bytearray()
                    for off in range(0, len(chunk) - TS + 1, TS):
                        if rnd.random() >= ARGS.ts_drop_file:
                            kept += chunk[off:off + TS]
                    if not SHAPER.wait(len(kept), STOP):
                        result = 'reset'
                        self.reset()
                        break
                    self.wfile.write(bytes(kept))
                    STATS.add(rec, len(kept))
        except (BrokenPipeError, ConnectionResetError, ConnectionAbortedError, OSError):
            result = 'client-closed'
        STATS.end(rec, result)

    # ---- live MPEG-TS relay -------------------------------------------------------------
    def serve_live(self, name):
        feed = LIVE[name]
        q = feed.subscribe()
        self.send_response(200)
        self.send_header('Content-Type', 'video/mp2t')
        self.send_header('Cache-Control', 'no-cache')
        self.send_header('Connection', 'close')
        self.end_headers()
        self.close_connection = True
        rec = STATS.begin('/' + name, None, self.client_address[1])
        rnd = random.Random(ARGS.seed + rec['id'])
        result = 'done'
        gen = SHAPER.generation
        try:
            while not STOP.is_set():
                try:
                    chunk = q.get(timeout=1.0)
                except queue.Empty:
                    continue
                if SHAPER.in_outage() or SHAPER.generation != gen:
                    result = 'reset'
                    self.reset()
                    break
                if SHAPER.stalled():
                    while SHAPER.stalled() and not STOP.is_set():
                        time.sleep(0.05)
                    # the stream moved on during the stall; a real stalled TCP link delivers the backlog
                if ARGS.ts_drop > 0:
                    kept = bytearray()
                    for off in range(0, len(chunk) - TS + 1, TS):
                        if rnd.random() >= ARGS.ts_drop:
                            kept += chunk[off:off + TS]
                    chunk = bytes(kept)
                self.wfile.write(chunk)
                STATS.add(rec, len(chunk))
        except (BrokenPipeError, ConnectionResetError, ConnectionAbortedError, OSError):
            result = 'client-closed'
        finally:
            feed.unsubscribe(q)
        STATS.end(rec, result)


class ControlHandler(http.server.BaseHTTPRequestHandler):
    """Statistics on a second port that no outage, stall or rate limit touches."""

    def log_message(self, fmt, *a):
        pass

    def do_GET(self):
        body = json.dumps(STATS.snapshot()).encode()
        self.send_response(200)
        self.send_header('Content-Type', 'application/json')
        self.send_header('Content-Length', str(len(body)))
        self.end_headers()
        self.wfile.write(body)


class LiveFeed:
    """ffmpeg -re -stream_loop -1 -c copy -f mpegts -  ->  every subscriber's bounded queue."""

    def __init__(self, path):
        self.path = path
        self.lock = threading.Lock()
        self.queues = []
        ffmpeg = ARGS.ffmpeg
        cmd = [ffmpeg, '-nostdin', '-hide_banner', '-loglevel', 'error', '-re', '-stream_loop', '-1', '-i', path,
               '-c', 'copy', '-muxdelay', '0', '-f', 'mpegts', '-']
        self.proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL)
        threading.Thread(target=self.pump, daemon=True).start()

    def pump(self):
        size = TS * 7 * 8     # 10528 bytes, a whole number of TS packets
        buf = b''
        while not STOP.is_set():
            data = self.proc.stdout.read(size)
            if not data:
                break
            buf += data
            usable = len(buf) // TS * TS
            chunk, buf = buf[:usable], buf[usable:]
            if not chunk:
                continue
            with self.lock:
                for q in self.queues:
                    try:
                        q.put_nowait(chunk)
                    except queue.Full:
                        pass      # a stalled client loses data, like a real overloaded link

    def subscribe(self):
        q = queue.Queue(maxsize=4000)
        with self.lock:
            self.queues.append(q)
        return q

    def unsubscribe(self, q):
        with self.lock:
            if q in self.queues:
                self.queues.remove(q)

    def close(self):
        try:
            self.proc.kill()
        except OSError:
            pass


class Server(socketserver.ThreadingMixIn, http.server.HTTPServer):
    daemon_threads = True
    allow_reuse_address = True
    request_queue_size = 64


def main():
    global ARGS, SHAPER, LOG
    p = argparse.ArgumentParser()
    p.add_argument('--root', required=True)
    p.add_argument('--port', type=int, default=0)
    p.add_argument('--port-file', default='')
    p.add_argument('--rate-mbps', type=float, default=0.0)
    p.add_argument('--stall-at', default='')
    p.add_argument('--stall-seconds', type=float, default=10.0)
    p.add_argument('--outage-at', type=float, default=-1.0)
    p.add_argument('--outage-seconds', type=float, default=8.0)
    p.add_argument('--drop-after-mb', type=float, default=0.0)
    p.add_argument('--ts-flip', type=float, default=0.0)
    p.add_argument('--ts-drop', type=float, default=0.0)
    p.add_argument('--ts-drop-file', type=float, default=0.0)
    p.add_argument('--live', action='append', default=[])
    p.add_argument('--ffmpeg', default=os.environ.get('FFMPEG', 'ffmpeg'))
    p.add_argument('--seed', type=int, default=48)
    p.add_argument('--log', default='')
    ARGS = p.parse_args()
    ARGS.root = os.path.abspath(ARGS.root)
    SHAPER = Shaper(ARGS)
    if ARGS.log:
        LOG = open(ARGS.log, 'w', encoding='utf8')
    for spec in ARGS.live:
        name, _, path = spec.partition('=')
        LIVE[name] = LiveFeed(os.path.join(ARGS.root, path) if not os.path.isabs(path) else path)
    if SHAPER.outage:
        threading.Thread(target=outage_watcher, daemon=True).start()
    server = Server(('127.0.0.1', ARGS.port), Handler)
    port = server.server_address[1]
    control = http.server.ThreadingHTTPServer(('127.0.0.1', 0), ControlHandler)
    threading.Thread(target=control.serve_forever, daemon=True).start()
    if ARGS.port_file:
        with open(ARGS.port_file + '.control', 'w') as f:
            f.write(str(control.server_address[1]))
        with open(ARGS.port_file, 'w') as f:
            f.write(str(port))
    log(dict(event='listening', port=port, args=vars(ARGS)))
    print(f'listening on http://127.0.0.1:{port}', flush=True)
    try:
        server.serve_forever(poll_interval=0.2)
    except KeyboardInterrupt:
        pass
    finally:
        STOP.set()
        for feed in LIVE.values():
            feed.close()
        server.server_close()


if __name__ == '__main__':
    main()