krono-flow 0.0.1 → 0.0.3

package/dist/decoder.js

@@ -205,22 +205,22 @@
         if (source.constructor === Uint8Array) { // We want a true Uint8Array, not something that extends it like Buffer
             return source;
         }
-        else if (source instanceof ArrayBuffer) {
-            return new Uint8Array(source);
+        else if (ArrayBuffer.isView(source)) {
+            return new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
         }
         else {
-            return new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
+            return new Uint8Array(source);
         }
     };
     const toDataView = (source) => {
         if (source.constructor === DataView) {
             return source;
         }
-        else if (source instanceof ArrayBuffer) {
-            return new DataView(source);
+        else if (ArrayBuffer.isView(source)) {
+            return new DataView(source.buffer, source.byteOffset, source.byteLength);
         }
         else {
-            return new DataView(source.buffer, source.byteOffset, source.byteLength);
+            return new DataView(source);
         }
     };
     const textDecoder = /* #__PURE__ */ new TextDecoder();
@@ -388,6 +388,16 @@
         // then correctly interprets the sign bit.
         return getUint24(view, byteOffset, littleEndian) << 8 >> 8;
     };
+    const setUint24 = (view, byteOffset, value, littleEndian) => {
+        // Ensure the value is within 24-bit unsigned range (0 to 16777215)
+        value = value >>> 0; // Convert to unsigned 32-bit
+        value = value & 0xFFFFFF; // Mask to 24 bits
+        {
+            view.setUint8(byteOffset, (value >>> 16) & 0xFF);
+            view.setUint8(byteOffset + 1, (value >>> 8) & 0xFF);
+            view.setUint8(byteOffset + 2, value & 0xFF);
+        }
+    };
     const clamp = (value, min, max) => {
         return Math.max(min, Math.min(max, value));
     };
@@ -460,13 +470,16 @@
         }
         return headers;
     };
-    const retriedFetch = async (fetchFn, url, requestInit, getRetryDelay) => {
+    const retriedFetch = async (fetchFn, url, requestInit, getRetryDelay, shouldStop) => {
         let attempts = 0;
         while (true) {
             try {
                 return await fetchFn(url, requestInit);
             }
             catch (error) {
+                if (shouldStop()) {
+                    throw error;
+                }
                 attempts++;
                 const retryDelayInSeconds = getRetryDelay(attempts, error, url);
                 if (retryDelayInSeconds === null) {
@@ -479,6 +492,9 @@
                 if (retryDelayInSeconds > 0) {
                     await new Promise(resolve => setTimeout(resolve, 1000 * retryDelayInSeconds));
                 }
+                if (shouldStop()) {
+                    throw error;
+                }
             }
         }
     };
@@ -496,7 +512,11 @@
             return isWebKitCache;
         }
         // This even returns true for WebKit-wrapping browsers such as Chrome on iOS
-        return isWebKitCache = !!(typeof navigator !== 'undefined' && navigator.vendor?.match(/apple/i));
+        return isWebKitCache = !!(typeof navigator !== 'undefined'
+            && (navigator.vendor?.match(/apple/i)
+                // Or, in workers:
+                || (/AppleWebKit/.test(navigator.userAgent) && !/Chrome/.test(navigator.userAgent))
+                || /\b(iPad|iPhone|iPod)\b/.test(navigator.userAgent)));
     };
     let isFirefoxCache = null;
     const isFirefox = () => {
@@ -510,7 +530,22 @@
         if (isChromiumCache !== null) {
             return isChromiumCache;
         }
-        return isChromiumCache = !!(typeof navigator !== 'undefined' && navigator.vendor?.includes('Google Inc'));
+        return isChromiumCache = !!(typeof navigator !== 'undefined'
+            && (navigator.vendor?.includes('Google Inc') || /Chrome/.test(navigator.userAgent)));
+    };
+    let chromiumVersionCache = null;
+    const getChromiumVersion = () => {
+        if (chromiumVersionCache !== null) {
+            return chromiumVersionCache;
+        }
+        if (typeof navigator === 'undefined') {
+            return null;
+        }
+        const match = /\bChrome\/(\d+)/.exec(navigator.userAgent);
+        if (!match) {
+            return null;
+        }
+        return chromiumVersionCache = Number(match[1]);
     };
     /** Acts like `??` except the condition is -1 and not null/undefined. */
     const coalesceIndex = (a, b) => {
@@ -907,6 +942,7 @@
     var AvcNalUnitType;
     (function (AvcNalUnitType) {
         AvcNalUnitType[AvcNalUnitType["IDR"] = 5] = "IDR";
+        AvcNalUnitType[AvcNalUnitType["SEI"] = 6] = "SEI";
         AvcNalUnitType[AvcNalUnitType["SPS"] = 7] = "SPS";
         AvcNalUnitType[AvcNalUnitType["PPS"] = 8] = "PPS";
         AvcNalUnitType[AvcNalUnitType["SPS_EXT"] = 13] = "SPS_EXT";
@@ -1014,6 +1050,45 @@
         }
         return new Uint8Array(result);
     };
+    const ANNEX_B_START_CODE = new Uint8Array([0, 0, 0, 1]);
+    const concatNalUnitsInAnnexB = (nalUnits) => {
+        const totalLength = nalUnits.reduce((a, b) => a + ANNEX_B_START_CODE.byteLength + b.byteLength, 0);
+        const result = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const nalUnit of nalUnits) {
+            result.set(ANNEX_B_START_CODE, offset);
+            offset += ANNEX_B_START_CODE.byteLength;
+            result.set(nalUnit, offset);
+            offset += nalUnit.byteLength;
+        }
+        return result;
+    };
+    const concatNalUnitsInLengthPrefixed = (nalUnits, lengthSize) => {
+        const totalLength = nalUnits.reduce((a, b) => a + lengthSize + b.byteLength, 0);
+        const result = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const nalUnit of nalUnits) {
+            const dataView = new DataView(result.buffer, result.byteOffset, result.byteLength);
+            switch (lengthSize) {
+                case 1:
+                    dataView.setUint8(offset, nalUnit.byteLength);
+                    break;
+                case 2:
+                    dataView.setUint16(offset, nalUnit.byteLength, false);
+                    break;
+                case 3:
+                    setUint24(dataView, offset, nalUnit.byteLength);
+                    break;
+                case 4:
+                    dataView.setUint32(offset, nalUnit.byteLength, false);
+                    break;
+            }
+            offset += lengthSize;
+            result.set(nalUnit, offset);
+            offset += nalUnit.byteLength;
+        }
+        return result;
+    };
     const extractAvcNalUnits = (packetData, decoderConfig) => {
         if (decoderConfig.description) {
             // Stream is length-prefixed. Let's extract the size of the length prefix from the decoder config
@@ -1027,6 +1102,19 @@
             return findNalUnitsInAnnexB(packetData);
         }
     };
+    const concatAvcNalUnits = (nalUnits, decoderConfig) => {
+        if (decoderConfig.description) {
+            // Stream is length-prefixed. Let's extract the size of the length prefix from the decoder config
+            const bytes = toUint8Array(decoderConfig.description);
+            const lengthSizeMinusOne = bytes[4] & 0b11;
+            const lengthSize = (lengthSizeMinusOne + 1);
+            return concatNalUnitsInLengthPrefixed(nalUnits, lengthSize);
+        }
+        else {
+            // Stream is in Annex B format
+            return concatNalUnitsInAnnexB(nalUnits);
+        }
+    };
     const extractNalUnitTypeForAvc = (data) => {
         return data[0] & 0x1F;
     };
@@ -1901,6 +1989,60 @@
                     }
                 }
             }
