@remotion/media-parser 4.0.254 → 4.0.256

package/dist/boxes/riff/parse-strf.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseStrf = void 0;
+const parseStrfAudio = ({ iterator, size, }) => {
+    const box = iterator.startBox(size);
+    const formatTag = iterator.getUint16Le();
+    const numberOfChannels = iterator.getUint16Le();
+    const samplesPerSec = iterator.getUint32Le();
+    const avgBytesPerSec = iterator.getUint32Le();
+    const blockAlign = iterator.getUint16Le();
+    const bitsPerSample = iterator.getUint16Le();
+    const cbSize = iterator.getUint16Le();
+    box.expectNoMoreBytes();
+    return {
+        type: 'strf-box-audio',
+        avgBytesPerSecond: avgBytesPerSec,
+        bitsPerSample,
+        blockAlign,
+        cbSize,
+        formatTag,
+        numberOfChannels,
+        sampleRate: samplesPerSec,
+    };
+};
+const parseStrfVideo = ({ iterator, size, }) => {
+    const box = iterator.startBox(size);
+    const biSize = iterator.getUint32Le();
+    const width = iterator.getInt32Le();
+    const height = iterator.getInt32Le();
+    const planes = iterator.getUint16Le();
+    const bitCount = iterator.getUint16Le();
+    const compression = iterator.getByteString(4);
+    const sizeImage = iterator.getUint32Le();
+    const xPelsPerMeter = iterator.getInt32Le();
+    const yPelsPerMeter = iterator.getInt32Le();
+    const clrUsed = iterator.getUint32Le();
+    const clrImportant = iterator.getUint32Le();
+    box.expectNoMoreBytes();
+    return {
+        type: 'strf-box-video',
+        biSize,
+        bitCount,
+        clrImportant,
+        clrUsed,
+        compression,
+        height,
+        planes,
+        sizeImage,
+        width,
+        xPelsPerMeter,
+        yPelsPerMeter,
+    };
+};
+const parseStrf = ({ iterator, size, boxes, }) => {
+    const strh = boxes.find((b) => b.type === 'strh-box');
+    if (!strh) {
+        throw new Error('strh box not found');
+    }
+    if (strh.fccType === 'vids') {
+        return parseStrfVideo({ iterator, size });
+    }
+    if (strh.fccType === 'auds') {
+        return parseStrfAudio({ iterator, size });
+    }
+    throw new Error(`Unsupported fccType: ${strh.fccType}`);
+};
+exports.parseStrf = parseStrf;

package/dist/boxes/riff/parse-strh.d.ts

@@ -0,0 +1,6 @@
+import type { BufferIterator } from '../../buffer-iterator';
+import type { RiffBox } from './riff-box';
+export declare const parseStrh: ({ iterator, size, }: {
+    iterator: BufferIterator;
+    size: number;
+}) => RiffBox;

package/dist/boxes/riff/parse-strh.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseStrh = void 0;
+const parseStrh = ({ iterator, size, }) => {
+    const box = iterator.startBox(size);
+    const fccType = iterator.getByteString(4);
+    if (fccType !== 'vids' && fccType !== 'auds') {
+        throw new Error('Expected AVI handler to be vids / auds');
+    }
+    const handler = fccType === 'vids' ? iterator.getByteString(4) : iterator.getUint32Le();
+    if (typeof handler === 'string' && handler !== 'H264') {
+        throw new Error(`Only H264 is supported as a stream type in .avi, got ${handler}`);
+    }
+    if (fccType === 'auds' && handler !== 1) {
+        throw new Error(`Only "1" is supported as a stream type in .avi, got ${handler}`);
+    }
+    const flags = iterator.getUint32Le();
+    const priority = iterator.getUint16Le();
+    const language = iterator.getUint16Le();
+    const initialFrames = iterator.getUint32Le();
+    const scale = iterator.getUint32Le();
+    const rate = iterator.getUint32Le();
+    const start = iterator.getUint32Le();
+    const length = iterator.getUint32Le();
+    const suggestedBufferSize = iterator.getUint32Le();
+    const quality = iterator.getUint32Le();
+    const sampleSize = iterator.getUint32Le();
+    box.discardRest();
+    return {
+        type: 'strh-box',
+        fccType,
+        handler,
+        flags,
+        priority,
+        initialFrames,
+        length,
+        quality,
+        rate,
+        sampleSize,
+        scale,
+        start,
+        suggestedBufferSize,
+        language,
+    };
+};
+exports.parseStrh = parseStrh;

