@blockcast/mmt-container 0.1.0 → 0.3.0-main.0bde85f7082f

package/dist/authored-timing.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Exact timing authored by an ISO-BMFF media fragment.
+ *
+ * `timestamp`/`duration` fields on the browser-facing APIs are converted to
+ * microseconds for legacy callers. This value remains in the media track's
+ * native timescale so consumers that own a CMAF/WebCodecs timeline do not
+ * have to reconstruct integer ticks from rounded wall-clock values.
+ */
+export interface AuthoredTiming {
+    /** Exact decode time in the media track's timescale. */
+    decodeTime: bigint;
+    /** Exact presentation time in the media track's timescale, including CTS. */
+    presentationTime: bigint;
+    /**
+     * Exact sample duration in the media track's timescale. This remains a
+     * number because ISO-BMFF stores sample_duration as an unsigned 32-bit
+     * field, whose full range is exactly representable by JavaScript numbers.
+     */
+    durationTicks: number;
+    /** `mdhd` timescale for all values above. */
+    mediaTimescale: number;
+}
+/** Convert authored media ticks to an integer target timescale without first
+ * narrowing the authored tick value to a wall-clock float. */
+export declare function scaleAuthoredTicks(ticks: bigint, mediaTimescale: number, targetTimescale: number): number | null;
+/** Convert exact authored presentation time and duration to an assembler's
+ * public timestamp scale. */
+export declare function scaleAuthoredTiming(timing: AuthoredTiming, targetTimescale: number): {
+    timestamp: number;
+    duration: number;
+} | null;
+//# sourceMappingURL=authored-timing.d.ts.map

package/dist/authored-timing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authored-timing.d.ts","sourceRoot":"","sources":["../src/authored-timing.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,WAAW,cAAc;IAC7B,wDAAwD;IACxD,UAAU,EAAE,MAAM,CAAA;IAClB,6EAA6E;IAC7E,gBAAgB,EAAE,MAAM,CAAA;IACxB;;;;OAIG;IACH,aAAa,EAAE,MAAM,CAAA;IACrB,6CAA6C;IAC7C,cAAc,EAAE,MAAM,CAAA;CACvB;AAED;8DAC8D;AAC9D,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,MAAM,EACb,cAAc,EAAE,MAAM,EACtB,eAAe,EAAE,MAAM,GACtB,MAAM,GAAG,IAAI,CAYf;AAED;6BAC6B;AAC7B,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,cAAc,EACtB,eAAe,EAAE,MAAM,GACtB;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAchD"}

package/dist/authored-timing.js

@@ -0,0 +1,32 @@
+// src/authored-timing.ts
+function scaleAuthoredTicks(ticks, mediaTimescale, targetTimescale) {
+  if (!Number.isSafeInteger(mediaTimescale) || mediaTimescale <= 0 || !Number.isSafeInteger(targetTimescale) || targetTimescale <= 0) return null;
+  const negative = ticks < 0n;
+  const numerator = (negative ? -ticks : ticks) * BigInt(targetTimescale);
+  const denominator = BigInt(mediaTimescale);
+  const whole = numerator / denominator;
+  const remainder = numerator % denominator;
+  if (whole > BigInt(Number.MAX_SAFE_INTEGER)) return null;
+  const value = Number(whole) + Number(remainder) / mediaTimescale;
+  return Number.isFinite(value) ? negative ? -value : value : null;
+}
+function scaleAuthoredTiming(timing, targetTimescale) {
+  if (!Number.isSafeInteger(timing.durationTicks) || timing.durationTicks <= 0) return null;
+  const timestamp = scaleAuthoredTicks(
+    timing.presentationTime,
+    timing.mediaTimescale,
+    targetTimescale
+  );
+  const duration = scaleAuthoredTicks(
+    BigInt(timing.durationTicks),
+    timing.mediaTimescale,
+    targetTimescale
+  );
+  if (timestamp === null || duration === null || duration <= 0) return null;
+  return { timestamp, duration };
+}
+export {
+  scaleAuthoredTicks,
+  scaleAuthoredTiming
+};
+//# sourceMappingURL=authored-timing.js.map

