@remotion/media-parser 4.0.255 → 4.0.256

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

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

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerTrack = void 0;
+const registerTrack = async ({ state, options, track, }) => {
+    if (track.type === 'video' && options.onVideoTrack) {
+        const callback = await options.onVideoTrack(track);
+        await state.registerVideoSampleCallback(track.trackId, callback !== null && callback !== void 0 ? callback : null);
+    }
+    if (track.type === 'audio' && options.onAudioTrack) {
+        const callback = await options.onAudioTrack(track);
+        await state.registerAudioSampleCallback(track.trackId, callback !== null && callback !== void 0 ? callback : null);
+    }
+};
+exports.registerTrack = registerTrack;

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/base-type.d.ts

@@ -0,0 +1,4 @@
+export interface BaseBox {
+    boxSize: number;
+    offset: number;
+}

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

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

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

@@ -0,0 +1,14 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+type UnknownDecoderSpecificConfig = {
+    type: 'unknown-decoder-specific-config';
+};
+type AudioSpecificConfig = {
+    type: 'mp4a-specific-config';
+    audioObjectType: number;
+    samplingFrequencyIndex: number;
+    channelConfiguration: number;
+    asBytes: Uint8Array;
+};
+export type DecoderSpecificConfig = UnknownDecoderSpecificConfig | AudioSpecificConfig;
+export declare const parseDecoderSpecificConfig: (iterator: BufferIterator) => DecoderSpecificConfig;
+export {};

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

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDecoderSpecificConfig = void 0;
+const parseDecoderSpecificConfig = (iterator) => {
+    const layerTag = iterator.getUint8();
+    const layerSize = iterator.getPaddedFourByteNumber();
+    const start = iterator.counter.getOffset();
+    if (layerTag !== 5) {
+        iterator.discard(layerSize);
+        return {
+            type: 'unknown-decoder-specific-config',
+        };
+    }
+    // https://csclub.uwaterloo.ca/~pbarfuss/ISO14496-3-2009.pdf
+    // 1.6.2.1 AudioSpecificConfig
+    const bytes = iterator.getSlice(layerSize);
+    iterator.counter.decrement(layerSize);
+    iterator.startReadingBits();
+    const audioObjectType = iterator.getBits(5);
+    const samplingFrequencyIndex = iterator.getBits(4);
+    if (samplingFrequencyIndex === 0xf) {
+        iterator.getBits(24);
+    }
+    const channelConfiguration = iterator.getBits(4);
+    iterator.stopReadingBits();
+    const read = iterator.counter.getOffset() - start;
+    if (read < layerSize) {
+        iterator.discard(layerSize - read);
+    }
+    return {
+        type: 'mp4a-specific-config',
+        audioObjectType,
+        samplingFrequencyIndex,
+        channelConfiguration,
+        asBytes: bytes,
+    };
+};
+exports.parseDecoderSpecificConfig = parseDecoderSpecificConfig;

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