package/dist/boxes/riff/riff-box.d.ts

@@ -0,0 +1,85 @@
+export type WaveFormatBox = {
+    type: 'wave-format-box';
+    formatTag: 1;
+    numberOfChannels: number;
+    sampleRate: number;
+    blockAlign: number;
+    byteRate: number;
+    bitsPerSample: number;
+};
+export type ListBox = {
+    type: 'list-box';
+    listType: string;
+    children: RiffBox[];
+};
+export type RiffRegularBox = {
+    type: 'riff-box';
+    size: number;
+    id: string;
+};
+export type AvihBox = {
+    type: 'avih-box';
+    microSecPerFrame: number;
+    maxBytesPerSecond: number;
+    paddingGranularity: number;
+    flags: number;
+    totalFrames: number;
+    initialFrames: number;
+    streams: number;
+    suggestedBufferSize: number;
+    width: number;
+    height: number;
+};
+export type StrhBox = {
+    type: 'strh-box';
+    fccType: 'vids' | 'auds';
+    handler: 'H264' | number;
+    flags: number;
+    priority: number;
+    initialFrames: number;
+    scale: number;
+    rate: number;
+    start: number;
+    length: number;
+    suggestedBufferSize: number;
+    quality: number;
+    sampleSize: number;
+    language: number;
+};
+export type StrfBoxVideo = {
+    type: 'strf-box-video';
+    biSize: number;
+    width: number;
+    height: number;
+    planes: number;
+    bitCount: number;
+    compression: string;
+    sizeImage: number;
+    xPelsPerMeter: number;
+    yPelsPerMeter: number;
+    clrUsed: number;
+    clrImportant: number;
+};
+export type StrfBoxAudio = {
+    type: 'strf-box-audio';
+    formatTag: number;
+    numberOfChannels: number;
+    sampleRate: number;
+    avgBytesPerSecond: number;
+    blockAlign: number;
+    bitsPerSample: number;
+    cbSize: number;
+};
+export type RiffHeader = {
+    type: 'riff-header';
+    fileSize: number;
+    fileType: string;
+};
+export type MoviBox = {
+    type: 'movi-box';
+};
+export type IsftBox = {
+    type: 'isft-box';
+    software: string;
+};
+export type RiffBox = RiffRegularBox | WaveFormatBox | RiffHeader | ListBox | AvihBox | StrhBox | StrfBoxVideo | StrfBoxAudio | MoviBox | IsftBox;

package/dist/boxes/riff/riff-box.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/boxes/riff/timescale.d.ts

@@ -0,0 +1 @@
+export declare const MEDIA_PARSER_RIFF_TIMESCALE = 1000000;

package/dist/boxes/riff/timescale.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MEDIA_PARSER_RIFF_TIMESCALE = void 0;
+exports.MEDIA_PARSER_RIFF_TIMESCALE = 1000000;

package/dist/boxes/riff/traversal.d.ts

@@ -0,0 +1,8 @@
+import type { RiffStructure } from '../../parse-result';
+import type { AvihBox, ListBox, RiffBox, StrfBoxAudio, StrfBoxVideo, StrhBox } from './riff-box';
+export declare const isRiffAvi: (structure: RiffStructure) => boolean;
+export declare const getHdlrBox: (structure: RiffStructure) => ListBox | null;
+export declare const getAvihBox: (structure: RiffStructure) => AvihBox | null;
+export declare const getStrlBoxes: (structure: RiffStructure) => ListBox[];
+export declare const getStrhBox: (strlBoxChildren: RiffBox[]) => StrhBox | null;
+export declare const getStrfBox: (strlBoxChildren: RiffBox[]) => StrfBoxAudio | StrfBoxVideo | null;

