@remotion/media-parser 4.0.287 → 4.0.289

package/dist/containers/aac/get-seeking-byte.d.ts

@@ -0,0 +1,6 @@
+import type { SeekResolution } from '../../work-on-seek-request';
+import type { AacSeekingHints } from './seeking-hints';
+export declare const getSeekingByteForAac: ({ time, seekingHints, }: {
+    time: number;
+    seekingHints: AacSeekingHints;
+}) => SeekResolution;

package/dist/containers/aac/get-seeking-byte.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSeekingByteForAac = void 0;
+const getSeekingByteForAac = ({ time, seekingHints, }) => {
+    let bestAudioSample;
+    for (const hint of seekingHints.audioSampleMap) {
+        if (hint.timeInSeconds > time) {
+            continue;
+        }
+        // Everything is a keyframe in flac, so if this sample does not cover the time, it's not a good candidate.
+        // Let's go to the next one. Exception: If we already saw the last sample, we use it so we find can at least
+        // find the closest one.
+        if (hint.timeInSeconds + hint.durationInSeconds < time &&
+            !seekingHints.lastSampleObserved) {
+            continue;
+        }
+        if (!bestAudioSample) {
+            bestAudioSample = hint;
+            continue;
+        }
+        if (bestAudioSample.timeInSeconds < hint.timeInSeconds) {
+            bestAudioSample = hint;
+        }
+    }
+    if (bestAudioSample) {
+        return { type: 'do-seek', byte: bestAudioSample.offset };
+    }
+    return { type: 'valid-but-must-wait' };
+};
+exports.getSeekingByteForAac = getSeekingByteForAac;

package/dist/containers/aac/parse-aac.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseAac = void 0;
 const aac_codecprivate_1 = require("../../aac-codecprivate");
 const convert_audio_or_video_sample_1 = require("../../convert-audio-or-video-sample");