@@ -0,0 +1,29 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+import type { DecoderSpecificConfig } from './decoder-specific-config';
+type AudioObjectType = 'aac' | 'mp3' | 'unknown';
+type DecoderConfigDescriptor = {
+    type: 'decoder-config-descriptor';
+    objectTypeIndication: AudioObjectType;
+    asNumber: number;
+    streamType: number;
+    upStream: number;
+    bufferSizeDB: number;
+    maxBitrate: number;
+    avgBitrate: number;
+    decoderSpecificConfigs: DecoderSpecificConfig[];
+};
+type SlConfigDescriptor = {
+    type: 'sl-config-descriptor';
+};
+type UnknownDescriptor = {
+    type: 'unknown-descriptor';
+};
+export type Descriptor = DecoderConfigDescriptor | SlConfigDescriptor | UnknownDescriptor;
+type DescriptorAndNext = {
+    descriptor: Descriptor | null;
+};
+export declare const processDescriptor: ({ iterator, }: {
+    iterator: BufferIterator;
+}) => DescriptorAndNext;
+export declare const parseDescriptors: (iterator: BufferIterator, maxBytes: number) => Descriptor[];
+export {};

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

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDescriptors = exports.processDescriptor = void 0;
+const decoder_specific_config_1 = require("./decoder-specific-config");
+const mapToObjectAudioIndicator = (num) => {
+    // https://chromium.googlesource.com/chromium/src/media/+/master/formats/mp4/es_descriptor.h
+    // http://netmedia.zju.edu.cn/multimedia2013/mpeg-4/ISO%20IEC%2014496-1%20MPEG-4%20System%20Standard.pdf
+    // Page 42, table 8
+    if (num === 0x40) {
+        return 'aac';
+    }
+    if (num === 0x6b) {
+        return 'mp3';
+    }
+    return 'unknown';
+};
+const processDescriptor = ({ iterator, }) => {
+    const tag = iterator.getUint8();
+    if (tag === 4) {
+        const size = iterator.getPaddedFourByteNumber();
+        const initialOffset = iterator.counter.getOffset();
+        const objectTypeIndication = iterator.getUint8();
+        iterator.startReadingBits();
+        const streamType = iterator.getBits(6);
+        const upStream = iterator.getBits(1);
+        // reserved
+        iterator.getBits(1);
+        const bufferSizeDB = iterator.getBits(24);
+        iterator.stopReadingBits();
+        const maxBitrate = iterator.getUint32();
+        const avgBitrate = iterator.getUint32();
+        const decoderSpecificConfigs = [];
+        while (size - (iterator.counter.getOffset() - initialOffset) > 0) {
+            const decoderSpecificConfig = (0, decoder_specific_config_1.parseDecoderSpecificConfig)(iterator);
+            decoderSpecificConfigs.push(decoderSpecificConfig);
+        }
+        return {
+            descriptor: {
+                type: 'decoder-config-descriptor',
+                objectTypeIndication: mapToObjectAudioIndicator(objectTypeIndication),
+                asNumber: objectTypeIndication,
+                bufferSizeDB,
+                streamType,
+                upStream,
+                avgBitrate,
+                maxBitrate,
+                decoderSpecificConfigs,
+            },
+        };
+    }
+    if (tag === 6) {
+        const size = iterator.getPaddedFourByteNumber();
+        iterator.discard(size);
+        return {
+            descriptor: {
+                type: 'sl-config-descriptor',
+            },
+        };
+    }
+    return {
+        descriptor: null,
+    };
+};
+exports.processDescriptor = processDescriptor;
+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,
+        });
+        if (descriptor) {
+            descriptors.push(descriptor);
+        }
+        else {
+            break;
+        }
+    }
+    return descriptors;
+};
+exports.parseDescriptors = parseDescriptors;

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

@@ -0,0 +1,15 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+import type { Descriptor } from './esds-descriptors';
+export interface EsdsBox {
+    type: 'esds-box';
+    version: number;
+    tag: number;
+    sizeOfInstance: number;
+    esId: number;
+    descriptors: Descriptor[];
+}
+export declare const parseEsds: ({ data, size, fileOffset, }: {
+    data: BufferIterator;
+    size: number;
+    fileOffset: number;
+}) => EsdsBox;

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseEsds = void 0;
+const esds_descriptors_1 = require("./esds-descriptors");
+const parseEsds = ({ data, size, fileOffset, }) => {
+    const version = data.getUint8();
+    // Flags, we discard them
+    data.discard(3);
+    const tag = data.getUint8();
+    const sizeOfInstance = data.getPaddedFourByteNumber();
+    const esId = data.getUint16();
+    // disard 1 byte, currently unknown
+    data.discard(1);
+    const remaining = size - (data.counter.getOffset() - fileOffset);
+    const descriptors = (0, esds_descriptors_1.parseDescriptors)(data, remaining);
+    const remainingNow = size - (data.counter.getOffset() - fileOffset);
+    data.discard(remainingNow);
+    return {
+        type: 'esds-box',
+        version,
+        tag,
+        sizeOfInstance,
+        esId,
+        descriptors,
+    };
+};
+exports.parseEsds = parseEsds;

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

