@norskvideo/moq-hang 0.1.0

package/catalog/video.d.ts

@@ -0,0 +1,171 @@
+import * as z from "zod/mini";
+/** Schema for a single video rendition's decoder config. Mirrors WebCodecs VideoDecoderConfig. */
+export declare const VideoConfigSchema: z.ZodMiniObject<{
+    codec: z.ZodMiniString<string>;
+    container: z.ZodMiniDefault<z.ZodMiniDiscriminatedUnion<[z.ZodMiniObject<{
+        kind: z.ZodMiniLiteral<"legacy">;
+    }, z.core.$strip>, z.ZodMiniObject<{
+        kind: z.ZodMiniLiteral<"cmaf">;
+        init: z.ZodMiniBase64;
+        timescale: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+        trackId: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+    }, z.core.$strip>, z.ZodMiniObject<{
+        kind: z.ZodMiniLiteral<"loc">;
+    }, z.core.$strip>], "kind">>;
+    description: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    codedWidth: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+    codedHeight: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+    displayAspectWidth: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+    displayAspectHeight: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+    framerate: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    bitrate: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+    optimizeForLatency: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+    jitter: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+    timeline: z.ZodMiniOptional<z.ZodMiniObject<{
+        track: z.ZodMiniString<string>;
+        timescale: z.ZodMiniDefault<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+        wall: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Schema for the catalog video section: renditions plus display size, rotation, and flip.
+ * Renditions mirror WebCodecs VideoDecoderConfig (https://w3c.github.io/webcodecs/#video-decoder-config).
+ */
+export declare const VideoSchema: z.ZodMiniUnion<readonly [z.ZodMiniObject<{
+    renditions: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniObject<{
+        codec: z.ZodMiniString<string>;
+        container: z.ZodMiniDefault<z.ZodMiniDiscriminatedUnion<[z.ZodMiniObject<{
+            kind: z.ZodMiniLiteral<"legacy">;
+        }, z.core.$strip>, z.ZodMiniObject<{
+            kind: z.ZodMiniLiteral<"cmaf">;
+            init: z.ZodMiniBase64;
+            timescale: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+            trackId: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+        }, z.core.$strip>, z.ZodMiniObject<{
+            kind: z.ZodMiniLiteral<"loc">;
+        }, z.core.$strip>], "kind">>;
+        description: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        codedWidth: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+        codedHeight: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+        displayAspectWidth: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+        displayAspectHeight: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+        framerate: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+        bitrate: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+        optimizeForLatency: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+        jitter: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+        timeline: z.ZodMiniOptional<z.ZodMiniObject<{
+            track: z.ZodMiniString<string>;
+            timescale: z.ZodMiniDefault<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+            wall: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    display: z.ZodMiniOptional<z.ZodMiniObject<{
+        width: z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">;
+        height: z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">;
+    }, z.core.$strip>>;
+    rotation: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    flip: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+}, z.core.$strip>, z.ZodMiniPipe<z.ZodMiniArray<z.ZodMiniObject<{
+    track: z.ZodMiniObject<{
+        name: z.ZodMiniString<string>;
+    }, z.core.$strip>;
+    config: z.ZodMiniObject<{
+        codec: z.ZodMiniString<string>;
+        container: z.ZodMiniDefault<z.ZodMiniDiscriminatedUnion<[z.ZodMiniObject<{
+            kind: z.ZodMiniLiteral<"legacy">;
+        }, z.core.$strip>, z.ZodMiniObject<{
+            kind: z.ZodMiniLiteral<"cmaf">;
+            init: z.ZodMiniBase64;
+            timescale: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+            trackId: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+        }, z.core.$strip>, z.ZodMiniObject<{
+            kind: z.ZodMiniLiteral<"loc">;
+        }, z.core.$strip>], "kind">>;
+        description: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        codedWidth: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+        codedHeight: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+        displayAspectWidth: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+        displayAspectHeight: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+        framerate: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+        bitrate: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+        optimizeForLatency: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+        jitter: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+        timeline: z.ZodMiniOptional<z.ZodMiniObject<{
+            track: z.ZodMiniString<string>;
+            timescale: z.ZodMiniDefault<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+            wall: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>>, z.ZodMiniTransform<{
+    renditions: {
+        [k: string]: {
+            codec: string;
+            container: {
+                kind: "legacy";
+            } | {
+                kind: "cmaf";
+                init: string;
+                timescale?: (number & z.$brand<"u53">) | undefined;
+                trackId?: (number & z.$brand<"u53">) | undefined;
+            } | {
+                kind: "loc";
+            };
+            description?: string | undefined;
+            codedWidth?: (number & z.$brand<"u53">) | undefined;
+            codedHeight?: (number & z.$brand<"u53">) | undefined;
+            displayAspectWidth?: (number & z.$brand<"u53">) | undefined;
+            displayAspectHeight?: (number & z.$brand<"u53">) | undefined;
+            framerate?: number | undefined;
+            bitrate?: (number & z.$brand<"u53">) | undefined;
+            optimizeForLatency?: boolean | undefined;
+            jitter?: (number & z.$brand<"u53">) | undefined;
+            timeline?: {
+                track: string;
+                timescale: number & z.$brand<"u53">;
+                wall?: (number & z.$brand<"u53">) | undefined;
+            } | undefined;
+        };
+    };
+    display: {
+        width: number & z.$brand<"u53">;
+        height: number & z.$brand<"u53">;
+    } | undefined;
+    rotation: undefined;
+    flip: undefined;
+}, {
+    track: {
+        name: string;
+    };
+    config: {
+        codec: string;
+        container: {
+            kind: "legacy";
+        } | {
+            kind: "cmaf";
+            init: string;
+            timescale?: (number & z.$brand<"u53">) | undefined;
+            trackId?: (number & z.$brand<"u53">) | undefined;
+        } | {
+            kind: "loc";
+        };
+        description?: string | undefined;
+        codedWidth?: (number & z.$brand<"u53">) | undefined;
+        codedHeight?: (number & z.$brand<"u53">) | undefined;
+        displayAspectWidth?: (number & z.$brand<"u53">) | undefined;
+        displayAspectHeight?: (number & z.$brand<"u53">) | undefined;
+        framerate?: number | undefined;
+        bitrate?: (number & z.$brand<"u53">) | undefined;
+        optimizeForLatency?: boolean | undefined;
+        jitter?: (number & z.$brand<"u53">) | undefined;
+        timeline?: {
+            track: string;
+            timescale: number & z.$brand<"u53">;
+            wall?: (number & z.$brand<"u53">) | undefined;
+        } | undefined;
+    };
+}[]>>]>;
+/** The catalog video section: renditions keyed by track name plus display options. */
+export type Video = z.infer<typeof VideoSchema>;
+/** Decoder config for a single video rendition. */
+export type VideoConfig = z.infer<typeof VideoConfigSchema>;
+//# sourceMappingURL=video.d.ts.map

package/catalog/video.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"video.d.ts","sourceRoot":"","sources":["../../src/catalog/video.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AAU9B,kGAAkG;AAClG,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8C5B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4CtB,CAAC;AAEH,sFAAsF;AACtF,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAChD,mDAAmD;AACnD,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

package/catalog/video.js

@@ -0,0 +1,87 @@
+/* @ts-self-types="./video.d.ts" */
+import * as z from "zod/mini";
+import { ContainerSchema } from "./container";
+import { u53Schema } from "./integers";
+import { TimelineSchema } from "./timeline";
+// Backwards compatibility: old track schema
+const TrackSchema = z.object({
+    name: z.string(),
+});
+/** Schema for a single video rendition's decoder config. Mirrors WebCodecs VideoDecoderConfig. */
+export const VideoConfigSchema = z.object({
+    // See: https://w3c.github.io/webcodecs/codec_registry.html
+    codec: z.string(),
+    // The container format, used to decode the timestamp and more.
+    container: ContainerSchema,
+    // The description is used for some codecs.
+    // If provided, we can initialize the decoder based on the catalog alone.
+    // Otherwise, the initialization information is (repeated) before each key-frame.
+    description: z.optional(z.string()), // hex encoded TODO use base64
+    // The width and height of the video in pixels.
+    // NOTE: formats that don't use a description can adjust these values in-band.
+    codedWidth: z.optional(u53Schema),
+    codedHeight: z.optional(u53Schema),
+    // Ratio of display width/height to coded width/height
+    // Allows stretching/squishing individual "pixels" of the video
+    // If not provided, the display ratio is 1:1
+    displayAspectWidth: z.optional(u53Schema),
+    displayAspectHeight: z.optional(u53Schema),
+    // The frame rate of the video in frames per second
+    framerate: z.optional(z.number()),
+    // The bitrate of the video in bits per second
+    // TODO: Support up to Number.MAX_SAFE_INTEGER
+    bitrate: z.optional(u53Schema),
+    // If true, the decoder will optimize for latency.
+    // Default: true
+    optimizeForLatency: z.optional(z.boolean()),
+    // The maximum jitter before the next frame is emitted in milliseconds.
+    // The player's jitter buffer should be larger than this value.
+    // If not provided, the player should assume each frame is flushed immediately.
+    //
+    // ex:
+    // - If each frame is flushed immediately, this would be 1000/fps.
+    // - If there can be up to 3 b-frames in a row, this would be 3 * 1000/fps.
+    // - If frames are buffered into 2s segments, this would be 2s.
+    jitter: z.optional(u53Schema),
+    // The companion timeline track indexing this rendition's groups, if the publisher offers one.
+    timeline: z.optional(TimelineSchema),
+});
+/**
+ * Schema for the catalog video section: renditions plus display size, rotation, and flip.
+ * Renditions mirror WebCodecs VideoDecoderConfig (https://w3c.github.io/webcodecs/#video-decoder-config).
+ */
+export const VideoSchema = z.union([
+    z.object({
+        // A map of track name to rendition configuration.
+        // This is not an array in order for it to work with JSON Merge Patch.
+        renditions: z.record(z.string(), VideoConfigSchema),
+        // Render the video at this size in pixels.
+        // This is separate from the display aspect ratio because it does not require reinitialization.
+        display: z.optional(z.object({
+            width: u53Schema,
+            height: u53Schema,
+        })),
+        // The rotation of the video in degrees.
+        // Default: 0
+        rotation: z.optional(z.number()),
+        // If true, the decoder will flip the video horizontally
+        // Default: false
+        flip: z.optional(z.boolean()),
+    }),
+    // Backwards compatibility: transform old array of {track, config} to new object format
+    z.pipe(z.array(z.object({
+        track: TrackSchema,
+        config: VideoConfigSchema,
+    })), z.transform((arr) => {
+        const config = arr[0]?.config;
+        return {
+            renditions: Object.fromEntries(arr.map((item) => [item.track.name, item.config])),
+            display: config?.displayAspectWidth !== undefined && config?.displayAspectHeight !== undefined
+                ? { width: config.displayAspectWidth, height: config.displayAspectHeight }
+                : undefined,
+            rotation: undefined,
+            flip: undefined,
+        };
+    })),
+]);
+//# sourceMappingURL=video.js.map

package/catalog/video.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"video.js","sourceRoot":"","sources":["../../src/catalog/video.ts"],"names":[],"mappings":"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","sourcesContent":["import * as z from \"zod/mini\";\nimport { ContainerSchema } from \"./container\";\nimport { u53Schema } from \"./integers\";\nimport { TimelineSchema } from \"./timeline\";\n\n// Backwards compatibility: old track schema\nconst TrackSchema = z.object({\n\tname: z.string(),\n});\n\n/** Schema for a single video rendition's decoder config. Mirrors WebCodecs VideoDecoderConfig. */\nexport const VideoConfigSchema = z.object({\n\t// See: https://w3c.github.io/webcodecs/codec_registry.html\n\tcodec: z.string(),\n\n\t// The container format, used to decode the timestamp and more.\n\tcontainer: ContainerSchema,\n\n\t// The description is used for some codecs.\n\t// If provided, we can initialize the decoder based on the catalog alone.\n\t// Otherwise, the initialization information is (repeated) before each key-frame.\n\tdescription: z.optional(z.string()), // hex encoded TODO use base64\n\n\t// The width and height of the video in pixels.\n\t// NOTE: formats that don't use a description can adjust these values in-band.\n\tcodedWidth: z.optional(u53Schema),\n\tcodedHeight: z.optional(u53Schema),\n\n\t// Ratio of display width/height to coded width/height\n\t// Allows stretching/squishing individual \"pixels\" of the video\n\t// If not provided, the display ratio is 1:1\n\tdisplayAspectWidth: z.optional(u53Schema),\n\tdisplayAspectHeight: z.optional(u53Schema),\n\n\t// The frame rate of the video in frames per second\n\tframerate: z.optional(z.number()),\n\n\t// The bitrate of the video in bits per second\n\t// TODO: Support up to Number.MAX_SAFE_INTEGER\n\tbitrate: z.optional(u53Schema),\n\n\t// If true, the decoder will optimize for latency.\n\t// Default: true\n\toptimizeForLatency: z.optional(z.boolean()),\n\n\t// The maximum jitter before the next frame is emitted in milliseconds.\n\t// The player's jitter buffer should be larger than this value.\n\t// If not provided, the player should assume each frame is flushed immediately.\n\t//\n\t// ex:\n\t// - If each frame is flushed immediately, this would be 1000/fps.\n\t// - If there can be up to 3 b-frames in a row, this would be 3 * 1000/fps.\n\t// - If frames are buffered into 2s segments, this would be 2s.\n\tjitter: z.optional(u53Schema),\n\n\t// The companion timeline track indexing this rendition's groups, if the publisher offers one.\n\ttimeline: z.optional(TimelineSchema),\n});\n\n/**\n * Schema for the catalog video section: renditions plus display size, rotation, and flip.\n * Renditions mirror WebCodecs VideoDecoderConfig (https://w3c.github.io/webcodecs/#video-decoder-config).\n */\nexport const VideoSchema = z.union([\n\tz.object({\n\t\t// A map of track name to rendition configuration.\n\t\t// This is not an array in order for it to work with JSON Merge Patch.\n\t\trenditions: z.record(z.string(), VideoConfigSchema),\n\n\t\t// Render the video at this size in pixels.\n\t\t// This is separate from the display aspect ratio because it does not require reinitialization.\n\t\tdisplay: z.optional(\n\t\t\tz.object({\n\t\t\t\twidth: u53Schema,\n\t\t\t\theight: u53Schema,\n\t\t\t}),\n\t\t),\n\n\t\t// The rotation of the video in degrees.\n\t\t// Default: 0\n\t\trotation: z.optional(z.number()),\n\n\t\t// If true, the decoder will flip the video horizontally\n\t\t// Default: false\n\t\tflip: z.optional(z.boolean()),\n\t}),\n\t// Backwards compatibility: transform old array of {track, config} to new object format\n\tz.pipe(\n\t\tz.array(\n\t\t\tz.object({\n\t\t\t\ttrack: TrackSchema,\n\t\t\t\tconfig: VideoConfigSchema,\n\t\t\t}),\n\t\t),\n\t\tz.transform((arr) => {\n\t\t\tconst config = arr[0]?.config;\n\t\t\treturn {\n\t\t\t\trenditions: Object.fromEntries(arr.map((item) => [item.track.name, item.config])),\n\t\t\t\tdisplay:\n\t\t\t\t\tconfig?.displayAspectWidth !== undefined && config?.displayAspectHeight !== undefined\n\t\t\t\t\t\t? { width: config.displayAspectWidth, height: config.displayAspectHeight }\n\t\t\t\t\t\t: undefined,\n\t\t\t\trotation: undefined,\n\t\t\t\tflip: undefined,\n\t\t\t};\n\t\t}),\n\t),\n]);\n\n/** The catalog video section: renditions keyed by track name plus display options. */\nexport type Video = z.infer<typeof VideoSchema>;\n/** Decoder config for a single video rendition. */\nexport type VideoConfig = z.infer<typeof VideoConfigSchema>;\n"]}

package/container/cmaf/decode.d.ts

@@ -0,0 +1,68 @@
+/**
+ * MP4 decoding utilities for parsing fMP4 init and data segments.
+ * Used by WebCodecs to extract raw frames from CMAF container.
+ */
+import type { Time } from "@norskvideo/moq-net";
+/**
+ * Result of parsing an init segment.
+ */
+export interface InitSegment {
+    /** Codec-specific description (avcC, hvcC, esds, dOps, etc.) */
+    description?: Uint8Array;
+    /** Time units per second */
+    timescale: number;
+    /** Track ID from the init segment */
+    trackId: number;
+    /** Default sample duration from moov/mvex/trex, used when not overridden in tfhd/trun. */
+    defaultSampleDuration: number;
+    /** Default sample size from moov/mvex/trex, used when not overridden in tfhd/trun. */
+    defaultSampleSize: number;
+    /**
+     * Default sample flags from moov/mvex/trex, used when not overridden in tfhd/trun.
+     *
+     * Some encoders (notably gstreamer/ffmpeg passthrough) only set sample flags
+     * in trex, leaving tfhd defaults and per-sample trun flags zero. Without this
+     * fallback every sample would appear as a sync sample.
+     */
+    defaultSampleFlags: number;
+}
+/**
+ * A decoded sample from a data segment.
+ */
+export interface Sample {
+    /** Raw sample data */
+    data: Uint8Array;
+    /** Timestamp in microseconds */
+    timestamp: number;
+    /** Whether this is a keyframe (sync sample) */
+    keyframe: boolean;
+}
+/**
+ * Parse an init segment (ftyp + moov) to extract codec description and timescale.
+ *
+ * @param init - The init segment data
+ * @returns Parsed init segment information
+ */
+export declare function decodeInitSegment(init: Uint8Array): InitSegment;
+/**
+ * Extract just the base media decode time from a data segment (moof + mdat).
+ * This is a lighter-weight function when you only need the timestamp.
+ *
+ * @param segment - The moof + mdat data
+ * @param init - Parsed init segment (provides timescale)
+ * @returns The base media decode time in microseconds
+ */
+export declare function decodeTimestamp(segment: Uint8Array, init: InitSegment): Time.Micro;
+/**
+ * Parse a data segment (moof + mdat) to extract raw samples.
+ *
+ * Sample duration/size/flags fall back through trun → tfhd → trex (init segment)
+ * per ISO/IEC 14496-12 §8.8.7. The init segment's trex defaults are required for
+ * fragments where the encoder only set them once in moov (e.g. gstreamer passthrough).
+ *
+ * @param segment - The moof + mdat data
+ * @param init - Parsed init segment (provides timescale and trex defaults)
+ * @returns Array of decoded samples
+ */
+export declare function decodeDataSegment(segment: Uint8Array, init: InitSegment): Sample[];
+//# sourceMappingURL=decode.d.ts.map

package/container/cmaf/decode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode.d.ts","sourceRoot":"","sources":["../../../src/container/cmaf/decode.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AAsErC;;GAEG;AACH,MAAM,WAAW,WAAW;IAC3B,gEAAgE;IAChE,WAAW,CAAC,EAAE,UAAU,CAAC;IACzB,4BAA4B;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,qCAAqC;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,0FAA0F;IAC1F,qBAAqB,EAAE,MAAM,CAAC;IAC9B,sFAAsF;IACtF,iBAAiB,EAAE,MAAM,CAAC;IAC1B;;;;;;OAMG;IACH,kBAAkB,EAAE,MAAM,CAAC;CAC3B;AAED;;GAEG;AACH,MAAM,WAAW,MAAM;IACtB,sBAAsB;IACtB,IAAI,EAAE,UAAU,CAAC;IACjB,gCAAgC;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,+CAA+C;IAC/C,QAAQ,EAAE,OAAO,CAAC;CAClB;AAeD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,UAAU,GAAG,WAAW,CAyC/D;AA+GD;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,WAAW,GAAG,IAAI,CAAC,KAAK,CASlF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,WAAW,GAAG,MAAM,EAAE,CAiGlF"}

package/container/cmaf/decode.js

@@ -0,0 +1,303 @@
+/* @ts-self-types="./decode.d.ts" */
+/**
+ * MP4 decoding utilities for parsing fMP4 init and data segments.
+ * Used by WebCodecs to extract raw frames from CMAF container.
+ */
+import { readAvc1, readHev1, readHvc1, readIsoBoxes, readMdat, readMdhd, readMfhd, readMp4a, readStsd, readTfdt, readTfhd, readTkhd, readTrex, readTrun, } from "@svta/cml-iso-bmff";
+// Configure readers for specific box types we need to parse
+const INIT_READERS = {
+    avc1: readAvc1,
+    avc3: readAvc1, // avc3 has same structure
+    hvc1: readHvc1,
+    hev1: readHev1,
+    mp4a: readMp4a,
+    stsd: readStsd,
+    mdhd: readMdhd,
+    tkhd: readTkhd,
+    trex: readTrex,
+};
+const DATA_READERS = {
+    mfhd: readMfhd,
+    tfhd: readTfhd,
+    tfdt: readTfdt,
+    trun: readTrun,
+    mdat: readMdat,
+};
+/**
+ * Recursively find a box by type in the box tree.
+ * This is more reliable than the library's findIsoBox which may not traverse all children.
+ */
+function findBox(boxes, predicate) {
+    for (const box of boxes) {
+        if (predicate(box)) {
+            return box;
+        }
+        // Recursively search children - boxes may have a 'boxes' property with children
+        // biome-ignore lint/suspicious/noExplicitAny: ISO box structure varies
+        const children = box.boxes;
+        if (children && Array.isArray(children)) {
+            const found = findBox(children, predicate);
+            if (found)
+                return found;
+        }
+    }
+    return undefined;
+}
+// Helper to convert Uint8Array to ArrayBuffer for the library
+function toArrayBuffer(data) {
+    // Create a new ArrayBuffer and copy data to avoid SharedArrayBuffer issues
+    const buffer = new ArrayBuffer(data.byteLength);
+    new Uint8Array(buffer).set(data);
+    return buffer;
+}
+// Type guard for finding boxes by type
+function isBoxType(type) {
+    return (box) => box.type === type;
+}
+/**
+ * Parse an init segment (ftyp + moov) to extract codec description and timescale.
+ *
+ * @param init - The init segment data
+ * @returns Parsed init segment information
+ */
+export function decodeInitSegment(init) {
+    // Cast to ParsedIsoBox[] since the library's return type changes with readers
+    const boxes = readIsoBoxes(toArrayBuffer(init), { readers: INIT_READERS });
+    // Find moov > trak > mdia > mdhd for timescale
+    const mdhd = findBox(boxes, isBoxType("mdhd"));
+    if (!mdhd) {
+        throw new Error("No mdhd box found in init segment");
+    }
+    // Find moov > trak > tkhd for track ID
+    // biome-ignore lint/suspicious/noExplicitAny: ISO box traversal
+    const tkhd = findBox(boxes, isBoxType("tkhd"));
+    const trackId = tkhd?.trackId ?? 1;
+    // Find moov > trak > mdia > minf > stbl > stsd for sample description
+    const stsd = findBox(boxes, isBoxType("stsd"));
+    if (!stsd?.entries || stsd.entries.length === 0) {
+        throw new Error("No stsd box found in init segment");
+    }
+    // Extract codec-specific description from the first sample entry
+    const entry = stsd.entries[0];
+    const description = extractDescription(entry);
+    // Find moov > mvex > trex for this track to extract default sample values.
+    // These are the bottom of the fallback chain when tfhd/trun don't specify them.
+    const trex = findBox(boxes, (box) => box.type === "trex" && box.trackId === trackId);
+    return {
+        description,
+        timescale: mdhd.timescale,
+        trackId,
+        defaultSampleDuration: trex?.defaultSampleDuration ?? 0,
+        defaultSampleSize: trex?.defaultSampleSize ?? 0,
+        defaultSampleFlags: trex?.defaultSampleFlags ?? 0,
+    };
+}
+/**
+ * Extract codec-specific description from a sample entry.
+ * The description is codec-specific: avcC for H.264, hvcC for H.265, esds for AAC, dOps for Opus.
+ */
+// biome-ignore lint/suspicious/noExplicitAny: ISO box types vary
+function extractDescription(entry) {
+    if (!entry.boxes || !Array.isArray(entry.boxes)) {
+        return undefined;
+    }
+    // Look for codec config boxes in the sample entry
+    for (const box of entry.boxes) {
+        // Handle raw Uint8Array boxes (already serialized)
+        if (box instanceof Uint8Array) {
+            // Extract the payload without the box header (8 bytes: 4 size + 4 type)
+            if (box.length > 8) {
+                // Check if this looks like a codec config box by reading the type
+                const typeBytes = String.fromCharCode(box[4], box[5], box[6], box[7]);
+                if (typeBytes === "avcC" || typeBytes === "hvcC" || typeBytes === "dOps") {
+                    return new Uint8Array(box.slice(8));
+                }
+                if (typeBytes === "esds") {
+                    // esds payload has nested descriptors; extract the AudioSpecificConfig (tag 0x05).
+                    return extractAudioSpecificConfig(new Uint8Array(box.slice(8)));
+                }
+            }
+            continue;
+        }
+        // Check for known codec config box types
+        const boxType = box.type;
+        if (boxType === "avcC" || boxType === "hvcC" || boxType === "dOps") {
+            if (box.view) {
+                const view = box.view;
+                const headerSize = 8;
+                const payloadOffset = view.byteOffset + headerSize;
+                const payloadLength = box.size - headerSize;
+                return new Uint8Array(view.buffer, payloadOffset, payloadLength);
+            }
+            if (box.data instanceof Uint8Array) {
+                return new Uint8Array(box.data);
+            }
+            if (box.raw instanceof Uint8Array) {
+                return new Uint8Array(box.raw.slice(8));
+            }
+        }
+        if (boxType === "esds") {
+            let payload;
+            if (box.view) {
+                const view = box.view;
+                const headerSize = 8;
+                payload = new Uint8Array(view.buffer, view.byteOffset + headerSize, box.size - headerSize);
+            }
+            else if (box.data instanceof Uint8Array) {
+                payload = new Uint8Array(box.data);
+            }
+            else if (box.raw instanceof Uint8Array) {
+                payload = new Uint8Array(box.raw.slice(8));
+            }
+            if (payload)
+                return extractAudioSpecificConfig(payload);
+        }
+    }
+    return undefined;
+}
+/**
+ * Extract AudioSpecificConfig from an esds box payload.
+ * The esds contains nested descriptors: ES_Descriptor (0x03) → DecoderConfigDescriptor (0x04)
+ * → DecoderSpecificInfo (0x05). The DecoderSpecificInfo payload is the AudioSpecificConfig
+ * that AudioDecoder.configure() expects.
+ */
+function extractAudioSpecificConfig(esds) {
+    // Skip version + flags (4 bytes)
+    let offset = 4;
+    // Scan for DecoderSpecificInfo tag (0x05)
+    while (offset < esds.length) {
+        const tag = esds[offset++];
+        // Parse variable-length size (up to 4 bytes, high bit = continuation)
+        let size = 0;
+        for (let i = 0; i < 4 && offset < esds.length; i++) {
+            const b = esds[offset++];
+            size = (size << 7) | (b & 0x7f);
+            if ((b & 0x80) === 0)
+                break;
+        }
+        if (tag === 0x05) {
+            // Found DecoderSpecificInfo — payload is the AudioSpecificConfig
+            if (offset + size <= esds.length) {
+                return new Uint8Array(esds.buffer, esds.byteOffset + offset, size);
+            }
+            return undefined;
+        }
+        // For container descriptors (0x03, 0x04), skip their fixed header fields
+        // but continue scanning their children (don't skip the full size).
+        if (tag === 0x03) {
+            offset += 3; // ES_ID (2) + flags (1)
+        }
+        else if (tag === 0x04) {
+            offset += 13; // objectTypeIndication (1) + streamType (1) + bufferSizeDB (3) + maxBitrate (4) + avgBitrate (4)
+        }
+        else {
+            // Unknown tag — skip its payload entirely
+            offset += size;
+        }
+    }
+    return undefined;
+}
+/**
+ * Extract just the base media decode time from a data segment (moof + mdat).
+ * This is a lighter-weight function when you only need the timestamp.
+ *
+ * @param segment - The moof + mdat data
+ * @param init - Parsed init segment (provides timescale)
+ * @returns The base media decode time in microseconds
+ */
+export function decodeTimestamp(segment, init) {
+    const boxes = readIsoBoxes(toArrayBuffer(segment), { readers: DATA_READERS });
+    // Find moof > traf > tfdt for base media decode time
+    const tfdt = findBox(boxes, isBoxType("tfdt"));
+    const baseDecodeTime = tfdt?.baseMediaDecodeTime ?? 0;
+    // Convert to microseconds
+    return ((baseDecodeTime * 1_000_000) / init.timescale);
+}
+/**
+ * Parse a data segment (moof + mdat) to extract raw samples.
+ *
+ * Sample duration/size/flags fall back through trun → tfhd → trex (init segment)
+ * per ISO/IEC 14496-12 §8.8.7. The init segment's trex defaults are required for
+ * fragments where the encoder only set them once in moov (e.g. gstreamer passthrough).
+ *
+ * @param segment - The moof + mdat data
+ * @param init - Parsed init segment (provides timescale and trex defaults)
+ * @returns Array of decoded samples
+ */
+export function decodeDataSegment(segment, init) {
+    // Cast to ParsedIsoBox[] since the library's return type changes with readers
+    const boxes = readIsoBoxes(toArrayBuffer(segment), { readers: DATA_READERS });
+    // Find moof > traf > tfdt for base media decode time
+    const tfdt = findBox(boxes, isBoxType("tfdt"));
+    const baseDecodeTime = tfdt?.baseMediaDecodeTime ?? 0;
+    // Find moof > traf > tfhd for default sample values, falling back to trex from the init segment.
+    const tfhd = findBox(boxes, isBoxType("tfhd"));
+    const defaultDuration = tfhd?.defaultSampleDuration ?? init.defaultSampleDuration;
+    const defaultSize = tfhd?.defaultSampleSize ?? init.defaultSampleSize;
+    const defaultFlags = tfhd?.defaultSampleFlags ?? init.defaultSampleFlags;
+    // Find moof > traf > trun for sample info
+    const trun = findBox(boxes, isBoxType("trun"));
+    if (!trun) {
+        throw new Error("No trun box found in data segment");
+    }
+    // Find mdat for sample data
+    // biome-ignore lint/suspicious/noExplicitAny: mdat box type
+    const mdat = findBox(boxes, isBoxType("mdat"));
+    if (!mdat) {
+        throw new Error("No mdat box found in data segment");
+    }
+    // mdat.data contains the raw sample data
+    const mdatData = mdat.data;
+    if (!mdatData) {
+        throw new Error("No data in mdat box");
+    }
+    const samples = [];
+    // trun.dataOffset is an offset from the base data offset (typically moof start) to the first sample.
+    // For simple CMAF segments where moof is followed immediately by mdat, this equals moof.size + 8.
+    // Since mdat.data is the mdat payload (excluding the 8-byte header), we need to compute the
+    // offset within mdatData. For now, we assume samples start at the beginning of mdat.data
+    // when dataOffset is not specified or when it points to the start of mdat payload.
+    // TODO: For complex cases with base_data_offset in tfhd, this needs additional handling.
+    let dataOffset = 0;
+    let decodeTime = baseDecodeTime;
+    for (let i = 0; i < trun.sampleCount; i++) {
+        const sample = trun.samples[i] ?? {};
+        const sampleSize = sample.sampleSize ?? defaultSize;
+        const sampleDuration = sample.sampleDuration ?? defaultDuration;
+        // Validate sample size - must be positive to produce valid data
+        if (sampleSize <= 0) {
+            throw new Error(`Invalid sample size ${sampleSize} for sample ${i} in trun`);
+        }
+        // Duration 0 is valid for single-sample CMAF fragments where duration
+        // is implicit. Negative duration would indicate corrupt data.
+        if (sampleDuration < 0) {
+            throw new Error(`Invalid sample duration ${sampleDuration} for sample ${i} in trun`);
+        }
+        // Bounds check before slicing to prevent reading past mdat data
+        if (dataOffset + sampleSize > mdatData.length) {
+            throw new Error(`Sample ${i} would overflow mdat: offset=${dataOffset}, size=${sampleSize}, mdatLength=${mdatData.length}`);
+        }
+        const sampleFlags = i === 0 && trun.firstSampleFlags !== undefined
+            ? trun.firstSampleFlags
+            : (sample.sampleFlags ?? defaultFlags);
+        const compositionOffset = sample.sampleCompositionTimeOffset ?? 0;
+        // Extract sample data
+        const data = new Uint8Array(mdatData.slice(dataOffset, dataOffset + sampleSize));
+        dataOffset += sampleSize;
+        // Calculate presentation timestamp in microseconds
+        // PTS = (decode_time + composition_offset) * 1_000_000 / timescale
+        const pts = decodeTime + compositionOffset;
+        const timestamp = Math.round((pts * 1_000_000) / init.timescale);
+        // Check if keyframe (sample_is_non_sync_sample flag is bit 16)
+        // If flag is 0, treat as keyframe for safety
+        const keyframe = sampleFlags === 0 || (sampleFlags & 0x00010000) === 0;
+        samples.push({
+            data,
+            timestamp,
+            keyframe,
+        });
+        decodeTime += sampleDuration;
+    }
+    return samples;
+}
+//# sourceMappingURL=decode.js.map