werift 0.22.9 → 0.24.0

package/lib/rtp/src/extra/container/mp4/container.d.ts

@@ -1,6 +1,7 @@
 import { Event } from "../../../imports/common";
 type DecoderConfig = AudioDecoderConfig | VideoDecoderConfig;
 type EncodedChunk = EncodedAudioChunk | EncodedVideoChunk;
+type TrackKind = "audio" | "video";
 export type DataType = "init" | "delta" | "key";
 export interface Mp4Data {
     type: DataType;
@@ -13,8 +14,13 @@ export declare class Mp4Container {
     #private;
     private props;
     audioTrack?: number;
+    frameBuffer: (EncodedChunk & {
+        track: TrackKind;
+    })[];
+    onData: Event<[Mp4Data | {
+        eol: true;
+    }]>;
     videoTrack?: number;
-    onData: Event<[Mp4Data]>;
     constructor(props: {
         track: {
             audio: boolean;
@@ -23,12 +29,9 @@ export declare class Mp4Container {
     });
     get tracksReady(): boolean;
     write(frame: (DecoderConfig | EncodedChunk) & {
-        track: "video" | "audio";
+        track: TrackKind;
     }): void;
-    frameBuffer: (EncodedChunk & {
-        track: "video" | "audio";
-    })[];
-    private _enqueue;
+    stop(): Promise<void>;
 }
 export interface AudioDecoderConfig {
     codec: string;

package/lib/rtp/src/extra/container/mp4/container.js

@@ -1,53 +1,20 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
 var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _Mp4Container_instances, _Mp4Container_mp4, _Mp4Container_audioFrame, _Mp4Container_videoFrame, _Mp4Container_audioSegment, _Mp4Container_videoSegment, _Mp4Container_init, _Mp4Container_enqueue;
+var _Mp4Container_instances, _Mp4Container_audioFrame, _Mp4Container_audioMeta, _Mp4Container_audioSource, _Mp4Container_currentFragment, _Mp4Container_ftyp, _Mp4Container_initializationEmitted, _Mp4Container_lastAudioDuration, _Mp4Container_lastMoof, _Mp4Container_lastMoofTimestamp, _Mp4Container_lastVideoDuration, _Mp4Container_moov, _Mp4Container_onDataOperation, _Mp4Container_operation, _Mp4Container_output, _Mp4Container_startPromise, _Mp4Container_stopPromise, _Mp4Container_stopped, _Mp4Container_videoFrame, _Mp4Container_videoMeta, _Mp4Container_videoSource, _Mp4Container_init, _Mp4Container_enqueue, _Mp4Container_drainFrameBuffer, _Mp4Container_ensureOutputStarted, _Mp4Container_emitInitializationSegment, _Mp4Container_emitData, _Mp4Container_flushOnData, _Mp4Container_enqueueOperation, _Mp4Container_defaultKind, _Mp4Container_flushPendingFrame, _Mp4Container_processFrame, _Mp4Container_writePacket, _Mp4Container_rememberFragmentPacket;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mp4SupportedCodecs = exports.Mp4Container = void 0;
+const mediabunny_1 = require("mediabunny");
 const common_1 = require("../../../imports/common");
-const MP4 = __importStar(require("./mp4box"));
 class Mp4Container {
     constructor(props) {
         _Mp4Container_instances.add(this);
@@ -57,37 +24,50 @@ class Mp4Container {
             writable: true,
             value: props
         });
-        _Mp4Container_mp4.set(this, void 0);
         _Mp4Container_audioFrame.set(this, void 0);
-        _Mp4Container_videoFrame.set(this, void 0); // 1 frame buffer
+        _Mp4Container_audioMeta.set(this, void 0);
+        _Mp4Container_audioSource.set(this, void 0);
+        _Mp4Container_currentFragment.set(this, void 0);
+        _Mp4Container_ftyp.set(this, void 0);
+        _Mp4Container_initializationEmitted.set(this, false);
+        _Mp4Container_lastAudioDuration.set(this, 0);
+        _Mp4Container_lastMoof.set(this, void 0);
+        _Mp4Container_lastMoofTimestamp.set(this, 0);
+        _Mp4Container_lastVideoDuration.set(this, 0);
+        _Mp4Container_moov.set(this, void 0);
+        _Mp4Container_onDataOperation.set(this, Promise.resolve());
+        _Mp4Container_operation.set(this, Promise.resolve());
+        _Mp4Container_output.set(this, void 0);
+        _Mp4Container_startPromise.set(this, void 0);
+        _Mp4Container_stopPromise.set(this, void 0);
+        _Mp4Container_stopped.set(this, false);
+        _Mp4Container_videoFrame.set(this, void 0);
+        _Mp4Container_videoMeta.set(this, void 0);
+        _Mp4Container_videoSource.set(this, void 0);
         Object.defineProperty(this, "audioTrack", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "videoTrack", {
+        Object.defineProperty(this, "frameBuffer", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: []
         });
-        _Mp4Container_audioSegment.set(this, 0);
-        _Mp4Container_videoSegment.set(this, 0);
         Object.defineProperty(this, "onData", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: new common_1.Event()
         });
-        Object.defineProperty(this, "frameBuffer", {
+        Object.defineProperty(this, "videoTrack", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: []
+            value: void 0
         });
-        __classPrivateFieldSet(this, _Mp4Container_mp4, new MP4.ISOFile(), "f");
-        __classPrivateFieldGet(this, _Mp4Container_mp4, "f").init();
     }
     get tracksReady() {
         let ready = true;
@@ -107,156 +87,248 @@ class Mp4Container {
             return __classPrivateFieldGet(this, _Mp4Container_instances, "m", _Mp4Container_enqueue).call(this, frame);
         }
     }
-    _enqueue(frame) {
-        const track = frame.track === "audio" ? this.audioTrack : this.videoTrack;
-        if (!track) {
-            throw new Error("track missing");
-        }
-        // Check if we should create a new segment
-        if (frame.track === "video") {
-            if (frame.type == "key") {
-                __classPrivateFieldSet(this, _Mp4Container_videoSegment, __classPrivateFieldGet(this, _Mp4Container_videoSegment, "f") + 1, "f");
-            }
-            else if (__classPrivateFieldGet(this, _Mp4Container_videoSegment, "f") == 0) {
-                throw new Error("must start with keyframe");
-            }
+    stop() {
+        if (__classPrivateFieldGet(this, _Mp4Container_stopPromise, "f")) {
+            return __classPrivateFieldGet(this, _Mp4Container_stopPromise, "f");
         }
-        else {
-            __classPrivateFieldSet(this, _Mp4Container_audioSegment, __classPrivateFieldGet(this, _Mp4Container_audioSegment, "f") + 1, "f");
-        }
-        // We need a one frame buffer to compute the duration
-        if (frame.track === "video") {
-            if (!__classPrivateFieldGet(this, _Mp4Container_videoFrame, "f")) {
-                __classPrivateFieldSet(this, _Mp4Container_videoFrame, frame, "f");
+        __classPrivateFieldSet(this, _Mp4Container_stopped, true, "f");
+        __classPrivateFieldSet(this, _Mp4Container_stopPromise, __classPrivateFieldGet(this, _Mp4Container_instances, "m", _Mp4Container_enqueueOperation).call(this, async () => {
+            if (!this.tracksReady) {
+                this.frameBuffer = [];
                 return;
             }
-        }
-        else {
-            if (!__classPrivateFieldGet(this, _Mp4Container_audioFrame, "f")) {
-                __classPrivateFieldSet(this, _Mp4Container_audioFrame, frame, "f");
-                return;
+            await __classPrivateFieldGet(this, _Mp4Container_instances, "m", _Mp4Container_ensureOutputStarted).call(this);
+            await __classPrivateFieldGet(this, _Mp4Container_instances, "m", _Mp4Container_drainFrameBuffer).call(this);
+            await __classPrivateFieldGet(this, _Mp4Container_instances, "m", _Mp4Container_flushPendingFrame).call(this, "audio");
+            await __classPrivateFieldGet(this, _Mp4Container_instances, "m", _Mp4Container_flushPendingFrame).call(this, "video");
+            __classPrivateFieldGet(this, _Mp4Container_audioSource, "f")?.close();
+            __classPrivateFieldGet(this, _Mp4Container_videoSource, "f")?.close();
+            if (__classPrivateFieldGet(this, _Mp4Container_output, "f")) {
+                await __classPrivateFieldGet(this, _Mp4Container_output, "f").finalize();
             }
+            await __classPrivateFieldGet(this, _Mp4Container_instances, "m", _Mp4Container_flushOnData).call(this);
+        }), "f");
+        return __classPrivateFieldGet(this, _Mp4Container_stopPromise, "f");
+    }
+}
+exports.Mp4Container = Mp4Container;
+_Mp4Container_audioFrame = new WeakMap(), _Mp4Container_audioMeta = new WeakMap(), _Mp4Container_audioSource = new WeakMap(), _Mp4Container_currentFragment = new WeakMap(), _Mp4Container_ftyp = new WeakMap(), _Mp4Container_initializationEmitted = new WeakMap(), _Mp4Container_lastAudioDuration = new WeakMap(), _Mp4Container_lastMoof = new WeakMap(), _Mp4Container_lastMoofTimestamp = new WeakMap(), _Mp4Container_lastVideoDuration = new WeakMap(), _Mp4Container_moov = new WeakMap(), _Mp4Container_onDataOperation = new WeakMap(), _Mp4Container_operation = new WeakMap(), _Mp4Container_output = new WeakMap(), _Mp4Container_startPromise = new WeakMap(), _Mp4Container_stopPromise = new WeakMap(), _Mp4Container_stopped = new WeakMap(), _Mp4Container_videoFrame = new WeakMap(), _Mp4Container_videoMeta = new WeakMap(), _Mp4Container_videoSource = new WeakMap(), _Mp4Container_instances = new WeakSet(), _Mp4Container_init = function _Mp4Container_init(frame) {
+    if (frame.track === "audio") {
+        if (isVideoConfig(frame)) {
+            throw new Error("audio track requires an audio decoder config");
         }
-        const bufferFrame = frame.track === "video" ? __classPrivateFieldGet(this, _Mp4Container_videoFrame, "f") : __classPrivateFieldGet(this, _Mp4Container_audioFrame, "f");
-        if (!bufferFrame) {
-            throw new Error("bufferFrame missing");
+        if (frame.codec !== "opus") {
+            throw new Error(`unsupported codec: ${frame.codec}`);
         }
-        const duration = frame.timestamp - bufferFrame.timestamp;
-        // TODO avoid this extra copy by writing to the mdat directly
-        // ...which means changing mp4box.js to take an offset instead of ArrayBuffer
-        const buffer = new ArrayBuffer(bufferFrame.byteLength);
-        bufferFrame.copyTo(buffer);
-        // Add the sample to the container
-        __classPrivateFieldGet(this, _Mp4Container_mp4, "f").addSample(track, buffer, {
-            duration,
-            dts: bufferFrame.timestamp,
-            cts: bufferFrame.timestamp,
-            is_sync: bufferFrame.type == "key",
-        });
-        const stream = new MP4.Stream(undefined, 0, MP4.Stream.BIG_ENDIAN);
-        // Moof and mdat atoms are written in pairs.
-        // TODO remove the moof/mdat from the Box to reclaim memory once everything works
-        for (;;) {
-            const moof = __classPrivateFieldGet(this, _Mp4Container_mp4, "f").moofs.shift();
-            const mdat = __classPrivateFieldGet(this, _Mp4Container_mp4, "f").mdats.shift();
-            if (!moof && !mdat)
-                break;
-            if (!moof)
-                throw new Error("moof missing");
-            if (!mdat)
-                throw new Error("mdat missing");
-            moof.write(stream);
-            mdat.write(stream);
+        __classPrivateFieldSet(this, _Mp4Container_audioMeta, {
+            decoderConfig: {
+                codec: "opus",
+                description: frame.description != undefined
+                    ? new Uint8Array(frame.description)
+                    : undefined,
+                numberOfChannels: frame.numberOfChannels,
+                sampleRate: frame.sampleRate,
+            },
+        }, "f");
+        this.audioTrack = 1;
+    }
+    else {
+        if (!isVideoConfig(frame)) {
+            throw new Error("video track requires a video decoder config");
         }
-        // TODO avoid this extra copy by writing to the buffer provided in copyTo
-        const data = new Uint8Array(stream.buffer);
-        if (frame.track === "video") {
-            __classPrivateFieldSet(this, _Mp4Container_videoFrame, frame, "f");
+        if (!frame.codec.startsWith("avc1")) {
+            throw new Error(`unsupported codec: ${frame.codec}`);
         }
-        else {
-            __classPrivateFieldSet(this, _Mp4Container_audioFrame, frame, "f");
+        if (frame.codedWidth == undefined || frame.codedHeight == undefined) {
+            throw new Error("missing coded video dimensions");
         }
-        const res = {
-            type: bufferFrame.type,
-            timestamp: bufferFrame.timestamp,
-            kind: frame.track,
-            duration,
-            data,
-        };
-        this.onData.execute(res);
+        __classPrivateFieldSet(this, _Mp4Container_videoMeta, {
+            decoderConfig: {
+                codec: frame.codec,
+                codedHeight: frame.codedHeight,
+                codedWidth: frame.codedWidth,
+                description: frame.description != undefined
+                    ? new Uint8Array(frame.description)
+                    : undefined,
+                displayAspectHeight: frame.displayAspectHeight,
+                displayAspectWidth: frame.displayAspectWidth,
+            },
+        }, "f");
+        this.videoTrack = this.props.track.audio ? 2 : 1;
     }
-}
-exports.Mp4Container = Mp4Container;
-_Mp4Container_mp4 = new WeakMap(), _Mp4Container_audioFrame = new WeakMap(), _Mp4Container_videoFrame = new WeakMap(), _Mp4Container_audioSegment = new WeakMap(), _Mp4Container_videoSegment = new WeakMap(), _Mp4Container_instances = new WeakSet(), _Mp4Container_init = function _Mp4Container_init(frame) {
-    let codec = frame.codec.substring(0, 4);
-    if (codec == "opus") {
-        codec = "Opus";
+    if (!this.tracksReady) {
+        return;
     }
-    const options = {
-        type: codec,
-        timescale: 1000000,
-    };
-    if (isVideoConfig(frame)) {
-        options.width = frame.codedWidth;
-        options.height = frame.codedHeight;
+    void __classPrivateFieldGet(this, _Mp4Container_instances, "m", _Mp4Container_enqueueOperation).call(this, async () => {
+        await __classPrivateFieldGet(this, _Mp4Container_instances, "m", _Mp4Container_ensureOutputStarted).call(this);
+        await __classPrivateFieldGet(this, _Mp4Container_instances, "m", _Mp4Container_drainFrameBuffer).call(this);
+    });
+}, _Mp4Container_enqueue = function _Mp4Container_enqueue(frame) {
+    this.frameBuffer.push(frame);
+    if (!this.tracksReady) {
+        return;
     }
-    else {
-        options.channel_count = frame.numberOfChannels;
-        options.samplerate = frame.sampleRate;
-        options.hdlr = "soun";
+    void __classPrivateFieldGet(this, _Mp4Container_instances, "m", _Mp4Container_enqueueOperation).call(this, async () => {
+        await __classPrivateFieldGet(this, _Mp4Container_instances, "m", _Mp4Container_ensureOutputStarted).call(this);
+        await __classPrivateFieldGet(this, _Mp4Container_instances, "m", _Mp4Container_drainFrameBuffer).call(this);
+    });
+}, _Mp4Container_drainFrameBuffer = async function _Mp4Container_drainFrameBuffer() {
+    const frames = this.frameBuffer;
+    this.frameBuffer = [];
+    for (const frame of frames) {
+        await __classPrivateFieldGet(this, _Mp4Container_instances, "m", _Mp4Container_processFrame).call(this, frame);
     }
-    if (!frame.description)
-        throw new Error("missing frame description");
-    const desc = frame.description;
-    if (codec === "avc1") {
-        options.avcDecoderConfigRecord = desc;
+}, _Mp4Container_ensureOutputStarted = async function _Mp4Container_ensureOutputStarted() {
+    if (__classPrivateFieldGet(this, _Mp4Container_startPromise, "f")) {
+        await __classPrivateFieldGet(this, _Mp4Container_startPromise, "f");
+        return;
     }
-    else if (codec === "hev1") {
-        options.hevcDecoderConfigRecord = desc;
+    if (!this.tracksReady) {
+        return;
     }
-    else if (codec === "Opus") {
-        // description is an identification header: https://datatracker.ietf.org/doc/html/rfc7845#section-5.1
-        // The first 8 bytes are the magic string "OpusHead", followed by what we actually want.
-        const dops = new MP4.BoxParser.dOpsBox();
-        // Annoyingly, the header is little endian while MP4 is big endian, so we have to parse.
-        dops.parse(new MP4.Stream(desc, 8, MP4.Stream.LITTLE_ENDIAN));
-        options.description = dops;
+    const output = new mediabunny_1.Output({
+        format: new mediabunny_1.Mp4OutputFormat({
+            fastStart: "fragmented",
+            minimumFragmentDuration: 0,
+            onFtyp: (data) => {
+                __classPrivateFieldSet(this, _Mp4Container_ftyp, copyBytes(data), "f");
+            },
+            onMdat: (data) => {
+                if (!__classPrivateFieldGet(this, _Mp4Container_lastMoof, "f")) {
+                    throw new Error("moof missing before mdat");
+                }
+                const fragment = __classPrivateFieldGet(this, _Mp4Container_currentFragment, "f");
+                const timestamp = fragment
+                    ? fragment.timestamp
+                    : Math.round(__classPrivateFieldGet(this, _Mp4Container_lastMoofTimestamp, "f") * 1000000);
+                const duration = fragment?.duration ?? 0;
+                const kind = fragment?.kind ?? __classPrivateFieldGet(this, _Mp4Container_instances, "m", _Mp4Container_defaultKind).call(this);
+                const type = fragment?.type ?? "key";
+                const segment = concatBytes(__classPrivateFieldGet(this, _Mp4Container_lastMoof, "f"), data);
+                __classPrivateFieldSet(this, _Mp4Container_currentFragment, undefined, "f");
+                __classPrivateFieldSet(this, _Mp4Container_lastMoof, undefined, "f");
+                void __classPrivateFieldGet(this, _Mp4Container_instances, "m", _Mp4Container_emitData).call(this, {
+                    type,
+                    timestamp,
+                    duration,
+                    data: segment,
+                    kind,
+                });
+            },
+            onMoof: (data, _position, timestamp) => {
+                __classPrivateFieldSet(this, _Mp4Container_lastMoof, copyBytes(data), "f");
+                __classPrivateFieldSet(this, _Mp4Container_lastMoofTimestamp, timestamp, "f");
+            },
+            onMoov: (data) => {
+                __classPrivateFieldSet(this, _Mp4Container_moov, copyBytes(data), "f");
+                __classPrivateFieldGet(this, _Mp4Container_instances, "m", _Mp4Container_emitInitializationSegment).call(this);
+            },
+        }),
+        target: new mediabunny_1.NullTarget(),
+    });
+    if (__classPrivateFieldGet(this, _Mp4Container_audioMeta, "f")) {
+        __classPrivateFieldSet(this, _Mp4Container_audioSource, new mediabunny_1.EncodedAudioPacketSource("opus"), "f");
+        output.addAudioTrack(__classPrivateFieldGet(this, _Mp4Container_audioSource, "f"));
+    }
+    if (__classPrivateFieldGet(this, _Mp4Container_videoMeta, "f")) {
+        __classPrivateFieldSet(this, _Mp4Container_videoSource, new mediabunny_1.EncodedVideoPacketSource("avc"), "f");
+        output.addVideoTrack(__classPrivateFieldGet(this, _Mp4Container_videoSource, "f"));
+    }
+    __classPrivateFieldSet(this, _Mp4Container_output, output, "f");
+    __classPrivateFieldSet(this, _Mp4Container_startPromise, output.start(), "f");
+    await __classPrivateFieldGet(this, _Mp4Container_startPromise, "f");
+}, _Mp4Container_emitInitializationSegment = function _Mp4Container_emitInitializationSegment() {
+    if (__classPrivateFieldGet(this, _Mp4Container_initializationEmitted, "f") || !__classPrivateFieldGet(this, _Mp4Container_ftyp, "f") || !__classPrivateFieldGet(this, _Mp4Container_moov, "f")) {
+        return;
+    }
+    __classPrivateFieldSet(this, _Mp4Container_initializationEmitted, true, "f");
+    void __classPrivateFieldGet(this, _Mp4Container_instances, "m", _Mp4Container_emitData).call(this, {
+        type: "init",
+        timestamp: 0,
+        duration: 0,
+        data: concatBytes(__classPrivateFieldGet(this, _Mp4Container_ftyp, "f"), __classPrivateFieldGet(this, _Mp4Container_moov, "f")),
+        kind: __classPrivateFieldGet(this, _Mp4Container_instances, "m", _Mp4Container_defaultKind).call(this),
+    });
+}, _Mp4Container_emitData = function _Mp4Container_emitData(data) {
+    const next = __classPrivateFieldGet(this, _Mp4Container_onDataOperation, "f").then(() => this.onData.execute(data));
+    __classPrivateFieldSet(this, _Mp4Container_onDataOperation, next, "f");
+    return next;
+}, _Mp4Container_flushOnData = async function _Mp4Container_flushOnData() {
+    await __classPrivateFieldGet(this, _Mp4Container_onDataOperation, "f");
+}, _Mp4Container_enqueueOperation = function _Mp4Container_enqueueOperation(operation) {
+    const next = __classPrivateFieldGet(this, _Mp4Container_operation, "f").then(operation);
+    __classPrivateFieldSet(this, _Mp4Container_operation, next, "f");
+    return next;
+}, _Mp4Container_defaultKind = function _Mp4Container_defaultKind() {
+    return this.props.track.video ? "video" : "audio";
+}, _Mp4Container_flushPendingFrame = async function _Mp4Container_flushPendingFrame(track) {
+    const buffered = track === "audio" ? __classPrivateFieldGet(this, _Mp4Container_audioFrame, "f") : __classPrivateFieldGet(this, _Mp4Container_videoFrame, "f");
+    if (!buffered) {
+        return;
+    }
+    const duration = track === "audio" ? __classPrivateFieldGet(this, _Mp4Container_lastAudioDuration, "f") : __classPrivateFieldGet(this, _Mp4Container_lastVideoDuration, "f");
+    await __classPrivateFieldGet(this, _Mp4Container_instances, "m", _Mp4Container_writePacket).call(this, buffered, duration);
+    if (track === "audio") {
+        __classPrivateFieldSet(this, _Mp4Container_audioFrame, undefined, "f");
     }
     else {
-        throw new Error(`unsupported codec: ${codec}`);
+        __classPrivateFieldSet(this, _Mp4Container_videoFrame, undefined, "f");
     }
-    const track = __classPrivateFieldGet(this, _Mp4Container_mp4, "f").addTrack(options);
-    if (track == undefined) {
-        throw new Error("failed to initialize MP4 track");
+}, _Mp4Container_processFrame = async function _Mp4Container_processFrame(frame) {
+    const buffered = frame.track === "audio" ? __classPrivateFieldGet(this, _Mp4Container_audioFrame, "f") : __classPrivateFieldGet(this, _Mp4Container_videoFrame, "f");
+    if (!buffered) {
+        if (frame.track === "audio") {
+            __classPrivateFieldSet(this, _Mp4Container_audioFrame, frame, "f");
+        }
+        else {
+            __classPrivateFieldSet(this, _Mp4Container_videoFrame, frame, "f");
+        }
+        return;
     }
+    const duration = Math.max(frame.timestamp - buffered.timestamp, 0);
+    await __classPrivateFieldGet(this, _Mp4Container_instances, "m", _Mp4Container_writePacket).call(this, buffered, duration);
     if (frame.track === "audio") {
-        this.audioTrack = track;
+        __classPrivateFieldSet(this, _Mp4Container_audioFrame, frame, "f");
+        __classPrivateFieldSet(this, _Mp4Container_lastAudioDuration, duration, "f");
     }
     else {
-        this.videoTrack = track;
+        __classPrivateFieldSet(this, _Mp4Container_videoFrame, frame, "f");
+        __classPrivateFieldSet(this, _Mp4Container_lastVideoDuration, duration, "f");
     }
-    if (!this.tracksReady) {
-        return;
+}, _Mp4Container_writePacket = async function _Mp4Container_writePacket(frame, duration) {
+    const data = new Uint8Array(frame.byteLength);
+    frame.copyTo(data.buffer);
+    const packet = new mediabunny_1.EncodedPacket(data, frame.type, frame.timestamp / 1000000, duration / 1000000);
+    if (frame.track === "audio") {
+        if (!__classPrivateFieldGet(this, _Mp4Container_audioSource, "f") || !__classPrivateFieldGet(this, _Mp4Container_audioMeta, "f")) {
+            throw new Error("audio track missing");
+        }
+        await __classPrivateFieldGet(this, _Mp4Container_audioSource, "f").add(packet, __classPrivateFieldGet(this, _Mp4Container_audioMeta, "f"));
     }
-    const buffer = MP4.ISOFile.writeInitializationSegment(__classPrivateFieldGet(this, _Mp4Container_mp4, "f").ftyp, __classPrivateFieldGet(this, _Mp4Container_mp4, "f").moov, 0, 0);
-    const data = new Uint8Array(buffer);
-    const res = {
-        type: "init",
-        timestamp: 0,
-        duration: 0,
-        data,
-        kind: frame.track,
-    };
-    this.onData.execute(res);
-}, _Mp4Container_enqueue = function _Mp4Container_enqueue(frame) {
-    this.frameBuffer.push(frame);
-    if (!this.tracksReady) {
+    else {
+        if (!__classPrivateFieldGet(this, _Mp4Container_videoSource, "f") || !__classPrivateFieldGet(this, _Mp4Container_videoMeta, "f")) {
+            throw new Error("video track missing");
+        }
+        await __classPrivateFieldGet(this, _Mp4Container_videoSource, "f").add(packet, __classPrivateFieldGet(this, _Mp4Container_videoMeta, "f"));
+    }
+    __classPrivateFieldGet(this, _Mp4Container_instances, "m", _Mp4Container_rememberFragmentPacket).call(this, frame.track, frame.type, frame.timestamp, duration);
+}, _Mp4Container_rememberFragmentPacket = function _Mp4Container_rememberFragmentPacket(kind, type, timestamp, duration) {
+    const end = timestamp + duration;
+    if (!__classPrivateFieldGet(this, _Mp4Container_currentFragment, "f")) {
+        __classPrivateFieldSet(this, _Mp4Container_currentFragment, {
+            kind,
+            type,
+            timestamp,
+            duration,
+        }, "f");
         return;
     }
-    for (const frame of this.frameBuffer) {
-        this._enqueue(frame);
+    if (kind === "video" && type === "key") {
+        __classPrivateFieldGet(this, _Mp4Container_currentFragment, "f").type = "key";
     }
-    this.frameBuffer = [];
+    const fragmentEnd = Math.max(__classPrivateFieldGet(this, _Mp4Container_currentFragment, "f").timestamp + __classPrivateFieldGet(this, _Mp4Container_currentFragment, "f").duration, end);
+    __classPrivateFieldGet(this, _Mp4Container_currentFragment, "f").duration =
+        fragmentEnd - __classPrivateFieldGet(this, _Mp4Container_currentFragment, "f").timestamp;
 };
 function isDecoderConfig(frame) {
     // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
@@ -266,4 +338,17 @@ function isVideoConfig(frame) {
     return frame.codedWidth !== undefined;
 }
 exports.mp4SupportedCodecs = ["avc1", "opus"];
+function concatBytes(...parts) {
+    const size = parts.reduce((sum, part) => sum + part.byteLength, 0);
+    const combined = new Uint8Array(size);
+    let offset = 0;
+    for (const part of parts) {
+        combined.set(part, offset);
+        offset += part.byteLength;
+    }
+    return combined;
+}
+function copyBytes(data) {
+    return new Uint8Array(data);
+}
 //# sourceMappingURL=container.js.map