@@ -0,0 +1,13 @@
+import type { BufferIterator } from '../../buffer-iterator';
+import type { BaseBox } from './base-type';
+export interface FtypBox extends BaseBox {
+    type: 'ftyp-box';
+    majorBrand: string;
+    minorVersion: number;
+    compatibleBrands: string[];
+}
+export declare const parseFtyp: ({ iterator, size, offset, }: {
+    iterator: BufferIterator;
+    size: number;
+    offset: number;
+}) => FtypBox;

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFtyp = void 0;
+const parseFtyp = ({ iterator, size, offset, }) => {
+    const majorBrand = iterator.getByteString(4);
+    const minorVersion = iterator.getFourByteNumber();
+    const types = (size - iterator.counter.getOffset()) / 4;
+    const compatibleBrands = [];
+    for (let i = 0; i < types; i++) {
+        compatibleBrands.push(iterator.getByteString(4).trim());
+    }
+    const offsetAtEnd = iterator.counter.getOffset();
+    return {
+        type: 'ftyp-box',
+        majorBrand,
+        minorVersion,
+        compatibleBrands,
+        offset,
+        boxSize: offsetAtEnd - offset,
+    };
+};
+exports.parseFtyp = parseFtyp;

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/get-sample-positions-from-track.d.ts

@@ -0,0 +1,4 @@
+import type { SamplePosition } from '../../get-sample-positions';
+import type { IsoBaseMediaBox } from '../../parse-result';
+import type { TrakBox } from './trak/trak';
+export declare const getSamplePositionsFromTrack: (trakBox: TrakBox, moofBox: IsoBaseMediaBox | null) => SamplePosition[];

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

@@ -0,0 +1,54 @@
+"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);
+    const stssBox = (0, traversal_1.getStssBox)(trakBox);
+    const sttsBox = (0, traversal_1.getSttsBox)(trakBox);
+    const tkhdBox = (0, traversal_1.getTkhdBox)(trakBox);
+    const cttsBox = (0, traversal_1.getCttsBox)(trakBox);
+    if (!tkhdBox) {
+        throw new Error('Expected tkhd box in trak box');
+    }
+    if (!stszBox) {
+        throw new Error('Expected stsz box in trak box');
+    }
+    if (!stcoBox) {
+        throw new Error('Expected stco box in trak box');
+    }
+    if (!stscBox) {
+        throw new Error('Expected stsc box in trak box');
+    }
+    if (!sttsBox) {
+        throw new Error('Expected stts box in trak box');
+    }
+    if (!timescaleAndDuration) {
+        throw new Error('Expected timescale and duration in trak box');
+    }
+    let samplePositions = (0, get_sample_positions_1.getSamplePositions)({
+        stcoBox,
+        stscBox,
+        stszBox,
+        stssBox,
+        sttsBox,
+        cttsBox,
+    });
+    if (samplePositions.length === 0 && moofBox) {
+        samplePositions = (0, samples_from_moof_1.getSamplesFromMoof)({ moofBox, trackId: tkhdBox.trackId });
+    }
+    return samplePositions;
+};
+exports.getSamplePositionsFromTrack = getSamplePositionsFromTrack;

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