package/dist/boxes/riff/traversal.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStrfBox = exports.getStrhBox = exports.getStrlBoxes = exports.getAvihBox = exports.getHdlrBox = exports.isRiffAvi = void 0;
+const isRiffAvi = (structure) => {
+    return structure.boxes.some((box) => box.type === 'riff-header' && box.fileType === 'AVI');
+};
+exports.isRiffAvi = isRiffAvi;
+const getHdlrBox = (structure) => {
+    return structure.boxes.find((box) => box.type === 'list-box' && box.listType === 'hdrl');
+};
+exports.getHdlrBox = getHdlrBox;
+const getAvihBox = (structure) => {
+    const hdlrBox = (0, exports.getHdlrBox)(structure);
+    if (!hdlrBox) {
+        return null;
+    }
+    return hdlrBox.children.find((box) => box.type === 'avih-box');
+};
+exports.getAvihBox = getAvihBox;
+const getStrlBoxes = (structure) => {
+    const hdlrBox = (0, exports.getHdlrBox)(structure);
+    if (!hdlrBox) {
+        return [];
+    }
+    return hdlrBox.children.filter((box) => box.type === 'list-box' && box.listType === 'strl');
+};
+exports.getStrlBoxes = getStrlBoxes;
+const getStrhBox = (strlBoxChildren) => {
+    return strlBoxChildren.find((box) => box.type === 'strh-box');
+};
+exports.getStrhBox = getStrhBox;
+const getStrfBox = (strlBoxChildren) => {
+    var _a;
+    return ((_a = strlBoxChildren.find((box) => box.type === 'strf-box-audio' || box.type === 'strf-box-video')) !== null && _a !== void 0 ? _a : null);
+};
+exports.getStrfBox = getStrfBox;

package/dist/boxes/webm/allowed-partial-segments.d.ts

@@ -0,0 +1 @@
+export declare const allowedPartialSegments: string[];

package/dist/boxes/webm/allowed-partial-segments.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.allowedPartialSegments = void 0;
+exports.allowedPartialSegments = ['0x1f43b675', '0x18538067'];

package/dist/boxes/webm/av1-codec-private.d.ts

@@ -0,0 +1,2 @@
+import type { ColorParameterBox } from '../iso-base-media/stsd/colr';
+export declare const parseAv1PrivateData: (data: Uint8Array, colrAtom: ColorParameterBox | null) => string;