package/dist/authored-timing.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/authored-timing.ts"],
+  "sourcesContent": ["/**\n * Exact timing authored by an ISO-BMFF media fragment.\n *\n * `timestamp`/`duration` fields on the browser-facing APIs are converted to\n * microseconds for legacy callers. This value remains in the media track's\n * native timescale so consumers that own a CMAF/WebCodecs timeline do not\n * have to reconstruct integer ticks from rounded wall-clock values.\n */\nexport interface AuthoredTiming {\n  /** Exact decode time in the media track's timescale. */\n  decodeTime: bigint\n  /** Exact presentation time in the media track's timescale, including CTS. */\n  presentationTime: bigint\n  /**\n   * Exact sample duration in the media track's timescale. This remains a\n   * number because ISO-BMFF stores sample_duration as an unsigned 32-bit\n   * field, whose full range is exactly representable by JavaScript numbers.\n   */\n  durationTicks: number\n  /** `mdhd` timescale for all values above. */\n  mediaTimescale: number\n}\n\n/** Convert authored media ticks to an integer target timescale without first\n * narrowing the authored tick value to a wall-clock float. */\nexport function scaleAuthoredTicks(\n  ticks: bigint,\n  mediaTimescale: number,\n  targetTimescale: number,\n): number | null {\n  if (!Number.isSafeInteger(mediaTimescale) || mediaTimescale <= 0 ||\n      !Number.isSafeInteger(targetTimescale) || targetTimescale <= 0) return null\n\n  const negative = ticks < 0n\n  const numerator = (negative ? -ticks : ticks) * BigInt(targetTimescale)\n  const denominator = BigInt(mediaTimescale)\n  const whole = numerator / denominator\n  const remainder = numerator % denominator\n  if (whole > BigInt(Number.MAX_SAFE_INTEGER)) return null\n  const value = Number(whole) + Number(remainder) / mediaTimescale\n  return Number.isFinite(value) ? (negative ? -value : value) : null\n}\n\n/** Convert exact authored presentation time and duration to an assembler's\n * public timestamp scale. */\nexport function scaleAuthoredTiming(\n  timing: AuthoredTiming,\n  targetTimescale: number,\n): { timestamp: number; duration: number } | null {\n  if (!Number.isSafeInteger(timing.durationTicks) || timing.durationTicks <= 0) return null\n  const timestamp = scaleAuthoredTicks(\n    timing.presentationTime,\n    timing.mediaTimescale,\n    targetTimescale,\n  )\n  const duration = scaleAuthoredTicks(\n    BigInt(timing.durationTicks),\n    timing.mediaTimescale,\n    targetTimescale,\n  )\n  if (timestamp === null || duration === null || duration <= 0) return null\n  return { timestamp, duration }\n}\n"],
+  "mappings": ";AAyBO,SAAS,mBACd,OACA,gBACA,iBACe;AACf,MAAI,CAAC,OAAO,cAAc,cAAc,KAAK,kBAAkB,KAC3D,CAAC,OAAO,cAAc,eAAe,KAAK,mBAAmB,EAAG,QAAO;AAE3E,QAAM,WAAW,QAAQ;AACzB,QAAM,aAAa,WAAW,CAAC,QAAQ,SAAS,OAAO,eAAe;AACtE,QAAM,cAAc,OAAO,cAAc;AACzC,QAAM,QAAQ,YAAY;AAC1B,QAAM,YAAY,YAAY;AAC9B,MAAI,QAAQ,OAAO,OAAO,gBAAgB,EAAG,QAAO;AACpD,QAAM,QAAQ,OAAO,KAAK,IAAI,OAAO,SAAS,IAAI;AAClD,SAAO,OAAO,SAAS,KAAK,IAAK,WAAW,CAAC,QAAQ,QAAS;AAChE;AAIO,SAAS,oBACd,QACA,iBACgD;AAChD,MAAI,CAAC,OAAO,cAAc,OAAO,aAAa,KAAK,OAAO,iBAAiB,EAAG,QAAO;AACrF,QAAM,YAAY;AAAA,IAChB,OAAO;AAAA,IACP,OAAO;AAAA,IACP;AAAA,EACF;AACA,QAAM,WAAW;AAAA,IACf,OAAO,OAAO,aAAa;AAAA,IAC3B,OAAO;AAAA,IACP;AAAA,EACF;AACA,MAAI,cAAc,QAAQ,aAAa,QAAQ,YAAY,EAAG,QAAO;AACrE,SAAO,EAAE,WAAW,SAAS;AAC/B;",
+  "names": []
+}

