@remotion/media-parser 4.0.233 → 4.0.235

package/dist/aac-codecprivate.d.ts

@@ -0,0 +1,19 @@
+/**
+ * bytes 17,144: 00010 001 | 1 0010 000
+                 ^^^^^ ^^^   ^ ^^^^ ^
+                 |     |       |    | padding
+                 |     |       |
+                 |     |       +-- channelConfiguration (2)
+                 |     +-- samplingFrequencyIndex (3)
+                 +-- audioConfigType (2)
+  */
+export declare const createAacCodecPrivate: ({ audioObjectType, sampleRate, channelConfiguration, }: {
+    audioObjectType: number;
+    sampleRate: number;
+    channelConfiguration: number;
+}) => Uint8Array;
+export declare const parseAacCodecPrivate: (bytes: Uint8Array) => {
+    audioObjectType: number;
+    sampleRate: number;
+    channelConfiguration: number;
+};

package/dist/aac-codecprivate.js

@@ -0,0 +1,122 @@
+"use strict";
+// codec private, for example [17, 144]
+// audioObjectType = 2 = 'AAC LC'
+// samplingFrequencyIndex = 3 = '48000 Hz'
+// channelConfiguration = 2 = '2 channels'
+/**
+ * bytes 17,144: 00010 001 | 1 0010 000
+                 ^^^^^ ^^^   ^ ^^^^ ^
+                 |     |       |    | padding
+                 |     |       |
+                 |     |       +-- channelConfiguration (2)
+                 |     +-- samplingFrequencyIndex (3)
+                 +-- audioConfigType (2)
+  */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAacCodecPrivate = exports.createAacCodecPrivate = void 0;
+// https://wiki.multimedia.cx/index.php/MPEG-4_Audio#Channel_Configurations
+const getConfigForSampleRate = (sampleRate) => {
+    if (sampleRate === 96000) {
+        return 0;
+    }
+    if (sampleRate === 88200) {
+        return 1;
+    }
+    if (sampleRate === 64000) {
+        return 2;
+    }
+    if (sampleRate === 48000) {
+        return 3;
+    }
+    if (sampleRate === 44100) {
+        return 4;
+    }
+    if (sampleRate === 32000) {
+        return 5;
+    }
+    if (sampleRate === 24000) {
+        return 6;
+    }
+    if (sampleRate === 22050) {
+        return 7;
+    }
+    if (sampleRate === 16000) {
+        return 8;
+    }
+    if (sampleRate === 12000) {
+        return 9;
+    }
+    if (sampleRate === 11025) {
+        return 10;
+    }
+    if (sampleRate === 8000) {
+        return 11;
+    }
+    if (sampleRate === 7350) {
+        return 12;
+    }
+    throw new Error(`Unexpected sample rate ${sampleRate}`);
+};
+const createAacCodecPrivate = ({ audioObjectType, sampleRate, channelConfiguration, }) => {
+    const bits = `${audioObjectType.toString(2).padStart(5, '0')}${getConfigForSampleRate(sampleRate).toString(2).padStart(4, '0')}${channelConfiguration.toString(2).padStart(4, '0')}000`;
+    if (bits.length !== 16) {
+        throw new Error('Invalid AAC codec private ' + bits.length);
+    }
+    if (channelConfiguration === 0 || channelConfiguration > 7) {
+        throw new Error('Invalid channel configuration ' + channelConfiguration);
+    }
+    const firstByte = parseInt(bits.slice(0, 8), 2);
+    const secondByte = parseInt(bits.slice(8, 16), 2);
+    return new Uint8Array([firstByte, secondByte]);
+};
+exports.createAacCodecPrivate = createAacCodecPrivate;
+const parseAacCodecPrivate = (bytes) => {
+    if (bytes.length < 2) {
+        throw new Error('Invalid AAC codec private length');
+    }
+    const bits = `${bytes[0].toString(2).padStart(8, '0')}${bytes[1].toString(2).padStart(8, '0')}`;
+    if (bits.length !== 16) {
+        throw new Error('Invalid AAC codec private bits length');
+    }
+    const audioObjectType = parseInt(bits.slice(0, 5), 2);
+    const samplingFrequencyIndex = parseInt(bits.slice(5, 9), 2);
+    const channelConfiguration = parseInt(bits.slice(9, 13), 2);
+    const sampleRate = (() => {
+        switch (samplingFrequencyIndex) {
+            case 0:
+                return 96000;
+            case 1:
+                return 88200;
+            case 2:
+                return 64000;
+            case 3:
+                return 48000;
+            case 4:
+                return 44100;
+            case 5:
+                return 32000;
+            case 6:
+                return 24000;
+            case 7:
+                return 22050;
+            case 8:
+                return 16000;
+            case 9:
+                return 12000;
+            case 10:
+                return 11025;
+            case 11:
+                return 8000;
+            case 12:
+                return 7350;
+            default:
+                throw new Error(`Unexpected sampling frequency index ${samplingFrequencyIndex}`);
+        }
+    })();
+    return {
+        audioObjectType,
+        sampleRate,
+        channelConfiguration,
+    };
+};
+exports.parseAacCodecPrivate = parseAacCodecPrivate;

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

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

