tgrtmp 0.3.0__cp315-cp315t-win_amd64.whl

tgrtmp/__init__.py

@@ -0,0 +1,27 @@
+"""""" # start delvewheel patch
+def _delvewheel_patch_1_13_2():
+    import os
+    if os.path.isdir(libs_dir := os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir, 'tgrtmp.libs'))):
+        os.add_dll_directory(libs_dir)
+
+
+_delvewheel_patch_1_13_2()
+del _delvewheel_patch_1_13_2
+# end delvewheel patch
+
+from ._core import Client, Source, connect
+from ._version import __version__
+from .client import Publisher, SourceError, stream
+from .player import Player, publish
+
+__all__ = [
+    "Client",
+    "Player",
+    "Publisher",
+    "Source",
+    "SourceError",
+    "connect",
+    "publish",
+    "stream",
+    "__version__",
+]

tgrtmp/_version.py

@@ -0,0 +1 @@
+__version__ = "0.3.0"

tgrtmp/client.py

@@ -0,0 +1,305 @@
+import os
+import time
+
+from urllib.parse import urlsplit
+
+from ._core import Publisher as _Publisher, Source as _Source, connect
+
+# A source that ends without producing one frame is broken, and no control
+# path should spin or sit silently on it.
+ZERO_MEDIA = (
+    "The source produced no media. If this is an MP4, remux it with its "
+    "index in front first: ffmpeg -i input -c copy -movflags +faststart output.mp4"
+)
+
+# The largest moov box a recovery is willing to read.
+_MOOV_CAP = 256 * 1024 * 1024
+
+
+def _tail_moov(handle):
+    """Walk the top-level MP4 box headers with seeks; return (moov_bytes,
+    moov_offset) when the index sits at the tail, else None. A non-MP4 or a
+    non-seekable handle returns None."""
+    try:
+        handle.seek(0)
+
+        if handle.read(16)[4:8] != b"ftyp":
+            return None
+
+        handle.seek(0, 2)
+        size = handle.tell()
+
+        pos = 0
+
+        while pos + 8 <= size:
+            handle.seek(pos)
+            header = handle.read(16)
+
+            if len(header) < 8:
+                return None
+
+            box_size = int.from_bytes(header[0:4], "big")
+            box_type = header[4:8]
+            header_len = 8
+
+            if box_size == 1:
+                if len(header) < 16:
+                    return None
+
+                box_size = int.from_bytes(header[8:16], "big")
+                header_len = 16
+
+            elif box_size == 0:
+                box_size = size - pos
+
+            if box_size < header_len or pos + box_size > size:
+                return None
+
+            if box_type == b"moov":
+                if box_size > _MOOV_CAP:
+                    return None
+
+                handle.seek(pos)
+                moov = handle.read(box_size)
+
+                if len(moov) != box_size:
+                    return None
+
+                return moov, pos
+
+            pos += box_size
+
+    except (OSError, ValueError):
+        return None
+
+    return None
+
+
+class SourceError(RuntimeError):
+    """The published source is broken (bad container, unsupported codec):
+    reconnecting cannot help, so :func:`stream` propagates it."""
+
+
+class Publisher(_Publisher):
+    """A :class:`Publisher` that keeps its attached client alive."""
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._client = None
+
+    def attach(self, client):
+        self._client = client
+
+        super().attach(client)
+
+    def detach(self):
+        self._client = None
+
+        super().detach()
+
+    def stop(self):
+        self._client = None
+
+        super().stop()
+
+
+def _read_chunks(source, size=65536):
+    # A file-like object, an iterable of bytes, or a zero-argument callable
+    # returning bytes until it returns b"" or None.
+    read = getattr(source, "read", None)
+
+    if read is not None:
+        while True:
+            chunk = read(size)
+
+            if not chunk:
+                return
+
+            yield chunk
+
+        return
+
+    try:
+        iterator = iter(source)
+    except TypeError:
+        while True:
+            chunk = source()
+
+            if not chunk:
+                return
+
+            yield chunk
+
+        return
+
+    yield from iterator
+
+
+def stream(
+    source,
+    url,
+    key,
+    *,
+    verify_tls=True,
+    connect_timeout=15.0,
+    command_timeout=10.0,
+    reconnect_delay=1.0,
+    max_reconnect_delay=30.0,
+    lookahead_ms=1000,
+    stop=None,
+    log=None,
+):
+    """Publish a live source to an RTMP(S) livestream, reconnecting on drops.
+
+    :param source: A file-like object (a path, an open file, or a live byte
+        stream handle), an iterable of byte chunks, or a callable returning
+        chunks until ``b""``.
+    :param url: The RTMP application, e.g. ``rtmps://dc4-1.rtmp.t.me/s/``.
+    :param stop: An optional zero-argument callable; when it returns True the
+        publishing stops.
+    :param log: An optional ``callable(message: str)`` for connection notices.
+    :return: The :class:`Publisher`, for its statistics.
+
+    The container of the source is auto-detected (MPEG-TS, MP4
+    faststart/fragmented, MKV/WebM); its H.264 video and AAC audio are
+    published untouched, paced to real time. Sources in other codecs are
+    rejected: Telegram's RTMP server accepts H.264 and AAC only.
+    """
+    publisher = Publisher(lookahead_ms=lookahead_ms)
+
+    # A path is opened here and closed when the publish ends.
+    opened = None
+
+    if isinstance(source, (str, os.PathLike)):
+        opened = open(source, "rb")
+        source = opened
+
+    if log is not None:
+        # Warnings about what the server will not accept are surfaced through
+        # the same log: nothing fails silently.
+        publisher.set_logger(lambda message: log(f"warning: {message}"))
+
+    delay = reconnect_delay
+    log = log or (lambda message: None)
+
+    try:
+        while stop is None or not stop():
+            src = None
+            client = None
+
+            try:
+                started = time.monotonic()
+
+                client = connect(
+                    url,
+                    key,
+                    verify_tls=verify_tls,
+                    connect_timeout=connect_timeout,
+                    command_timeout=command_timeout,
+                )
+
+                elapsed_ms = (time.monotonic() - started) * 1000.0
+
+                publisher.attach(client)
+
+                log(
+                    f"Connected to {urlsplit(url).hostname or url} in {elapsed_ms:.0f}ms"
+                )
+                delay = reconnect_delay
+
+                src = _Source(publisher)
+
+                # A broken source is permanent: its errors propagate instead
+                # of triggering a reconnect.
+                try:
+                    for chunk in _read_chunks(source):
+                        if stop is not None and stop():
+                            return publisher
+
+                        src.feed(chunk)
+
+                    src.finish()
+                except RuntimeError as error:
+                    if client.is_closed:
+                        raise ConnectionError(str(error)) from error
+
+                    raise SourceError(str(error)) from error
+
+                # EOF without a single frame is a broken source (an MP4 whose
+                # moov index is not faststart reads exactly like this): say so
+                # instead of returning a silent zero-frame publish.
+                if publisher.frames_sent == 0:
+                    # A progressive MP4 whose moov sits at the tail streams
+                    # blind to EOF: read the index, prime the demuxer, and
+                    # replay the media against absolute offsets.
+                    found = _tail_moov(source)
+
+                    if found is not None:
+                        try:
+                            src.prime(found[0])
+                            source.seek(0)
+
+                            pos = 0
+
+                            for chunk in _read_chunks(source):
+                                if stop is not None and stop():
+                                    return publisher
+
+                                src.feed_at(chunk, pos)
+                                pos += len(chunk)
+
+                            src.finish()
+                        except RuntimeError as error:
+                            if client.is_closed:
+                                raise ConnectionError(str(error)) from error
+
+                            raise SourceError(str(error)) from error
+
+                if publisher.frames_sent == 0:
+                    raise SourceError(ZERO_MEDIA)
+
+                # A finite source: let the pacer flush everything it holds.
+                publisher.drain(10.0)
+                client.wait_closed(1.0)
+
+                if stop is None or not stop():
+                    log("The source ended")
+
+                return publisher
+
+            except SourceError:
+                raise
+
+            except (RuntimeError, ConnectionError, OSError) as error:
+                if stop is not None and stop():
+                    return publisher
+
+                log(
+                    f"The RTMP connection dropped ({error}); retrying in "
+                    f"{delay:.0f} seconds..."
+                )
+
+                if stop is None:
+                    time.sleep(delay)
+                else:
+                    for _ in range(int(delay * 10)):
+                        if stop():
+                            return publisher
+
+                        time.sleep(0.1)
+
+                delay = min(delay * 2, max_reconnect_delay)
+
+            finally:
+                publisher.detach()
+
+                if client is not None:
+                    client.close()
+
+    finally:
+        publisher.stop()
+
+        if opened is not None:
+            opened.close()
+
+    return publisher