package/dist/boxes/webm/av1-codec-private.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAv1PrivateData = void 0;
+const buffer_iterator_1 = require("../../buffer-iterator");
+const parseAv1PrivateData = (data, colrAtom) => {
+    const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(data, data.byteLength);
+    iterator.startReadingBits();
+    if (iterator.getBits(1) !== 1) {
+        iterator.destroy();
+        throw new Error('Expected av1 private data to be version 1');
+    }
+    const version = iterator.getBits(7);
+    if (version !== 1) {
+        iterator.destroy();
+        throw new Error(`Expected av1 private data to be version 1, got ${version}`);
+    }
+    let str = 'av01.';
+    // https://aomediacodec.github.io/av1-isobmff/#codecsparam
+    const seqProfile = iterator.getBits(3);
+    // Profile
+    str += seqProfile;
+    str += '.';
+    const seq_level_idx = iterator.getBits(5);
+    const seq_tier_0 = iterator.getBits(1);
+    // Level
+    // The level parameter value SHALL equal the first level value indicated by seq_level_idx in the Sequence Header OBU
+    str += seq_level_idx.toString(16).padStart(2, '0');
+    str += seq_tier_0 ? 'H' : 'M';
+    str += '.';
+    // bitDepth
+    // The bitDepth parameter value SHALL equal the value of BitDepth variable as defined in [AV1] derived from the Sequence Header OBU
+    const high_bitdepth = iterator.getBits(1);
+    const twelve_bit = iterator.getBits(1);
+    const bitDepth = high_bitdepth && seqProfile === 2
+        ? twelve_bit
+            ? 12
+            : 10
+        : high_bitdepth
+            ? 10
+            : 8;
+    str += bitDepth.toString().padStart(2, '0');
+    str += '.';
+    // monochrome
+    // The monochrome parameter value, represented by a single digit decimal, SHALL equal the value of mono_chrome in the Sequence Header OBU
+    const mono_chrome = iterator.getBits(1);
+    str += mono_chrome ? '1' : '0';
+    str += '.';
+    // The chromaSubsampling parameter value, represented by a three-digit decimal,
+    // SHALL have its first digit equal to subsampling_x
+    const subsampling_x = iterator.getBits(1);
+    str += subsampling_x ? '1' : '0';
+    // and its second digit equal to subsampling_y.
+    const subsampling_y = iterator.getBits(1);
+    str += subsampling_y ? '1' : '0';
+    // If both subsampling_x and subsampling_y are set to 1, then the third digit SHALL be equal to chroma_sample_position, otherwise it SHALL be set to 0
+    const chroma_sample_position = iterator.getBits(2);
+    str +=
+        subsampling_x && subsampling_y
+            ? chroma_sample_position === 1
+                ? '1'
+                : '0'
+            : '0';
+    str += '.';
+    if (colrAtom && colrAtom.colorType === 'transfer-characteristics') {
+        str += colrAtom.primaries.toString().padStart(2, '0');
+        str += '.';
+        str += colrAtom.transfer.toString().padStart(2, '0');
+        str += '.';
+        str += colrAtom.matrixIndex.toString().padStart(2, '0');
+        str += '.';
+        str += colrAtom.fullRangeFlag ? '1' : '0';
+    }
+    else {
+        // Otherwise, the color_description_present_flag is set to 0 in the Sequence Header OBU. The colorPrimaries, transferCharacteristics, and matrixCoefficients parameter values SHOULD be set to the default values below.
+        // colorPrimaries 01 (ITU-R BT.709)
+        str += '01';
+        str += '.';
+        // transferCharacteristics 01 (ITU-R BT.709)
+        str += '01';
+        str += '.';
+        // matrixCoefficients 00 (ITU-R BT.709)
+        str += '01';
+        str += '.';
+        // videoFullRangeFlag 0 (studio swing representation)
+        str += '0';
+    }
+    // If the codecs parameter string ends with ".0.110.01.01.01.0" (containing all the default values below), that trailing part of the string SHOULD be omitted.
+    const suffix = '.0.110.01.01.01.0';
+    if (str.endsWith(suffix)) {
+        str = str.slice(0, -suffix.length);
+    }
+    iterator.destroy();
+    return str;
+};
+exports.parseAv1PrivateData = parseAv1PrivateData;

package/dist/boxes/webm/color.d.ts

@@ -0,0 +1,4 @@
+import type { VideoTrackColorParams } from '../../get-tracks';
+import type { ColourSegment } from './segments/all-segments';
+export declare const parseColorSegment: (colourSegment: ColourSegment) => VideoTrackColorParams;
+export declare const makeMatroskaColorBytes: ({ transferCharacteristics, matrixCoefficients, primaries, fullRange, }: VideoTrackColorParams) => import("./segments/all-segments").BytesAndOffset;