package/dist/boxes/iso-base-media/get-actual-number-of-channels.d.ts

@@ -0,0 +1,13 @@
+import type { MediaParserAudioCodec } from '../../get-tracks';
+type AudioDecoderConfig = {
+    numberOfChannels: number;
+    sampleRate: number;
+    codecPrivate: Uint8Array | null;
+};
+export declare const getActualDecoderParameters: ({ audioCodec, codecPrivate, numberOfChannels, sampleRate, }: {
+    audioCodec: MediaParserAudioCodec;
+    codecPrivate: Uint8Array | null;
+    numberOfChannels: number;
+    sampleRate: number;
+}) => AudioDecoderConfig;
+export {};

package/dist/boxes/iso-base-media/get-actual-number-of-channels.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getActualDecoderParameters = void 0;
+const aac_codecprivate_1 = require("../../aac-codecprivate");
+// Example video:	'https://remotion-assets.s3.eu-central-1.amazonaws.com/example-videos/riverside.mp4';
+// This video has `numberOfChannels = 2`, but the actual number of channels is `1` according to Codec Private.
+// Therefore, prioritizing Codec Private over `numberOfChannels`.
+const getActualDecoderParameters = ({ audioCodec, codecPrivate, numberOfChannels, sampleRate, }) => {
+    if (audioCodec !== 'aac') {
+        return { numberOfChannels, sampleRate, codecPrivate };
+    }
+    if (codecPrivate === null) {
+        return { numberOfChannels, sampleRate, codecPrivate };
+    }
+    const parsed = (0, aac_codecprivate_1.parseAacCodecPrivate)(codecPrivate);
+    return {
+        numberOfChannels: parsed.channelConfiguration,
+        sampleRate: parsed.sampleRate,
+        codecPrivate: (0, aac_codecprivate_1.createAacCodecPrivate)(parsed),
+    };
+};
+exports.getActualDecoderParameters = getActualDecoderParameters;

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

@@ -5,9 +5,10 @@ const get_audio_codec_1 = require("../../get-audio-codec");
 const get_fps_1 = require("../../get-fps");
 const get_sample_aspect_ratio_1 = require("../../get-sample-aspect-ratio");
 const get_video_codec_1 = require("../../get-video-codec");