-const emit_audio_sample_1 = require("../../emit-audio-sample");
 const register_track_1 = require("../../register-track");
 const parseAac = async (state) => {
     const { iterator } = state;
@@ -47,6 +46,10 @@ const parseAac = async (state) => {
     iterator.counter.decrement(iterator.counter.getOffset() - startOffset);
     const data = iterator.getSlice(frameLength);
     if (state.callbacks.tracks.getTracks().length === 0) {
+        state.mediaSection.addMediaSection({
+            start: startOffset,
+            size: state.contentLength - startOffset,
+        });
         await (0, register_track_1.registerAudioTrack)({
             container: 'aac',
             track: {
@@ -71,25 +74,27 @@ const parseAac = async (state) => {
     const duration = 1024 / sampleRate;
     const { index } = state.aac.addSample({ offset: startOffset, size: frameLength });
     const timestamp = (1024 / sampleRate) * index;
+    state.aac.audioSamples.addSample({
+        timeInSeconds: timestamp,
+        offset: startOffset,
+        durationInSeconds: duration,
+    });
     // One ADTS frame contains 1024 samples
-    await (0, emit_audio_sample_1.emitAudioSample)({
-        trackId: 0,
-        audioSample: (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)({
-            sample: {
-                duration,
-                type: 'key',
-                data,
-                offset: startOffset,
-                timescale: 1000000,
-                trackId: 0,
-                cts: timestamp,
-                dts: timestamp,
-                timestamp,
-            },
-            timescale: 1,
-        }),
-        callbacks: state.callbacks,
+    const audioSample = (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)({
+        sample: {
+            duration,
+            type: 'key',
+            data,
+            offset: startOffset,
+            timescale: 1000000,
+            trackId: 0,
+            cts: timestamp,
+            dts: timestamp,
+            timestamp,
+        },
+        timescale: 1,
     });
+    await state.callbacks.onAudioSample(0, audioSample);
     return Promise.resolve(null);
 };
 exports.parseAac = parseAac;

package/dist/containers/aac/seeking-hints.d.ts

@@ -0,0 +1,13 @@
+import type { AacState } from '../../state/aac-state';
+import type { AudioSampleOffset } from '../../state/audio-sample-map';
+import type { SamplesObservedState } from '../../state/samples-observed/slow-duration-fps';
+export type AacSeekingHints = {
+    type: 'aac-seeking-hints';
+    audioSampleMap: AudioSampleOffset[];
+    lastSampleObserved: boolean;
+};
+export declare const getSeekingHintsForAac: ({ aacState, samplesObserved, }: {
+    aacState: AacState;
+    samplesObserved: SamplesObservedState;
+}) => AacSeekingHints;
+export declare const setSeekingHintsForAac: () => void;

package/dist/containers/aac/seeking-hints.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setSeekingHintsForAac = exports.getSeekingHintsForAac = void 0;
+const getSeekingHintsForAac = ({ aacState, samplesObserved, }) => {
+    return {
+        type: 'aac-seeking-hints',
+        audioSampleMap: aacState.audioSamples.getSamples(),
+        lastSampleObserved: samplesObserved.getLastSampleObserved(),
+    };
+};
+exports.getSeekingHintsForAac = getSeekingHintsForAac;
+// TODO: Implement this and maintain index
+const setSeekingHintsForAac = () => { };
+exports.setSeekingHintsForAac = setSeekingHintsForAac;

package/dist/containers/flac/get-channel-count.d.ts

@@ -1,2 +1,2 @@
 import type { BufferIterator } from '../../iterator/buffer-iterator';
-export declare const getChannelCount: (iterator: BufferIterator) => 2 | 8 | 1 | 7 | 3 | 4 | 5 | 6;
+export declare const getChannelCount: (iterator: BufferIterator) => 2 | 1 | 4 | 3 | 5 | 6 | 8 | 7;

package/dist/containers/flac/get-seeking-byte.d.ts

@@ -0,0 +1,5 @@
+import type { FlacSeekingHints } from './seeking-hints';
+export declare const getSeekingByteForFlac: ({ time, seekingHints, }: {
+    time: number;
+    seekingHints: FlacSeekingHints;
+}) => number | null;

package/dist/containers/flac/get-seeking-byte.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSeekingByteForFlac = void 0;
+const getSeekingByteForFlac = ({ time, seekingHints, }) => {
+    let bestAudioSample;
+    for (const hint of seekingHints.audioSampleMap) {
+        if (hint.timeInSeconds > time) {
+            continue;
+        }
+        // Everything is a keyframe in flac, so if this sample does not cover the time, it's not a good candidate.
+        // Let's go to the next one. Exception: If we already saw the last sample, we use it so we find can at least
+        // find the closest one.
+        if (hint.timeInSeconds + hint.durationInSeconds < time &&
+            !seekingHints.lastSampleObserved) {
+            continue;
+        }
+        if (!bestAudioSample) {
+            bestAudioSample = hint;
+            continue;
+        }
+        if (bestAudioSample.timeInSeconds < hint.timeInSeconds) {
+            bestAudioSample = hint;
+        }
+    }
+    if (bestAudioSample) {
+        return bestAudioSample.offset;
+    }
+    return null;
+};
+exports.getSeekingByteForFlac = getSeekingByteForFlac;

package/dist/containers/flac/parse-flac-frame.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseFlacFrame = exports.parseFrameHeader = void 0;
 const convert_audio_or_video_sample_1 = require("../../convert-audio-or-video-sample");
-const emit_audio_sample_1 = require("../../emit-audio-sample");
 const buffer_iterator_1 = require("../../iterator/buffer-iterator");
 const get_block_size_1 = require("./get-block-size");
 const get_channel_count_1 = require("./get-channel-count");
@@ -81,24 +80,26 @@ const emitSample = async ({ state, data, offset, }) => {
         throw new Error('Cannot determine timestamp');
     }
     const timestamp = (num * streamInfo.maximumBlockSize) / streamInfo.sampleRate;
-    await (0, emit_audio_sample_1.emitAudioSample)({
-        trackId: 0,
-        audioSample: (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)({
-            sample: {
-                data,
-                duration,
-                cts: timestamp,
-                dts: timestamp,
-                timestamp,
-                type: 'key',
-                offset,
-                timescale: 1000000,
-                trackId: 0,
-            },
+    state.flac.audioSamples.addSample({
+        timeInSeconds: timestamp,
+        offset,
+        durationInSeconds: duration,
+    });
+    const audioSample = (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)({
+        sample: {
+            data,
+            duration,
+            cts: timestamp,
+            dts: timestamp,
+            timestamp,
+            type: 'key',
+            offset,
             timescale: 1,
-        }),
-        callbacks: state.callbacks,
+            trackId: 0,
+        },
+        timescale: 1,
     });
+    await state.callbacks.onAudioSample(0, audioSample);
     iterator.destroy();
 };
 const parseFlacFrame = async ({ state, iterator, }) => {

package/dist/containers/flac/parse-flac.js

@@ -5,13 +5,7 @@ const skip_1 = require("../../skip");
 const may_skip_video_data_1 = require("../../state/may-skip-video-data");
 const parse_flac_frame_1 = require("./parse-flac-frame");
 const parse_header_1 = require("./parse-header");
-const parse_metadata_1 = require("./parse-metadata");
-const parse_streaminfo_1 = require("./parse-streaminfo");
-const parse_unknown_block_1 = require("./parse-unknown-block");
-const flacTypes = {
-    streaminfo: 0,
-    vorbisComment: 4,
-};
+const parse_meta_1 = require("./parse-meta");
 const parseFlac = ({ iterator, state, }) => {
     const mediaSectionState = state.mediaSection.isCurrentByteInMediaSection(iterator);
     if (mediaSectionState === 'in-section') {
@@ -27,23 +21,9 @@ const parseFlac = ({ iterator, state, }) => {
     iterator.counter.decrement(4);
     // https://www.rfc-editor.org/rfc/rfc9639.html#name-streaminfo
     // section 8.1
-    iterator.startReadingBits();
-    const isLastMetadata = iterator.getBits(1);
-    const metaBlockType = iterator.getBits(7);
-    iterator.stopReadingBits();
-    const size = iterator.getUint24();
-    if (isLastMetadata) {
-        state.mediaSection.addMediaSection({
-            start: iterator.counter.getOffset() + size,
-            size: state.contentLength - iterator.counter.getOffset() - size,
-        });
-    }
-    if (metaBlockType === flacTypes.streaminfo) {
-        return (0, parse_streaminfo_1.parseStreamInfo)({ iterator, state });
-    }
-    if (metaBlockType === flacTypes.vorbisComment) {
-        return (0, parse_metadata_1.parseVorbisComment)({ iterator, state, size });
-    }
-    return (0, parse_unknown_block_1.parseFlacUnkownBlock)({ iterator, state, size });
+    return (0, parse_meta_1.parseMetaBlock)({
+        iterator,
+        state,
+    });
 };
 exports.parseFlac = parseFlac;

package/dist/containers/flac/parse-meta.d.ts

@@ -0,0 +1,6 @@
+import type { BufferIterator } from '../../iterator/buffer-iterator';
+import type { ParserState } from '../../state/parser-state';
+export declare const parseMetaBlock: ({ iterator, state, }: {
+    iterator: BufferIterator;
+    state: ParserState;
+}) => Promise<import("../../parse-result").ParseResult>;

package/dist/containers/flac/parse-meta.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMetaBlock = void 0;
+const parse_metadata_1 = require("./parse-metadata");
+const parse_streaminfo_1 = require("./parse-streaminfo");
+const parse_unknown_block_1 = require("./parse-unknown-block");
+const flacTypes = {
+    streaminfo: 0,
+    vorbisComment: 4,
+};
+const parseMetaBlock = ({ iterator, state, }) => {
+    iterator.startReadingBits();
+    const isLastMetadata = iterator.getBits(1);
+    const metaBlockType = iterator.getBits(7);
+    iterator.stopReadingBits();
+    const size = iterator.getUint24();
+    if (isLastMetadata) {
+        state.mediaSection.addMediaSection({
+            start: iterator.counter.getOffset() + size,
+            size: state.contentLength - iterator.counter.getOffset() - size,
+        });
+    }
+    if (metaBlockType === flacTypes.streaminfo) {
+        return (0, parse_streaminfo_1.parseStreamInfo)({ iterator, state });
+    }
+    if (metaBlockType === flacTypes.vorbisComment) {
+        return (0, parse_metadata_1.parseVorbisComment)({ iterator, state, size });
+    }
+    return (0, parse_unknown_block_1.parseFlacUnkownBlock)({ iterator, state, size });
+};
+exports.parseMetaBlock = parseMetaBlock;

package/dist/containers/flac/seeking-hints.d.ts

@@ -0,0 +1,18 @@
+import type { AudioSampleOffset } from '../../state/audio-sample-map';
+import type { FlacState } from '../../state/flac-state';
+import type { ParserState } from '../../state/parser-state';
+import type { SamplesObservedState } from '../../state/samples-observed/slow-duration-fps';
+export type FlacSeekingHints = {
+    type: 'flac-seeking-hints';
+    audioSampleMap: AudioSampleOffset[];
+    blockingBitStrategy: number | null;
+    lastSampleObserved: boolean;
+};
+export declare const getSeekingHintsForFlac: ({ flacState, samplesObserved, }: {
+    flacState: FlacState;
+    samplesObserved: SamplesObservedState;
+}) => FlacSeekingHints;
+export declare const setSeekingHintsForFlac: ({ hints, state, }: {
+    hints: FlacSeekingHints;
+    state: ParserState;
+}) => void;

package/dist/containers/flac/seeking-hints.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setSeekingHintsForFlac = exports.getSeekingHintsForFlac = void 0;
+const getSeekingHintsForFlac = ({ flacState, samplesObserved, }) => {
+    var _a;
+    return {
+        type: 'flac-seeking-hints',
+        audioSampleMap: flacState.audioSamples.getSamples(),
+        blockingBitStrategy: (_a = flacState.getBlockingBitStrategy()) !== null && _a !== void 0 ? _a : null,
+        lastSampleObserved: samplesObserved.getLastSampleObserved(),
+    };
+};
+exports.getSeekingHintsForFlac = getSeekingHintsForFlac;
+const setSeekingHintsForFlac = ({ hints, state, }) => {
+    if (hints.blockingBitStrategy !== null) {
+        state.flac.setBlockingBitStrategy(hints.blockingBitStrategy);
+    }
+    state.flac.audioSamples.setFromSeekingHints(hints.audioSampleMap);
+};
+exports.setSeekingHintsForFlac = setSeekingHintsForFlac;

package/dist/containers/iso-base-media/collect-sample-positions-from-trak.js

@@ -1,17 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.collectSamplePositionsFromTrak = void 0;
-const get_audio_codec_1 = require("../../get-audio-codec");
 const get_fps_1 = require("../../get-fps");
 const get_sample_positions_1 = require("../../get-sample-positions");
 const get_sample_positions_from_mp4_1 = require("../../get-sample-positions-from-mp4");
+const should_group_audio_samples_1 = require("./should-group-audio-samples");
 const traversal_1 = require("./traversal");
 const collectSamplePositionsFromTrak = (trakBox) => {
-    const isLpcm = (0, get_audio_codec_1.isLpcmAudioCodec)(trakBox);
+    const shouldGroupSamples = (0, should_group_audio_samples_1.shouldGroupAudioSamples)(trakBox);
     const timescaleAndDuration = (0, get_fps_1.getTimescaleAndDuration)(trakBox);
-    const isIn24 = (0, get_audio_codec_1.isIn24AudioCodec)(trakBox);
-    if (isLpcm || isIn24) {
-        return (0, get_sample_positions_from_mp4_1.getGroupedSamplesPositionsFromMp4)(trakBox);
+    if (shouldGroupSamples) {
+        return (0, get_sample_positions_from_mp4_1.getGroupedSamplesPositionsFromMp4)({
+            trakBox,
+            bigEndian: shouldGroupSamples.bigEndian,
+        });
     }
     const stszBox = (0, traversal_1.getStszBox)(trakBox);
     const stcoBox = (0, traversal_1.getStcoBox)(trakBox);

package/dist/containers/iso-base-media/get-children.d.ts

@@ -2,9 +2,10 @@ import type { BufferIterator } from '../../iterator/buffer-iterator';
 import type { LogLevel } from '../../log';
 import type { IsoBaseMediaBox } from './base-media-box';
 import type { OnlyIfMoovAtomExpected } from './process-box';
-export declare const getIsoBaseMediaChildren: ({ size, iterator, logLevel, onlyIfMoovAtomExpected, }: {
+export declare const getIsoBaseMediaChildren: ({ size, iterator, logLevel, onlyIfMoovAtomExpected, contentLength, }: {
     size: number;
     iterator: BufferIterator;
     logLevel: LogLevel;
     onlyIfMoovAtomExpected: OnlyIfMoovAtomExpected | null;
+    contentLength: number;
 }) => Promise<IsoBaseMediaBox[]>;

package/dist/containers/iso-base-media/get-children.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getIsoBaseMediaChildren = void 0;
 const process_box_1 = require("./process-box");
-const getIsoBaseMediaChildren = async ({ size, iterator, logLevel, onlyIfMoovAtomExpected, }) => {
+const getIsoBaseMediaChildren = async ({ size, iterator, logLevel, onlyIfMoovAtomExpected, contentLength, }) => {
     const boxes = [];
     const initial = iterator.counter.getOffset();
     while (iterator.counter.getOffset() < size + initial) {
@@ -11,6 +11,7 @@ const getIsoBaseMediaChildren = async ({ size, iterator, logLevel, onlyIfMoovAto
             logLevel,
             onlyIfMoovAtomExpected,
             onlyIfMdatAtomExpected: null,
+            contentLength,
         });
         if (!parsed) {
             throw new Error('Expected box');

package/dist/containers/iso-base-media/get-mfra-seeking-box.js

@@ -27,6 +27,7 @@ const getMfraSeekingBox = async ({ contentLength, controller, readerInterface, s
         logLevel,
         size: parentSize - 8,
         onlyIfMoovAtomExpected: null,
+        contentLength,
     });
 };
 exports.getMfraSeekingBox = getMfraSeekingBox;

package/dist/containers/iso-base-media/get-moov-atom.js

@@ -51,7 +51,7 @@ const getMoovAtom = async ({ endOfMdat, state, }) => {
             return null;
         }
         : null;
-    const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(new Uint8Array([]), state.contentLength);
+    const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(new Uint8Array([]), state.contentLength - endOfMdat);
     while (true) {
         const result = await reader.reader.read();
         if (result.value) {
@@ -82,6 +82,7 @@ const getMoovAtom = async ({ endOfMdat, state, }) => {
                 registerAudioSampleCallback: () => Promise.resolve(),
             },
             onlyIfMdatAtomExpected: null,
+            contentLength: state.contentLength - endOfMdat,
         });
         if (box) {
             boxes.push(box);

package/dist/containers/iso-base-media/get-video-codec-from-iso-track.d.ts

@@ -1,2 +1,2 @@
 import type { TrakBox } from './trak/trak';
-export declare const getVideoCodecFromIsoTrak: (trakBox: TrakBox) => "h264" | "av1" | "h265" | "prores";
+export declare const getVideoCodecFromIsoTrak: (trakBox: TrakBox) => "h265" | "h264" | "av1" | "prores";

package/dist/containers/iso-base-media/mdat/mdat.js

@@ -2,13 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMdatSection = void 0;
 const convert_audio_or_video_sample_1 = require("../../../convert-audio-or-video-sample");
-const emit_audio_sample_1 = require("../../../emit-audio-sample");
 const get_tracks_1 = require("../../../get-tracks");
 const skip_1 = require("../../../skip");
 const cached_sample_positions_1 = require("../../../state/iso-base-media/cached-sample-positions");
 const may_skip_video_data_1 = require("../../../state/may-skip-video-data");
 const video_section_1 = require("../../../state/video-section");
 const get_moov_atom_1 = require("../get-moov-atom");
+const postprocess_bytes_1 = require("./postprocess-bytes");
 const parseMdatSection = async (state) => {
     const mediaSection = (0, video_section_1.getCurrentMediaSection)({
         offset: state.iterator.counter.getOffset(),
@@ -62,27 +62,28 @@ const parseMdatSection = async (state) => {
     if (iterator.bytesRemaining() < samplesWithIndex.samplePosition.size) {
         return null;
     }
-    const bytes = iterator.getSlice(samplesWithIndex.samplePosition.size);
-    const { cts, dts, duration, isKeyframe, offset } = samplesWithIndex.samplePosition;
+    const { cts, dts, duration, isKeyframe, offset, bigEndian, chunkSize } = samplesWithIndex.samplePosition;
+    const bytes = (0, postprocess_bytes_1.postprocessBytes)({
+        bytes: iterator.getSlice(samplesWithIndex.samplePosition.size),
+        bigEndian,
+        chunkSize,
+    });
     if (samplesWithIndex.track.type === 'audio') {
-        await (0, emit_audio_sample_1.emitAudioSample)({
-            trackId: samplesWithIndex.track.trackId,
-            audioSample: (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)({
-                sample: {
-                    data: bytes,
-                    timestamp: cts,
-                    duration,
-                    cts,
-                    dts,
-                    trackId: samplesWithIndex.track.trackId,
-                    type: isKeyframe ? 'key' : 'delta',
-                    offset,
-                    timescale: samplesWithIndex.track.timescale,
-                },
+        const audioSample = (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)({
+            sample: {
+                data: bytes,
+                timestamp: cts,
+                duration,
+                cts,
+                dts,
+                trackId: samplesWithIndex.track.trackId,
+                type: isKeyframe ? 'key' : 'delta',
+                offset,
                 timescale: samplesWithIndex.track.timescale,
-            }),
-            callbacks: state.callbacks,
+            },
+            timescale: samplesWithIndex.track.timescale,
         });
+        await state.callbacks.onAudioSample(samplesWithIndex.track.trackId, audioSample);
     }
     if (samplesWithIndex.track.type === 'video') {
         // https://remotion-assets.s3.eu-central-1.amazonaws.com/example-videos/sei_checkpoint.mp4
@@ -97,24 +98,21 @@ const parseMdatSection = async (state) => {
             const seiType = bytes[5];
             isRecoveryPoint = seiType === 6;
         }
-        await (0, emit_audio_sample_1.emitVideoSample)({
-            trackId: samplesWithIndex.track.trackId,
-            videoSample: (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)({
-                sample: {
-                    data: bytes,
-                    timestamp: cts,
-                    duration,
-                    cts,
-                    dts,
-                    trackId: samplesWithIndex.track.trackId,
-                    type: isKeyframe && !isRecoveryPoint ? 'key' : 'delta',
-                    offset,
-                    timescale: samplesWithIndex.track.timescale,
-                },
+        const videoSample = (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)({
+            sample: {
+                data: bytes,
+                timestamp: cts,
+                duration,
+                cts,
+                dts,
+                trackId: samplesWithIndex.track.trackId,
+                type: isKeyframe && !isRecoveryPoint ? 'key' : 'delta',
+                offset,
                 timescale: samplesWithIndex.track.timescale,
-            }),
-            callbacks: state.callbacks,
+            },
+            timescale: samplesWithIndex.track.timescale,
         });
+        await state.callbacks.onVideoSample(samplesWithIndex.track.trackId, videoSample);
     }
     return null;
 };

package/dist/containers/iso-base-media/mdat/postprocess-bytes.d.ts

@@ -0,0 +1,5 @@
+export declare const postprocessBytes: ({ bytes, bigEndian, chunkSize, }: {
+    bytes: Uint8Array;
+    bigEndian: boolean;
+    chunkSize: number | null;
+}) => Uint8Array<ArrayBufferLike>;

package/dist/containers/iso-base-media/mdat/postprocess-bytes.js

@@ -0,0 +1,25 @@
+"use strict";
+// Addressing the issue of audio that is stored in big-endian format!
+// If a "twos" atom is present, that is the case.
+// The samples are stored internally in small chunks, like 4 bytes
+// but WebCodecs does not accept such small chunks.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postprocessBytes = void 0;
+// When entering this function, they are already concatenated, but in litte endian order.
+// This function reverses the bytes in each chunk, so that they are in big-endian order.
+const postprocessBytes = ({ bytes, bigEndian, chunkSize, }) => {
+    if (!bigEndian) {
+        return bytes;
+    }
+    if (chunkSize === null) {
+        return bytes;
+    }
+    const newBuffer = new Uint8Array(bytes);
+    for (let i = 0; i < newBuffer.length; i += chunkSize) {
+        const slice = newBuffer.slice(i, i + chunkSize);
+        slice.reverse();
+        newBuffer.set(slice, i);
+    }
+    return newBuffer;
+};
+exports.postprocessBytes = postprocessBytes;

package/dist/containers/iso-base-media/moov/moov.d.ts

@@ -7,10 +7,11 @@ export interface MoovBox extends BaseBox {
     type: 'moov-box';
     children: AnySegment[];
 }
-export declare const parseMoov: ({ offset, size, onlyIfMoovAtomExpected, iterator, logLevel, }: {
+export declare const parseMoov: ({ offset, size, onlyIfMoovAtomExpected, iterator, logLevel, contentLength, }: {
     offset: number;
     size: number;
     onlyIfMoovAtomExpected: OnlyIfMoovAtomExpected;
     iterator: BufferIterator;
     logLevel: LogLevel;
+    contentLength: number;
 }) => Promise<MoovBox>;

package/dist/containers/iso-base-media/moov/moov.js

@@ -2,12 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMoov = void 0;
 const get_children_1 = require("../get-children");
-const parseMoov = async ({ offset, size, onlyIfMoovAtomExpected, iterator, logLevel, }) => {
+const parseMoov = async ({ offset, size, onlyIfMoovAtomExpected, iterator, logLevel, contentLength, }) => {
     const children = await (0, get_children_1.getIsoBaseMediaChildren)({
         onlyIfMoovAtomExpected,
         size: size - 8,
         iterator,
         logLevel,
+        contentLength,
     });
     return {
         offset,

package/dist/containers/iso-base-media/parse-boxes.js

@@ -23,6 +23,7 @@ const parseIsoBaseMedia = async (state) => {
         onlyIfMdatAtomExpected: {
             mediaSectionState: state.mediaSection,
         },
+        contentLength: state.contentLength,
     });
     if (result) {
         state.structure.getIsoStructure().boxes.push(result);

package/dist/containers/iso-base-media/process-box.d.ts

@@ -17,9 +17,10 @@ export type OnlyIfMoovAtomExpected = {
 export type OnlyIfMdatAtomExpected = {
     mediaSectionState: MediaSectionState;
 };
-export declare const processBox: ({ iterator, logLevel, onlyIfMoovAtomExpected, onlyIfMdatAtomExpected, }: {
+export declare const processBox: ({ iterator, logLevel, onlyIfMoovAtomExpected, onlyIfMdatAtomExpected, contentLength, }: {
     iterator: BufferIterator;
     logLevel: LogLevel;
     onlyIfMoovAtomExpected: OnlyIfMoovAtomExpected | null;
     onlyIfMdatAtomExpected: OnlyIfMdatAtomExpected | null;
+    contentLength: number;
 }) => Promise<BoxAndNext>;