@remotion/media-parser 4.0.231 → 4.0.233

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/esds/decoder-specific-config.d.ts

@@ -1,5 +1,4 @@
 import type { BufferIterator } from '../../../buffer-iterator';
-import type { LogLevel } from '../../../log';
 type UnknownDecoderSpecificConfig = {
     type: 'unknown-decoder-specific-config';
 };
@@ -11,5 +10,5 @@ type AudioSpecificConfig = {
     asBytes: Uint8Array;
 };
 export type DecoderSpecificConfig = UnknownDecoderSpecificConfig | AudioSpecificConfig;
-export declare const parseDecoderSpecificConfig: (iterator: BufferIterator, logLevel: LogLevel) => DecoderSpecificConfig;
+export declare const parseDecoderSpecificConfig: (iterator: BufferIterator) => DecoderSpecificConfig;
 export {};

package/dist/boxes/iso-base-media/esds/decoder-specific-config.js

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseDecoderSpecificConfig = void 0;
-const log_1 = require("../../../log");
-const parseDecoderSpecificConfig = (iterator, logLevel) => {
+const parseDecoderSpecificConfig = (iterator) => {
     const layerTag = iterator.getUint8();
     const layerSize = iterator.getPaddedFourByteNumber();
     const start = iterator.counter.getOffset();
@@ -28,9 +27,6 @@ const parseDecoderSpecificConfig = (iterator, logLevel) => {
     if (read < layerSize) {
         iterator.discard(layerSize - read);
     }
-    if (bytes.byteLength === 2 && bytes[0] === 17 && bytes[1] === 136) {
-        log_1.Log.warn(logLevel, 'Chrome has a bug and might not be able to decode this audio. It will be fixed, see: https://issues.chromium.org/issues/360083330');
-    }
     return {
         type: 'mp4a-specific-config',
         audioObjectType,

package/dist/boxes/iso-base-media/esds/esds-descriptors.d.ts

@@ -1,5 +1,4 @@
 import type { BufferIterator } from '../../../buffer-iterator';
-import type { LogLevel } from '../../../log';
 import type { DecoderSpecificConfig } from './decoder-specific-config';
 type AudioObjectType = 'aac' | 'mp3' | 'unknown';
 type DecoderConfigDescriptor = {
@@ -23,9 +22,8 @@ export type Descriptor = DecoderConfigDescriptor | SlConfigDescriptor | UnknownD
 type DescriptorAndNext = {
     descriptor: Descriptor | null;
 };
-export declare const processDescriptor: ({ iterator, logLevel, }: {
+export declare const processDescriptor: ({ iterator, }: {
     iterator: BufferIterator;
-    logLevel: LogLevel;
 }) => DescriptorAndNext;
-export declare const parseDescriptors: (iterator: BufferIterator, maxBytes: number, logLevel: LogLevel) => Descriptor[];
+export declare const parseDescriptors: (iterator: BufferIterator, maxBytes: number) => Descriptor[];
 export {};

package/dist/boxes/iso-base-media/esds/esds-descriptors.js

@@ -14,7 +14,7 @@ const mapToObjectAudioIndicator = (num) => {
     }
     return 'unknown';
 };
-const processDescriptor = ({ iterator, logLevel, }) => {
+const processDescriptor = ({ iterator, }) => {
     const tag = iterator.getUint8();
     if (tag === 4) {
         const size = iterator.getPaddedFourByteNumber();
@@ -31,7 +31,7 @@ const processDescriptor = ({ iterator, logLevel, }) => {
         const avgBitrate = iterator.getUint32();
         const decoderSpecificConfigs = [];
         while (size - (iterator.counter.getOffset() - initialOffset) > 0) {
-            const decoderSpecificConfig = (0, decoder_specific_config_1.parseDecoderSpecificConfig)(iterator, logLevel);
+            const decoderSpecificConfig = (0, decoder_specific_config_1.parseDecoderSpecificConfig)(iterator);
             decoderSpecificConfigs.push(decoderSpecificConfig);
         }
         return {
@@ -62,14 +62,13 @@ const processDescriptor = ({ iterator, logLevel, }) => {
     };
 };
 exports.processDescriptor = processDescriptor;
-const parseDescriptors = (iterator, maxBytes, logLevel) => {
+const parseDescriptors = (iterator, maxBytes) => {
     const descriptors = [];
     const initialOffset = iterator.counter.getOffset();
     while (iterator.bytesRemaining() > 0 &&
         iterator.counter.getOffset() - initialOffset < maxBytes) {
         const { descriptor } = (0, exports.processDescriptor)({
             iterator,
-            logLevel,
         });
         if (descriptor) {
             descriptors.push(descriptor);

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

@@ -1,5 +1,4 @@
 import type { BufferIterator } from '../../../buffer-iterator';
-import type { LogLevel } from '../../../log';
 import type { Descriptor } from './esds-descriptors';
 export interface EsdsBox {
     type: 'esds-box';
@@ -9,9 +8,8 @@ export interface EsdsBox {
     esId: number;
     descriptors: Descriptor[];
 }
-export declare const parseEsds: ({ data, size, fileOffset, logLevel, }: {
+export declare const parseEsds: ({ data, size, fileOffset, }: {
     data: BufferIterator;
     size: number;
     fileOffset: number;
-    logLevel: LogLevel;
 }) => EsdsBox;

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

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseEsds = void 0;
 const esds_descriptors_1 = require("./esds-descriptors");
-const parseEsds = ({ data, size, fileOffset, logLevel, }) => {
+const parseEsds = ({ data, size, fileOffset, }) => {
     const version = data.getUint8();
     // Flags, we discard them
     data.discard(3);
@@ -12,7 +12,7 @@ const parseEsds = ({ data, size, fileOffset, logLevel, }) => {
     // disard 1 byte, currently unknown
     data.discard(1);
     const remaining = size - (data.counter.getOffset() - fileOffset);
-    const descriptors = (0, esds_descriptors_1.parseDescriptors)(data, remaining, logLevel);
+    const descriptors = (0, esds_descriptors_1.parseDescriptors)(data, remaining);
     const remainingNow = size - (data.counter.getOffset() - fileOffset);
     data.discard(remainingNow);
     return {

package/dist/boxes/iso-base-media/get-sample-positions-from-track.js

@@ -1,11 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSamplePositionsFromTrack = 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_lpcm_1 = require("../../get-sample-positions-from-lpcm");
 const samples_from_moof_1 = require("../../samples-from-moof");
 const traversal_1 = require("./traversal");
 const getSamplePositionsFromTrack = (trakBox, moofBox) => {
+    const isLpcm = (0, get_audio_codec_1.isLpcmAudioCodec)(trakBox);
+    const timescaleAndDuration = (0, get_fps_1.getTimescaleAndDuration)(trakBox);
+    if (isLpcm) {
+        return (0, get_sample_positions_from_lpcm_1.getSamplePositionsFromLpcm)(trakBox);
+    }
     const stszBox = (0, traversal_1.getStszBox)(trakBox);
     const stcoBox = (0, traversal_1.getStcoBox)(trakBox);
     const stscBox = (0, traversal_1.getStscBox)(trakBox);
@@ -13,7 +20,6 @@ const getSamplePositionsFromTrack = (trakBox, moofBox) => {
     const sttsBox = (0, traversal_1.getSttsBox)(trakBox);
     const tkhdBox = (0, traversal_1.getTkhdBox)(trakBox);
     const cttsBox = (0, traversal_1.getCttsBox)(trakBox);
-    const timescaleAndDuration = (0, get_fps_1.getTimescaleAndDuration)(trakBox);
     if (!tkhdBox) {
         throw new Error('Expected tkhd box in trak box');
     }

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>>;