tgrtmp/cpp/amf0.cpp

@@ -0,0 +1,218 @@
+#include "amf0.h"
+
+#include <cstring>
+
+namespace tgrtmp::amf0 {
+
+namespace {
+
+constexpr uint8_t MARKER_NUMBER = 0x00;
+constexpr uint8_t MARKER_BOOLEAN = 0x01;
+constexpr uint8_t MARKER_STRING = 0x02;
+constexpr uint8_t MARKER_OBJECT = 0x03;
+constexpr uint8_t MARKER_NULL = 0x05;
+constexpr uint8_t MARKER_UNDEFINED = 0x06;
+constexpr uint8_t MARKER_ECMA_ARRAY = 0x08;
+constexpr uint8_t MARKER_OBJECT_END = 0x09;
+constexpr uint8_t MARKER_STRICT_ARRAY = 0x0A;
+constexpr uint8_t MARKER_DATE = 0x0B;
+constexpr uint8_t MARKER_LONG_STRING = 0x0C;
+
+// Doubles are stored big-endian in AMF0.
+void put_be64(std::string &out, double value) {
+    uint64_t bits;
+    std::memcpy(&bits, &value, 8);
+    for (int i = 7; i >= 0; --i)
+        out.push_back(static_cast<char>((bits >> (8 * i)) & 0xFF));
+}
+
+void put_be32(std::string &out, uint32_t v) {
+    out.push_back(static_cast<char>((v >> 24) & 0xFF));
+    out.push_back(static_cast<char>((v >> 16) & 0xFF));
+    out.push_back(static_cast<char>((v >> 8) & 0xFF));
+    out.push_back(static_cast<char>(v & 0xFF));
+}
+
+void put_be16(std::string &out, uint32_t v) {
+    out.push_back(static_cast<char>((v >> 8) & 0xFF));
+    out.push_back(static_cast<char>(v & 0xFF));
+}
+
+struct Decoder {
+    std::string_view data;
+    size_t offset = 0;
+
+    [[noreturn]] static void fail(const char *what) { throw std::runtime_error(what); }
+
+    uint8_t u8() {
+        if (offset >= data.size())
+            fail("truncated AMF0 data");
+        return static_cast<uint8_t>(data[offset++]);
+    }
+
+    uint32_t u24() {
+        return (static_cast<uint32_t>(u8()) << 16) | (static_cast<uint32_t>(u8()) << 8) | u8();
+    }
+
+    uint32_t u32() {
+        uint32_t v = 0;
+        for (int i = 0; i < 4; ++i)
+            v = (v << 8) | u8();
+        return v;
+    }
+
+    uint32_t u16() { return (static_cast<uint32_t>(u8()) << 8) | u8(); }
+
+    double f64() {
+        uint64_t bits = 0;
+        for (int i = 0; i < 8; ++i)
+            bits = (bits << 8) | u8();
+        double d;
+        std::memcpy(&d, &bits, 8);
+        return d;
+    }
+
+    std::string_view take(size_t length) {
+        if (length > data.size() - offset)
+            fail("truncated AMF0 data");
+        std::string_view out = data.substr(offset, length);
+        offset += length;
+        return out;
+    }
+
+    std::string take_string() {
+        uint32_t length = u16();
+        return std::string(take(length));
+    }
+
+    void decode_properties(std::vector<std::pair<std::string, AmfValue>> &out) {
+        while (true) {
+            if (offset + 2 > data.size())
+                fail("truncated AMF0 properties");
+            uint32_t key_length = (static_cast<uint32_t>(static_cast<uint8_t>(data[offset])) << 8) |
+                                  static_cast<uint8_t>(data[offset + 1]);
+            if (key_length == 0) {
+                // Object end: 0x00 0x00 followed by the object-end marker.
+                if (offset + 3 > data.size())
+                    fail("truncated AMF0 object end");
+                if (static_cast<uint8_t>(data[offset + 2]) != MARKER_OBJECT_END) {
+                    fail("missing AMF0 object end marker");
+                }
+                offset += 3;
+                return;
+            }
+            offset += 2;
+            std::string key(take(key_length));
+            out.emplace_back(std::move(key), decode_value());
+        }
+    }
+
+    AmfValue decode_value() {
+        switch (uint8_t marker = u8(); marker) {
+        case MARKER_NUMBER:
+            return AmfValue(f64());
+        case MARKER_BOOLEAN:
+            return AmfValue(u8() != 0);
+        case MARKER_STRING:
+            return AmfValue(take_string());
+        case MARKER_LONG_STRING:
+            return AmfValue(std::string(take(u32())));
+        case MARKER_NULL:
+        case MARKER_UNDEFINED:
+            return AmfValue();
+        case MARKER_ECMA_ARRAY: {
+            u32(); // The associative-count is only a hint.
+            AmfObject obj(true, {});
+            decode_properties(obj.entries);
+            return AmfValue(std::move(obj));
+        }
+        case MARKER_OBJECT: {
+            AmfObject obj(false, {});
+            decode_properties(obj.entries);
+            return AmfValue(std::move(obj));
+        }
+        case MARKER_STRICT_ARRAY: {
+            uint32_t count = u32();
+            std::vector<AmfValue> list;
+            list.reserve(count);
+            for (uint32_t i = 0; i < count; ++i)
+                list.push_back(decode_value());
+            return AmfValue(std::move(list));
+        }
+        case MARKER_DATE: {
+            double ms = f64();
+            u16(); // Time zone, unused (reserved to be 0).
+            return AmfValue(ms);
+        }
+        default:
+            fail("unsupported AMF0 marker");
+        }
+    }
+};
+
+void encode_properties(std::string &out, const AmfObject &obj) {
+    for (const auto &[key, value] : obj.entries) {
+        put_be16(out, static_cast<uint32_t>(key.size()));
+        out.append(key);
+        encode(out, value);
+    }
+    out.push_back('\x00');
+    out.push_back('\x00');
+    out.push_back(static_cast<char>(MARKER_OBJECT_END));
+}
+
+} // namespace
+
+void encode(std::string &out, const AmfValue &value) {
+    if (auto *b = std::get_if<bool>(&value.v)) {
+        out.push_back(static_cast<char>(MARKER_BOOLEAN));
+        out.push_back(*b ? '\x01' : '\x00');
+        return;
+    }
+    if (auto *d = std::get_if<double>(&value.v)) {
+        out.push_back(static_cast<char>(MARKER_NUMBER));
+        put_be64(out, *d);
+        return;
+    }
+    if (auto *s = std::get_if<std::string>(&value.v)) {
+        if (s->size() > 0xFFFF) {
+            out.push_back(static_cast<char>(MARKER_LONG_STRING));
+            put_be32(out, static_cast<uint32_t>(s->size()));
+        } else {
+            out.push_back(static_cast<char>(MARKER_STRING));
+            put_be16(out, static_cast<uint32_t>(s->size()));
+        }
+        out.append(*s);
+        return;
+    }
+    if (auto *list = std::get_if<std::vector<AmfValue>>(&value.v)) {
+        out.push_back(static_cast<char>(MARKER_STRICT_ARRAY));
+        put_be32(out, static_cast<uint32_t>(list->size()));
+        for (const auto &item : *list)
+            encode(out, item);
+        return;
+    }
+    if (auto *obj = std::get_if<AmfObject>(&value.v)) {
+        if (obj->ecma) {
+            out.push_back(static_cast<char>(MARKER_ECMA_ARRAY));
+            put_be32(out, static_cast<uint32_t>(obj->entries.size()));
+        } else {
+            out.push_back(static_cast<char>(MARKER_OBJECT));
+        }
+        encode_properties(out, *obj);
+        return;
+    }
+    // std::monostate: null and undefined both decode to it; encode null.
+    out.push_back(static_cast<char>(MARKER_NULL));
+}
+
+std::vector<AmfValue> decode(std::string_view data) {
+    Decoder decoder{data, 0};
+    std::vector<AmfValue> values;
+    while (decoder.offset < data.size()) {
+        values.push_back(decoder.decode_value());
+    }
+    return values;
+}
+
+} // namespace tgrtmp::amf0

