@synapse-sdk/media 0.3.0 → 0.3.3

package/dist/video.js

@@ -1,250 +1,172 @@
-// Glue between the codecs and a Synapse node: `VideoPublisher` (encoder → `publishMedia`, serves
-// `<topic>/idr`), `VideoSubscriber` (raw subscription → `H264Decoder`, calls `<topic>/idr` when
-// stuck or waiting, keeps stats), `h264Topic` (the raw `fec` datagram topic with an H.264 layout).
-import { SynapseError, defineTopic, nowUs, resolveTopic } from "@synapse-sdk/core";
-import { ParamSetCache } from "./reinsert.js";
-export const H264 = "video/h264";
-/** A raw topic for H.264 access units: `contentType: "video/h264"`, `layout: {codec: "h264", stream: "annexb", ...}`, datagrams with FEC. */
-export function h264Topic(name, layout = {}, opts = {}) {
-    const l = { codec: "h264", stream: "annexb", ...layout };
-    if (opts.retain)
-        return defineTopic({ name, contentType: H264, layout: l, delivery: "stream" });
-    return defineTopic({ name, contentType: H264, layout: l, delivery: "datagram", fec: { repairPct: opts.repairPct ?? 30, deadlineMs: opts.deadlineMs ?? 50 } });
-}
-/** The IDR-on-demand service a video publisher serves (decision 4): `<topic>/idr`, no arguments, `{ ok: true }`. */
-export function idrServiceName(topic) { return `${topic}/idr`; }
-function rawContract(topic, who) {
-    const c = resolveTopic(topic);
-    if (!c.raw)
-        throw new SynapseError("invalid_input", `${who}: topic ${c.name} must be a raw topic (use h264Topic())`);
-    return c;
+// Video in one call each way (PLAN v0.25 §2), the browser spelling of the Rust client's `video.rs`:
+// `videoPublisher(node, topic)` takes `VideoFrame`s (WebCodecs H.264 encode + publish in the
+// caller's `publish`), `videoSubscriber(node, topic)` gives decoded `VideoFrame`s. Underneath they
+// are the two-step path anyone may still take: an `H264Encoder` feeding a publisher on a
+// `video/h264` topic, and a subscription feeding an `H264Decoder` (its `DecoderSync` policy decides
+// where decoding starts and when to ask for an IDR).
+//
+// The publisher serves `<topic>/idr`: the next picture is an IDR with SPS/PPS. The subscriber calls
+// it when its decoder's policy says `request_idr` (one call in flight at a time).
+import { SynapseError, defineTopic } from "@synapse-sdk/core";
+import { pumpTrack } from "./camera.js";
+import { H264Decoder } from "./decoder.js";
+import { H264Encoder } from "./encoder.js";
+const H264 = "video/h264";
+/** The key of a client publisher handle's encoder-frame path (`@synapse-sdk/client` `PUBLISH_MEDIA_FRAME`): flags and `STAGES` as the encoder made them. */
+const PUBLISH_MEDIA_FRAME = Symbol.for("@synapse-sdk/client:publishMediaFrame");
+/** The `video/h264` contract of `topic`: a name gets one; a contract must already be `video/h264`. */
+function videoContract(topic) {
+    if (typeof topic === "string")
+        return defineTopic({ name: topic, contentType: H264 });
+    if (topic.contentType !== H264)
+        throw new SynapseError("invalid_input", `topic ${topic.name}: a video publisher needs contentType ${H264} (it has ${topic.contentType})`);
+    return topic;
 }
 /**
- * Encoder output → `publisher.publishMedia()`: `t_us` = capture (the `VideoFrame.timestamp`),
- * `STAGES` = encoder stamp + `sentUs` 0 (the publisher stamps it at the write, WP §4.1), SPS/PPS
- * re-insertion at recovery points, plus the `<topic>/idr` service that forces the next frame to be
- * an IDR. `VideoPublisher.open()` resolves once the runtime admitted the topic (and the service).
+ * A video publisher on `topic` (a name, or a `video/h264` topic: datagrams with FEC unless the
+ * contract says otherwise). Resolves once the topic and its `<topic>/idr` service are admitted.
  */
-export class VideoPublisher {
-    node;
-    topic;
-    publisher;
-    registration;
-    encoder;
-    #cache = new ParamSetCache();
-    #detach;
-    #sent = 0;
-    #idrCalls = 0;
-    constructor(node, topic, publisher, registration, encoder) {
-        this.node = node;
-        this.topic = topic;
-        this.publisher = publisher;
-        this.registration = registration;
-        this.encoder = encoder;
-        this.#detach = encoder.attachSink(f => this.#onFrame(f));
+export async function videoPublisher(node, topic, opts = {}) {
+    const contract = videoContract(topic);
+    const publisher = await node.publisher(contract);
+    let encoder;
+    let requests = 0;
+    let idr;
+    try {
+        idr = await node.serve(`${contract.name}/idr`, () => { requests++; encoder?.forceIdr(); return { ok: true, requests }; }, { minRole: "observer", description: "force the next picture to be an IDR with SPS/PPS" });
     }
-    static async open(node, topic, encoder, opts = {}) {
-        const contract = rawContract(topic, "VideoPublisher");
-        const publisher = await node.publisher(contract);
-        let reg;
-        if (opts.idrService !== false) {
-            let self;
-            try {
-                reg = await node.serve(idrServiceName(contract.name), () => { if (self)
-                    self.#idrCalls++; encoder.forceIdr(); return { ok: true }; }, { minRole: "observer", description: `force the next ${contract.name} frame to be an IDR` });
-            }
-            catch (e) {
-                publisher.close();
-                throw e;
-            }
-            self = new VideoPublisher(node, contract, publisher, reg, encoder);
-            return self;
-        }
-        return new VideoPublisher(node, contract, publisher, undefined, encoder);
+    catch (e) {
+        publisher.close();
+        throw e;
     }
-    #onFrame(f) {
-        const p = this.#cache.prepare(f, false);
-        p.stages = { encodedUs: f.stages?.encodedUs ?? nowUs(), sentUs: 0 };
-        this.#sent++;
-        try {
-            this.publisher.publishMedia(p);
+    let closed = false;
+    const send = publisher;
+    const publish = (frame, tUs) => {
+        if (closed)
+            throw new SynapseError("not_connected", "video publisher closed");
+        if (encoder && (encoder.cfg.width !== frame.displayWidth || encoder.cfg.height !== frame.displayHeight)) {
+            // TODO(video, D 2026-10-08): one publisher per video topic is assumed, not enforced;
+            // resolution and settings do not change while a publisher lives. Codify later.
+            throw new SynapseError("invalid_input", "frame size changed; one publisher, one size");
         }
-        catch (e) {
-            this.node.warn(`VideoPublisher ${this.topic.name}: publish failed: ${e instanceof Error ? e.message : String(e)}`);
-        }
-    }
-    stats() { return { sent: this.#sent, idrCalls: this.#idrCalls, reinserted: this.#cache.reinserted }; }
-    /** Stops publishing (the encoder stays yours to close). */
-    close() {
-        this.#detach();
-        this.registration?.unregister();
-        this.publisher.close();
-    }
-}
-const freshWindow = () => ({ t0: performance.now(), frames: 0, bytes: 0, e2e: 0, e2eN: 0, enc: 0, encN: 0, send: 0, sendN: 0, net: 0, netN: 0, dec: 0, decN: 0, eps: 0, epsN: 0 });
-/** A received envelope on a raw media topic as a `MediaFrame` (the header's flags and `STAGES`). */
-export function mediaFrameOf(env) {
-    const f = { data: env.data, tUs: env.tUs, key: (env.flags & 1) !== 0, config: (env.flags & 32) !== 0, recovery: (env.flags & 64) !== 0 };
-    for (const t of env.tlvs)
-        if (t.kind === "stages") {
-            f.stages = { encodedUs: Number(t.encodedUs), sentUs: Number(t.sentUs) };
-            break;
+        if (!encoder) {
+            encoder = new H264Encoder({ width: frame.displayWidth, height: frame.displayHeight, ...opts, onError: e => node.warn(`video ${contract.name}: encoder: ${e instanceof Error ? e.message : String(e)}`) });
+            // flags and `STAGES` as the encoder made them; `sentUs` 0 is stamped at the write
+            encoder.attachSink(f => {
+                try {
+                    send[PUBLISH_MEDIA_FRAME](f);
+                }
+                catch (e) {
+                    node.warn(`video ${contract.name}: publish failed: ${e instanceof Error ? e.message : String(e)}`);
+                }
+            });
         }
-    return f;
+        encoder.encode(frame, tUs === undefined ? {} : { tUs });
+    };
+    return {
+        publish,
+        pumpTrack: (track, o = {}) => pumpTrack(track, publish, o),
+        close() {
+            if (closed)
+                return;
+            closed = true;
+            encoder?.close();
+            idr.unregister();
+            publisher.close();
+        },
+        get encoder() { return encoder; },
+    };
 }
 /**
- * A raw subscription feeding an `H264Decoder`. Every envelope becomes a `MediaFrame` and goes to
- * `decoder.push()`; the decoder's stuck signal and the waiting state (a late joiner on an IDR-only
- * stream sees nothing until an IDR comes) both call the publisher's `<topic>/idr` service, at most
- * once per `idrMinIntervalMs`. Stats: fps, totals, and the latency split from `t_us` and `STAGES`.
+ * Decoded pictures of the video topic `topic` (by name; the established descriptor says what it
+ * carries). Every frame is fed to the decoder in order and every picture it gives is delivered.
+ * Frames before a start point are dropped by the decoder's policy, which asks the publisher for an
+ * IDR when stuck or waiting. Throws `not_supported` where WebCodecs is missing.
  */
-export class VideoSubscriber {
-    node;
-    decoder;
-    opts;
-    topic;
-    sub;
-    #win = freshWindow();
-    #received = 0;
-    #idrRequests = 0;
-    #idrFailed = 0;
-    #lastIdrMs = -Infinity;
-    #waitingDropped = 0;
-    /** Capture stamp of each frame in flight, converted to our clock (`toLocalUs`); absent when the clocks are not comparable. */
-    #captureLocal = new WeakMap();
-    #closed = false;
-    constructor(node, topic, decoder, opts = {}) {
-        this.node = node;
-        this.decoder = decoder;
-        this.opts = opts;
-        this.topic = rawContract(topic, "VideoSubscriber");
-        const prevIdr = decoder.onRequestIdr;
-        const onIdr = () => { prevIdr?.(); this.#requestIdr("stuck"); };
-        decoder.onRequestIdr = onIdr;
-        const prevOut = decoder.onOutput;
-        const onOut = (meta) => { prevOut?.(meta); this.#onOutput(meta); };
-        decoder.onOutput = onOut;
-        // `close()` puts the decoder's previous callbacks back when ours are still the ones installed.
-        this.#restore = () => {
-            if (decoder.onRequestIdr === onIdr)
-                decoder.onRequestIdr = prevIdr;
-            if (decoder.onOutput === onOut)
-                decoder.onOutput = prevOut;
-        };
-        // Every frame reaches the decoder (queueDepth 0): the decoder's own queue sheds, in picture order.
-        this.sub = node.subscribe(this.topic, { priority: opts.priority ?? 2, queueDepth: 0 });
-        void this.#read();
-    }
-    async #read() {
-        for (;;) {
-            const batch = await this.sub.next();
-            if (!batch || this.#closed)
-                return;
-            for (const env of batch)
-                this.#onEnvelope(env);
-        }
-    }
-    #onEnvelope(env) {
-        if (this.#closed)
+export function videoSubscriber(node, topic, opts = {}) {
+    const name = typeof topic === "string" ? topic : topic.name;
+    const idrService = `${name}/idr`;
+    const decoder = new H264Decoder();
+    // every frame reaches the decoder (a P picture references the one before it)
+    const sub = node.subscribe(name, { queueDepth: 0 });
+    const pending = [];
+    let wake;
+    let ended = false;
+    const signal = () => { const w = wake; wake = undefined; w?.(); };
+    let idrInFlight = false;
+    // `<topic>/idr` unless a call is still in flight; a failure is the policy's business (it asks again after another stuck window).
+    decoder.onRequestIdr = () => {
+        if (idrInFlight || ended)
             return;
-        const f = mediaFrameOf(env);
-        this.#received++;
-        this.#win.frames++;
-        this.#win.bytes += f.data.length;
-        const recvUs = nowUs();
-        // Stamps within the publisher's clock need no conversion; those compared with ours go through `toLocalUs` (SDK §4.4).
-        if (f.stages) {
-            if (f.stages.encodedUs > 0 && f.tUs > 0) {
-                this.#win.enc += (f.stages.encodedUs - f.tUs) / 1000;
-                this.#win.encN++;
-            }
-            if (f.stages.sentUs > 0 && f.stages.encodedUs > 0) {
-                this.#win.send += (f.stages.sentUs - f.stages.encodedUs) / 1000;
-                this.#win.sendN++;
-            }
-            if (f.stages.sentUs > 0) {
-                const sent = this.node.toLocalUs(f.stages.sentUs, env.dom);
-                if (sent) {
-                    this.#win.net += (recvUs - sent.localUs) / 1000;
-                    this.#win.netN++;
-                }
-            }
-        }
-        if (f.tUs > 0) {
-            const capture = this.node.toLocalUs(f.tUs, env.dom);
-            if (capture) {
-                this.#captureLocal.set(f, capture);
-                this.#win.eps += capture.epsUs / 1000;
-                this.#win.epsN++;
-            }
-        }
-        const droppedBefore = this.decoder.sync.stats.dropped;
-        this.decoder.push(f);
-        if (this.decoder.sync.stats.dropped > droppedBefore) {
-            // Waiting for a start point: a browser publisher emits IDRs only on demand, so ask (first frame, then every stuck window).
-            this.#waitingDropped++;
-            if (this.#waitingDropped === 1 || this.#waitingDropped % this.decoder.sync.cfg.stuckFrames === 0)
-                this.#requestIdr("waiting");
-        }
-        else
-            this.#waitingDropped = 0;
-    }
-    #onOutput(meta) {
-        this.#win.dec += meta.decodeMs;
-        this.#win.decN++;
-        const capture = this.#captureLocal.get(meta.frame);
-        if (capture) {
-            this.#win.e2e += (nowUs() - capture.localUs) / 1000;
-            this.#win.e2eN++;
+        let run;
+        try {
+            run = node.call(idrService, {}, { deadlineMs: 1000 });
         }
-    }
-    #requestIdr(why) {
-        if (this.opts.requestIdr === false || this.#closed)
+        catch {
             return;
-        const now = performance.now();
-        if (now - this.#lastIdrMs < (this.opts.idrMinIntervalMs ?? 1000))
+        } // no session: the next window asks again
+        idrInFlight = true;
+        run.result.then(() => { }, () => { }).finally(() => { idrInFlight = false; });
+    };
+    decoder.attachSink((vf, meta) => {
+        if (ended) {
+            vf.close();
             return;
-        this.#lastIdrMs = now;
-        this.#idrRequests++;
+        }
+        if (!opts.onFrame) {
+            pending.push(vf);
+            signal();
+            return;
+        }
+        const env = meta.frame;
+        const m = "seq" in env ? env : { data: env.data, tUs: env.tUs, seq: 0, publisher: "", dom: "", flags: 0, type: 0, tlvs: [], key: env.key, config: env.config, recovery: env.recovery };
         try {
-            this.node.call(idrServiceName(this.topic.name), {}, { deadlineMs: 1000 }).result.catch(() => { this.#idrFailed++; });
+            opts.onFrame(vf, m);
         }
-        catch {
-            this.#idrFailed++;
+        finally {
+            vf.close();
         }
-        void why;
-    }
-    /** Window averages since the previous call plus totals; resets the window. */
-    stats() {
-        const w = this.#win;
-        const dt = (performance.now() - w.t0) / 1000;
-        const avg = (sum, n) => (n ? sum / n : undefined);
-        const d = this.decoder.stats();
-        const superseded = this.sub.stats.superseded;
-        const s = {
-            fps: dt > 0 ? (d.output - this.#lastOutput) / dt : 0, kbps: dt > 0 ? (w.bytes * 8) / dt / 1000 : 0,
-            received: this.#received, decoded: d.output, dropped: d.dropped + superseded, superseded, resets: d.resets, idrRequests: this.#idrRequests,
-            queue: d.queue, width: d.width, height: d.height, state: d.state,
-            latency: { e2eMs: avg(w.e2e, w.e2eN), encMs: avg(w.enc, w.encN), sendMs: avg(w.send, w.sendN), netMs: avg(w.net, w.netN), decodeMs: avg(w.dec, w.decN), epsMs: avg(w.eps, w.epsN) },
-        };
-        this.#lastOutput = d.output;
-        this.#win = freshWindow();
-        return s;
-    }
-    #lastOutput = 0;
-    /** IDR calls that failed (no publisher serving `<topic>/idr`, or timed out). */
-    get idrFailed() { return this.#idrFailed; }
-    /**
-     * Stops the subscription and gives the decoder back its previous callbacks (the decoder stays
-     * yours to close). Close subscribers sharing one decoder newest first: a subscriber whose
-     * callbacks another one wrapped since cannot take them back, so the newer one still calls them.
-     */
-    close() {
-        if (this.#closed)
+    });
+    const close = () => {
+        if (ended)
             return;
-        this.#closed = true;
-        this.sub.unsubscribe();
-        this.#restore();
-    }
-    #restore;
+        ended = true;
+        sub.unsubscribe();
+        decoder.close();
+        for (const vf of pending.splice(0))
+            vf.close();
+        signal();
+    };
+    void (async () => {
+        for (;;) {
+            const batch = await sub.next();
+            if (!batch || ended)
+                break;
+            // an envelope is the decoder's `MediaFrame` (data, tUs, key, config, recovery): the picture's meta is the envelope itself
+            for (const env of batch)
+                if (env.data instanceof Uint8Array)
+                    decoder.push(env);
+        }
+        close();
+    })();
+    return {
+        close,
+        async *[Symbol.asyncIterator]() {
+            try {
+                for (;;) {
+                    const vf = pending.shift();
+                    if (vf) {
+                        yield vf;
+                        continue;
+                    }
+                    if (ended)
+                        return;
+                    await new Promise(r => { wake = r; });
+                }
+            }
+            finally {
+                close();
+            }
+        },
+    };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@synapse-sdk/media",
-  "version": "0.3.0",
+  "version": "0.3.3",
   "description": "Synapse SDK media: H.264 video in the browser — encoder, decoder, canvas sink, video publisher/subscriber and the React useVideo hook.",
   "type": "module",
   "sideEffects": false,
@@ -18,11 +18,11 @@
     "dist"
   ],
   "dependencies": {
-    "@synapse-sdk/core": "0.3.0",
-    "@synapse-sdk/client": "0.3.0"
+    "@synapse-sdk/core": "0.3.3",
+    "@synapse-sdk/client": "0.3.3"
   },
   "peerDependencies": {
-    "@synapse-sdk/react": "0.3.0",
+    "@synapse-sdk/react": "0.3.3",
     "react": ">=18"
   },
   "peerDependenciesMeta": {

package/dist/annexb.d.ts

@@ -1,93 +0,0 @@
-import type { MediaFrame } from "@synapse-sdk/core";
-/** NAL unit types this package cares about (H.264 Table 7-1). */
-export declare const NAL_TYPE: {
-    readonly SLICE: 1;
-    readonly SLICE_DPA: 2;
-    readonly SLICE_DPB: 3;
-    readonly SLICE_DPC: 4;
-    readonly IDR: 5;
-    readonly SEI: 6;
-    readonly SPS: 7;
-    readonly PPS: 8;
-    readonly AUD: 9;
-};
-/** SEI payload type of a recovery point (H.264 D.1.8). */
-export declare const SEI_RECOVERY_POINT = 6;
-/** One NAL unit inside an Annex-B buffer. */
-export interface Nal {
-    /** Offset of the start code in the buffer. */
-    offset: number;
-    /** 3 or 4 (bytes of `00 00 01` / `00 00 00 01`). */
-    startCodeLen: number;
-    /** The NAL unit bytes after the start code: header byte, then the payload (still escaped). A view, not a copy. */
-    bytes: Uint8Array;
-}
-/** `nal_unit_type` (low 5 bits of the header byte); 0 for an empty NAL. */
-export declare function nalType(n: Nal): number;
-/** Payload after the 1-byte NAL header (escaped RBSP). */
-export declare function nalPayload(n: Nal): Uint8Array;
-/** A VCL NAL type: a coded slice (types 1-5). */
-export declare function isVclType(t: number): boolean;
-export declare function nalIsVcl(n: Nal): boolean;
-/** Start code plus NAL unit, as it sits in the stream (a view). */
-export declare function nalWithStartCode(buf: Uint8Array, n: Nal): Uint8Array;
-/** Next Annex-B start code (`00 00 01` or `00 00 00 01`) at or after `from`: `[offset, len]`. */
-export declare function findStartCode(buf: Uint8Array, from: number): [offset: number, len: number] | undefined;
-/**
- * The NAL units of an Annex-B buffer, in order. Bytes before the first start code are skipped;
- * trailing zero bytes (`trailing_zero_8bits`) stay attached to the NAL before them, which is
- * harmless for type/flag decisions and keeps the bytes of a walked AU identical to the input.
- */
-export declare function nalUnits(buf: Uint8Array): Nal[];
-/** The SPS + PPS NAL units of an access unit (with their start codes, in stream order), if it carries any. Defined ⇒ the AU deserves the `CONFIG` flag. */
-export declare function auParamSets(au: Uint8Array): Uint8Array | undefined;
-/**
- * The sync points an Annex-B access unit offers.
- * - `idr`: an IDR slice (NAL type 5) is present → instantaneous start point (`KEY`).
- * - `recovery`: a recovery point SEI (NAL 6, payload type 6) is present → gradual start point,
- *   clean one refresh period later (`RECOVERY`; x264 and nvenc both emit it at each intra-refresh sweep).
- * Decided from the bitstream rather than the encoder's keyframe flag, which libx264 raises for
- * both kinds and nvenc only for IDRs.
- */
-export declare function auSyncPoints(au: Uint8Array): {
-    idr: boolean;
-    recovery: boolean;
-};
-/** An IDR is present: the AU is a keyframe in the `KEY` sense. */
-export declare function isKeyframe(au: Uint8Array): boolean;
-/** The AU carries at least one coded slice (otherwise it is parameter sets / SEI only). */
-export declare function hasVcl(au: Uint8Array): boolean;
-/** Whether an SEI NAL payload (after the NAL header byte) contains a recovery point message (payload type 6). */
-export declare function seiHasRecoveryPoint(payload: Uint8Array): boolean;
-/** The payload types of the SEI messages in an SEI NAL payload (D.1.1), in order. Emulation-prevention bytes are removed first. */
-export declare function seiPayloadTypes(payload: Uint8Array): number[];
-/** Strip H.264 emulation-prevention bytes (the `03` in `00 00 03`), giving the RBSP. */
-export declare function rbspUnescape(nal: Uint8Array): Uint8Array;
-/** The SPS of an AU (NAL bytes without start code), if present. */
-export declare function findSps(au: Uint8Array): Uint8Array | undefined;
-/** The WebCodecs / RFC 6381 codec string for an AU that carries an SPS: `avc1.` + profile_idc + constraint flags + level_idc as hex (e.g. `avc1.42c01e`). */
-export declare function codecStringFromSps(au: Uint8Array): string | undefined;
-/** `parts` joined into one new buffer (a single part is copied too, so the result never aliases the input). */
-export declare function concatBytes(parts: readonly Uint8Array[]): Uint8Array;
-/**
- * Splits a continuous Annex-B byte stream (a file, an encoder pipe) into access units. Rule
- * (dylithium's reader loop): an AU ends with its coded slice; the next NAL of any kind starts a
- * new AU, so non-VCL NALs (SPS, PPS, SEI, AUD) are attached to the picture that follows them.
- * Sufficient for one-slice-per-picture streams (x264 `slices=1`, nvenc, WebCodecs), which is what
- * the encoder options enforce.
- */
-export declare class AuSplitter {
-    #private;
-    /** Feeds bytes; returns every access unit completed by them (in order). */
-    push(bytes: Uint8Array): Uint8Array[];
-    /** End of stream: the last NAL (whose end no start code marks) closes the last AU, or starts one more if the current AU already has its slice. */
-    finish(): Uint8Array[];
-}
-/** Splits a whole Annex-B buffer into access units (see {@link AuSplitter}). */
-export declare function splitAccessUnits(stream: Uint8Array): Uint8Array[];
-/**
- * A `MediaFrame` for an H.264 Annex-B access unit with `key`/`config`/`recovery` derived from the
- * NAL units (IDR present / SPS+PPS present / recovery-point SEI present), so the header flags
- * always agree with the bytes (R27 §2 publisher rule). `tUs` is the capture time (0 = stamp at publish).
- */
-export declare function mediaFrameFromAnnexb(au: Uint8Array, tUs?: number): MediaFrame;