package/dist/boxes/webm/color.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMatroskaColorBytes = exports.parseColorSegment = void 0;
+const truthy_1 = require("../../truthy");
+const make_header_1 = require("./make-header");
+const traversal_1 = require("./traversal");
+const parseColorSegment = (colourSegment) => {
+    const transferCharacteristics = (0, traversal_1.getTransferCharacteristicsSegment)(colourSegment);
+    const matrixCoefficients = (0, traversal_1.getMatrixCoefficientsSegment)(colourSegment);
+    const primaries = (0, traversal_1.getPrimariesSegment)(colourSegment);
+    const range = (0, traversal_1.getRangeSegment)(colourSegment);
+    return {
+        transferCharacteristics: transferCharacteristics
+            ? transferCharacteristics.value.value === 1
+                ? 'bt709'
+                : transferCharacteristics.value.value === 6
+                    ? 'smpte170m'
+                    : transferCharacteristics.value.value === 13
+                        ? 'iec61966-2-1'
+                        : null
+            : null,
+        matrixCoefficients: matrixCoefficients
+            ? matrixCoefficients.value.value === 1
+                ? 'bt709'
+                : matrixCoefficients.value.value === 6
+                    ? 'smpte170m'
+                    : matrixCoefficients.value.value === 5
+                        ? 'bt470bg'
+                        : null
+            : null,
+        primaries: primaries
+            ? primaries.value.value === 1
+                ? 'bt709'
+                : primaries.value.value === 6
+                    ? 'smpte170m'
+                    : primaries.value.value === 5
+                        ? 'bt470bg'
+                        : null
+            : null,
+        fullRange: (transferCharacteristics === null || transferCharacteristics === void 0 ? void 0 : transferCharacteristics.value.value) && (matrixCoefficients === null || matrixCoefficients === void 0 ? void 0 : matrixCoefficients.value.value)
+            ? null
+            : range
+                ? Boolean(range === null || range === void 0 ? void 0 : range.value.value)
+                : null,
+    };
+};
+exports.parseColorSegment = parseColorSegment;
+const makeMatroskaColorBytes = ({ transferCharacteristics, matrixCoefficients, primaries, fullRange, }) => {
+    const rangeValue = transferCharacteristics && matrixCoefficients
+        ? 3
+        : fullRange === true
+            ? 2
+            : fullRange === false
+                ? 1
+                : 0;
+    // https://datatracker.ietf.org/doc/draft-ietf-cellar-matroska/
+    // 5.1.4.1.28.27
+    const primariesValue = primaries === 'bt709'
+        ? 1
+        : primaries === 'smpte170m'
+            ? 6
+            : primaries === 'bt470bg'
+                ? 5
+                : 2;
+    const transferChracteristicsValue = transferCharacteristics === 'bt709'
+        ? 1
+        : transferCharacteristics === 'smpte170m'
+            ? 6
+            : transferCharacteristics === 'iec61966-2-1'
+                ? 13
+                : 2;
+    if (matrixCoefficients === 'rgb') {
+        throw new Error('Cannot encode Matroska in RGB');
+    }
+    const matrixCoefficientsValue = matrixCoefficients === 'bt709'
+        ? 1
+        : matrixCoefficients === 'bt470bg'
+            ? 5
+            : matrixCoefficients === 'smpte170m'
+                ? 6
+                : 2;
+    return (0, make_header_1.makeMatroskaBytes)({
+        type: 'Colour',
+        minVintWidth: null,
+        value: [
+            transferChracteristicsValue === 2
+                ? null
+                : {
+                    type: 'TransferCharacteristics',
+                    value: {
+                        value: transferChracteristicsValue,
+                        byteLength: null,
+                    },
+                    minVintWidth: null,
+                },
+            matrixCoefficientsValue === 2
+                ? null
+                : {
+                    type: 'MatrixCoefficients',
+                    value: {
+                        value: matrixCoefficientsValue,
+                        byteLength: null,
+                    },
+                    minVintWidth: null,
+                },
+            primariesValue === 2
+                ? null
+                : {
+                    type: 'Primaries',
+                    value: {
+                        value: primariesValue,
+                        byteLength: null,
+                    },
+                    minVintWidth: null,
+                },
+            {
+                type: 'Range',
+                value: {
+                    value: rangeValue,
+                    byteLength: null,
+                },
+                minVintWidth: null,
+            },
+        ].filter(truthy_1.truthy),
+    });
+};
+exports.makeMatroskaColorBytes = makeMatroskaColorBytes;

package/dist/boxes/webm/description.d.ts

@@ -0,0 +1,2 @@
+import type { TrackEntry } from './segments/all-segments';
+export declare const getAudioDescription: (track: TrackEntry) => undefined | Uint8Array;