+            // Frame size
+            const frameWidthBitsMinus1 = bitstream.readBits(4);
+            const frameHeightBitsMinus1 = bitstream.readBits(4);
+            const n1 = frameWidthBitsMinus1 + 1;
+            bitstream.skipBits(n1); // max_frame_width_minus_1
+            const n2 = frameHeightBitsMinus1 + 1;
+            bitstream.skipBits(n2); // max_frame_height_minus_1
+            // Frame IDs
+            let frameIdNumbersPresentFlag = 0;
+            if (reducedStillPictureHeader) {
+                frameIdNumbersPresentFlag = 0;
+            }
+            else {
+                frameIdNumbersPresentFlag = bitstream.readBits(1);
+            }
+            if (frameIdNumbersPresentFlag) {
+                bitstream.skipBits(4); // delta_frame_id_length_minus_2
+                bitstream.skipBits(3); // additional_frame_id_length_minus_1
+            }
+            bitstream.skipBits(1); // use_128x128_superblock
+            bitstream.skipBits(1); // enable_filter_intra
+            bitstream.skipBits(1); // enable_intra_edge_filter
+            if (!reducedStillPictureHeader) {
+                bitstream.skipBits(1); // enable_interintra_compound
+                bitstream.skipBits(1); // enable_masked_compound
+                bitstream.skipBits(1); // enable_warped_motion
+                bitstream.skipBits(1); // enable_dual_filter
+                const enableOrderHint = bitstream.readBits(1);
+                if (enableOrderHint) {
+                    bitstream.skipBits(1); // enable_jnt_comp
+                    bitstream.skipBits(1); // enable_ref_frame_mvs
+                }
+                const seqChooseScreenContentTools = bitstream.readBits(1);
+                let seqForceScreenContentTools = 0;
+                if (seqChooseScreenContentTools) {
+                    seqForceScreenContentTools = 2; // SELECT_SCREEN_CONTENT_TOOLS
+                }
+                else {
+                    seqForceScreenContentTools = bitstream.readBits(1);
+                }
+                if (seqForceScreenContentTools > 0) {
+                    const seqChooseIntegerMv = bitstream.readBits(1);
+                    if (!seqChooseIntegerMv) {
+                        bitstream.skipBits(1); // seq_force_integer_mv
+                    }
+                }
+                if (enableOrderHint) {
+                    bitstream.skipBits(3); // order_hint_bits_minus_1
+                }
+            }
+            bitstream.skipBits(1); // enable_superres
+            bitstream.skipBits(1); // enable_cdef
+            bitstream.skipBits(1); // enable_restoration
+            // color_config()
             const highBitdepth = bitstream.readBits(1);
             let bitDepth = 8;
             if (seqProfile === 2 && highBitdepth) {
@@ -2075,7 +2217,59 @@
             case 'avc':
                 {
                     const nalUnits = extractAvcNalUnits(packetData, decoderConfig);
-                    const isKeyframe = nalUnits.some(x => extractNalUnitTypeForAvc(x) === AvcNalUnitType.IDR);
+                    let isKeyframe = nalUnits.some(x => extractNalUnitTypeForAvc(x) === AvcNalUnitType.IDR);
+                    if (!isKeyframe && (!isChromium() || getChromiumVersion() >= 144)) {
+                        // In addition to IDR, Recovery Point SEI also counts as a valid H.264 keyframe by current consensus.
+                        // See https://github.com/w3c/webcodecs/issues/650 for the relevant discussion. WebKit and Firefox have
+                        // always supported them, but Chromium hasn't, therefore the (admittedly dirty) version check.
+                        for (const nalUnit of nalUnits) {
+                            const type = extractNalUnitTypeForAvc(nalUnit);
+                            if (type !== AvcNalUnitType.SEI) {
+                                continue;
+                            }
+                            const bytes = removeEmulationPreventionBytes(nalUnit);
+                            let pos = 1; // Skip NALU header
+                            // sei_rbsp()
+                            do {
+                                // sei_message()
+                                let payloadType = 0;
+                                while (true) {
+                                    const nextByte = bytes[pos++];
+                                    if (nextByte === undefined)
+                                        break;
+                                    payloadType += nextByte;
+                                    if (nextByte < 255) {
+                                        break;
+                                    }
+                                }
+                                let payloadSize = 0;
+                                while (true) {
+                                    const nextByte = bytes[pos++];
+                                    if (nextByte === undefined)
+                                        break;
+                                    payloadSize += nextByte;
+                                    if (nextByte < 255) {
+                                        break;
+                                    }
+                                }
+                                // sei_payload()
+                                const PAYLOAD_TYPE_RECOVERY_POINT = 6;
+                                if (payloadType === PAYLOAD_TYPE_RECOVERY_POINT) {
+                                    const bitstream = new Bitstream(bytes);
+                                    bitstream.pos = 8 * pos;
+                                    const recoveryFrameCount = readExpGolomb(bitstream);
+                                    const exactMatchFlag = bitstream.readBits(1);
+                                    if (recoveryFrameCount === 0 && exactMatchFlag === 1) {
+                                        // https://github.com/w3c/webcodecs/pull/910
+                                        // "recovery_frame_cnt == 0 and exact_match_flag=1 in the SEI recovery payload"
+                                        isKeyframe = true;
+                                        break;
+                                    }
+                                }
+                                pos += payloadSize;
+                            } while (pos < bytes.length - 1);
+                        }
+                    }
                     return isKeyframe ? 'key' : 'delta';
                 }
             case 'hevc':
@@ -2560,6 +2754,79 @@
      * file, You can obtain one at https://mozilla.org/MPL/2.0/.
      */
     polyfillSymbolDispose();
+    // Let's manually handle logging the garbage collection errors that are typically logged by the browser. This way, they
+    // also kick for audio samples (which is normally not the case), making sure any incorrect code is quickly caught.
+    let lastVideoGcErrorLog = -Infinity;
+    let lastAudioGcErrorLog = -Infinity;
+    let finalizationRegistry = null;
+    if (typeof FinalizationRegistry !== 'undefined') {
+        finalizationRegistry = new FinalizationRegistry((value) => {
+            const now = Date.now();
+            if (value.type === 'video') {
+                if (now - lastVideoGcErrorLog >= 1000) {
+                    // This error is annoying but oh so important
+                    console.error(`A VideoSample was garbage collected without first being closed. For proper resource management,`
+                        + ` make sure to call close() on all your VideoSamples as soon as you're done using them.`);
+                    lastVideoGcErrorLog = now;
+                }
+                if (typeof VideoFrame !== 'undefined' && value.data instanceof VideoFrame) {
+                    value.data.close(); // Prevent the browser error since we're logging our own
+                }
+            }
+            else {
+                if (now - lastAudioGcErrorLog >= 1000) {
+                    console.error(`An AudioSample was garbage collected without first being closed. For proper resource management,`
+                        + ` make sure to call close() on all your AudioSamples as soon as you're done using them.`);
+                    lastAudioGcErrorLog = now;
+                }
+                if (typeof AudioData !== 'undefined' && value.data instanceof AudioData) {
+                    value.data.close();
+                }
+            }
+        });
+    }
+    /**
+     * The list of {@link VideoSample} pixel formats.
+     * @group Samples
+     * @public
+     */
+    const VIDEO_SAMPLE_PIXEL_FORMATS = [
+        // 4:2:0 Y, U, V
+        'I420',
+        'I420P10',
+        'I420P12',
+        // 4:2:0 Y, U, V, A
+        'I420A',
+        'I420AP10',
+        'I420AP12',
+        // 4:2:2 Y, U, V
+        'I422',
+        'I422P10',
+        'I422P12',
+        // 4:2:2 Y, U, V, A
+        'I422A',
+        'I422AP10',
+        'I422AP12',
+        // 4:4:4 Y, U, V
+        'I444',
+        'I444P10',
+        'I444P12',
+        // 4:4:4 Y, U, V, A
+        'I444A',
+        'I444AP10',
+        'I444AP12',
+        // 4:2:0 Y, UV
+        'NV12',
+        // 4:4:4 RGBA
+        'RGBA',
+        // 4:4:4 RGBX (opaque)
+        'RGBX',
+        // 4:4:4 BGRA
+        'BGRA',
+        // 4:4:4 BGRX (opaque)
+        'BGRX',
+    ];
+    const VIDEO_SAMPLE_PIXEL_FORMATS_SET = new Set(VIDEO_SAMPLE_PIXEL_FORMATS);
     /**
      * Represents a raw, unencoded video sample (frame). Mainly used as an expressive wrapper around WebCodecs API's
      * [`VideoFrame`](https://developer.mozilla.org/en-US/docs/Web/API/VideoFrame), but can also be used standalone.
@@ -2593,12 +2860,14 @@
         constructor(data, init) {
             /** @internal */
             this._closed = false;
-            if (data instanceof ArrayBuffer || ArrayBuffer.isView(data)) {
+            if (data instanceof ArrayBuffer
+                || (typeof SharedArrayBuffer !== 'undefined' && data instanceof SharedArrayBuffer)
+                || ArrayBuffer.isView(data)) {
                 if (!init || typeof init !== 'object') {
                     throw new TypeError('init must be an object.');
                 }
-                if (!('format' in init) || typeof init.format !== 'string') {
-                    throw new TypeError('init.format must be a string.');
+                if (init.format === undefined || !VIDEO_SAMPLE_PIXEL_FORMATS_SET.has(init.format)) {
+                    throw new TypeError('init.format must be one of: ' + VIDEO_SAMPLE_PIXEL_FORMATS.join(', '));
                 }
                 if (!Number.isInteger(init.codedWidth) || init.codedWidth <= 0) {
                     throw new TypeError('init.codedWidth must be a positive integer.');
@@ -2616,13 +2885,14 @@
                     throw new TypeError('init.duration, when provided, must be a non-negative number.');
                 }
                 this._data = toUint8Array(data).slice(); // Copy it
+                this._layout = init.layout ?? createDefaultPlaneLayout(init.format, init.codedWidth, init.codedHeight);
                 this.format = init.format;
                 this.codedWidth = init.codedWidth;
                 this.codedHeight = init.codedHeight;
                 this.rotation = init.rotation ?? 0;
                 this.timestamp = init.timestamp;
                 this.duration = init.duration ?? 0;
-                this.colorSpace = new VideoColorSpace(init.colorSpace);
+                this.colorSpace = new VideoSampleColorSpace(init.colorSpace);
             }
             else if (typeof VideoFrame !== 'undefined' && data instanceof VideoFrame) {
                 if (init?.rotation !== undefined && ![0, 90, 180, 270].includes(init.rotation)) {
@@ -2635,6 +2905,7 @@
                     throw new TypeError('init.duration, when provided, must be a non-negative number.');
                 }
                 this._data = data;
+                this._layout = null;
                 this.format = data.format;
                 // Copying the display dimensions here, assuming no innate VideoFrame rotation
                 this.codedWidth = data.displayWidth;
@@ -2644,7 +2915,7 @@
                 this.rotation = init?.rotation ?? 0;
                 this.timestamp = init?.timestamp ?? data.timestamp / 1e6;
                 this.duration = init?.duration ?? (data.duration ?? 0) / 1e6;
-                this.colorSpace = data.colorSpace;
+                this.colorSpace = new VideoSampleColorSpace(data.colorSpace);
             }
             else if ((typeof HTMLImageElement !== 'undefined' && data instanceof HTMLImageElement)
                 || (typeof SVGImageElement !== 'undefined' && data instanceof SVGImageElement)
@@ -2698,13 +2969,14 @@
                 // Draw it to a canvas
                 context.drawImage(data, 0, 0);
                 this._data = canvas;
+                this._layout = null;
                 this.format = 'RGBX';
                 this.codedWidth = width;
                 this.codedHeight = height;
                 this.rotation = init.rotation ?? 0;
                 this.timestamp = init.timestamp;
                 this.duration = init.duration ?? 0;
-                this.colorSpace = new VideoColorSpace({
+                this.colorSpace = new VideoSampleColorSpace({
                     matrix: 'rgb',
                     primaries: 'bt709',
                     transfer: 'iec61966-2-1',
@@ -2714,6 +2986,7 @@
             else {
                 throw new TypeError('Invalid data type: Must be a BufferSource or CanvasImageSource.');
             }
+            finalizationRegistry?.register(this, { type: 'video', data: this._data }, this);
         }
         /** Clones this video sample. */
         clone() {
@@ -2729,8 +3002,10 @@
                 });
             }
             else if (this._data instanceof Uint8Array) {
-                return new VideoSample(this._data.slice(), {
+                assert(this._layout);
+                return new VideoSample(this._data, {
                     format: this.format,
+                    layout: this._layout,
                     codedWidth: this.codedWidth,
                     codedHeight: this.codedHeight,
                     timestamp: this.timestamp,
@@ -2759,6 +3034,7 @@
             if (this._closed) {
                 return;
             }
+            finalizationRegistry?.unregister(this);
             if (isVideoFrame(this._data)) {
                 this._data.close();
             }
@@ -2767,14 +3043,34 @@
             }
             this._closed = true;
         }
-        /** Returns the number of bytes required to hold this video sample's pixel data. */
-        allocationSize() {
+        /**
+         * Returns the number of bytes required to hold this video sample's pixel data. Throws if `format` is `null`;
+         * specify an explicit RGB format in the options in this case.
+         */
+        allocationSize(options = {}) {
+            validateVideoFrameCopyToOptions(options);
             if (this._closed) {
                 throw new Error('VideoSample is closed.');
             }
+            if ((options.format ?? this.format) === null) {
+                throw new Error('Cannot get allocation size when format is null. Please manually provide an RGB pixel format in the'
+                    + ' options instead.');
+            }
             assert(this._data !== null);
+            if (!isVideoFrame(this._data)) {
+                if (options.colorSpace
+                    || (options.format && options.format !== this.format)
+                    || options.layout
+                    || options.rect) {
+                    // Temporarily convert to VideoFrame to get it done
+                    const videoFrame = this.toVideoFrame();
+                    const size = videoFrame.allocationSize(options);
+                    videoFrame.close();
+                    return size;
+                }
+            }
             if (isVideoFrame(this._data)) {
-                return this._data.allocationSize();
+                return this._data.allocationSize(options);
             }
             else if (this._data instanceof Uint8Array) {
                 return this._data.byteLength;
@@ -2783,21 +3079,44 @@
                 return this.codedWidth * this.codedHeight * 4; // RGBX
             }
         }
-        /** Copies this video sample's pixel data to an ArrayBuffer or ArrayBufferView. */
-        async copyTo(destination) {
+        /**
+         * Copies this video sample's pixel data to an ArrayBuffer or ArrayBufferView. Throws if `format` is `null`;
+         * specify an explicit RGB format in the options in this case.
+         * @returns The byte layout of the planes of the copied data.
+         */
+        async copyTo(destination, options = {}) {
             if (!isAllowSharedBufferSource(destination)) {
                 throw new TypeError('destination must be an ArrayBuffer or an ArrayBuffer view.');
             }
+            validateVideoFrameCopyToOptions(options);
             if (this._closed) {
                 throw new Error('VideoSample is closed.');
             }
+            if ((options.format ?? this.format) === null) {
+                throw new Error('Cannot copy video sample data when format is null. Please manually provide an RGB pixel format in the'
+                    + ' options instead.');
+            }
             assert(this._data !== null);
+            if (!isVideoFrame(this._data)) {
+                if (options.colorSpace
+                    || (options.format && options.format !== this.format)
+                    || options.layout
+                    || options.rect) {
+                    // Temporarily convert to VideoFrame to get it done
+                    const videoFrame = this.toVideoFrame();
+                    const layout = await videoFrame.copyTo(destination, options);
+                    videoFrame.close();
+                    return layout;
+                }
+            }
             if (isVideoFrame(this._data)) {
-                await this._data.copyTo(destination);
+                return this._data.copyTo(destination, options);
             }
             else if (this._data instanceof Uint8Array) {
+                assert(this._layout);
                 const dest = toUint8Array(destination);
                 dest.set(this._data);
+                return this._layout;
             }
             else {
                 const canvas = this._data;
@@ -2806,6 +3125,10 @@
                 const imageData = context.getImageData(0, 0, this.codedWidth, this.codedHeight);
                 const dest = toUint8Array(destination);
                 dest.set(imageData.data);
+                return [{
+                        offset: 0,
+                        stride: 4 * this.codedWidth,
+                    }];
             }
         }
         /**
@@ -3064,6 +3387,29 @@
             this.close();
         }
     }
+    /**
+     * Describes the color space of a {@link VideoSample}. Corresponds to the WebCodecs API's VideoColorSpace.
+     * @group Samples
+     * @public
+     */
+    class VideoSampleColorSpace {
+        /** Creates a new VideoSampleColorSpace. */
+        constructor(init) {
+            this.primaries = init?.primaries ?? null;
+            this.transfer = init?.transfer ?? null;
+            this.matrix = init?.matrix ?? null;
+            this.fullRange = init?.fullRange ?? null;
+        }
+        /** Serializes the color space to a JSON object. */
+        toJSON() {
+            return {
+                primaries: this.primaries,
+                transfer: this.transfer,
+                matrix: this.matrix,
+                fullRange: this.fullRange,
+            };
+        }
+    }
     const isVideoFrame = (x) => {
         return typeof VideoFrame !== 'undefined' && x instanceof VideoFrame;
     };
@@ -3092,6 +3438,133 @@
             throw new TypeError(prefix + 'crop.height must be a non-negative integer.');
         }
     };
+    const validateVideoFrameCopyToOptions = (options) => {
+        if (!options || typeof options !== 'object') {
+            throw new TypeError('options must be an object.');
+        }
+        if (options.colorSpace !== undefined && !['display-p3', 'srgb'].includes(options.colorSpace)) {
+            throw new TypeError('options.colorSpace, when provided, must be \'display-p3\' or \'srgb\'.');
+        }
+        if (options.format !== undefined && typeof options.format !== 'string') {
+            throw new TypeError('options.format, when provided, must be a string.');
+        }
+        if (options.layout !== undefined) {
+            if (!Array.isArray(options.layout)) {
+                throw new TypeError('options.layout, when provided, must be an array.');
+            }
+            for (const plane of options.layout) {
+                if (!plane || typeof plane !== 'object') {
+                    throw new TypeError('Each entry in options.layout must be an object.');
+                }
+                if (!Number.isInteger(plane.offset) || plane.offset < 0) {
+                    throw new TypeError('plane.offset must be a non-negative integer.');
+                }
+                if (!Number.isInteger(plane.stride) || plane.stride < 0) {
+                    throw new TypeError('plane.stride must be a non-negative integer.');
+                }
+            }
+        }
+        if (options.rect !== undefined) {
+            if (!options.rect || typeof options.rect !== 'object') {
+                throw new TypeError('options.rect, when provided, must be an object.');
+            }
+            if (options.rect.x !== undefined && (!Number.isInteger(options.rect.x) || options.rect.x < 0)) {
+                throw new TypeError('options.rect.x, when provided, must be a non-negative integer.');
+            }
+            if (options.rect.y !== undefined && (!Number.isInteger(options.rect.y) || options.rect.y < 0)) {
+                throw new TypeError('options.rect.y, when provided, must be a non-negative integer.');
+            }
+            if (options.rect.width !== undefined && (!Number.isInteger(options.rect.width) || options.rect.width < 0)) {
+                throw new TypeError('options.rect.width, when provided, must be a non-negative integer.');
+            }
+            if (options.rect.height !== undefined && (!Number.isInteger(options.rect.height) || options.rect.height < 0)) {
+                throw new TypeError('options.rect.height, when provided, must be a non-negative integer.');
+            }
+        }
+    };
+    /** Implements logic from WebCodecs § 9.4.6 "Compute Layout and Allocation Size" */
+    const createDefaultPlaneLayout = (format, codedWidth, codedHeight) => {
+        const planes = getPlaneConfigs(format);
+        const layouts = [];
+        let currentOffset = 0;
+        for (const plane of planes) {
+            // Per § 9.8, dimensions are usually "rounded up to the nearest integer".
+            const planeWidth = Math.ceil(codedWidth / plane.widthDivisor);
+            const planeHeight = Math.ceil(codedHeight / plane.heightDivisor);
+            const stride = planeWidth * plane.sampleBytes;
+            // Tight packing
+            const planeSize = stride * planeHeight;
+            layouts.push({
+                offset: currentOffset,
+                stride: stride,
+            });
+            currentOffset += planeSize;
+        }
+        return layouts;
+    };
+    /** Helper to retrieve plane configurations based on WebCodecs § 9.8 Pixel Format definitions. */
+    const getPlaneConfigs = (format) => {
+        // Helper for standard YUV planes
+        const yuv = (yBytes, uvBytes, subX, subY, hasAlpha) => {
+            const configs = [
+                { sampleBytes: yBytes, widthDivisor: 1, heightDivisor: 1 },
+                { sampleBytes: uvBytes, widthDivisor: subX, heightDivisor: subY },
+                { sampleBytes: uvBytes, widthDivisor: subX, heightDivisor: subY },
+            ];
+            if (hasAlpha) {
+                // Match luma dimensions
+                configs.push({ sampleBytes: yBytes, widthDivisor: 1, heightDivisor: 1 });
+            }
+            return configs;
+        };
+        switch (format) {
+            case 'I420':
+                return yuv(1, 1, 2, 2, false);
+            case 'I420P10':
+            case 'I420P12':
+                return yuv(2, 2, 2, 2, false);
+            case 'I420A':
+                return yuv(1, 1, 2, 2, true);
+            case 'I420AP10':
+            case 'I420AP12':
+                return yuv(2, 2, 2, 2, true);
+            case 'I422':
+                return yuv(1, 1, 2, 1, false);
+            case 'I422P10':
+            case 'I422P12':
+                return yuv(2, 2, 2, 1, false);
+            case 'I422A':
+                return yuv(1, 1, 2, 1, true);
+            case 'I422AP10':
+            case 'I422AP12':
+                return yuv(2, 2, 2, 1, true);
+            case 'I444':
+                return yuv(1, 1, 1, 1, false);
+            case 'I444P10':
+            case 'I444P12':
+                return yuv(2, 2, 1, 1, false);
+            case 'I444A':
+                return yuv(1, 1, 1, 1, true);
+            case 'I444AP10':
+            case 'I444AP12':
+                return yuv(2, 2, 1, 1, true);
+            case 'NV12':
+                return [
+                    { sampleBytes: 1, widthDivisor: 1, heightDivisor: 1 },
+                    { sampleBytes: 2, widthDivisor: 2, heightDivisor: 2 }, // Interleaved U and V
+                ];
+            case 'RGBA':
+            case 'RGBX':
+            case 'BGRA':
+            case 'BGRX':
+                return [
+                    { sampleBytes: 4, widthDivisor: 1, heightDivisor: 1 },
+                ];
+            default:
+                assertNever(format);
+                assert(false);
+        }
+    };
     const AUDIO_SAMPLE_FORMATS = new Set(['f32', 'f32-planar', 's16', 's16-planar', 's32', 's32-planar', 'u8', 'u8-planar']);
     /**
      * Represents a raw, unencoded audio sample. Mainly used as an expressive wrapper around WebCodecs API's
@@ -3170,6 +3643,7 @@
                 }
                 this._data = dataBuffer;
             }
+            finalizationRegistry?.register(this, { type: 'audio', data: this._data }, this);
         }
         /** Returns the number of bytes required to hold the audio sample's data as specified by the given options. */
         allocationSize(options) {
@@ -3235,6 +3709,7 @@
                 throw new Error('AudioSample is closed.');
             }
             const { planeIndex, format, frameCount: optFrameCount, frameOffset: optFrameOffset } = options;
+            const srcFormat = this.format;
             const destFormat = format ?? this.format;
             if (!destFormat)
                 throw new Error('Destination format not determined');
@@ -3264,60 +3739,24 @@
             const destView = toDataView(destination);
             const writeFn = getWriteFunction(destFormat);
             if (isAudioData(this._data)) {
-                if (destIsPlanar) {
-                    if (destFormat === 'f32-planar') {
-                        // Simple, since the browser must support f32-planar, we can just delegate here
-                        this._data.copyTo(destination, {
-                            planeIndex,
-                            frameOffset,
-                            frameCount: copyFrameCount,
-                            format: 'f32-planar',
-                        });
-                    }
-                    else {
-                        // Allocate temporary buffer for f32-planar data
-                        const tempBuffer = new ArrayBuffer(copyFrameCount * 4);
-                        const tempArray = new Float32Array(tempBuffer);
-                        this._data.copyTo(tempArray, {
-                            planeIndex,
-                            frameOffset,
-                            frameCount: copyFrameCount,
-                            format: 'f32-planar',
-                        });
-                        // Convert each f32 sample to destination format
-                        const tempView = new DataView(tempBuffer);
-                        for (let i = 0; i < copyFrameCount; i++) {
-                            const destOffset = i * destBytesPerSample;
-                            const sample = tempView.getFloat32(i * 4, true);
-                            writeFn(destView, destOffset, sample);
-                        }
-                    }
+                if (isWebKit() && numChannels > 2 && destFormat !== srcFormat) {
+                    // WebKit bug workaround
+                    doAudioDataCopyToWebKitWorkaround(this._data, destView, srcFormat, destFormat, numChannels, planeIndex, frameOffset, copyFrameCount);
                 }
                 else {
-                    // Destination is interleaved.
-                    // Allocate a temporary Float32Array to hold one channel's worth of data.
-                    const numCh = numChannels;
-                    const temp = new Float32Array(copyFrameCount);
-                    for (let ch = 0; ch < numCh; ch++) {
-                        this._data.copyTo(temp, {
-                            planeIndex: ch,
-                            frameOffset,
-                            frameCount: copyFrameCount,
-                            format: 'f32-planar',
-                        });
-                        for (let i = 0; i < copyFrameCount; i++) {
-                            const destIndex = i * numCh + ch;
-                            const destOffset = destIndex * destBytesPerSample;
-                            writeFn(destView, destOffset, temp[i]);
-                        }
-                    }
+                    // Per spec, only f32-planar conversion must be supported, but in practice, all browsers support all
+                    // destination formats, so let's just delegate here:
+                    this._data.copyTo(destination, {
+                        planeIndex,
+                        frameOffset,
+                        frameCount: copyFrameCount,
+                        format: destFormat,
+                    });
                 }
             }
             else {
-                // Branch for Uint8Array data (non-AudioData)
                 const uint8Data = this._data;
-                const srcView = new DataView(uint8Data.buffer, uint8Data.byteOffset, uint8Data.byteLength);
-                const srcFormat = this.format;
+                const srcView = toDataView(uint8Data);
                 const readFn = getReadFunction(srcFormat);
                 const srcBytesPerSample = getBytesPerSample(srcFormat);
                 const srcIsPlanar = formatIsPlanar(srcFormat);
@@ -3381,6 +3820,7 @@
             if (this._closed) {
                 return;
             }
+            finalizationRegistry?.unregister(this);
             if (isAudioData(this._data)) {
                 this._data.close();
             }
@@ -3441,7 +3881,9 @@
                     numberOfFrames: this.numberOfFrames,
                     numberOfChannels: this.numberOfChannels,
                     timestamp: this.microsecondTimestamp,
-                    data: this._data,
+                    data: this._data.buffer instanceof ArrayBuffer
+                        ? this._data.buffer
+                        : this._data.slice(), // In the case of SharedArrayBuffer, convert to ArrayBuffer
                 });
             }
         }
@@ -3607,6 +4049,99 @@
     const isAudioData = (x) => {
         return typeof AudioData !== 'undefined' && x instanceof AudioData;
     };
+    /**
+     * WebKit has a bug where calling AudioData.copyTo with a format different from the source format
+     * crashes the tab when there are more than 2 channels. This function works around that by always
+     * copying with the source format and then manually converting to the destination format.
+     *
+     * See https://bugs.webkit.org/show_bug.cgi?id=302521.
+     */
+    const doAudioDataCopyToWebKitWorkaround = (audioData, destView, srcFormat, destFormat, numChannels, planeIndex, frameOffset, copyFrameCount) => {
+        const readFn = getReadFunction(srcFormat);
+        const writeFn = getWriteFunction(destFormat);
+        const srcBytesPerSample = getBytesPerSample(srcFormat);
+        const destBytesPerSample = getBytesPerSample(destFormat);
+        const srcIsPlanar = formatIsPlanar(srcFormat);
+        const destIsPlanar = formatIsPlanar(destFormat);
+        if (destIsPlanar) {
+            if (srcIsPlanar) {
+                // src planar -> dest planar: copy single plane and convert
+                const data = new ArrayBuffer(copyFrameCount * srcBytesPerSample);
+                const dataView = toDataView(data);
+                audioData.copyTo(data, {
+                    planeIndex,
+                    frameOffset,
+                    frameCount: copyFrameCount,
+                    format: srcFormat,
+                });
+                for (let i = 0; i < copyFrameCount; i++) {
+                    const srcOffset = i * srcBytesPerSample;
+                    const destOffset = i * destBytesPerSample;
+                    const sample = readFn(dataView, srcOffset);
+                    writeFn(destView, destOffset, sample);
+                }
+            }
+            else {
+                // src interleaved -> dest planar: copy all interleaved data, extract one channel
+                const data = new ArrayBuffer(copyFrameCount * numChannels * srcBytesPerSample);
+                const dataView = toDataView(data);
+                audioData.copyTo(data, {
+                    planeIndex: 0,
+                    frameOffset,
+                    frameCount: copyFrameCount,
+                    format: srcFormat,
+                });
+                for (let i = 0; i < copyFrameCount; i++) {
+                    const srcOffset = (i * numChannels + planeIndex) * srcBytesPerSample;
+                    const destOffset = i * destBytesPerSample;
+                    const sample = readFn(dataView, srcOffset);
+                    writeFn(destView, destOffset, sample);
+                }
+            }
+        }
+        else {
+            if (srcIsPlanar) {
+                // src planar -> dest interleaved: copy each plane and interleave
+                const planeSize = copyFrameCount * srcBytesPerSample;
+                const data = new ArrayBuffer(planeSize);
+                const dataView = toDataView(data);
+                for (let ch = 0; ch < numChannels; ch++) {
+                    audioData.copyTo(data, {
+                        planeIndex: ch,
+                        frameOffset,
+                        frameCount: copyFrameCount,
+                        format: srcFormat,
+                    });
+                    for (let i = 0; i < copyFrameCount; i++) {
+                        const srcOffset = i * srcBytesPerSample;
+                        const destOffset = (i * numChannels + ch) * destBytesPerSample;
+                        const sample = readFn(dataView, srcOffset);
+                        writeFn(destView, destOffset, sample);
+                    }
+                }
+            }
+            else {
+                // src interleaved -> dest interleaved: copy all and convert
+                const data = new ArrayBuffer(copyFrameCount * numChannels * srcBytesPerSample);
+                const dataView = toDataView(data);
+                audioData.copyTo(data, {
+                    planeIndex: 0,
+                    frameOffset,
+                    frameCount: copyFrameCount,
+                    format: srcFormat,
+                });
+                for (let i = 0; i < copyFrameCount; i++) {
+                    for (let ch = 0; ch < numChannels; ch++) {
+                        const idx = i * numChannels + ch;
+                        const srcOffset = idx * srcBytesPerSample;
+                        const destOffset = idx * destBytesPerSample;
+                        const sample = readFn(dataView, srcOffset);
+                        writeFn(destView, destOffset, sample);
+                    }
+                }
+            }
+        }
+    };
 
     /*!
      * Copyright (c) 2025-present, Vanilagy and contributors
@@ -3727,9 +4262,10 @@
                 return this._track._backing.getKeyPacket(timestamp, options);
             }
             const packet = await this._track._backing.getKeyPacket(timestamp, options);
-            if (!packet || packet.type === 'delta') {
+            if (!packet) {
                 return packet;
             }
+            assert(packet.type === 'key');
             const determinedType = await this._track.determinePacketType(packet);
             if (determinedType === 'delta') {
                 // Try returning the previous key packet (in hopes that it's actually a key packet)
@@ -3755,9 +4291,10 @@
                 return this._track._backing.getNextKeyPacket(packet, options);
             }
             const nextPacket = await this._track._backing.getNextKeyPacket(packet, options);
-            if (!nextPacket || nextPacket.type === 'delta') {
+            if (!nextPacket) {
                 return nextPacket;
             }
+            assert(nextPacket.type === 'key');
             const determinedType = await this._track.determinePacketType(nextPacket);
             if (determinedType === 'delta') {
                 // Try returning the next key packet (in hopes that it's actually a key packet)
@@ -3899,7 +4436,6 @@
             let outOfBandError = null;
             // The following is the "pump" process that keeps pumping packets into the decoder
             (async () => {
-                const decoderError = new Error();
                 const decoder = await this._createDecoder((sample) => {
                     onQueueDequeue();
                     if (sample.timestamp >= endTimestamp) {
@@ -3933,7 +4469,6 @@
                     }
                 }, (error) => {
                     if (!outOfBandError) {
-                        error.stack = decoderError.stack; // Provide a more useful stack trace
                         outOfBandError = error;
                         onQueueNotEmpty();
                     }
@@ -3941,9 +4476,6 @@
                 const packetSink = this._createPacketSink();
                 const keyPacket = await packetSink.getKeyPacket(startTimestamp, { verifyKeyPackets: true })
                     ?? await packetSink.getFirstPacket();
-                if (!keyPacket) {
-                    return;
-                }
                 let currentPacket = keyPacket;
                 let endPacket = undefined;
                 if (endTimestamp < Infinity) {
@@ -3961,7 +4493,7 @@
                         endPacket = keyPacket;
                     }
                 }
-                const packets = packetSink.packets(keyPacket, endPacket);
+                const packets = packetSink.packets(keyPacket ?? undefined, endPacket);
                 await packets.next(); // Skip the start packet as we already have it
                 while (currentPacket && !ended && !this._track.input._disposed) {
                     const maxQueueSize = computeMaxQueueSize(sampleQueue.length);
@@ -4064,7 +4596,6 @@
             };
             // The following is the "pump" process that keeps pumping packets into the decoder
             (async () => {
-                const decoderError = new Error();
                 const decoder = await this._createDecoder((sample) => {
                     onQueueDequeue();
                     if (terminated) {
@@ -4089,7 +4620,6 @@
                     }
                 }, (error) => {
                     if (!outOfBandError) {
-                        error.stack = decoderError.stack; // Provide a more useful stack trace
                         outOfBandError = error;
                         onQueueNotEmpty();
                     }
@@ -4302,6 +4832,7 @@
                         }
                     }
                 }
+                const stack = new Error('Decoding error').stack;
                 this.decoder = new VideoDecoder({
                     output: (frame) => {
                         try {
@@ -4311,7 +4842,10 @@
                             this.onError(error);
                         }
                     },
-                    error: onError,
+                    error: (error) => {
+                        error.stack = stack; // Provide a more useful stack trace, the default one sucks
+                        this.onError(error);
+                    },
                 });
                 this.decoder.configure(this.decoderConfig);
             }
@@ -4332,7 +4866,6 @@
                 }
                 this.raslSkipped = true;
             }
-            this.currentPacketIndex++;
             if (this.customDecoder) {
                 this.customDecoderQueueSize++;
                 void this.customDecoderCallSerializer
@@ -4344,9 +4877,21 @@
                 if (!isWebKit()) {
                     insertSorted(this.inputTimestamps, packet.timestamp, x => x);
                 }
+                // Workaround for https://issues.chromium.org/issues/470109459
+                if (isChromium() && this.currentPacketIndex === 0 && this.codec === 'avc') {
+                    const nalUnits = extractAvcNalUnits(packet.data, this.decoderConfig);
+                    const filteredNalUnits = nalUnits.filter((x) => {
+                        const type = extractNalUnitTypeForAvc(x);
+                        // These trip up Chromium's key frame detection, so let's strip them
+                        return !(type >= 20 && type <= 31);
+                    });
+                    const newData = concatAvcNalUnits(filteredNalUnits, this.decoderConfig);
+                    packet = new EncodedPacket(newData, packet.type, packet.timestamp, packet.duration);
+                }
                 this.decoder.decode(packet.toEncodedVideoChunk());
                 this.decodeAlphaData(packet);
             }
+            this.currentPacketIndex++;
         }
         decodeAlphaData(packet) {
             if (!packet.sideData.alpha || this.mergerCreationFailed) {
@@ -4392,6 +4937,7 @@
                         }
                     }
                 };
+                const stack = new Error('Decoding error').stack;
                 this.alphaDecoder = new VideoDecoder({
                     output: (frame) => {
                         try {
@@ -4401,7 +4947,10 @@
                             this.onError(error);
                         }
                     },
-                    error: this.onError,
+                    error: (error) => {
+                        error.stack = stack; // Provide a more useful stack trace, the default one sucks
+                        this.onError(error);
+                    },
                 });
                 this.alphaDecoder.configure(this.decoderConfig);
             }
@@ -4786,6 +5335,7 @@
                 void this.customDecoderCallSerializer.call(() => this.customDecoder.init());
             }
             else {
+                const stack = new Error('Decoding error').stack;
                 this.decoder = new AudioDecoder({
                     output: (data) => {
                         try {
@@ -4795,7 +5345,10 @@
                             this.onError(error);
                         }
                     },
-                    error: onError,
+                    error: (error) => {
+                        error.stack = stack; // Provide a more useful stack trace, the default one sucks
+                        this.onError(error);
+                    },
                 });
                 this.decoder.configure(decoderConfig);
             }
@@ -7496,11 +8049,8 @@
         async getKeyPacket(timestamp, options) {
             const timestampInTimescale = this.mapTimestampIntoTimescale(timestamp);
             const sampleTable = this.internalTrack.demuxer.getSampleTableForTrack(this.internalTrack);
-            const sampleIndex = getSampleIndexForTimestamp(sampleTable, timestampInTimescale);
-            const keyFrameSampleIndex = sampleIndex === -1
-                ? -1
-                : getRelevantKeyframeIndexForSample(sampleTable, sampleIndex);
-            const regularPacket = await this.fetchPacketForSampleIndex(keyFrameSampleIndex, options);
+            const sampleIndex = getKeyframeSampleIndexForTimestamp(sampleTable, timestampInTimescale);
+            const regularPacket = await this.fetchPacketForSampleIndex(sampleIndex, options);
             if (!sampleTableIsEmpty(sampleTable) || !this.internalTrack.demuxer.isFragmented) {
                 // Prefer the non-fragmented packet
                 return regularPacket;
@@ -7807,6 +8357,32 @@
                 + Math.min(Math.floor((timescaleUnits - entry.startDecodeTimestamp) / entry.delta), entry.count - 1);
         }
     };
+    const getKeyframeSampleIndexForTimestamp = (sampleTable, timescaleUnits) => {
+        if (!sampleTable.keySampleIndices) {
+            // Every sample is a keyframe
+            return getSampleIndexForTimestamp(sampleTable, timescaleUnits);
+        }
+        if (sampleTable.presentationTimestamps) {
+            const index = binarySearchLessOrEqual(sampleTable.presentationTimestamps, timescaleUnits, x => x.presentationTimestamp);
+            if (index === -1) {
+                return -1;
+            }
+            // Walk the samples in presentation order until we find one that's a keyframe
+            for (let i = index; i >= 0; i--) {
+                const sampleIndex = sampleTable.presentationTimestamps[i].sampleIndex;
+                const isKeyFrame = binarySearchExact(sampleTable.keySampleIndices, sampleIndex, x => x) !== -1;
+                if (isKeyFrame) {
+                    return sampleIndex;
+                }
+            }
+            return -1;
+        }
+        else {
+            const sampleIndex = getSampleIndexForTimestamp(sampleTable, timescaleUnits);
+            const index = binarySearchLessOrEqual(sampleTable.keySampleIndices, sampleIndex, x => x);
+            return sampleTable.keySampleIndices[index] ?? -1;
+        }
+    };
     const getSampleInfo = (sampleTable, sampleIndex) => {
         const timingEntryIndex = binarySearchLessOrEqual(sampleTable.sampleTimingEntries, sampleIndex, x => x.startIndex);
         const timingEntry = sampleTable.sampleTimingEntries[timingEntryIndex];
@@ -7869,13 +8445,6 @@
                 : true,
         };
     };
-    const getRelevantKeyframeIndexForSample = (sampleTable, sampleIndex) => {
-        if (!sampleTable.keySampleIndices) {
-            return sampleIndex;
-        }
-        const index = binarySearchLessOrEqual(sampleTable.keySampleIndices, sampleIndex, x => x);
-        return sampleTable.keySampleIndices[index] ?? -1;
-    };
     const getNextKeyframeIndexForSample = (sampleTable, sampleIndex) => {
         if (!sampleTable.keySampleIndices) {
             return sampleIndex + 1;
@@ -13984,6 +14553,8 @@
             // If user is offline, it is probably not a CORS error.
             const isOnline = typeof navigator !== 'undefined' && typeof navigator.onLine === 'boolean' ? navigator.onLine : true;
             if (isOnline && originOfSrc !== null && originOfSrc !== window.location.origin) {
+                console.warn(`Request will not be retried because a CORS error was suspected due to different origins. You can`
+                    + ` modify this behavior by providing your own function for the 'getRetryDelay' option.`);
                 return null;
             }
         }
@@ -14049,7 +14620,7 @@
                     Range: 'bytes=0-',
                 },
                 signal: abortController.signal,
-            }), this._getRetryDelay);
+            }), this._getRetryDelay, () => this._disposed);
             if (!response.ok) {
                 // eslint-disable-next-line @typescript-eslint/no-base-to-string
                 throw new Error(`Error fetching ${String(this._url)}: ${response.status} ${response.statusText}`);
@@ -14057,7 +14628,7 @@
             let worker;
             let fileSize;
             if (response.status === 206) {
-                fileSize = this._getPartialLengthFromRangeResponse(response);
+                fileSize = this._getTotalLengthFromRangeResponse(response);
                 worker = this._orchestrator.createWorker(0, Math.min(fileSize, URL_SOURCE_MIN_LOAD_AMOUNT));
             }
             else {
@@ -14099,7 +14670,7 @@
                             Range: `bytes=${worker.currentPos}-`,
                         },
                         signal: abortController.signal,
-                    }), this._getRetryDelay);
+                    }), this._getRetryDelay, () => this._disposed);
                 }
                 assert(response);
                 if (!response.ok) {
@@ -14110,11 +14681,6 @@
                     throw new Error('HTTP server did not respond with 206 Partial Content to a range request. To enable efficient media'
                         + ' file streaming across a network, please make sure your server supports range requests.');
                 }
-                const length = this._getPartialLengthFromRangeResponse(response);
-                const required = worker.targetPos - worker.currentPos;
-                if (length < required) {
-                    throw new Error(`HTTP response unexpectedly too short: Needed at least ${required} bytes, got only ${length}.`);
-                }
                 if (!response.body) {
                     throw new Error('Missing HTTP response body stream. The used fetch function must provide the response body as a'
                         + ' ReadableStream.');
@@ -14131,6 +14697,10 @@
                         readResult = await reader.read();
                     }
                     catch (error) {
+                        if (this._disposed) {
+                            // No need to try to retry
+                            throw error;
+                        }
                         const retryDelayInSeconds = this._getRetryDelay(1, error, this._url);
                         if (retryDelayInSeconds !== null) {
                             console.error('Error while reading response stream. Attempting to resume.', error);
@@ -14142,50 +14712,45 @@
                         }
                     }
                     if (worker.aborted) {
-                        break;
+                        continue; // Cleanup happens in next iteration
                     }
                     const { done, value } = readResult;
                     if (done) {
-                        this._orchestrator.forgetWorker(worker);
-                        if (worker.currentPos < worker.targetPos) {
-                            throw new Error('Response stream reader stopped unexpectedly before all requested data was read.');
-                        }
-                        worker.running = false;
-                        return;
+                        if (worker.currentPos >= worker.targetPos) {
+                            // All data was delivered, we're good
+                            this._orchestrator.forgetWorker(worker);
+                            worker.running = false;
+                            return;
+                        }
+                        // The response stopped early, before the target. This can happen if server decides to cap range
+                        // requests arbitrarily, even if the request had an uncapped end. In this case, let's fetch the rest
+                        // of the data using a new request.
+                        break;
                     }
                     this.onread?.(worker.currentPos, worker.currentPos + value.length);
                     this._orchestrator.supplyWorkerData(worker, value);
                 }
-                if (worker.aborted) {
-                    break;
-                }
             }
-            worker.running = false;
             // The previous UrlSource had logic for circumventing https://issues.chromium.org/issues/436025873; I haven't
             // been able to observe this bug with the new UrlSource (maybe because we're using response streaming), so the
             // logic for that has vanished for now. Leaving a comment here if this becomes relevant again.
         }
         /** @internal */
-        _getPartialLengthFromRangeResponse(response) {
+        _getTotalLengthFromRangeResponse(response) {
             const contentRange = response.headers.get('Content-Range');
             if (contentRange) {
                 const match = /\/(\d+)/.exec(contentRange);
                 if (match) {
                     return Number(match[1]);
                 }
-                else {
-                    throw new Error(`Invalid Content-Range header: ${contentRange}`);
-                }
+            }
+            const contentLength = response.headers.get('Content-Length');
+            if (contentLength) {
+                return Number(contentLength);
             }
             else {
-                const contentLength = response.headers.get('Content-Length');
-                if (contentLength) {
-                    return Number(contentLength);
-                }
-                else {
-                    throw new Error('Partial HTTP response (status 206) must surface either Content-Range or'
-                        + ' Content-Length header.');
-                }
+                throw new Error('Partial HTTP response (status 206) must surface either Content-Range or'
+                    + ' Content-Length header.');
             }
         }
         /** @internal */
@@ -15188,7 +15753,6 @@
                         if (cache) {
                             return [2 /*return*/, { status: 206, arrayBuffer: cache.arrayBuffer }];
                         }
-                        console.log('miss', id);
                         return [4 /*yield*/, fetch(url, __assign(__assign({}, options), { cache: 'force-cache', headers: {
                                     'Cache-Control': 'max-age=31536000',
                                     Range: "bytes=".concat(start, "-").concat(end),
@@ -15216,6 +15780,7 @@
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
+                        if (!!(options === null || options === void 0 ? void 0 : options.indexedDB)) return [3 /*break*/, 4];
                         return [4 /*yield*/, fetch(url, __assign(__assign({}, options), { cache: 'force-cache', headers: {
                                     'Cache-Control': 'max-age=31536000',
                                     Range: "bytes=".concat(start, "-").concat(end),
@@ -15262,15 +15827,13 @@
     (function (DecoderType) {
         DecoderType[DecoderType["META"] = 0] = "META";
         DecoderType[DecoderType["DECODE"] = 1] = "DECODE";
-        DecoderType[DecoderType["DECODE_FRAME"] = 2] = "DECODE_FRAME";
-        DecoderType[DecoderType["RELEASE"] = 3] = "RELEASE";
+        DecoderType[DecoderType["RELEASE"] = 2] = "RELEASE";
     })(exports.DecoderType || (exports.DecoderType = {}));
     exports.DecoderEvent = void 0;
     (function (DecoderEvent) {
         DecoderEvent["META"] = "meta";
         DecoderEvent["ERROR"] = "error";
         DecoderEvent["DECODED"] = "decoded";
-        DecoderEvent["DECODED_FRAME"] = "decoded_frame";
     })(exports.DecoderEvent || (exports.DecoderEvent = {}));
     exports.GOPState = void 0;
     (function (GOPState) {
@@ -15289,10 +15852,10 @@
     }
     var FILE_HASH = {};
     var onMessage = function (e) { return __awaiter(void 0, void 0, void 0, function () {
-        var _a, url, id, type, isWorker, onError, fileData, headResponse, cl, fileSize_1, meta, source, input, data, e_1, videoTrack, duration, sink, _b, _c, _d, packet, len_1, last, e_2_1, len, last, timestamp, audioTrack, duration, timestamp, gopMinDuration, sink, timestamp_1, isFirst, sequenceNumber, _e, _f, _g, packet, diff, len_2, last, e_3_1, len, last, simpleGOPList, res, gop, videoFrames, sink, _h, _j, _k, sample, e_4_1, audioChunks, sampleRate, audioTimeStamp, audioDuration, sink, start, end, samples, _l, samples_1, samples_1_1, sample, numberOfChannels, numberOfFrames, timestamp, duration, channels, ch, tmp, e_5_1, transferList_1, res, gop, time, videoFrame, sink, sample, audioChunks, sampleRate, audioTimeStamp, audioDuration, sink, start, end, samples, _m, samples_2, samples_2_1, sample, numberOfChannels, numberOfFrames, timestamp, duration, channels, ch, tmp, e_6_1, transferList_2, res, gop, i;
-        var _o, e_2, _p, _q, _r, e_3, _s, _t, _u, e_4, _v, _w, _x, e_5, _y, _z, _0, e_6, _1, _2;
-        return __generator(this, function (_3) {
-            switch (_3.label) {
+        var _a, url, id, type, isWorker, onError, fileData, headResponse, cl, fileSize_1, meta, source, input, data, e_1, videoTrack, duration, sink, _b, _c, _d, packet, len_1, last, e_2_1, len, last, timestamp, audioTrack, duration, timestamp, gopMinDuration, sink, timestamp_1, isFirst, sequenceNumber, _e, _f, _g, packet, diff, len_2, last, e_3_1, len, last, simpleGOPList, res, gop, videoFrames, sink, _h, _j, _k, sample, e_4_1, audioChunks, sampleRate, audioTimeStamp, audioDuration, sink, start, end, samples, _l, samples_1, samples_1_1, sample, numberOfChannels, numberOfFrames, timestamp, duration, channels, ch, tmp, e_5_1, transferList_1, res, gop, i;
+        var _m, e_2, _o, _p, _q, e_3, _r, _s, _t, e_4, _u, _v, _w, e_5, _x, _y;
+        return __generator(this, function (_z) {
+            switch (_z.label) {
                 case 0:
                     _a = e.data, url = _a.url, id = _a.id, type = _a.type, isWorker = _a.isWorker;
                     onError = function (e) {
@@ -15315,7 +15878,7 @@
                     if (!(type === exports.DecoderType.META)) return [3 /*break*/, 38];
                     return [4 /*yield*/, fetch(url, { method: 'HEAD' })];
                 case 1:
-                    headResponse = _3.sent();
+                    headResponse = _z.sent();
                     cl = headResponse.headers.get('content-length');
                     if (!cl || headResponse.status !== 200 && headResponse.status !== 304) {
                         return [2 /*return*/, onError('Unknown content-length')];
@@ -15336,7 +15899,7 @@
                                 var arrayBuffer;
                                 return __generator(this, function (_a) {
                                     switch (_a.label) {
-                                        case 0: return [4 /*yield*/, loadRange(url, start, end - 1, fileSize_1)];
+                                        case 0: return [4 /*yield*/, loadRange(url, start, end - 1, fileSize_1, { indexedDB: e.data.indexedDB })];
                                         case 1:
                                             arrayBuffer = (_a.sent()).arrayBuffer;
                                             if (!arrayBuffer) {
@@ -15358,37 +15921,37 @@
                         formats: ALL_FORMATS,
                         source: source,
                     });
-                    _3.label = 2;
+                    _z.label = 2;
                 case 2:
-                    _3.trys.push([2, 4, , 5]);
+                    _z.trys.push([2, 4, , 5]);
                     return [4 /*yield*/, input.computeDuration()];
                 case 3:
-                    data = _3.sent();
+                    data = _z.sent();
                     meta.duration = data * 1e3;
                     return [3 /*break*/, 5];
                 case 4:
-                    e_1 = _3.sent();
+                    e_1 = _z.sent();
                     return [2 /*return*/, onError(e_1.message)];
                 case 5: return [4 /*yield*/, input.getPrimaryVideoTrack()];
                 case 6:
-                    videoTrack = _3.sent();
+                    videoTrack = _z.sent();
                     if (!videoTrack) return [3 /*break*/, 21];
                     fileData.videoTrack = videoTrack;
                     return [4 /*yield*/, videoTrack.computeDuration()];
                 case 7:
-                    duration = _3.sent();
+                    duration = _z.sent();
                     sink = new EncodedPacketSink(videoTrack);
-                    _3.label = 8;
+                    _z.label = 8;
                 case 8:
-                    _3.trys.push([8, 13, 14, 19]);
+                    _z.trys.push([8, 13, 14, 19]);
                     _b = true, _c = __asyncValues(sink.packets(undefined, undefined, { metadataOnly: true }));
-                    _3.label = 9;
+                    _z.label = 9;
                 case 9: return [4 /*yield*/, _c.next()];
                 case 10:
-                    if (!(_d = _3.sent(), _o = _d.done, !_o)) return [3 /*break*/, 12];
-                    _q = _d.value;
+                    if (!(_d = _z.sent(), _m = _d.done, !_m)) return [3 /*break*/, 12];
+                    _p = _d.value;
                     _b = false;
-                    packet = _q;
+                    packet = _p;
                     if (packet.type === 'key') {
                         len_1 = fileData.gopList.length;
                         if (len_1) {
@@ -15410,22 +15973,22 @@
                             users: [],
                         });
                     }
-                    _3.label = 11;
+                    _z.label = 11;
                 case 11:
                     _b = true;
                     return [3 /*break*/, 9];
                 case 12: return [3 /*break*/, 19];
                 case 13:
-                    e_2_1 = _3.sent();
+                    e_2_1 = _z.sent();
                     e_2 = { error: e_2_1 };
                     return [3 /*break*/, 19];
                 case 14:
-                    _3.trys.push([14, , 17, 18]);
-                    if (!(!_b && !_o && (_p = _c.return))) return [3 /*break*/, 16];
-                    return [4 /*yield*/, _p.call(_c)];
+                    _z.trys.push([14, , 17, 18]);
+                    if (!(!_b && !_m && (_o = _c.return))) return [3 /*break*/, 16];
+                    return [4 /*yield*/, _o.call(_c)];
                 case 15:
-                    _3.sent();
-                    _3.label = 16;
+                    _z.sent();
+                    _z.label = 16;
                 case 16: return [3 /*break*/, 18];
                 case 17:
                     if (e_2) throw e_2.error;
@@ -15439,7 +16002,7 @@
                     }
                     return [4 /*yield*/, videoTrack.getFirstTimestamp()];
                 case 20:
-                    timestamp = _3.sent();
+                    timestamp = _z.sent();
                     meta.video = {
                         id: videoTrack.id,
                         languageCode: videoTrack.languageCode,
@@ -15456,18 +16019,18 @@
                         timestamp: timestamp * 1e3,
                         duration: duration * 1e3,
                     };
-                    _3.label = 21;
+                    _z.label = 21;
                 case 21: return [4 /*yield*/, input.getPrimaryAudioTrack()];
                 case 22:
-                    audioTrack = _3.sent();
+                    audioTrack = _z.sent();
                     if (!audioTrack) return [3 /*break*/, 37];
                     fileData.audioTrack = audioTrack;
                     return [4 /*yield*/, audioTrack.computeDuration()];
                 case 23:
-                    duration = _3.sent();
+                    duration = _z.sent();
                     return [4 /*yield*/, audioTrack.getFirstTimestamp()];
                 case 24:
-                    timestamp = _3.sent();
+                    timestamp = _z.sent();
                     meta.audio = {
                         id: audioTrack.id,
                         languageCode: audioTrack.languageCode,
@@ -15484,17 +16047,17 @@
                     timestamp_1 = -1;
                     isFirst = true;
                     sequenceNumber = 0;
-                    _3.label = 25;
+                    _z.label = 25;
                 case 25:
-                    _3.trys.push([25, 30, 31, 36]);
+                    _z.trys.push([25, 30, 31, 36]);
                     _e = true, _f = __asyncValues(sink.packets(undefined, undefined, { metadataOnly: true }));
-                    _3.label = 26;
+                    _z.label = 26;
                 case 26: return [4 /*yield*/, _f.next()];
                 case 27:
-                    if (!(_g = _3.sent(), _r = _g.done, !_r)) return [3 /*break*/, 29];
-                    _t = _g.value;
+                    if (!(_g = _z.sent(), _q = _g.done, !_q)) return [3 /*break*/, 29];
+                    _s = _g.value;
                     _e = false;
-                    packet = _t;
+                    packet = _s;
                     if (timestamp_1 === -1) {
                         timestamp_1 = packet.timestamp;
                     }
@@ -15519,22 +16082,22 @@
                         timestamp_1 = packet.timestamp;
                     }
                     sequenceNumber++;
-                    _3.label = 28;
+                    _z.label = 28;
                 case 28:
                     _e = true;
                     return [3 /*break*/, 26];
                 case 29: return [3 /*break*/, 36];
                 case 30:
-                    e_3_1 = _3.sent();
+                    e_3_1 = _z.sent();
                     e_3 = { error: e_3_1 };
                     return [3 /*break*/, 36];
                 case 31:
-                    _3.trys.push([31, , 34, 35]);
-                    if (!(!_e && !_r && (_s = _f.return))) return [3 /*break*/, 33];
-                    return [4 /*yield*/, _s.call(_f)];
+                    _z.trys.push([31, , 34, 35]);
+                    if (!(!_e && !_q && (_r = _f.return))) return [3 /*break*/, 33];
+                    return [4 /*yield*/, _r.call(_f)];
                 case 32:
-                    _3.sent();
-                    _3.label = 33;
+                    _z.sent();
+                    _z.label = 33;
                 case 33: return [3 /*break*/, 35];
                 case 34:
                     if (e_3) throw e_3.error;
@@ -15546,7 +16109,7 @@
                         last = fileData.gopList[len - 1];
                         last.duration = last.audioDuration = duration * 1e3 - last.timestamp;
                     }
-                    _3.label = 37;
+                    _z.label = 37;
                 case 37:
                     simpleGOPList = fileData.gopList.map(function (item) {
                         return {
@@ -15586,7 +16149,7 @@
                     return [4 /*yield*/, sleep(100)];
                 case 39:
                     // 截流，先等待一段时间，防止如频繁拖动时间轴，再检查是否被release移除users
-                    _3.sent();
+                    _z.sent();
                     if (!gop.users.includes(id)) {
                         return [2 /*return*/];
                     }
@@ -15599,35 +16162,35 @@
                     videoFrames = [];
                     if (!fileData.videoTrack) return [3 /*break*/, 51];
                     sink = new VideoSampleSink(fileData.videoTrack);
-                    _3.label = 40;
+                    _z.label = 40;
                 case 40:
-                    _3.trys.push([40, 45, 46, 51]);
+                    _z.trys.push([40, 45, 46, 51]);
                     _h = true, _j = __asyncValues(sink.samples(gop.timestamp * 1e-3, (gop.timestamp + gop.duration) * 1e-3));
-                    _3.label = 41;
+                    _z.label = 41;
                 case 41: return [4 /*yield*/, _j.next()];
                 case 42:
-                    if (!(_k = _3.sent(), _u = _k.done, !_u)) return [3 /*break*/, 44];
-                    _w = _k.value;
+                    if (!(_k = _z.sent(), _t = _k.done, !_t)) return [3 /*break*/, 44];
+                    _v = _k.value;
                     _h = false;
-                    sample = _w;
+                    sample = _v;
                     videoFrames.push(sample.toVideoFrame());
                     sample.close();
-                    _3.label = 43;
+                    _z.label = 43;
                 case 43:
                     _h = true;
                     return [3 /*break*/, 41];
                 case 44: return [3 /*break*/, 51];
                 case 45:
-                    e_4_1 = _3.sent();
+                    e_4_1 = _z.sent();
                     e_4 = { error: e_4_1 };
                     return [3 /*break*/, 51];
                 case 46:
-                    _3.trys.push([46, , 49, 50]);
-                    if (!(!_h && !_u && (_v = _j.return))) return [3 /*break*/, 48];
-                    return [4 /*yield*/, _v.call(_j)];
+                    _z.trys.push([46, , 49, 50]);
+                    if (!(!_h && !_t && (_u = _j.return))) return [3 /*break*/, 48];
+                    return [4 /*yield*/, _u.call(_j)];
                 case 47:
-                    _3.sent();
-                    _3.label = 48;
+                    _z.sent();
+                    _z.label = 48;
                 case 48: return [3 /*break*/, 50];
                 case 49:
                     if (e_4) throw e_4.error;
@@ -15644,17 +16207,17 @@
                     start = gop.timestamp * 1e-3;
                     end = (gop.timestamp + gop.duration) * 1e-3;
                     samples = sink.samples(start, end);
-                    _3.label = 52;
+                    _z.label = 52;
                 case 52:
-                    _3.trys.push([52, 57, 58, 63]);
+                    _z.trys.push([52, 57, 58, 63]);
                     _l = true, samples_1 = __asyncValues(samples);
-                    _3.label = 53;
+                    _z.label = 53;
                 case 53: return [4 /*yield*/, samples_1.next()];
                 case 54:
-                    if (!(samples_1_1 = _3.sent(), _x = samples_1_1.done, !_x)) return [3 /*break*/, 56];
-                    _z = samples_1_1.value;
+                    if (!(samples_1_1 = _z.sent(), _w = samples_1_1.done, !_w)) return [3 /*break*/, 56];
+                    _y = samples_1_1.value;
                     _l = false;
-                    sample = _z;
+                    sample = _y;
                     sampleRate = sample.sampleRate;
                     numberOfChannels = sample.numberOfChannels, numberOfFrames = sample.numberOfFrames, timestamp = sample.timestamp, duration = sample.duration;
                     // 位于2个gop之间的sample归属上一个gop
@@ -15682,22 +16245,22 @@
                         duration: duration * 1e3,
                     });
                     sample.close();
-                    _3.label = 55;
+                    _z.label = 55;
                 case 55:
                     _l = true;
                     return [3 /*break*/, 53];
                 case 56: return [3 /*break*/, 63];
                 case 57:
-                    e_5_1 = _3.sent();
+                    e_5_1 = _z.sent();
                     e_5 = { error: e_5_1 };
                     return [3 /*break*/, 63];
                 case 58:
-                    _3.trys.push([58, , 61, 62]);
-                    if (!(!_l && !_x && (_y = samples_1.return))) return [3 /*break*/, 60];
-                    return [4 /*yield*/, _y.call(samples_1)];
+                    _z.trys.push([58, , 61, 62]);
+                    if (!(!_l && !_w && (_x = samples_1.return))) return [3 /*break*/, 60];
+                    return [4 /*yield*/, _x.call(samples_1)];
                 case 59:
-                    _3.sent();
-                    _3.label = 60;
+                    _z.sent();
+                    _z.label = 60;
                 case 60: return [3 /*break*/, 62];
                 case 61:
                     if (e_5) throw e_5.error;
@@ -15737,124 +16300,6 @@
                     }
                     return [2 /*return*/, { data: res }];
                 case 64:
-                    if (!(type === exports.DecoderType.DECODE_FRAME)) return [3 /*break*/, 79];
-                    gop = fileData.gopList[e.data.index];
-                    // 理论不会，预防，只有加载成功后才会进入解码状态
-                    if (!gop || gop.state === exports.GOPState.ERROR) {
-                        return [2 /*return*/];
-                    }
-                    time = e.data.time;
-                    videoFrame = void 0;
-                    if (!fileData.videoTrack) return [3 /*break*/, 66];
-                    sink = new VideoSampleSink(fileData.videoTrack);
-                    return [4 /*yield*/, sink.getSample(time * 1e-3)];
-                case 65:
-                    sample = _3.sent();
-                    if (sample) {
-                        videoFrame = sample.toVideoFrame();
-                        sample.close();
-                    }
-                    _3.label = 66;
-                case 66:
-                    audioChunks = [];
-                    sampleRate = 0;
-                    audioTimeStamp = -1;
-                    audioDuration = 0;
-                    if (!(fileData.audioTrack && !e.data.mute && !gop.didAudioChunk)) return [3 /*break*/, 78];
-                    gop.didAudioChunk = true;
-                    sink = new AudioSampleSink(fileData.audioTrack);
-                    start = gop.timestamp * 1e-3;
-                    end = (gop.timestamp + gop.duration) * 1e-3;
-                    samples = sink.samples(start, end);
-                    _3.label = 67;
-                case 67:
-                    _3.trys.push([67, 72, 73, 78]);
-                    _m = true, samples_2 = __asyncValues(samples);
-                    _3.label = 68;
-                case 68: return [4 /*yield*/, samples_2.next()];
-                case 69:
-                    if (!(samples_2_1 = _3.sent(), _0 = samples_2_1.done, !_0)) return [3 /*break*/, 71];
-                    _2 = samples_2_1.value;
-                    _m = false;
-                    sample = _2;
-                    sampleRate = sample.sampleRate;
-                    numberOfChannels = sample.numberOfChannels, numberOfFrames = sample.numberOfFrames, timestamp = sample.timestamp, duration = sample.duration;
-                    // 位于2个gop之间的sample归属上一个gop
-                    if (timestamp >= end && gop.index < fileData.gopList.length - 1 || timestamp < start) {
-                        return [3 /*break*/, 70];
-                    }
-                    if (audioTimeStamp === -1) {
-                        audioTimeStamp = timestamp * 1e3;
-                    }
-                    audioDuration = timestamp * 1e3 - audioTimeStamp + duration * 1e3;
-                    channels = [];
-                    for (ch = 0; ch < numberOfChannels; ch++) {
-                        tmp = new Float32Array(numberOfFrames);
-                        // audioBuffer只支持f32
-                        sample.copyTo(tmp, { planeIndex: ch, format: 'f32-planar' });
-                        channels.push(tmp);
-                    }
-                    audioChunks.push({
-                        format: 'f32-planar',
-                        channels: channels,
-                        sampleRate: sampleRate,
-                        numberOfFrames: numberOfFrames,
-                        numberOfChannels: numberOfChannels,
-                        timestamp: timestamp * 1e3,
-                        duration: duration * 1e3,
-                    });
-                    sample.close();
-                    _3.label = 70;
-                case 70:
-                    _m = true;
-                    return [3 /*break*/, 68];
-                case 71: return [3 /*break*/, 78];
-                case 72:
-                    e_6_1 = _3.sent();
-                    e_6 = { error: e_6_1 };
-                    return [3 /*break*/, 78];
-                case 73:
-                    _3.trys.push([73, , 76, 77]);
-                    if (!(!_m && !_0 && (_1 = samples_2.return))) return [3 /*break*/, 75];
-                    return [4 /*yield*/, _1.call(samples_2)];
-                case 74:
-                    _3.sent();
-                    _3.label = 75;
-                case 75: return [3 /*break*/, 77];
-                case 76:
-                    if (e_6) throw e_6.error;
-                    return [7 /*endfinally*/];
-                case 77: return [7 /*endfinally*/];
-                case 78:
-                    transferList_2 = [];
-                    if (videoFrame) {
-                        transferList_2.push(videoFrame);
-                    }
-                    if (audioChunks) {
-                        audioChunks.forEach(function (item) {
-                            item.channels.forEach(function (item) {
-                                transferList_2.push(item.buffer);
-                            });
-                        });
-                    }
-                    res = {
-                        url: url,
-                        type: exports.DecoderEvent.DECODED_FRAME,
-                        data: {
-                            index: e.data.index,
-                            time: time,
-                            videoFrame: videoFrame,
-                            audioChunks: audioChunks,
-                            sampleRate: sampleRate,
-                            audioTimeStamp: audioTimeStamp,
-                            audioDuration: audioDuration,
-                        },
-                    };
-                    if (isWorker) {
-                        self.postMessage(res, transferList_2);
-                    }
-                    return [2 /*return*/, { data: res }];
-                case 79:
                     if (type === exports.DecoderType.RELEASE) {
                         gop = fileData.gopList[e.data.index];
                         if (!gop) {
@@ -15866,10 +16311,11 @@
                         }
                         if (!gop.users.length) {
                             gop.state = exports.GOPState.NONE;
+                            gop.didAudioChunk = false;
                         }
                     }
-                    _3.label = 80;
-                case 80: return [2 /*return*/];
+                    _z.label = 65;
+                case 65: return [2 /*return*/];
             }
         });
     }); };