+const get_actual_number_of_channels_1 = require("./get-actual-number-of-channels");
 const traversal_1 = require("./traversal");
 const makeBaseMediaTrack = (trakBox) => {
-    var _a, _b, _c;
+    var _a, _b, _c, _d;
     const tkhdBox = (0, traversal_1.getTkhdBox)(trakBox);
     const videoDescriptors = (0, traversal_1.getVideoDescriptors)(trakBox);
     const timescaleAndDuration = (0, get_fps_1.getTimescaleAndDuration)(trakBox);
@@ -27,17 +28,25 @@ const makeBaseMediaTrack = (trakBox) => {
             throw new Error('Could not find sample rate');
         }
         const { codecString, description } = (0, get_audio_codec_1.getAudioCodecStringFromTrak)(trakBox);
+        const codecPrivate = (_b = (_a = (0, get_audio_codec_1.getCodecPrivateFromTrak)(trakBox)) !== null && _a !== void 0 ? _a : description) !== null && _b !== void 0 ? _b : null;
+        const codecWithoutConfig = (0, get_audio_codec_1.getAudioCodecFromTrack)(trakBox);
+        const actual = (0, get_actual_number_of_channels_1.getActualDecoderParameters)({
+            audioCodec: codecWithoutConfig,
+            codecPrivate,
+            numberOfChannels,
+            sampleRate,
+        });
         return {
             type: 'audio',
             trackId: tkhdBox.trackId,
             timescale: timescaleAndDuration.timescale,
             codec: codecString,
-            numberOfChannels,
-            sampleRate,
-            description,
+            numberOfChannels: actual.numberOfChannels,
+            sampleRate: actual.sampleRate,
+            description: (_c = actual.codecPrivate) !== null && _c !== void 0 ? _c : undefined,
             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),
+            codecPrivate: actual.codecPrivate,
+            codecWithoutConfig,
         };
     }
     if (!(0, get_fps_1.trakBoxContainsVideo)(trakBox)) {
@@ -84,7 +93,7 @@ const makeBaseMediaTrack = (trakBox) => {
         rotation,
         trakBox,
         codecPrivate: privateData,
-        color: (_c = (0, get_video_codec_1.getIsoBmColrConfig)(trakBox)) !== null && _c !== void 0 ? _c : {
+        color: (_d = (0, get_video_codec_1.getIsoBmColrConfig)(trakBox)) !== null && _d !== void 0 ? _d : {
             fullRange: null,
             matrixCoefficients: null,
             primaries: null,

package/dist/boxes/iso-base-media/meta/hdlr.d.ts

@@ -0,0 +1,12 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+import type { BaseBox } from '../base-type';
+export interface HdlrBox extends BaseBox {
+    type: 'hdlr-box';
+    hdlrType: string;
+    componentName: string;
+}
+export declare const parseHdlr: ({ iterator, size, offset, }: {
+    iterator: BufferIterator;
+    size: number;
+    offset: number;
+}) => Promise<HdlrBox>;

package/dist/boxes/iso-base-media/meta/hdlr.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseHdlr = void 0;
+const parseHdlr = ({ iterator, size, offset, }) => {
+    const box = iterator.startBox(size - 8);
+    const version = iterator.getUint8();
+    if (version !== 0) {
+        throw new Error(`Unsupported hdlr version: ${version}`);
+    }
+    // version
+    iterator.discard(3);
+    // predefined
+    iterator.discard(4);
+    // type
+    const hdlrType = iterator.getByteString(4);
+    // component manufactor
+    iterator.discard(4);
+    // component flags
+    iterator.discard(4);
+    // component flags mask
+    iterator.discard(4);
+    // component name
+    const componentName = iterator.readUntilNullTerminator();
+    box.discardRest();
+    return Promise.resolve({
+        type: 'hdlr-box',
+        boxSize: size,
+        offset,
+        hdlrType,
+        componentName,
+    });
+};
+exports.parseHdlr = parseHdlr;

package/dist/boxes/iso-base-media/meta/ilst.d.ts

@@ -0,0 +1,28 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+import type { BaseBox } from '../base-type';
+type IlstEntry = {
+    index: number;
+    wellKnownType: number;
+    type: string;
+    value: Value;
+};
+export type Value = {
+    type: 'text';
+    value: string;
+} | {
+    type: 'number';
+    value: number;
+} | {
+    type: 'unknown';
+    value: unknown;
+};
+export interface IlstBox extends BaseBox {
+    type: 'ilst-box';
+    entries: IlstEntry[];
+}
+export declare const parseIlstBox: ({ iterator, size, offset, }: {
+    iterator: BufferIterator;
+    size: number;
+    offset: number;
+}) => IlstBox;
+export {};

package/dist/boxes/iso-base-media/meta/ilst.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseIlstBox = void 0;
+// https://developer.apple.com/documentation/quicktime-file-format/well-known_types
+const parseFromWellKnownType = (wellKnownType, iterator, size) => {
+    if (wellKnownType === 1) {
+        const value = iterator.getByteString(size);
+        return { type: 'text', value };
+    }
+    if (wellKnownType === 21) {
+        if (size === 1) {
+            return { type: 'number', value: iterator.getInt8() };
+        }
+        if (size === 2) {
+            return { type: 'number', value: iterator.getInt16() };
+        }
+        if (size === 3) {
+            return { type: 'number', value: iterator.getInt24() };
+        }
+        if (size === 4) {
+            return { type: 'number', value: iterator.getInt32() };
+        }
+        if (size === 8) {
+            return { type: 'number', value: Number(iterator.getInt64()) };
+        }
+        throw new Error(`Weird size for number ${size}`);
+    }
+    if (wellKnownType === 22) {
+        if (size === 1) {
+            return { type: 'number', value: iterator.getUint8() };
+        }
+        if (size === 2) {
+            return { type: 'number', value: iterator.getUint16() };
+        }
+        if (size === 3) {
+            return { type: 'number', value: iterator.getUint24() };
+        }
+        if (size === 4) {
+            return { type: 'number', value: iterator.getUint32() };
+        }
+        throw new Error(`Weird size for number ${size}`);
+    }
+    if (wellKnownType === 23) {
+        if (size === 4) {
+            return { type: 'number', value: iterator.getFloat32() };
+        }
+        if (size === 8) {
+            return { type: 'number', value: iterator.getFloat64() };
+        }
+        throw new Error(`Weird size for number ${size}`);
+    }
+    iterator.discard(size);
+    return { type: 'unknown', value: null };
+};
+const parseIlstBox = ({ iterator, size, offset, }) => {
+    const box = iterator.startBox(size - 8);
+    const entries = [];
+    while (iterator.counter.getOffset() < size + offset) {
+        // metadata size
+        const metadataSize = iterator.getUint32();
+        const index = iterator.getUint32();
+        // "skip" as a number
+        if (index === 1936419184) {
+            iterator.discard(metadataSize - 8);
+            continue;
+        }
+        const innerSize = iterator.getUint32();
+        const type = iterator.getAtom();
+        const typeIndicator = iterator.getUint8();
+        if (typeIndicator !== 0) {
+            throw new Error('Expected type indicator to be 0');
+        }
+        const wellKnownType = iterator.getUint24();
+        iterator.discard(4);
+        const value = parseFromWellKnownType(wellKnownType, iterator, innerSize - 16);
+        entries.push({ index, type, wellKnownType, value });
+    }
+    box.discardRest();
+    return {
+        type: 'ilst-box',
+        boxSize: size,
+        offset,
+        entries,
+    };
+};
+exports.parseIlstBox = parseIlstBox;

package/dist/boxes/iso-base-media/meta/keys.d.ts

@@ -0,0 +1,10 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+import type { BaseBox } from '../base-type';
+export interface KeysBox extends BaseBox {
+    type: 'keys-box';
+}
+export declare const parseKeys: ({ iterator, size, offset, }: {
+    iterator: BufferIterator;
+    size: number;
+    offset: number;
+}) => Promise<KeysBox>;

package/dist/boxes/iso-base-media/meta/keys.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseKeys = void 0;
+const parseKeys = ({ iterator, size, offset, }) => {
+    const box = iterator.startBox(size - 8);
+    const version = iterator.getUint8();
+    if (version !== 0) {
+        throw new Error(`Unsupported hdlr version: ${version}`);
+    }
+    box.discardRest();
+    return Promise.resolve({
+        type: 'keys-box',
+        boxSize: size,
+        offset,
+    });
+};
+exports.parseKeys = parseKeys;

package/dist/boxes/iso-base-media/meta/list.d.ts

@@ -0,0 +1,12 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+import type { BaseBox } from '../base-type';
+export interface HdlrBox extends BaseBox {
+    type: 'hdlr-box';
+    hdlrType: string;
+    componentName: string;
+}
+export declare const parseHdlr: ({ iterator, size, offset, }: {
+    iterator: BufferIterator;
+    size: number;
+    offset: number;
+}) => Promise<HdlrBox>;

package/dist/boxes/iso-base-media/meta/list.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseHdlr = void 0;
+const parseHdlr = ({ iterator, size, offset, }) => {
+    const box = iterator.startBox(size - 8);
+    const version = iterator.getUint8();
+    if (version !== 0) {
+        throw new Error(`Unsupported hdlr version: ${version}`);
+    }
+    // version
+    iterator.discard(3);
+    // predefined
+    iterator.discard(4);
+    // type
+    const hdlrType = iterator.getByteString(4);
+    // component manufactor
+    iterator.discard(4);
+    // component flags
+    iterator.discard(4);
+    // component flags mask
+    iterator.discard(4);
+    // component name
+    const componentName = iterator.readUntilNullTerminator();
+    box.discardRest();
+    return Promise.resolve({
+        type: 'hdlr-box',
+        boxSize: size,
+        offset,
+        hdlrType,
+        componentName,
+    });
+};
+exports.parseHdlr = parseHdlr;

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

@@ -1,5 +1,6 @@
 import type { BufferIterator } from '../../../buffer-iterator';
 import type { LogLevel } from '../../../log';
+import type { Options, ParseMediaFields } from '../../../options';
 import type { AnySegment } from '../../../parse-result';
 import type { ParserContext } from '../../../parser-context';
 import type { BaseBox } from '../base-type';
@@ -7,11 +8,12 @@ export interface MoovBox extends BaseBox {
     type: 'moov-box';
     children: AnySegment[];
 }
-export declare const parseMoov: ({ iterator, offset, size, options, signal, logLevel, }: {
+export declare const parseMoov: ({ iterator, offset, size, options, signal, logLevel, fields, }: {
     iterator: BufferIterator;
     offset: number;
     size: number;
     options: ParserContext;
     signal: AbortSignal | null;
     logLevel: LogLevel;
+    fields: Options<ParseMediaFields>;
 }) => Promise<MoovBox>;

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

@@ -2,7 +2,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 parseMoov = async ({ iterator, offset, size, options, signal, logLevel, fields, }) => {
     const children = await (0, process_box_1.parseIsoBaseMediaBoxes)({
         iterator,
         maxBytes: size - (iterator.counter.getOffset() - offset),
@@ -12,6 +12,7 @@ const parseMoov = async ({ iterator, offset, size, options, signal, logLevel, })
         continueMdat: false,
         signal,
         logLevel,
+        fields,
     });
     if (children.status === 'incomplete') {
         throw new Error('Incomplete boxes are not allowed');

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

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