@remotion/media-parser 4.0.302 → 4.0.303

package/dist/check-if-done.js

@@ -19,6 +19,10 @@ const checkIfDone = async (state) => {
             !state.m3u.getAllChunksProcessedOverall()) {
             return false;
         }
+        state.riff.queuedBFrames.flush();
+        if (state.riff.queuedBFrames.hasReleasedFrames()) {
+            return false;
+        }
         log_1.Log.verbose(state.logLevel, 'Reached end of file');
         await state.discardReadBytes(true);
         return true;

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

@@ -62,6 +62,7 @@ const parseAac = async (state) => {
                 timescale: 1000000,
                 trackId: 0,
                 type: 'audio',
+                startInSeconds: 0,
             },
             registerAudioSampleCallback: state.callbacks.registerAudioSampleCallback,
             tracks: state.callbacks.tracks,

package/dist/containers/avc/key.d.ts

@@ -1,2 +1,2 @@
 import type { AvcInfo } from './parse-avc';
-export declare const getKeyFrameOrDeltaFromAvcInfo: (infos: AvcInfo[]) => "key" | "delta";
+export declare const getKeyFrameOrDeltaFromAvcInfo: (infos: AvcInfo[]) => "key" | "delta" | "bidirectional";

package/dist/containers/avc/key.js

@@ -6,6 +6,10 @@ const getKeyFrameOrDeltaFromAvcInfo = (infos) => {
     if (!keyOrDelta) {
         throw new Error('expected avc to contain info about key or delta');
     }
-    return keyOrDelta.type === 'keyframe' ? 'key' : 'delta';
+    return keyOrDelta.type === 'keyframe'
+        ? 'key'
+        : keyOrDelta.isBidirectionalFrame
+            ? 'bidirectional'
+            : 'delta';
 };
 exports.getKeyFrameOrDeltaFromAvcInfo = getKeyFrameOrDeltaFromAvcInfo;

package/dist/containers/avc/max-buffer-size.d.ts

@@ -0,0 +1,3 @@
+import type { SpsInfo } from './parse-avc';
+export declare const macroBlocksPerFrame: (sps: SpsInfo) => number;
+export declare const maxMacroblockBufferSize: (sps: SpsInfo) => number;

package/dist/containers/avc/max-buffer-size.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.maxMacroblockBufferSize = exports.macroBlocksPerFrame = void 0;
+// https://www.itu.int/rec/T-REC-H.264-202408-I
+// Table A-1 – Level limits
+const maxMacroblocksByLevel = {
+    10: 396, // Level 1.0
+    11: 900, // Level 1.1
+    12: 2376, // Level 1.2
+    13: 2376, // Level 1.3
+    20: 2376, // Level 2.0
+    21: 4752, // Level 2.1
+    22: 8100, // Level 2.2
+    30: 8100, // Level 3.0
+    31: 18000, // Level 3.1
+    32: 20480, // Level 3.2
+    40: 32768, // Level 4.0
+    41: 32768, // Level 4.1
+    42: 34816, // Level 4.2
+    50: 110400, // Level 5.0
+    51: 184320, // Level 5.1
+    52: 184320, // Level 5.2
+    60: 696320, // Level 6.0
+    61: 696320, // Level 6.1
+    62: 696320, // Level 6.2
+};
+const macroBlocksPerFrame = (sps) => {
+    const { pic_width_in_mbs_minus1, pic_height_in_map_units_minus1 } = sps;
+    return (pic_width_in_mbs_minus1 + 1) * (pic_height_in_map_units_minus1 + 1);
+};
+exports.macroBlocksPerFrame = macroBlocksPerFrame;
+const maxMacroblockBufferSize = (sps) => {
+    const { level } = sps;
+    const maxMacroblocks = maxMacroblocksByLevel[level];
+    if (maxMacroblocks === undefined) {
+        throw new Error(`Unsupported level: ${level.toString(16)}`);
+    }
+    return maxMacroblocks;
+};
+exports.maxMacroblockBufferSize = maxMacroblockBufferSize;