@@ -0,0 +1,3 @@
+import type { AudioTrack, OtherTrack, VideoTrack } from '../../get-tracks';
+import type { TrakBox } from './trak/trak';
+export declare const makeBaseMediaTrack: (trakBox: TrakBox) => VideoTrack | AudioTrack | OtherTrack | null;

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

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeBaseMediaTrack = void 0;
+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, _d;
+    const tkhdBox = (0, traversal_1.getTkhdBox)(trakBox);
+    const videoDescriptors = (0, traversal_1.getVideoDescriptors)(trakBox);
+    const timescaleAndDuration = (0, get_fps_1.getTimescaleAndDuration)(trakBox);
+    if (!tkhdBox) {
+        throw new Error('Expected tkhd box in trak box');
+    }
+    if (!timescaleAndDuration) {
+        throw new Error('Expected timescale and duration in trak box');
+    }
+    if ((0, get_fps_1.trakBoxContainsAudio)(trakBox)) {
+        const numberOfChannels = (0, get_audio_codec_1.getNumberOfChannelsFromTrak)(trakBox);
+        if (numberOfChannels === null) {
+            throw new Error('Could not find number of channels');
+        }
+        const sampleRate = (0, get_audio_codec_1.getSampleRate)(trakBox);
+        if (sampleRate === null) {
+            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: actual.numberOfChannels,
+            sampleRate: actual.sampleRate,
+            description: (_c = actual.codecPrivate) !== null && _c !== void 0 ? _c : undefined,
+            trakBox,
+            codecPrivate: actual.codecPrivate,
+            codecWithoutConfig,
+        };
+    }
+    if (!(0, get_fps_1.trakBoxContainsVideo)(trakBox)) {
+        return {
+            type: 'other',
+            trackId: tkhdBox.trackId,
+            timescale: timescaleAndDuration.timescale,
+            trakBox,
+        };
+    }
+    const videoSample = (0, get_sample_aspect_ratio_1.getStsdVideoConfig)(trakBox);
+    if (!videoSample) {
+        throw new Error('No video sample');
+    }
+    const sampleAspectRatio = (0, get_sample_aspect_ratio_1.getSampleAspectRatio)(trakBox);
+    const aspectRatioApplied = (0, get_sample_aspect_ratio_1.applyAspectRatios)({
+        dimensions: videoSample,
+        sampleAspectRatio,
+        displayAspectRatio: (0, get_sample_aspect_ratio_1.getDisplayAspectRatio)({
+            sampleAspectRatio,
+            nativeDimensions: videoSample,
+        }),
+    });
+    const { displayAspectHeight, displayAspectWidth, height, rotation, width } = (0, get_sample_aspect_ratio_1.applyTkhdBox)(aspectRatioApplied, tkhdBox);
+    const codec = (0, get_video_codec_1.getVideoCodecString)(trakBox);
+    if (!codec) {
+        throw new Error('Could not find video codec');
+    }
+    const privateData = (0, get_video_codec_1.getVideoPrivateData)(trakBox);
+    const track = {
+        type: 'video',
+        trackId: tkhdBox.trackId,
+        description: videoDescriptors !== null && videoDescriptors !== void 0 ? videoDescriptors : undefined,
+        timescale: timescaleAndDuration.timescale,
+        codec,
+        sampleAspectRatio: (0, get_sample_aspect_ratio_1.getSampleAspectRatio)(trakBox),
+        width,
+        height,
+        codedWidth: videoSample.width,
+        codedHeight: videoSample.height,
+        // Repeating those keys because they get picked up by VideoDecoder
+        displayAspectWidth,
+        displayAspectHeight,
+        rotation,
+        trakBox,
+        codecPrivate: privateData,
+        color: (_d = (0, get_video_codec_1.getIsoBmColrConfig)(trakBox)) !== null && _d !== void 0 ? _d : {
+            fullRange: null,
+            matrixCoefficients: null,
+            primaries: null,
+            transferCharacteristics: null,
+        },
+        codecWithoutConfig: (0, get_video_codec_1.getVideoCodecFromIsoTrak)(trakBox),
+        fps: (0, get_fps_1.getFpsFromMp4TrakBox)(trakBox),
+    };
+    return track;
+};
+exports.makeBaseMediaTrack = makeBaseMediaTrack;

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

@@ -0,0 +1,25 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+import type { IsoBaseMediaBox } from '../../../parse-result';
+import type { ParserContext } from '../../../parser-context';
+type MdatStatus = {
+    status: 'samples-buffered';
+} | {
+    status: 'samples-skipped';
+} | {
+    status: 'samples-processed';
+};
+export type MdatBox = {
+    type: 'mdat-box';
+    boxSize: number;
+    fileOffset: number;
+} & MdatStatus;
+export declare const parseMdat: ({ data, size, fileOffset, existingBoxes, options, signal, maySkipSampleProcessing, }: {
+    data: BufferIterator;
+    size: number;
+    fileOffset: number;
+    existingBoxes: IsoBaseMediaBox[];
+    options: ParserContext;
+    signal: AbortSignal | null;
+    maySkipSampleProcessing: boolean;
+}) => Promise<MdatBox>;
+export {};