package/dist/block-policy.d.ts

@@ -0,0 +1,314 @@
+/**
+ * Keyframe-protected FEC repair policy.
+ *
+ * Every FEC block still gets in-band FEC decode. What this module decides is
+ * (1) which blocks may hold a keyframe (RAP), so a block short of K at its
+ * repair deadline can be repaired over QUIC with the right priority, and
+ * (2) what a sink must do with the first frame released after a gap: stall
+ * until the next RAP, or conceal and keep playing.
+ *
+ * The two decisions are deliberately independent. Classification only sets
+ * repair priority. The stall/conceal decision is made again per released gap
+ * from the media that is actually missing, so a wrong classification can only
+ * lower a block's repair priority; it can never make playback wrong.
+ *
+ * Everything here is derived from catalog-authored timing and in-band MMTP
+ * evidence. There are no timers, no cadence heuristics, and no defaults: a
+ * track whose geometry cannot be derived exactly runs in the defined
+ * fail-closed mode `all-protected`, where every block is treated as possibly
+ * keyframe-bearing.
+ *
+ * All three players (moqtail, hang, Shaka) consume this one implementation.
+ */
+/**
+ * Repair class of one FEC block.
+ *
+ * - `keyframe`: the block holds (or held) a RAP / MPU start.
+ * - `delta`: the block provably holds only non-RAP video frames.
+ * - `unknown`: neither could be proven; treated exactly like `keyframe`.
+ * - `audio`: an audio block.
+ */
+export type BlockClass = 'keyframe' | 'delta' | 'unknown' | 'audio';
+/** Repair priority. Lower is more urgent. */
+export type RepairPriority = 0 | 1 | 2;
+export type TrackKind = 'video' | 'audio';
+/** P0 = keyframe/unknown (stall-preventing), P1 = audio, P2 = delta. */
+export declare function repairPriorityForClass(blockClass: BlockClass): RepairPriority;
+export type ClassifierMode = 'classifying' | 'all-protected';
+/** Why a track runs `all-protected`. */
+export type ClassifierReason = 'framerate-absent' | 'keyframe-cadence-absent' | 'keyframe-interval-not-integral' | 'block-spans-gop'
+/**
+ * The catalog keyframe interval is not an exact integer number of ticks
+ * in the media track's own timescale (ISO-BMFF `mdhd`), so released RAP
+ * spacing cannot be verified and hold-last cannot predict the next RAP.
+ * Nothing is wrong with the stream; the cadence is simply unprovable.
+ */
+ | 'keyframe-interval-not-media-integral'
+/**
+ * Another stream on this packetId was configured with its own geometry
+ * and this one was not, so no geometry provably belongs to it (ABR rungs
+ * sharing a packetId).
+ */
+ | 'stream-geometry-absent' | 'rap-not-mpu-start' | 'mpu-longer-than-gop' | 'block-not-contiguous' | 'rap-spacing-mismatch' | 'mpu-multiple-fragments' | 'block-wider-than-interleave';
+/** Raw catalog timing for one track. Never a resolved cadence. */
+export interface BlockClassifierGeometryInput {
+    readonly trackKind: TrackKind;
+    /** Catalog `framerate` (frames per second). */
+    readonly framerate?: number;
+    /** Catalog `fec.interleaveDepthMs`: the full FEC block span (§5.1). */
+    readonly interleaveDepthMs: number;
+    /** Catalog track `timescale` for `keyframeIntervalTicks`. */
+    readonly timescale?: number;
+    /** Catalog `keyframeIntervalTicks` (preferred when the timescale is present). */
+    readonly keyframeIntervalTicks?: number;
+    /** Catalog `keyframeIntervalMs`. */
+    readonly keyframeIntervalMs?: number;
+}
+/** Exact keyframe interval as a rational number of seconds: ticks / timescale. */
+export interface KeyframeInterval {
+    readonly ticks: number;
+    readonly timescale: number;
+}
+export type BlockClassifierGeometry = {
+    readonly trackKind: 'audio';
+} | {
+    readonly trackKind: 'video';
+    readonly mode: 'classifying';
+    /** F: one frame's duration in milliseconds (1000 / framerate). */
+    readonly frameDurationMs: number;
+    /** D: media units per FEC block (deriveFecInterleaveDepth). */
+    readonly interleaveUnits: number;
+    /** G: frames per GOP. */
+    readonly gopFrames: number;
+    readonly keyframeInterval: KeyframeInterval;
+} | {
+    readonly trackKind: 'video';
+    readonly mode: 'all-protected';
+    readonly reason: ClassifierReason;
+};
+/**
+ * Derive the per-track classifier geometry from raw catalog fields.
+ *
+ * `all-protected` is the policy's defined fail-closed state, not a default:
+ * it is returned with the exact reason. The only throw is for a value the
+ * catalog validator already rejects (a non-positive block span).
+ */
+export declare function deriveBlockClassifierGeometry(input: BlockClassifierGeometryInput): BlockClassifierGeometry;
+/**
+ * The keyframe interval expressed in a media track's timescale, or null when
+ * the geometry is not `classifying` or the interval is not an exact integer
+ * number of media ticks.
+ */
+export declare function keyframeIntervalMediaTicks(geometry: BlockClassifierGeometry, mediaTimescale: number): bigint | null;
+/**
+ * In-band evidence from ONE first-arrival source symbol received from the
+ * network. Recovered symbols and repair symbols never contribute, and the
+ * MFU `priority > 0x80` hint is not evidence.
+ */
+export interface SourceSymbolEvidence {
+    /** The MMTP header R (RAP) bit. */
+    readonly rap: boolean;
+    /** MPU_sequence_number, when parsed from this packet. */
+    readonly mpu?: number;
+    /**
+     * 0-based sample position within the MPU: the MFU DU-header
+     * `sample_number` minus one (ISO/IEC 23008-1 numbers samples from 1, and
+     * the parser rejects `sample_number` 0). Present only when this packet
+     * carried a DU header.
+     */
+    readonly idx?: number;
+    /** movie_fragment_sequence_number from the DU header, when present. */
+    readonly movieFragment?: number;
+    /**
+     * DU-header `offset`: the data unit's authored byte position within its
+     * sample (0 for a whole-sample data unit, the partition boundary for a
+     * subsample data unit). Present only with `idx`; absent reads as 0.
+     */
+    readonly offset?: number;
+    /**
+     * The MMTP header packet_sequence_number (contiguous per packet_id). Not
+     * classification evidence: FECManager uses it to bound how many blocks the
+     * producer can have started between two source symbols, so an outage is
+     * never mistaken for a source restart.
+     */
+    readonly packetSequenceNumber?: number;
+}
+export type ReclassificationEvidence = 'rap' | 'mpu-span' | 'window' | 'classifier-disabled';
+export type ClassifierChange = {
+    readonly kind: 'reclassified';
+    readonly sbn: number;
+    readonly from: BlockClass;
+    readonly to: BlockClass;
+    readonly evidence: ReclassificationEvidence;
+} | {
+    readonly kind: 'mode';
+    readonly mode: 'all-protected';
+    readonly reason: ClassifierReason;
+};
+/**
+ * Per-stream block classifier.
+ *
+ * Classes only move toward more protection or narrower evidence:
+ * `unknown→delta` and `unknown→keyframe` / `delta→keyframe` on evidence, and
+ * `delta→unknown` when an invariant disables classification. `keyframe` is
+ * terminal.
+ *
+ * The delta window rule rests on three premises, each guarded by an
+ * invariant that fires on positive evidence only:
+ *
+ * - P1: the source packets of one block are one contiguous run of the
+ *   stream's authored order, and blocks follow each other in SBN order
+ *   (`block-not-contiguous`). The producer assigns SS_IDs in authored order
+ *   and a block is the SS_ID range [SBN*K, SBN*K + K), so this holds for a
+ *   block that closes at K symbols in the middle of a frame: that frame's
+ *   fragments then land in two ADJACENT blocks, which is still one run each.
+ *   A frame split across adjacent blocks is not a violation.
+ * - P2: that run touches at most D media units, counting a frame continued
+ *   from the previous block (`block-wider-than-interleave`). The producer
+ *   counts a media-unit boundary only once the open block holds a symbol.
+ * - P3: an MPU starts with its only RAP and holds at most G frames
+ *   (`rap-not-mpu-start`, `mpu-longer-than-gop`, `rap-spacing-mismatch`), in
+ *   one movie fragment (`mpu-multiple-fragments`).
+ *
+ * P1 and P2 are what make a block's frames contiguous and lie within
+ * [idxMax − D + 1, idxMin + D − 1] of its MPU. What refutes P1 is a pair of
+ * source packets whose wire-stated authored order and SBN order disagree:
+ * a later MPU in an earlier block, a later data unit of one MPU (by
+ * movie_fragment_sequence_number, sample_number, then DU offset) in an
+ * earlier block, or one data unit in two blocks. That is the signature of a
+ * round-robin interleave, which scatters one run over several concurrent
+ * blocks. Non-adjacency alone is not: a sample larger than K packets
+ * legitimately spans blocks SBN..SBN+n.
+ */
+export declare class BlockClassifier {
+    #private;
+    constructor(geometry: BlockClassifierGeometry);
+    get geometry(): BlockClassifierGeometry;
+    get mode(): ClassifierMode;
+    get reason(): ClassifierReason | null;
+    /**
+     * Whether "same MPU on both sides of a gap" still proves the gap held no
+     * RAP. It stops holding for the rest of the epoch once a RAP was received
+     * inside an MPU or an MPU ran longer than a GOP.
+     */
+    get mpuBoundsRaps(): boolean;
+    /** Begin a fresh epoch (catalog change or track reset). */
+    reset(geometry?: BlockClassifierGeometry): void;
+    /**
+     * Retire this classifier (its stream moves to a new catalog epoch). Every
+     * block it had classified `delta` loses the evidence behind that class and
+     * reads `unknown` from now on; the returned changes say so.
+     */
+    retire(): ClassifierChange[];
+    /**
+     * The stream's SBN sequence restarted (FECManager source discontinuity:
+     * a publisher restart, or the SS_ID space wrapped). Authored order and SBN
+     * order are comparable only within one continuous sequence, so the P1
+     * ledger starts again.
+     */
+    noteSourceDiscontinuity(): void;
+    /** Register a block that exists without evidence (a vanished block). */
+    touch(sbn: number): void;
+    /** Forget a resolved block. */
+    forget(sbn: number): void;
+    classOf(sbn: number): BlockClass;
+    /** Record one first-arrival source symbol's evidence for block `sbn`. */
+    observe(sbn: number, evidence: SourceSymbolEvidence): ClassifierChange[];
+    /**
+     * Record a RAP frame released in order. Released MPU-start RAPs of MPUs m
+     * and m+n must be exactly n keyframe intervals apart in the media
+     * timescale, compared as integers.
+     *
+     * Comparing only consecutive MPUs would miss exactly the case the window
+     * rule cannot survive: a short MPU whose successor's RAP was lost (that
+     * RAP-bearing block is the one a wrong G calls delta), because the next
+     * released RAP then belongs to m+2. Every MPU is one interval long, so the
+     * span to any later released RAP proves or refutes all MPUs in between.
+     */
+    noteReleasedRap(mpu: number, presentationTime: bigint, mediaTimescale: number): ClassifierChange[];
+}
+export interface GapStreamIdentity {
+    readonly packetId: number;
+    /** Non-empty catalog identity, or null when the producer has no track name. */
+    readonly catalogTrackName: string | null;
+}
+/** What the sink knows about one side of a released gap. */
+export interface GapFrameEvidence {
+    /**
+     * Codec-aware RAP check: `MmtpContainerParser.isKeyframe(data, rapFlag,
+     * codec)`, bitstream-only for recovered frames. Never the priority hint.
+     */
+    readonly rap: boolean;
+    /**
+     * MPU_sequence_number of the frame. Omit it once the stream showed that
+     * an MPU boundary does not bound its RAPs (`BlockClassifier.mpuBoundsRaps`):
+     * same-MPU then no longer proves a gap lost only deltas.
+     */
+    readonly mpu?: number;
+    /** 0-based sample position within the MPU, when the geometry verifies it. */
+    readonly idx?: number;
+    /** Authored presentation time in `timescale` ticks. */
+    readonly pts?: bigint;
+    /** Authored sample duration in `timescale` ticks. */
+    readonly durationTicks?: number;
+    /** The media timescale of `pts` and `durationTicks`. */
+    readonly timescale?: number;
+}
+export type FrameGapAction = 'stall' | 'conceal';
+export type FrameGapReason = 'rap-lost' | 'rap-unknown' | 'discontinuity' | 'delta-lost' | 'rap-next' | 'audio-gap' | 'audio-discontinuity';
+/**
+ * The decision attached to the first frame released after a gap
+ * (`RoutedFrameMeta.gapBefore`). It is the same frozen object the manager
+ * emits as its `gap` repair lifecycle event, so a sink that acts on the frame
+ * and an observer that counts events see one fact.
+ */
+export interface FrameGapDecision {
+    readonly version: 2;
+    readonly type: 'gap';
+    readonly stream: GapStreamIdentity;
+    readonly trackKind: TrackKind;
+    readonly action: FrameGapAction;
+    readonly reason: FrameGapReason;
+    /** FEC blocks in the gap whose media was lost (failed or vanished). */
+    readonly blocks: readonly number[];
+    /** Missing video frames or audio access units, when exactly known. */
+    readonly missingFrames: number | null;
+    /** Authored duration of the missing media in milliseconds, when known. */
+    readonly missingMs: number | null;
+    /** Manager epoch of the stream when the decision was made. */
+    readonly epoch: number;
+}
+export interface DecideGapInput {
+    readonly stream: GapStreamIdentity;
+    readonly trackKind: TrackKind;
+    /** Last frame released before the gap. */
+    readonly before: GapFrameEvidence;
+    /** First frame released after the gap. */
+    readonly after: GapFrameEvidence;
+    /** The stream restarted (FEC SBN went backwards or the publisher reset). */
+    readonly discontinuity: boolean;
+    readonly blocks: readonly number[];
+    /**
+     * The most media units the gap can hold: the FEC blocks spanned from the
+     * frame before to the frame after, times D (media units per block,
+     * ceil(interleaveDepthMs / unit duration), §5.1). A block touches at most D
+     * units whether it closes at D or at K symbols. Null when the span or D is
+     * unknown. An audio PTS delta that implies more AUs than this is a clock
+     * jump, not loss, and re-anchors instead of concealing every slot.
+     */
+    readonly maxMissingUnits: number | null;
+    readonly epoch: number;
+}
+/**
+ * Pure stall/conceal decision for the first frame released after a gap.
+ *
+ * Video stalls only when a RAP may be inside the gap: the frame after it is
+ * not a RAP and either sits in another MPU (`rap-lost`) or the MPU cannot be
+ * proven on both sides (`rap-unknown`), or the stream restarted
+ * (`discontinuity`). A gap inside one MPU lost only deltas (`delta-lost`) and
+ * a RAP after the gap resynchronises by itself (`rap-next`). Audio never
+ * stalls: an exact gap is concealed per access unit (`audio-gap`), anything
+ * else re-anchors at the next frame (`audio-discontinuity`).
+ */
+export declare function decideGap(input: DecideGapInput): FrameGapDecision;
+//# sourceMappingURL=block-policy.d.ts.map

package/dist/block-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block-policy.d.ts","sourceRoot":"","sources":["../src/block-policy.ts"],"names":[],"mappings":"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"}