package/dist/containers/avc/parse-avc.d.ts

@@ -1,3 +1,5 @@
+import type { AvcState } from '../../state/avc/avc-state';
+import type { MediaParserAvcDeltaFrameInfo, MediaParserAvcKeyframeInfo } from '../../webcodec-sample-types';
 type VuiParameters = {
     sar_width: number | null;
     sar_height: number | null;
@@ -19,7 +21,7 @@ export type SpsInfo = {
     bit_depth_luma_minus8: number | null;
     bit_depth_chroma_minus8: number | null;
     qpprime_y_zero_transform_bypass_flag: number | null;
-    log2_max_frame_num_minus4: number | null;
+    log2_max_frame_num_minus4: number;
     log2_max_pic_order_cnt_lsb_minus4: number | null;
     max_num_ref_frames: number | null;
     gaps_in_frame_num_value_allowed_flag: number | null;
@@ -32,6 +34,7 @@ export type SpsInfo = {
     frame_crop_top_offset: number | null;
     frame_crop_bottom_offset: number | null;
     vui_parameters: VuiParameters | null;
+    pic_order_cnt_type: number;
 };
 export type AvcProfileInfo = {
     spsData: SpsInfo;
@@ -42,10 +45,6 @@ export type AvcPPs = {
     type: 'avc-pps';
     pps: Uint8Array;
 };
-export type AvcInfo = AvcProfileInfo | AvcPPs | {
-    type: 'keyframe';
-} | {
-    type: 'delta-frame';
-};
-export declare const parseAvc: (buffer: Uint8Array) => AvcInfo[];
+export type AvcInfo = AvcProfileInfo | AvcPPs | MediaParserAvcKeyframeInfo | MediaParserAvcDeltaFrameInfo;
+export declare const parseAvc: (buffer: Uint8Array, avcState: AvcState) => AvcInfo[];
 export {};

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

@@ -5,6 +5,37 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseAvc = void 0;
 const buffer_iterator_1 = require("../../iterator/buffer-iterator");
 const Extended_SAR = 255;
+const getPoc = (iterator, sps, avcState, isReferencePicture) => {
+    const { pic_order_cnt_type, log2_max_pic_order_cnt_lsb_minus4 } = sps;
+    if (pic_order_cnt_type !== 0) {
+        return null;
+    }
+    const prevPicOrderCntLsb = avcState.getPrevPicOrderCntLsb();
+    const prevPicOrderCntMsb = avcState.getPrevPicOrderCntMsb();
+    if (log2_max_pic_order_cnt_lsb_minus4 === null) {
+        throw new Error('log2_max_pic_order_cnt_lsb_minus4 is null');
+    }
+    const max_pic_order_cnt_lsb = 2 ** (log2_max_pic_order_cnt_lsb_minus4 + 4);
+    const pic_order_cnt_lsb = iterator.getBits(log2_max_pic_order_cnt_lsb_minus4 + 4);
+    let picOrderCntMsb;
+    if (pic_order_cnt_lsb < prevPicOrderCntLsb &&
+        prevPicOrderCntLsb - pic_order_cnt_lsb >= max_pic_order_cnt_lsb / 2) {
+        picOrderCntMsb = prevPicOrderCntMsb + max_pic_order_cnt_lsb;
+    }
+    else if (pic_order_cnt_lsb > prevPicOrderCntLsb &&
+        pic_order_cnt_lsb - prevPicOrderCntLsb > max_pic_order_cnt_lsb / 2) {
+        picOrderCntMsb = prevPicOrderCntMsb - max_pic_order_cnt_lsb;
+    }
+    else {
+        picOrderCntMsb = prevPicOrderCntMsb;
+    }
+    const poc = picOrderCntMsb + pic_order_cnt_lsb;
+    if (isReferencePicture) {
+        avcState.setPrevPicOrderCntLsb(pic_order_cnt_lsb);
+        avcState.setPrevPicOrderCntMsb(picOrderCntMsb);
+    }
+    return poc;
+};
 const readVuiParameters = (iterator) => {
     let sar_width = null;
     let sar_height = null;
@@ -168,6 +199,7 @@ const readSps = (iterator) => {
         frame_crop_top_offset,
         mb_adaptive_frame_field_flag,
         vui_parameters,
+        pic_order_cnt_type,
     };
 };
 const findEnd = (buffer) => {
@@ -185,17 +217,23 @@ const findEnd = (buffer) => {
     }
     return null;
 };
-const inspect = (buffer) => {
+const inspect = (buffer, avcState) => {
     const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(buffer, buffer.byteLength);
     iterator.startReadingBits();
-    iterator.getBits(1);
-    iterator.getBits(2);
-    const type = iterator.getBits(5);
-    iterator.stopReadingBits();
+    iterator.getBits(1); // forbidden_zero_bit
+    const nal_ref_idc = iterator.getBits(2); // nal_ref_idc
+    const isReferencePicture = nal_ref_idc !== 0;
+    const type = iterator.getBits(5); // nal_unit_type
     if (type === 7) {
+        iterator.stopReadingBits();
         const end = findEnd(buffer);
         const data = readSps(iterator);
         const sps = buffer.slice(0, end === null ? Infinity : end);
+        avcState.setSps(data);
+        if (isReferencePicture) {
+            avcState.setPrevPicOrderCntLsb(0);
+            avcState.setPrevPicOrderCntMsb(0);
+        }
         return {
             spsData: data,
             sps,
@@ -203,11 +241,31 @@ const inspect = (buffer) => {
         };
     }
     if (type === 5) {
+        avcState.setPrevPicOrderCntLsb(0);
+        avcState.setPrevPicOrderCntMsb(0);
+        iterator.readExpGolomb(); // ignore first_mb_in_slice
+        iterator.readExpGolomb(); // slice_type
+        iterator.readExpGolomb(); // pic_parameter_set_id
+        const sps = avcState.getSps();
+        if (!sps) {
+            throw new Error('SPS not found');
+        }
+        const numberOfBitsForFrameNum = sps.log2_max_frame_num_minus4 + 4;
+        iterator.getBits(numberOfBitsForFrameNum); // frame_num
+        iterator.readExpGolomb(); // idr_pic_id
+        const { pic_order_cnt_type } = sps;
+        let poc = null;
+        if (pic_order_cnt_type === 0) {
+            poc = getPoc(iterator, sps, avcState, isReferencePicture);
+        }
+        iterator.stopReadingBits();
         return {
             type: 'keyframe',
+            poc,
         };
     }
     if (type === 8) {
+        iterator.stopReadingBits();
         const end = findEnd(buffer);
         const pps = buffer.slice(0, end === null ? Infinity : end);
         return {
@@ -216,15 +274,33 @@ const inspect = (buffer) => {
         };
     }
     if (type === 1) {
+        iterator.readExpGolomb(); // ignore first_mb_in_slice
+        const slice_type = iterator.readExpGolomb();
+        const isBidirectionalFrame = slice_type === 6;
+        iterator.readExpGolomb(); // pic_parameter_set_id
+        const sps = avcState.getSps();
+        if (!sps) {
+            throw new Error('SPS not found');
+        }
+        const numberOfBitsForFrameNum = sps.log2_max_frame_num_minus4 + 4;
+        iterator.getBits(numberOfBitsForFrameNum); // frame_num
+        const { pic_order_cnt_type } = sps;
+        let poc = null;
+        if (pic_order_cnt_type === 0) {
+            poc = getPoc(iterator, sps, avcState, isReferencePicture);
+        }
+        iterator.stopReadingBits();
         return {
             type: 'delta-frame',
+            isBidirectionalFrame,
+            poc,
         };
     }
     iterator.destroy();
     return null;
 };
 // https://stackoverflow.com/questions/24884827/possible-locations-for-sequence-picture-parameter-sets-for-h-264-stream
-const parseAvc = (buffer) => {
+const parseAvc = (buffer, avcState) => {
     let zeroesInARow = 0;
     const infos = [];
     for (let i = 0; i < buffer.length; i++) {
@@ -235,7 +311,7 @@ const parseAvc = (buffer) => {
         }
         if (zeroesInARow >= 2 && val === 1) {
             zeroesInARow = 0;
-            const info = inspect(buffer.slice(i + 1, i + 100));
+            const info = inspect(buffer.slice(i + 1, i + 100), avcState);
             if (info) {
                 infos.push(info);
                 if (info.type === 'keyframe' || info.type === 'delta-frame') {

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

@@ -43,6 +43,7 @@ const parseStreamInfo = async ({ iterator, state, }) => {
             sampleRate,
             timescale: 1000000,
             trackId: 0,
+            startInSeconds: 0,
         },
         registerAudioSampleCallback: state.callbacks.registerAudioSampleCallback,
         tracks: state.callbacks.tracks,

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

@@ -1,4 +1,5 @@
 import type { BaseBox } from './base-type';
+import type { ElstBox } from './elst';
 import type { EsdsBox } from './esds/esds';
 import type { FtypBox } from './ftyp';
 import type { MdhdBox } from './mdhd';
@@ -34,4 +35,4 @@ export interface RegularBox extends BaseBox {
     offset: number;
     type: 'regular-box';
 }
-export type IsoBaseMediaBox = RegularBox | FtypBox | MvhdBox | TkhdBox | StsdBox | MebxBox | KeysBox | MoovBox | TrakBox | SttsBox | MdhdBox | IlstBox | EsdsBox | StszBox | StcoBox | StscBox | AvccBox | HvccBox | VoidBox | StssBox | PaspBox | CttsBox | Av1CBox | TrunBox | HdlrBox | ColorParameterBox | TfdtBox | TfhdBox | TfraBox;
+export type IsoBaseMediaBox = RegularBox | FtypBox | MvhdBox | TkhdBox | StsdBox | ElstBox | MebxBox | KeysBox | MoovBox | TrakBox | SttsBox | MdhdBox | IlstBox | EsdsBox | StszBox | StcoBox | StscBox | AvccBox | HvccBox | VoidBox | StssBox | PaspBox | CttsBox | Av1CBox | TrunBox | HdlrBox | ColorParameterBox | TfdtBox | TfhdBox | TfraBox;

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

@@ -0,0 +1,19 @@
+import type { BufferIterator } from '../../iterator/buffer-iterator';
+import type { BaseBox } from './base-type';
+export interface ElstBox extends BaseBox {
+    type: 'elst-box';
+    version: number;
+    flags: number;
+    entries: ElstEntry[];
+}
+export type ElstEntry = {
+    editDuration: number;
+    mediaTime: number;
+    mediaRateInteger: number;
+    mediaRateFraction: number;
+};
+export declare const parseElst: ({ iterator, size, offset, }: {
+    iterator: BufferIterator;
+    size: number;
+    offset: number;
+}) => ElstBox;

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseElst = void 0;
+const parseElst = ({ iterator, size, offset, }) => {
+    const { expectNoMoreBytes } = iterator.startBox(size - 8);
+    const version = iterator.getUint8();
+    const flags = iterator.getUint24();
+    const entryCount = iterator.getUint32();
+    const entries = [];
+    for (let i = 0; i < entryCount; i++) {
+        const editDuration = iterator.getUint32();
+        const mediaTime = iterator.getInt32();
+        const mediaRateInteger = iterator.getUint16();
+        const mediaRateFraction = iterator.getUint16();
+        entries.push({
+            editDuration,
+            mediaTime,
+            mediaRateInteger,
+            mediaRateFraction,
+        });
+    }
+    expectNoMoreBytes();
+    const result = {
+        type: 'elst-box',
+        version,
+        flags,
+        entries,
+        boxSize: size,
+        offset,
+    };
+    return result;
+};
+exports.parseElst = parseElst;

package/dist/containers/iso-base-media/find-keyframe-before-time.d.ts

@@ -1,10 +1,11 @@
 import type { SamplePosition } from '../../get-sample-positions';
 import type { MediaParserLogLevel } from '../../log';
 import type { MediaSection } from '../../state/video-section';
-export declare const findKeyframeBeforeTime: ({ samplePositions, time, timescale, mediaSections, logLevel, }: {
+export declare const findKeyframeBeforeTime: ({ samplePositions, time, timescale, mediaSections, logLevel, startInSeconds, }: {
     samplePositions: SamplePosition[];
     time: number;
     timescale: number;
     mediaSections: MediaSection[];
     logLevel: MediaParserLogLevel;
+    startInSeconds: number;
 }) => number | null;

package/dist/containers/iso-base-media/find-keyframe-before-time.js

@@ -2,12 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.findKeyframeBeforeTime = void 0;
 const log_1 = require("../../log");
-const findKeyframeBeforeTime = ({ samplePositions, time, timescale, mediaSections, logLevel, }) => {
+const findKeyframeBeforeTime = ({ samplePositions, time, timescale, mediaSections, logLevel, startInSeconds, }) => {
     let videoByte = 0;
     let videoSample = null;
     for (const sample of samplePositions) {
-        const ctsInSeconds = sample.cts / timescale;
-        const dtsInSeconds = sample.dts / timescale;
+        const ctsInSeconds = sample.cts / timescale + startInSeconds;
+        const dtsInSeconds = sample.dts / timescale + startInSeconds;
         if (!sample.isKeyframe) {
             continue;
         }

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

@@ -79,6 +79,7 @@ const getMoovAtom = async ({ endOfMdat, state, }) => {
             onlyIfMoovAtomExpected: {
                 tracks: tracksState,
                 isoState: null,
+                movieTimeScaleState: state.iso.movieTimeScale,
                 onAudioTrack,
                 onVideoTrack,
                 registerVideoSampleCallback: () => Promise.resolve(),

package/dist/containers/iso-base-media/get-seeking-byte-from-fragmented-mp4.js

@@ -54,6 +54,7 @@ const getSeekingByteFromFragmentedMp4 = async ({ info, time, logLevel, currentPo
                 timescale: firstTrack.timescale,
                 logLevel,
                 mediaSections: info.mediaSections,
+                startInSeconds: firstTrack.startInSeconds,
             });
             if (kf) {
                 return {

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

@@ -53,6 +53,7 @@ const getSeekingByteFromIsoBaseMedia = ({ info, time, logLevel, currentPosition,
         timescale: track.timescale,
         logLevel,
         mediaSections: info.mediaSections,
+        startInSeconds: track.startInSeconds,
     });
     if (keyframe) {
         return Promise.resolve({

package/dist/containers/iso-base-media/make-track.d.ts

@@ -1,3 +1,3 @@
 import type { MediaParserAudioTrack, MediaParserOtherTrack, MediaParserVideoTrack } from '../../get-tracks';
 import type { TrakBox } from './trak/trak';
-export declare const makeBaseMediaTrack: (trakBox: TrakBox) => MediaParserVideoTrack | MediaParserAudioTrack | MediaParserOtherTrack | null;
+export declare const makeBaseMediaTrack: (trakBox: TrakBox, startTimeInSeconds: number) => MediaParserVideoTrack | MediaParserAudioTrack | MediaParserOtherTrack | null;

package/dist/containers/iso-base-media/make-track.js

@@ -9,7 +9,7 @@ const color_to_webcodecs_colors_1 = require("./color-to-webcodecs-colors");
 const get_actual_number_of_channels_1 = require("./get-actual-number-of-channels");
 const get_video_codec_from_iso_track_1 = require("./get-video-codec-from-iso-track");
 const traversal_1 = require("./traversal");
-const makeBaseMediaTrack = (trakBox) => {
+const makeBaseMediaTrack = (trakBox, startTimeInSeconds) => {
     var _a, _b, _c, _d, _e;
     const tkhdBox = (0, traversal_1.getTkhdBox)(trakBox);
     const videoDescriptors = (0, traversal_1.getVideoDescriptors)(trakBox);
@@ -48,6 +48,7 @@ const makeBaseMediaTrack = (trakBox) => {
             description: (_d = (_c = actual.codecPrivate) === null || _c === void 0 ? void 0 : _c.data) !== null && _d !== void 0 ? _d : undefined,
             codecData: actual.codecPrivate,
             codecEnum,
+            startInSeconds: startTimeInSeconds,
         };
     }
     if (!(0, get_fps_1.trakBoxContainsVideo)(trakBox)) {
@@ -56,6 +57,7 @@ const makeBaseMediaTrack = (trakBox) => {
             trackId: tkhdBox.trackId,
             timescale: timescaleAndDuration.timescale,
             trakBox,
+            startInSeconds: startTimeInSeconds,
         };
     }
     const videoSample = (0, get_sample_aspect_ratio_1.getStsdVideoConfig)(trakBox);
@@ -104,6 +106,7 @@ const makeBaseMediaTrack = (trakBox) => {
         advancedColor,
         codecEnum: (0, get_video_codec_from_iso_track_1.getVideoCodecFromIsoTrak)(trakBox),
         fps: (0, get_fps_1.getFpsFromMp4TrakBox)(trakBox),
+        startInSeconds: startTimeInSeconds,
     };
     return track;
 };

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

@@ -0,0 +1,5 @@
+import type { TrakBox } from '../trak/trak';
+export declare const findTrackStartTimeInSeconds: ({ movieTimeScale, trakBox, }: {
+    movieTimeScale: number;
+    trakBox: TrakBox;
+}) => number;

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findTrackStartTimeInSeconds = void 0;
+const traversal_1 = require("../traversal");
+const findTrackStartTimeInSeconds = ({ movieTimeScale, trakBox, }) => {
+    const elstBox = (0, traversal_1.getElstBox)(trakBox);
+    if (!elstBox) {
+        return 0;
+    }
+    const { entries } = elstBox;
+    let dwellTime = 0;
+    for (const entry of entries) {
+        const { editDuration, mediaTime } = entry;
+        if (mediaTime !== -1) {
+            continue;
+        }
+        dwellTime += editDuration;
+    }
+    return dwellTime / movieTimeScale;
+};
+exports.findTrackStartTimeInSeconds = findTrackStartTimeInSeconds;

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

@@ -107,7 +107,10 @@ const parseMdatSection = async (state) => {
     if (iterator.bytesRemaining() < samplesWithIndex.samplePosition.size) {
         return (0, skip_1.makeFetchMoreData)(samplesWithIndex.samplePosition.size - iterator.bytesRemaining());
     }
-    const { cts, dts, duration, isKeyframe, offset, bigEndian, chunkSize } = samplesWithIndex.samplePosition;
+    const { cts: rawCts, dts: rawDts, duration, isKeyframe, offset, bigEndian, chunkSize, } = samplesWithIndex.samplePosition;
+    const { timescale, startInSeconds } = samplesWithIndex.track;
+    const cts = rawCts + startInSeconds * timescale;
+    const dts = rawDts + startInSeconds * timescale;
     const bytes = (0, postprocess_bytes_1.postprocessBytes)({
         bytes: iterator.getSlice(samplesWithIndex.samplePosition.size),
         bigEndian,
@@ -124,9 +127,9 @@ const parseMdatSection = async (state) => {
                 trackId: samplesWithIndex.track.trackId,
                 type: isKeyframe ? 'key' : 'delta',
                 offset,
-                timescale: samplesWithIndex.track.timescale,
+                timescale,
             },
-            timescale: samplesWithIndex.track.timescale,
+            timescale,
         });
         await state.callbacks.onAudioSample(samplesWithIndex.track.trackId, audioSample);
     }
@@ -153,9 +156,9 @@ const parseMdatSection = async (state) => {
                 trackId: samplesWithIndex.track.trackId,
                 type: isKeyframe && !isRecoveryPoint ? 'key' : 'delta',
                 offset,
-                timescale: samplesWithIndex.track.timescale,
+                timescale,
             },
-            timescale: samplesWithIndex.track.timescale,
+            timescale,
         });
         await state.callbacks.onVideoSample(samplesWithIndex.track.trackId, videoSample);
     }

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

@@ -15,6 +15,7 @@ const parseIsoBaseMedia = async (state) => {
         onlyIfMoovAtomExpected: {
             tracks: state.callbacks.tracks,
             isoState: state.iso,
+            movieTimeScaleState: state.iso.movieTimeScale,
             onAudioTrack: state.onAudioTrack,
             onVideoTrack: state.onVideoTrack,
             registerAudioSampleCallback: state.callbacks.registerAudioSampleCallback,

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

@@ -3,6 +3,7 @@ import type { MediaParserLogLevel } from '../../log';
 import type { FetchMoreData } from '../../skip';
 import type { TracksState } from '../../state/has-tracks-section';
 import type { IsoBaseMediaState } from '../../state/iso-base-media/iso-state';
+import type { MovieTimeScaleState } from '../../state/iso-base-media/timescale-state';
 import type { CallbacksState } from '../../state/sample-callbacks';
 import type { MediaSectionState } from '../../state/video-section';
 import type { MediaParserOnAudioTrack, MediaParserOnVideoTrack } from '../../webcodec-sample-types';
@@ -10,6 +11,7 @@ import type { IsoBaseMediaBox } from './base-media-box';
 export type OnlyIfMoovAtomExpected = {
     tracks: TracksState;
     isoState: IsoBaseMediaState | null;
+    movieTimeScaleState: MovieTimeScaleState;
     onVideoTrack: MediaParserOnVideoTrack | null;
     onAudioTrack: MediaParserOnAudioTrack | null;
     registerVideoSampleCallback: CallbacksState['registerVideoSampleCallback'];

package/dist/containers/iso-base-media/process-box.js

@@ -4,10 +4,12 @@ exports.processBox = void 0;
 const log_1 = require("../../log");
 const register_track_1 = require("../../register-track");
 const skip_1 = require("../../skip");
+const elst_1 = require("./elst");
 const esds_1 = require("./esds/esds");
 const ftyp_1 = require("./ftyp");
 const get_children_1 = require("./get-children");
 const make_track_1 = require("./make-track");
+const get_editlist_1 = require("./mdat/get-editlist");
 const mdhd_1 = require("./mdhd");
 const hdlr_1 = require("./meta/hdlr");
 const ilst_1 = require("./meta/ilst");
@@ -84,6 +86,16 @@ const processBox = async ({ iterator, logLevel, onlyIfMoovAtomExpected, onlyIfMd
             box: (0, ftyp_1.parseFtyp)({ iterator, size: boxSize, offset: fileOffset }),
         };
     }
+    if (boxType === 'elst') {
+        return {
+            type: 'box',
+            box: (0, elst_1.parseElst)({
+                iterator,
+                size: boxSize,
+                offset: fileOffset,
+            }),
+        };
+    }
     if (boxType === 'colr') {
         return {
             type: 'box',
@@ -94,9 +106,18 @@ const processBox = async ({ iterator, logLevel, onlyIfMoovAtomExpected, onlyIfMd
         };
     }
     if (boxType === 'mvhd') {
+        const mvhdBox = (0, mvhd_1.parseMvhd)({
+            iterator,
+            offset: fileOffset,
+            size: boxSize,
+        });
+        if (!onlyIfMoovAtomExpected) {
+            throw new Error('State is required');
+        }
+        onlyIfMoovAtomExpected.movieTimeScaleState.setTrackTimescale(mvhdBox.timeScale);
         return {
             type: 'box',
-            box: (0, mvhd_1.parseMvhd)({ iterator, offset: fileOffset, size: boxSize }),
+            box: mvhdBox,
         };
     }
     if (boxType === 'tkhd') {
@@ -266,14 +287,19 @@ const processBox = async ({ iterator, logLevel, onlyIfMoovAtomExpected, onlyIfMd
             throw new Error('State is required');
         }
         const { tracks, onAudioTrack, onVideoTrack } = onlyIfMoovAtomExpected;
-        const box = await (0, trak_1.parseTrak)({
+        const trakBox = await (0, trak_1.parseTrak)({
             size: boxSize,
             offsetAtStart: fileOffset,
             iterator,
             logLevel,
             contentLength,
         });
-        const transformedTrack = (0, make_track_1.makeBaseMediaTrack)(box);
+        const movieTimeScale = onlyIfMoovAtomExpected.movieTimeScaleState.getTrackTimescale();
+        if (movieTimeScale === null) {
+            throw new Error('Movie timescale is not set');
+        }
+        const editList = (0, get_editlist_1.findTrackStartTimeInSeconds)({ movieTimeScale, trakBox });
+        const transformedTrack = (0, make_track_1.makeBaseMediaTrack)(trakBox, editList);
         if (transformedTrack && transformedTrack.type === 'video') {
             await (0, register_track_1.registerVideoTrack)({
                 track: transformedTrack,
@@ -294,7 +320,7 @@ const processBox = async ({ iterator, logLevel, onlyIfMoovAtomExpected, onlyIfMd
                 onAudioTrack,
             });
         }
-        return { type: 'box', box };
+        return { type: 'box', box: trakBox };
     }
     if (boxType === 'stts') {
         return {
@@ -377,6 +403,7 @@ const processBox = async ({ iterator, logLevel, onlyIfMoovAtomExpected, onlyIfMd
         boxType === 'wave' ||
         boxType === 'traf' ||
         boxType === 'mfra' ||
+        boxType === 'edts' ||
         boxType === 'stsb') {
         const children = await (0, get_children_1.getIsoBaseMediaChildren)({
             iterator,

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

@@ -3,6 +3,7 @@ import type { IsoBaseMediaState } from '../../state/iso-base-media/iso-state';
 import type { MoofBox } from '../../state/iso-base-media/precomputed-moof';
 import type { StructureState } from '../../state/structure';
 import type { IsoBaseMediaBox, RegularBox } from './base-media-box';
+import type { ElstBox } from './elst';
 import type { FtypBox } from './ftyp';
 import type { MdhdBox } from './mdhd';
 import type { TfraBox } from './mfra/tfra';
@@ -49,3 +50,4 @@ export declare const getTrunBoxes: (segment: IsoBaseMediaBox) => TrunBox[];
 export declare const getTfraBoxesFromMfraBoxChildren: (mfraBoxChildren: IsoBaseMediaBox[]) => TfraBox[];
 export declare const getTfraBoxes: (structure: IsoBaseMediaBox[]) => TfraBox[];
 export declare const getTrakBoxByTrackId: (moovBox: MoovBox, trackId: number) => TrakBox | null;
+export declare const getElstBox: (trakBox: TrakBox) => ElstBox | null;