tgrtmp/cpp/amf0.h

@@ -0,0 +1,105 @@
+// AMF0 (Action Message Format 0) encoder/decoder for the RTMP command and
+// metadata messages, per the Adobe AMF0 spec (§2.1 of "Action Message Format
+// -- AMF 0", 2006). Only the marker types RTMP servers actually use are
+// supported: number, boolean, string, object, null, undefined, ECMA array,
+// strict array, date and long string.
+//
+// This is a clean-room implementation written against the public spec.
+
+#pragma once
+
+#include <cstdint>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <utility>
+#include <variant>
+#include <vector>
+
+namespace tgrtmp {
+
+struct AmfValue;
+
+// An ordered string -> value map. Encoded as an AMF0 ECMA array (0x08) when
+// `ecma` is true (the type of @setDataFrame's onMetaData), otherwise as an
+// AMF0 object (0x03).
+struct AmfObject {
+    bool ecma = false;
+    // AmfValue is incomplete here; std::vector tolerates incomplete value
+    // types as long as it is completed before members are used (C++17).
+    std::vector<std::pair<std::string, AmfValue>> entries;
+
+    AmfObject() = default;
+    AmfObject(bool ecma_, std::vector<std::pair<std::string, AmfValue>> entries_)
+        : ecma(ecma_), entries(std::move(entries_)) {}
+};
+
+struct AmfValue {
+    std::variant<std::monostate, bool, double, std::string, std::vector<AmfValue>, AmfObject> v;
+
+    AmfValue() = default;
+    AmfValue(std::monostate) {}
+    AmfValue(bool b) : v(b) {}
+    AmfValue(double d) : v(d) {}
+    AmfValue(int i) : v(static_cast<double>(i)) {}
+    AmfValue(const char *s) : v(std::string(s)) {}
+    AmfValue(std::string s) : v(std::move(s)) {}
+    AmfValue(std::string_view s) : v(std::string(s)) {}
+    AmfValue(std::vector<AmfValue> list) : v(std::move(list)) {}
+    AmfValue(AmfObject obj) : v(std::move(obj)) {}
+
+    bool is_null() const { return std::holds_alternative<std::monostate>(v); }
+    bool is_number() const { return std::holds_alternative<double>(v); }
+    bool is_string() const { return std::holds_alternative<std::string>(v); }
+    bool is_object() const { return std::holds_alternative<AmfObject>(v); }
+
+    double as_number(double fallback = 0.0) const {
+        if (auto *d = std::get_if<double>(&v))
+            return *d;
+        return fallback;
+    }
+    const std::string *as_string() const { return std::get_if<std::string>(&v); }
+    const AmfObject *as_object() const { return std::get_if<AmfObject>(&v); }
+
+    // Object/ECMA property lookup by key.
+    const AmfValue *find(std::string_view key) const {
+        if (auto *obj = std::get_if<AmfObject>(&v)) {
+            for (const auto &[k, val] : obj->entries) {
+                if (k == key)
+                    return &val;
+            }
+        }
+        return nullptr;
+    }
+};
+
+namespace amf0 {
+
+// Append the AMF0 encoding of `value` to `out`.
+void encode(std::string &out, const AmfValue &value);
+
+// Encode several values back to back, as the arguments of a command message.
+template <typename... Rest>
+void encode_args(std::string &out, const AmfValue &first, const Rest &...rest) {
+    encode(out, first);
+    (encode(out, rest), ...);
+}
+
+// Decode every value of a payload. Throws std::runtime_error on malformed or
+// truncated data, or on unsupported markers.
+std::vector<AmfValue> decode(std::string_view data);
+
+inline AmfValue null_value() { return AmfValue(); }
+inline AmfValue boolean(bool b) { return AmfValue(b); }
+inline AmfValue number(double d) { return AmfValue(d); }
+inline AmfValue string(std::string_view s) { return AmfValue(s); }
+
+inline AmfValue object(std::vector<std::pair<std::string, AmfValue>> entries) {
+    return AmfValue(AmfObject(false, std::move(entries)));
+}
+inline AmfValue ecma_array(std::vector<std::pair<std::string, AmfValue>> entries) {
+    return AmfValue(AmfObject(true, std::move(entries)));
+}
+
+} // namespace amf0
+} // namespace tgrtmp