@remotion/media-parser 4.0.231 → 4.0.232

package/dist/add-avc-profile-to-track.d.ts

@@ -0,0 +1,3 @@
+import type { VideoTrack } from './get-tracks';
+import type { SpsAndPps } from './parser-state';
+export declare const addAvcProfileToTrack: (track: VideoTrack, avc1Profile: SpsAndPps | null) => VideoTrack;

package/dist/add-avc-profile-to-track.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addAvcProfileToTrack = void 0;
+const make_header_1 = require("./boxes/webm/make-header");
+const addAvcProfileToTrack = (track, avc1Profile) => {
+    if (avc1Profile === null) {
+        return track;
+    }
+    return {
+        ...track,
+        codec: `avc1.${avc1Profile.sps.profile.toString(16).padStart(2, '0')}${avc1Profile.sps.compatibility.toString(16).padStart(2, '0')}${avc1Profile.sps.level.toString(16).padStart(2, '0')}`,
+        codecPrivate: (0, make_header_1.combineUint8Arrays)([
+            new Uint8Array([
+                // https://gist.github.com/uupaa/8493378ec15f644a3d2b
+                1,
+                avc1Profile.sps.level,
+                avc1Profile.sps.compatibility,
+                avc1Profile.sps.profile,
+                0xff,
+                0xe1,
+            ]),
+            // sequence parameter set length
+            (0, make_header_1.serializeUint16)(avc1Profile.sps.sps.length),
+            // sequence parameter set
+            avc1Profile.sps.sps,
+            // num of PPS
+            new Uint8Array([0x01]),
+            // picture parameter set length
+            (0, make_header_1.serializeUint16)(avc1Profile.pps.pps.length),
+            // PPS
+            avc1Profile.pps.pps,
+        ]),
+    };
+};
+exports.addAvcProfileToTrack = addAvcProfileToTrack;

package/dist/add-new-matroska-tracks.d.ts