package/dist/boxes/webm/description.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAudioDescription = void 0;
+const buffer_iterator_1 = require("../../buffer-iterator");
+const traversal_1 = require("./traversal");
+const getAudioDescription = (track) => {
+    const codec = (0, traversal_1.getCodecSegment)(track);
+    if (!codec || codec.value !== 'A_VORBIS') {
+        return undefined;
+    }
+    // how to parse vorbis private
+    // https://github.com/google/ExoPlayer/blob/dd430f7053a1a3958deea3ead6a0565150c06bfc/library/extractor/src/main/java/com/google/android/exoplayer2/extractor/mkv/MatroskaExtractor.java#L2466
+    const privateData = (0, traversal_1.getPrivateData)(track);
+    if (!privateData) {
+        return undefined;
+    }
+    if (privateData[0] !== 2) {
+        throw new Error('Expected vorbis private data version 2');
+    }
+    let offset = 1;
+    let vorbisInfoLength = 0;
+    let vorbisSkipLength = 0;
+    while ((privateData[offset] & 0xff) === 0xff) {
+        vorbisInfoLength += 0xff;
+        offset++;
+    }
+    vorbisInfoLength += privateData[offset++] & 0xff;
+    while ((privateData[offset] & 0xff) === 0xff) {
+        vorbisSkipLength += 0xff;
+        offset++;
+    }
+    vorbisSkipLength += privateData[offset++] & 0xff;
+    if (privateData[offset] !== 0x01) {
+        throw new Error('Error parsing vorbis codec private');
+    }
+    const vorbisInfo = privateData.slice(offset, offset + vorbisInfoLength);
+    offset += vorbisInfoLength;
+    if (privateData[offset] !== 0x03) {
+        throw new Error('Error parsing vorbis codec private');
+    }
+    const vorbisComments = privateData.slice(offset, offset + vorbisSkipLength);
+    offset += vorbisSkipLength;
+    if (privateData[offset] !== 0x05) {
+        throw new Error('Error parsing vorbis codec private');
+    }
+    const vorbisBooks = privateData.slice(offset);
+    const bufferIterator = (0, buffer_iterator_1.getArrayBufferIterator)(vorbisInfo.slice(0), vorbisInfo.length);
+    // type
+    bufferIterator.getUint8();
+    // vorbis
+    const vorbis = bufferIterator.getByteString(6);
+    if (vorbis !== 'vorbis') {
+        throw new Error('Error parsing vorbis codec private');
+    }
+    const vorbisVersion = bufferIterator.getUint32Le();
+    if (vorbisVersion !== 0) {
+        throw new Error('Error parsing vorbis codec private');
+    }
+    const vorbisDescription = new Uint8Array([
+        // constructing the vorbis description
+        // This format consists in the page_segments field
+        /**
+         * The number of segment entries to appear in the segment table.
+         * The maximum number of 255 segments (255 bytes each) sets the maximum possible physical page size at 65307 bytes or just under 64kB (thus we know that a header corrupted so as destroy sizing/alignment information will not cause a runaway bitstream.
+         * We'll read in the page according to the corrupted size information that's guaranteed to be a reasonable size regardless, notice the checksum mismatch, drop sync and then look for recapture).
+         */
+        2,
+        // followed by the segment_table field
+        // offset of the comments table
+        vorbisInfo.length,
+        // offset of the codebooks table
+        vorbisComments.length,
+        // followed by the three Vorbis header packets,
+        // respectively the identification header,
+        ...vorbisInfo,
+        // the comments header,
+        ...vorbisComments,
+        // and the setup header, in this order, as described in section 4.2 of [VORBIS].
+        ...vorbisBooks,
+    ]);
+    return vorbisDescription;
+};
+exports.getAudioDescription = getAudioDescription;

package/dist/boxes/webm/ebml.d.ts

@@ -0,0 +1,2 @@
+export declare const measureEBMLVarInt: (value: number) => 2 | 5 | 1 | 3 | 4 | 6;
+export declare const getVariableInt: (value: number, minWidth: number | null) => Uint8Array;