@@ -1,4 +1,4 @@
-import type { Track } from './get-tracks';
+import type { Track, VideoTrack } from './get-tracks';
 import type { ParserContext } from './parser-context';
 import type { ParserState } from './parser-state';
 export declare const registerTrack: ({ state, options, track, }: {
@@ -6,3 +6,8 @@ export declare const registerTrack: ({ state, options, track, }: {
     options: ParserContext;
     track: Track;
 }) => Promise<void>;
+export declare const registerVideoTrackWhenProfileIsAvailable: ({ options, state, track, }: {
+    state: ParserState;
+    options: ParserContext;
+    track: VideoTrack;
+}) => void;

package/dist/add-new-matroska-tracks.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerTrack = void 0;
+exports.registerVideoTrackWhenProfileIsAvailable = exports.registerTrack = void 0;
 const registerTrack = async ({ state, options, track, }) => {
     if (track.type === 'video' && options.onVideoTrack) {
         const callback = await options.onVideoTrack(track);
@@ -12,3 +12,18 @@ const registerTrack = async ({ state, options, track, }) => {
     }
 };
 exports.registerTrack = registerTrack;
+const registerVideoTrackWhenProfileIsAvailable = ({ options, state, track, }) => {
+    state.registerOnAvcProfileCallback(async (profile) => {
+        const newTrack = {
+            ...track,
+            codec: 'avc1...',
+        };
+        console.log(profile, newTrack);
+        await (0, exports.registerTrack)({
+            options,
+            state,
+            track: newTrack,
+        });
+    });
+};
+exports.registerVideoTrackWhenProfileIsAvailable = registerVideoTrackWhenProfileIsAvailable;

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

@@ -0,0 +1,18 @@
+export type AvcProfileInfo = {
+    profile: number;
+    level: number;
+    compatibility: number;
+    sps: Uint8Array;
+    type: 'avc-profile';
+};
+export type AvcPPs = {
+    type: 'avc-pps';
+    pps: Uint8Array;
+};
+type AvcInfo = AvcProfileInfo | AvcPPs | {
+    type: 'keyframe';
+} | {
+    type: 'delta-frame';
+};
+export declare const parseAvc: (buffer: Uint8Array) => AvcInfo[];
+export {};

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

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAvc = void 0;
+const buffer_iterator_1 = require("../../buffer-iterator");
+const readSps = (iterator) => {
+    const profile = iterator.getUint8();
+    const compatibility = iterator.getUint8();
+    const level = iterator.getUint8();
+    return {
+        profile,
+        compatibility,
+        level,
+    };
+};
+const findEnd = (buffer) => {
+    let zeroesInARow = 0;
+    for (let i = 0; i < buffer.length; i++) {
+        const val = buffer[i];
+        if (val === 0) {
+            zeroesInARow++;
+            continue;
+        }
+        if (zeroesInARow >= 2 && val === 1) {
+            return i - zeroesInARow;
+        }
+        zeroesInARow = 0;
+    }
+    return null;
+};
+const inspect = (buffer) => {
+    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();
+    if (type === 7) {
+        const end = findEnd(buffer);
+        const data = readSps(iterator);
+        const sps = buffer.slice(1, end === null ? Infinity : end);
+        return {
+            level: data.level,
+            profile: data.profile,
+            compatibility: data.compatibility,
+            sps,
+            type: 'avc-profile',
+        };
+    }
+    if (type === 5) {
+        return {
+            type: 'keyframe',
+        };
+    }
+    if (type === 8) {
+        const end = findEnd(buffer);
+        const pps = buffer.slice(0, end === null ? Infinity : end);
+        return {
+            type: 'avc-pps',
+            pps,
+        };
+    }
+    if (type === 1) {
+        return {
+            type: 'delta-frame',
+        };
+    }
+    iterator.destroy();
+    return null;
+};
+// https://stackoverflow.com/questions/24884827/possible-locations-for-sequence-picture-parameter-sets-for-h-264-stream
+const parseAvc = (buffer) => {
+    let zeroesInARow = 0;
+    const infos = [];
+    for (let i = 0; i < buffer.length; i++) {
+        const val = buffer[i];
+        if (val === 0) {
+            zeroesInARow++;
+            continue;
+        }
+        if (zeroesInARow >= 2 && val === 1) {
+            zeroesInARow = 0;
+            const info = inspect(buffer.slice(i + 1, i + 100));
+            if (info) {
+                infos.push(info);
+                if (info.type === 'keyframe' || info.type === 'delta-frame') {
+                    break;
+                }
+            }
+        }
+        if (val !== 1) {
+            zeroesInARow = 0;
+        }
+    }
+    return infos;
+};
+exports.parseAvc = parseAvc;

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

@@ -7,7 +7,7 @@ const get_sample_aspect_ratio_1 = require("../../get-sample-aspect-ratio");
 const get_video_codec_1 = require("../../get-video-codec");
 const traversal_1 = require("./traversal");
 const makeBaseMediaTrack = (trakBox) => {
-    var _a;
+    var _a, _b, _c;
     const tkhdBox = (0, traversal_1.getTkhdBox)(trakBox);
     const videoDescriptors = (0, traversal_1.getVideoDescriptors)(trakBox);
     const timescaleAndDuration = (0, get_fps_1.getTimescaleAndDuration)(trakBox);
@@ -36,7 +36,7 @@ const makeBaseMediaTrack = (trakBox) => {
             sampleRate,
             description,
             trakBox,
-            codecPrivate: (0, get_audio_codec_1.getCodecPrivateFromTrak)(trakBox),
+            codecPrivate: (_b = (_a = (0, get_audio_codec_1.getCodecPrivateFromTrak)(trakBox)) !== null && _a !== void 0 ? _a : description) !== null && _b !== void 0 ? _b : null,
             codecWithoutConfig: (0, get_audio_codec_1.getAudioCodecFromTrack)(trakBox),
         };
     }
@@ -84,7 +84,7 @@ const makeBaseMediaTrack = (trakBox) => {
         rotation,
         trakBox,
         codecPrivate: privateData,
-        color: (_a = (0, get_video_codec_1.getIsoBmColrConfig)(trakBox)) !== null && _a !== void 0 ? _a : {
+        color: (_c = (0, get_video_codec_1.getIsoBmColrConfig)(trakBox)) !== null && _c !== void 0 ? _c : {
             fullRange: null,
             matrixCoefficients: null,
             primaries: null,

package/dist/boxes/iso-base-media/mdat/mdat.d.ts

@@ -1,5 +1,5 @@
 import type { BufferIterator } from '../../../buffer-iterator';
-import type { AnySegment } from '../../../parse-result';
+import type { IsoBaseMediaBox } from '../../../parse-result';
 import type { ParserContext } from '../../../parser-context';
 type MdatStatus = {
     status: 'samples-buffered';
@@ -17,7 +17,7 @@ export declare const parseMdat: ({ data, size, fileOffset, existingBoxes, option
     data: BufferIterator;
     size: number;
     fileOffset: number;
-    existingBoxes: AnySegment[];
+    existingBoxes: IsoBaseMediaBox[];
     options: ParserContext;
     signal: AbortSignal | null;
     maySkipSampleProcessing: boolean;

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

@@ -5,7 +5,10 @@ const get_tracks_1 = require("../../../get-tracks");
 const get_sample_positions_from_track_1 = require("../get-sample-positions-from-track");
 const traversal_1 = require("../traversal");
 const parseMdat = async ({ data, size, fileOffset, existingBoxes, options, signal, maySkipSampleProcessing, }) => {
-    const alreadyHas = (0, get_tracks_1.hasTracks)(existingBoxes);
+    const alreadyHas = (0, get_tracks_1.hasTracks)({
+        type: 'iso-base-media',
+        boxes: existingBoxes,
+    }, options.parserState);
     if (!alreadyHas) {
         if (maySkipSampleProcessing) {
             data.discard(size - (data.counter.getOffset() - fileOffset));
@@ -25,7 +28,7 @@ const parseMdat = async ({ data, size, fileOffset, existingBoxes, options, signa
             fileOffset,
         });
     }
-    const tracks = (0, get_tracks_1.getTracks)(existingBoxes, options.parserState);
+    const tracks = (0, get_tracks_1.getTracks)({ type: 'iso-base-media', boxes: existingBoxes }, options.parserState);
     const allTracks = [
         ...tracks.videoTracks,
         ...tracks.audioTracks,

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

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMoov = void 0;
 const process_box_1 = require("../process-box");
 const parseMoov = async ({ iterator, offset, size, options, signal, logLevel, }) => {
-    const children = await (0, process_box_1.parseBoxes)({
+    const children = await (0, process_box_1.parseIsoBaseMediaBoxes)({
         iterator,
         maxBytes: size - (iterator.counter.getOffset() - offset),
         allowIncompleteBoxes: false,
@@ -20,7 +20,7 @@ const parseMoov = async ({ iterator, offset, size, options, signal, logLevel, })
         offset,
         boxSize: size,
         type: 'moov-box',
-        children: children.segments,
+        children: children.segments.boxes,
     };
 };
 exports.parseMoov = parseMoov;

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

@@ -1,25 +1,25 @@
 import type { BufferIterator } from '../../buffer-iterator';
 import type { LogLevel } from '../../log';
-import type { AnySegment, IsoBaseMediaBox, ParseResult } from '../../parse-result';
+import type { IsoBaseMediaBox, IsoBaseMediaStructure, ParseResult } from '../../parse-result';
 import type { BoxAndNext, PartialMdatBox } from '../../parse-video';
 import type { ParserContext } from '../../parser-context';
 export declare const parseMdatPartially: ({ iterator, boxSize, fileOffset, parsedBoxes, options, signal, }: {
     iterator: BufferIterator;
     boxSize: number;
     fileOffset: number;
-    parsedBoxes: AnySegment[];
+    parsedBoxes: IsoBaseMediaBox[];
     options: ParserContext;
     signal: AbortSignal | null;
 }) => Promise<BoxAndNext>;
 export declare const processBox: ({ iterator, allowIncompleteBoxes, parsedBoxes, options, signal, logLevel, }: {
     iterator: BufferIterator;
     allowIncompleteBoxes: boolean;
-    parsedBoxes: AnySegment[];
+    parsedBoxes: IsoBaseMediaBox[];
     options: ParserContext;
     signal: AbortSignal | null;
     logLevel: LogLevel;
 }) => Promise<BoxAndNext>;
-export declare const parseBoxes: ({ iterator, maxBytes, allowIncompleteBoxes, initialBoxes, options, continueMdat, signal, logLevel, }: {
+export declare const parseIsoBaseMediaBoxes: ({ iterator, maxBytes, allowIncompleteBoxes, initialBoxes, options, continueMdat, signal, logLevel, }: {
     iterator: BufferIterator;
     maxBytes: number;
     allowIncompleteBoxes: boolean;
@@ -28,4 +28,4 @@ export declare const parseBoxes: ({ iterator, maxBytes, allowIncompleteBoxes, in
     continueMdat: false | PartialMdatBox;
     signal: AbortSignal | null;
     logLevel: LogLevel;
-}) => Promise<ParseResult>;
+}) => Promise<ParseResult<IsoBaseMediaStructure>>;

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

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseBoxes = exports.processBox = exports.parseMdatPartially = void 0;
+exports.parseIsoBaseMediaBoxes = exports.processBox = exports.parseMdatPartially = void 0;
 const get_tracks_1 = require("../../get-tracks");
+const register_track_1 = require("../../register-track");
 const esds_1 = require("./esds/esds");
 const ftyp_1 = require("./ftyp");
 const make_track_1 = require("./make-track");
@@ -39,7 +40,7 @@ const getChildren = async ({ boxType, iterator, bytesRemainingInBox, options, si
         boxType === 'stsb';
     if (parseChildren) {
         // eslint-disable-next-line @typescript-eslint/no-use-before-define
-        const parsed = await (0, exports.parseBoxes)({
+        const parsed = await (0, exports.parseIsoBaseMediaBoxes)({
             iterator,
             maxBytes: bytesRemainingInBox,
             allowIncompleteBoxes: false,
@@ -52,7 +53,7 @@ const getChildren = async ({ boxType, iterator, bytesRemainingInBox, options, si
         if (parsed.status === 'incomplete') {
             throw new Error('Incomplete boxes are not allowed');
         }
-        return parsed.segments;
+        return parsed.segments.boxes;
     }
     if (bytesRemainingInBox < 0) {
         throw new Error('Box size is too big ' + JSON.stringify({ boxType }));
@@ -87,7 +88,6 @@ const parseMdatPartially = async ({ iterator, boxSize, fileOffset, parsedBoxes,
 };
 exports.parseMdatPartially = parseMdatPartially;
 const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options, signal, logLevel, }) => {
-    var _a, _b;
     const fileOffset = iterator.counter.getOffset();
     const bytesRemaining = iterator.bytesRemaining();
     const boxSizeRaw = iterator.getFourByteNumber();
@@ -117,7 +117,8 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options
     const boxSize = boxSizeRaw === 1 ? iterator.getEightByteNumber() : boxSizeRaw;
     if (bytesRemaining < boxSize) {
         if (boxType === 'mdat') {
-            const shouldSkip = (options.canSkipVideoData || !(0, get_tracks_1.hasTracks)(parsedBoxes)) &&
+            const shouldSkip = (options.canSkipVideoData ||
+                !(0, get_tracks_1.hasTracks)({ type: 'iso-base-media', boxes: parsedBoxes }, options.parserState)) &&
                 options.supportsContentRange;
             if (shouldSkip) {
                 const skipTo = fileOffset + boxSize;
@@ -349,14 +350,11 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options
         });
         const transformedTrack = (0, make_track_1.makeBaseMediaTrack)(box);
         if (transformedTrack) {
-            if (transformedTrack.type === 'audio') {
-                const callback = await ((_a = options.onAudioTrack) === null || _a === void 0 ? void 0 : _a.call(options, transformedTrack));
-                await options.parserState.registerAudioSampleCallback(transformedTrack.trackId, callback !== null && callback !== void 0 ? callback : null);
-            }
-            if (transformedTrack.type === 'video') {
-                const callback = await ((_b = options.onVideoTrack) === null || _b === void 0 ? void 0 : _b.call(options, transformedTrack));
-                await options.parserState.registerVideoSampleCallback(transformedTrack.trackId, callback !== null && callback !== void 0 ? callback : null);
-            }
+            await (0, register_track_1.registerTrack)({
+                options,
+                state: options.parserState,
+                track: transformedTrack,
+            });
         }
         return {
             type: 'complete',
@@ -498,10 +496,13 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, options
     };
 };
 exports.processBox = processBox;
-const parseBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBoxes, options, continueMdat, signal, logLevel, }) => {
-    let boxes = initialBoxes;
+const parseIsoBaseMediaBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBoxes, options, continueMdat, signal, logLevel, }) => {
+    const structure = {
+        type: 'iso-base-media',
+        boxes: initialBoxes,
+    };
     const initialOffset = iterator.counter.getOffset();
-    const alreadyHasMdat = boxes.find((b) => b.type === 'mdat-box');
+    const alreadyHasMdat = structure.boxes.find((b) => b.type === 'mdat-box');
     while (iterator.bytesRemaining() > 0 &&
         iterator.counter.getOffset() - initialOffset < maxBytes) {
         const result = continueMdat
@@ -527,13 +528,13 @@ const parseBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBox
             }
             return {
                 status: 'incomplete',
-                segments: boxes,
+                segments: structure,
                 continueParsing: () => {
-                    return (0, exports.parseBoxes)({
+                    return (0, exports.parseIsoBaseMediaBoxes)({
                         iterator,
                         maxBytes,
                         allowIncompleteBoxes,
-                        initialBoxes: boxes,
+                        initialBoxes: structure.boxes,
                         options,
                         continueMdat: false,
                         signal,
@@ -546,13 +547,13 @@ const parseBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBox
         if (result.type === 'partial-mdat-box') {
             return {
                 status: 'incomplete',
-                segments: boxes,
+                segments: structure,
                 continueParsing: () => {
-                    return Promise.resolve((0, exports.parseBoxes)({
+                    return Promise.resolve((0, exports.parseIsoBaseMediaBoxes)({
                         iterator,
                         maxBytes,
                         allowIncompleteBoxes,
-                        initialBoxes: boxes,
+                        initialBoxes: structure.boxes,
                         options,
                         continueMdat: result,
                         signal,
@@ -563,8 +564,8 @@ const parseBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBox
             };
         }
         if (result.box.type === 'mdat-box' && alreadyHasMdat) {
-            boxes = boxes.filter((b) => b.type !== 'mdat-box');
-            boxes.push(result.box);
+            structure.boxes = structure.boxes.filter((b) => b.type !== 'mdat-box');
+            structure.boxes.push(result.box);
             iterator.allowDiscard();
             if (result.box.status !== 'samples-processed') {
                 throw new Error('unexpected');
@@ -572,7 +573,7 @@ const parseBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBox
             break;
         }
         else {
-            boxes.push(result.box);
+            structure.boxes.push(result.box);
         }
         if (result.skipTo !== null) {
             if (!options.supportsContentRange) {
@@ -580,13 +581,13 @@ const parseBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBox
             }
             return {
                 status: 'incomplete',
-                segments: boxes,
+                segments: structure,
                 continueParsing: () => {
-                    return (0, exports.parseBoxes)({
+                    return (0, exports.parseIsoBaseMediaBoxes)({
                         iterator,
                         maxBytes,
                         allowIncompleteBoxes,
-                        initialBoxes: boxes,
+                        initialBoxes: structure.boxes,
                         options,
                         continueMdat: false,
                         signal,
@@ -599,13 +600,13 @@ const parseBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBox
         if (iterator.bytesRemaining() < 0) {
             return {
                 status: 'incomplete',
-                segments: boxes,
+                segments: structure,
                 continueParsing: () => {
-                    return (0, exports.parseBoxes)({
+                    return (0, exports.parseIsoBaseMediaBoxes)({
                         iterator,
                         maxBytes,
                         allowIncompleteBoxes,
-                        initialBoxes: boxes,
+                        initialBoxes: structure.boxes,
                         options,
                         continueMdat: false,
                         signal,
@@ -617,7 +618,7 @@ const parseBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBox
         }
         iterator.removeBytesRead();
     }
-    const mdatState = (0, traversal_1.getMdatBox)(boxes);
+    const mdatState = (0, traversal_1.getMdatBox)(structure.boxes);
     const skipped = (mdatState === null || mdatState === void 0 ? void 0 : mdatState.status) === 'samples-skipped' &&
         !options.canSkipVideoData &&
         options.supportsContentRange;
@@ -625,16 +626,16 @@ const parseBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBox
     if (skipped || buffered) {
         return {
             status: 'incomplete',
-            segments: boxes,
+            segments: structure,
             continueParsing: () => {
                 if (buffered) {
                     iterator.skipTo(mdatState.fileOffset, false);
                 }
-                return (0, exports.parseBoxes)({
+                return (0, exports.parseIsoBaseMediaBoxes)({
                     iterator,
                     maxBytes,
                     allowIncompleteBoxes: false,
-                    initialBoxes: boxes,
+                    initialBoxes: structure.boxes,
                     options,
                     continueMdat: false,
                     signal,
@@ -646,7 +647,7 @@ const parseBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBox
     }
     return {
         status: 'done',
-        segments: boxes,
+        segments: structure,
     };
 };
-exports.parseBoxes = parseBoxes;
+exports.parseIsoBaseMediaBoxes = parseIsoBaseMediaBoxes;

package/dist/boxes/iso-base-media/stsd/mebx.js

@@ -6,7 +6,7 @@ const parseMebx = async ({ iterator, offset, size, options, signal, }) => {
     // reserved, 6 bit
     iterator.discard(6);
     const dataReferenceIndex = iterator.getUint16();
-    const children = await (0, process_box_1.parseBoxes)({
+    const children = await (0, process_box_1.parseIsoBaseMediaBoxes)({
         iterator,
         maxBytes: iterator.counter.getOffset() - offset,
         allowIncompleteBoxes: false,
@@ -25,7 +25,7 @@ const parseMebx = async ({ iterator, offset, size, options, signal, }) => {
         offset,
         dataReferenceIndex,
         format: 'mebx',
-        children: children.segments,
+        children: children.segments.boxes,
     };
 };
 exports.parseMebx = parseMebx;

package/dist/boxes/iso-base-media/stsd/samples.d.ts

@@ -1,6 +1,6 @@
 import type { BufferIterator } from '../../../buffer-iterator';
 import type { LogLevel } from '../../../log';
-import type { AnySegment } from '../../../parse-result';
+import type { AnySegment, IsoBaseMediaBox } from '../../../parse-result';
 import type { ParserContext } from '../../../parser-context';
 type SampleBase = {
     format: string;
@@ -37,7 +37,7 @@ export type VideoSample = SampleBase & {
     frameCountPerSample: number;
     depth: number;
     colorTableId: number;
-    descriptors: AnySegment[];
+    descriptors: IsoBaseMediaBox[];
     version: number;
     revisionLevel: number;
     vendor: number[];

package/dist/boxes/iso-base-media/stsd/samples.js

@@ -98,7 +98,7 @@ const processSample = async ({ iterator, options, signal, logLevel, }) => {
             const packetSize = iterator.getUint16();
             const sampleRate = iterator.getFixedPointUnsigned1616Number();
             const bytesRemainingInBox = boxSize - (iterator.counter.getOffset() - fileOffset);
-            const children = await (0, process_box_1.parseBoxes)({
+            const children = await (0, process_box_1.parseIsoBaseMediaBoxes)({
                 iterator,
                 allowIncompleteBoxes: false,
                 maxBytes: bytesRemainingInBox,
@@ -130,7 +130,7 @@ const processSample = async ({ iterator, options, signal, logLevel, }) => {
                     bytesPerPacket: null,
                     bytesPerFrame: null,
                     bitsPerSample: null,
-                    children: children.segments,
+                    children: children.segments.boxes,
                 },
             };
         }
@@ -145,7 +145,7 @@ const processSample = async ({ iterator, options, signal, logLevel, }) => {
             const bytesPerFrame = iterator.getUint32();
             const bytesPerSample = iterator.getUint32();
             const bytesRemainingInBox = boxSize - (iterator.counter.getOffset() - fileOffset);
-            const children = await (0, process_box_1.parseBoxes)({
+            const children = await (0, process_box_1.parseIsoBaseMediaBoxes)({
                 iterator,
                 allowIncompleteBoxes: false,
                 maxBytes: bytesRemainingInBox,
@@ -177,7 +177,7 @@ const processSample = async ({ iterator, options, signal, logLevel, }) => {
                     bytesPerPacket,
                     bytesPerFrame,
                     bitsPerSample: bytesPerSample,
-                    children: children.segments,
+                    children: children.segments.boxes,
                 },
             };
         }
@@ -196,7 +196,7 @@ const processSample = async ({ iterator, options, signal, logLevel, }) => {
             const bytesPerFrame = iterator.getUint32();
             const samplesPerPacket = iterator.getUint32();
             const bytesRemainingInBox = boxSize - (iterator.counter.getOffset() - fileOffset);
-            const children = await (0, process_box_1.parseBoxes)({
+            const children = await (0, process_box_1.parseIsoBaseMediaBoxes)({
                 iterator,
                 allowIncompleteBoxes: false,
                 maxBytes: bytesRemainingInBox,
@@ -228,7 +228,7 @@ const processSample = async ({ iterator, options, signal, logLevel, }) => {
                     bytesPerPacket: null,
                     bytesPerFrame,
                     bitsPerSample: bitsPerCodedSample,
-                    children: children.segments,
+                    children: children.segments.boxes,
                 },
             };
         }
@@ -251,7 +251,7 @@ const processSample = async ({ iterator, options, signal, logLevel, }) => {
         const colorTableId = iterator.getInt16();
         const bytesRemainingInBox = boxSize - (iterator.counter.getOffset() - fileOffset);
         const children = bytesRemainingInBox > 8
-            ? await (0, process_box_1.parseBoxes)({
+            ? await (0, process_box_1.parseIsoBaseMediaBoxes)({
                 iterator,
                 allowIncompleteBoxes: false,
                 maxBytes: bytesRemainingInBox,
@@ -262,7 +262,7 @@ const processSample = async ({ iterator, options, signal, logLevel, }) => {
                 logLevel,
             })
             : (iterator.discard(bytesRemainingInBox),
-                { status: 'done', segments: [] });
+                { status: 'done', segments: { boxes: [], type: 'iso-base-media' } });
         if (children.status === 'incomplete') {
             throw new Error('Incomplete boxes are not allowed');
         }
@@ -287,7 +287,7 @@ const processSample = async ({ iterator, options, signal, logLevel, }) => {
                 compressorName,
                 depth,
                 colorTableId,
-                descriptors: children.segments,
+                descriptors: children.segments.boxes,
             },
         };
     }

package/dist/boxes/iso-base-media/trak/trak.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseTrak = void 0;
 const process_box_1 = require("../process-box");
 const parseTrak = async ({ data, size, offsetAtStart, options, signal, logLevel, }) => {
-    const children = await (0, process_box_1.parseBoxes)({
+    const children = await (0, process_box_1.parseIsoBaseMediaBoxes)({
         iterator: data,
         maxBytes: size - (data.counter.getOffset() - offsetAtStart),
         allowIncompleteBoxes: false,
@@ -20,7 +20,7 @@ const parseTrak = async ({ data, size, offsetAtStart, options, signal, logLevel,
         offset: offsetAtStart,
         boxSize: size,
         type: 'trak-box',
-        children: children.segments,
+        children: children.segments.boxes,
     };
 };
 exports.parseTrak = parseTrak;