@remotion/media-parser 4.0.192 → 4.0.194

package/dist/get-tracks.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTracks = exports.getNumberOfTracks = void 0;
+const get_fps_1 = require("./get-fps");
+const get_sample_positions_1 = require("./get-sample-positions");
+const traversal_1 = require("./traversal");
+// TODO: Use this to determine if all tracks are present
+const getNumberOfTracks = (segments) => {
+    const moovBox = (0, traversal_1.getMoovBox)(segments);
+    if (!moovBox) {
+        return 0;
+    }
+    const mvHdBox = (0, traversal_1.getMvhdBox)(moovBox);
+    if (!mvHdBox) {
+        return 0;
+    }
+    return mvHdBox.nextTrackId - 1;
+};
+exports.getNumberOfTracks = getNumberOfTracks;
+const getTracks = (segments) => {
+    const moovBox = (0, traversal_1.getMoovBox)(segments);
+    if (!moovBox) {
+        return [];
+    }
+    const foundTracks = [];
+    const tracks = (0, traversal_1.getTraks)(moovBox);
+    for (const track of tracks) {
+        const stszBox = (0, traversal_1.getStszBox)(track);
+        const stcoBox = (0, traversal_1.getStcoBox)(track);
+        const stscBox = (0, traversal_1.getStscBox)(track);
+        const tkhdBox = (0, traversal_1.getTkhdBox)(track);
+        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');
+        }
+        const samplePositions = (0, get_sample_positions_1.getSamplePositions)({
+            stcoBox,
+            stscBox,
+            stszBox,
+        });
+        if ((0, get_fps_1.trakBoxContainsAudio)(track)) {
+            foundTracks.push({
+                type: 'audio',
+                samplePositions,
+                trackId: tkhdBox.trackId,
+            });
+        }
+        if ((0, get_fps_1.trakBoxContainsVideo)(track)) {
+            foundTracks.push({
+                type: 'video',
+                samplePositions,
+                trackId: tkhdBox.trackId,
+            });
+        }
+    }
+    return foundTracks;
+};
+exports.getTracks = getTracks;

package/dist/get-video-codec.js

@@ -68,6 +68,9 @@ const getVideoCodec = (boxes) => {
                 if (trackType.codec === 'V_AV1') {
                     return 'av1';
                 }
+                if (trackType.codec === 'V_MPEG4/ISO/AVC') {
+                    return 'h264';
+                }
             }
         }
     }

package/dist/has-all-info.d.ts

@@ -1,3 +1,3 @@
 import type { Options } from './options';
 import type { ParseResult } from './parse-result';
-export declare const hasAllInfo: (options: Options<boolean, boolean, boolean, boolean, boolean>, parseResult: ParseResult) => boolean;
+export declare const hasAllInfo: (options: Options<boolean, boolean, boolean, boolean, boolean, boolean>, parseResult: ParseResult) => boolean;

package/dist/has-all-info.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hasAllInfo = void 0;
+const get_audio_codec_1 = require("./get-audio-codec");
 const get_dimensions_1 = require("./get-dimensions");
 const get_duration_1 = require("./get-duration");
 const get_fps_1 = require("./get-fps");
@@ -25,6 +26,9 @@ const hasAllInfo = (options, parseResult) => {
         if (key === 'videoCodec') {
             return (0, get_video_codec_1.hasVideoCodec)(parseResult.segments) !== null;
         }
+        if (key === 'audioCodec') {
+            return (0, get_audio_codec_1.hasAudioCodec)(parseResult.segments) !== null;
+        }
         throw new Error(`Unknown key: ${key}`);
     });
 };

package/dist/options.d.ts

@@ -2,14 +2,16 @@ import type { Dimensions } from './get-dimensions';
 import type { AnySegment } from './parse-result';
 import type { ReaderInterface } from './reader';
 export type KnownVideoCodecs = 'h264' | 'h265' | 'vp8' | 'vp9' | 'av1' | 'prores';
-export type Options<EnableDimensions extends boolean, EnableDuration extends boolean, EnableBoxes extends boolean, EnableFps extends boolean, EnableVideoCodec extends boolean> = {
+export type KnownAudioCodecs = 'aac' | 'mp3' | 'aiff' | 'opus' | 'pcm' | 'unknown';
+export type Options<EnableDimensions extends boolean, EnableDuration extends boolean, EnableBoxes extends boolean, EnableFps extends boolean, EnableVideoCodec extends boolean, EnableAudioCodec extends boolean> = {
     dimensions?: EnableDimensions;
     durationInSeconds?: EnableDuration;
     boxes?: EnableBoxes;
     fps?: EnableFps;
     videoCodec?: EnableVideoCodec;
+    audioCodec?: EnableAudioCodec;
 };
-export type Metadata<EnableDimensions extends boolean, EnableDuration extends boolean, EnableBoxes extends boolean, EnableFps extends boolean, EnableVideoCodec extends boolean> = (EnableDimensions extends true ? {
+export type Metadata<EnableDimensions extends boolean, EnableDuration extends boolean, EnableBoxes extends boolean, EnableFps extends boolean, EnableVideoCodec extends boolean, EnableAudioCodec extends boolean> = (EnableDimensions extends true ? {
     dimensions: Dimensions;
 } : {}) & (EnableDuration extends true ? {
     durationInSeconds: number | null;
@@ -19,5 +21,7 @@ export type Metadata<EnableDimensions extends boolean, EnableDuration extends bo
     fps: number | null;
 } : {}) & (EnableVideoCodec extends true ? {
     videoCodec: KnownVideoCodecs | null;
+} : {}) & (EnableAudioCodec extends true ? {
+    audioCodec: KnownAudioCodecs | null;
 } : {});
-export type ParseMedia = <EnableDimensions extends boolean, EnableDuration extends boolean, EnableBoxes extends boolean, EnableFps extends boolean, EnableVideoCodec extends boolean>(src: string, options: Options<EnableDimensions, EnableDuration, EnableBoxes, EnableFps, EnableVideoCodec>, readerInterface?: ReaderInterface) => Promise<Metadata<EnableDimensions, EnableDuration, EnableBoxes, EnableFps, EnableVideoCodec>>;
+export type ParseMedia = <EnableDimensions extends boolean, EnableDuration extends boolean, EnableBoxes extends boolean, EnableFps extends boolean, EnableVideoCodec extends boolean, EnableAudioCodec extends boolean>(src: string, options: Options<EnableDimensions, EnableDuration, EnableBoxes, EnableFps, EnableVideoCodec, EnableAudioCodec>, readerInterface?: ReaderInterface) => Promise<Metadata<EnableDimensions, EnableDuration, EnableBoxes, EnableFps, EnableVideoCodec, EnableAudioCodec>>;

package/dist/parse-media.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMedia = void 0;
 const buffer_iterator_1 = require("./buffer-iterator");
 const from_web_1 = require("./from-web");
+const get_audio_codec_1 = require("./get-audio-codec");
 const get_dimensions_1 = require("./get-dimensions");
 const get_duration_1 = require("./get-duration");
 const get_fps_1 = require("./get-fps");
@@ -10,23 +11,47 @@ const get_video_codec_1 = require("./get-video-codec");
 const has_all_info_1 = require("./has-all-info");
 const parse_video_1 = require("./parse-video");
 const parseMedia = async (src, options, readerInterface = from_web_1.webReader) => {
-    const reader = await readerInterface.read(src, null);
+    const { reader, contentLength } = await readerInterface.read(src, null);
+    let currentReader = reader;
     const returnValue = {};
-    const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(new Uint8Array([]));
-    let parseResult = (0, parse_video_1.parseVideo)(iterator);
-    while (parseResult.status === 'incomplete') {
-        const result = await reader.read();
+    let iterator = null;
+    let parseResult = null;
+    while (parseResult === null || parseResult.status === 'incomplete') {
+        const result = await currentReader.read();
         if (result.done) {
             break;
         }
-        iterator.addData(result.value);
-        parseResult = parseResult.continueParsing();
+        if (iterator) {
+            iterator.addData(result.value);
+        }
+        else {
+            iterator = (0, buffer_iterator_1.getArrayBufferIterator)(result.value, contentLength !== null && contentLength !== void 0 ? contentLength : undefined);
+        }
+        if (parseResult) {
+            parseResult = parseResult.continueParsing();
+        }
+        else {
+            parseResult = (0, parse_video_1.parseVideo)(iterator);
+        }
         if ((0, has_all_info_1.hasAllInfo)(options, parseResult)) {
-            if (!reader.closed) {
-                reader.cancel(new Error('has all information'));
+            if (!currentReader.closed) {
+                currentReader.cancel(new Error('has all information'));
             }
             break;
         }
+        if (parseResult &&
+            parseResult.status === 'incomplete' &&
+            parseResult.skipTo !== null) {
+            if (!currentReader.closed) {
+                currentReader.cancel(new Error('skipped ahead'));
+            }
+            const { reader: newReader } = await readerInterface.read(src, parseResult.skipTo);
+            currentReader = newReader;
+            iterator.skipTo(parseResult.skipTo);
+        }
+    }
+    if (!parseResult) {
+        throw new Error('Could not parse video');
     }
     if (options.dimensions) {
         returnValue.dimensions = (0, get_dimensions_1.getDimensions)(parseResult.segments);
@@ -40,6 +65,9 @@ const parseMedia = async (src, options, readerInterface = from_web_1.webReader)
     if (options.videoCodec) {
         returnValue.videoCodec = (0, get_video_codec_1.getVideoCodec)(parseResult.segments);
     }
+    if (options.audioCodec) {
+        returnValue.audioCodec = (0, get_audio_codec_1.getAudioCodec)(parseResult.segments);
+    }
     if (options.boxes) {
         returnValue.boxes = parseResult.segments;
     }

package/dist/parse-result.d.ts

@@ -1,4 +1,5 @@
 import type { BaseBox } from './boxes/iso-base-media/base-type';
+import type { EsdsBox } from './boxes/iso-base-media/esds/esds';
 import type { FtypBox } from './boxes/iso-base-media/ftyp';
 import type { MdhdBox } from './boxes/iso-base-media/mdhd';
 import type { MoovBox } from './boxes/iso-base-media/moov/moov';
@@ -17,7 +18,7 @@ interface RegularBox extends BaseBox {
     offset: number;
     type: 'regular-box';
 }
-export type IsoBaseMediaBox = RegularBox | FtypBox | MvhdBox | TkhdBox | StsdBox | MebxBox | KeysBox | MoovBox | TrakBox | SttsBox | MdhdBox;
+export type IsoBaseMediaBox = RegularBox | FtypBox | MvhdBox | TkhdBox | StsdBox | MebxBox | KeysBox | MoovBox | TrakBox | SttsBox | MdhdBox | EsdsBox;
 export type AnySegment = MatroskaSegment | IsoBaseMediaBox;
 export type ParseResult = {
     status: 'done';
@@ -25,6 +26,7 @@ export type ParseResult = {
 } | {
     status: 'incomplete';
     segments: AnySegment[];
+    skipTo: number | null;
     continueParsing: () => ParseResult;
 };
 export {};

package/dist/parse-video.d.ts

@@ -4,6 +4,7 @@ export type BoxAndNext = {
     type: 'complete';
     box: IsoBaseMediaBox;
     size: number;
+    skipTo: number | null;
 } | {
     type: 'incomplete';
 };

package/dist/parse-video.js

@@ -11,6 +11,7 @@ const parseVideo = (iterator) => {
             continueParsing: () => {
                 return (0, exports.parseVideo)(iterator);
             },
+            skipTo: null,
         };
     }
     if (iterator.isIsoBaseMedia()) {

package/dist/reader.d.ts

@@ -1,4 +1,8 @@
-type ReadContent = (src: string, range: [number, number] | null) => Promise<ReadableStreamDefaultReader<Uint8Array>>;
+type ReadResult = {
+    reader: ReadableStreamDefaultReader<Uint8Array>;
+    contentLength: number | null;
+};
+type ReadContent = (src: string, range: [number, number] | number | null) => Promise<ReadResult>;
 type GetLength = (src: string) => Promise<number>;
 export type ReaderInterface = {
     read: ReadContent;

package/dist/traversal.d.ts

@@ -0,0 +1,19 @@
+import type { MoovBox } from './boxes/iso-base-media/moov/moov';
+import type { MvhdBox } from './boxes/iso-base-media/mvhd';
+import type { StcoBox } from './boxes/iso-base-media/stsd/stco';
+import type { StscBox } from './boxes/iso-base-media/stsd/stsc';
+import type { StsdBox } from './boxes/iso-base-media/stsd/stsd';
+import type { StszBox } from './boxes/iso-base-media/stsd/stsz';
+import type { TkhdBox } from './boxes/iso-base-media/tkhd';
+import type { TrakBox } from './boxes/iso-base-media/trak/trak';
+import type { AnySegment, RegularBox } from './parse-result';
+export declare const getMoovBox: (segments: AnySegment[]) => MoovBox | null;
+export declare const getMvhdBox: (moovBox: MoovBox) => MvhdBox | null;
+export declare const getTraks: (moovBox: MoovBox) => TrakBox[];
+export declare const getTkhdBox: (trakBox: TrakBox) => TkhdBox | null;
+export declare const getMdiaBox: (trakBox: TrakBox) => RegularBox | null;
+export declare const getStblBox: (trakBox: TrakBox) => RegularBox | null;
+export declare const getStsdBox: (trakBox: TrakBox) => StsdBox | null;
+export declare const getStcoBox: (trakBox: TrakBox) => StcoBox | null;
+export declare const getStszBox: (trakBox: TrakBox) => StszBox | null;
+export declare const getStscBox: (trakBox: TrakBox) => StscBox | null;

package/dist/traversal.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStscBox = exports.getStszBox = exports.getStcoBox = exports.getStsdBox = exports.getStblBox = exports.getMdiaBox = exports.getTkhdBox = exports.getTraks = exports.getMvhdBox = exports.getMoovBox = void 0;
+const getMoovBox = (segments) => {
+    const moovBox = segments.find((s) => s.type === 'moov-box');
+    if (!moovBox || moovBox.type !== 'moov-box') {
+        return null;
+    }
+    return moovBox;
+};
+exports.getMoovBox = getMoovBox;
+const getMvhdBox = (moovBox) => {
+    const mvHdBox = moovBox.children.find((s) => s.type === 'mvhd-box');
+    if (!mvHdBox || mvHdBox.type !== 'mvhd-box') {
+        return null;
+    }
+    return mvHdBox;
+};
+exports.getMvhdBox = getMvhdBox;
+const getTraks = (moovBox) => {
+    return moovBox.children.filter((s) => s.type === 'trak-box');
+};
+exports.getTraks = getTraks;
+const getTkhdBox = (trakBox) => {
+    const tkhdBox = trakBox.children.find((s) => s.type === 'tkhd-box');
+    return tkhdBox;
+};
+exports.getTkhdBox = getTkhdBox;
+const getMdiaBox = (trakBox) => {
+    const mdiaBox = trakBox.children.find((s) => s.type === 'regular-box' && s.boxType === 'mdia');
+    if (!mdiaBox || mdiaBox.type !== 'regular-box') {
+        return null;
+    }
+    return mdiaBox;
+};
+exports.getMdiaBox = getMdiaBox;
+const getStblBox = (trakBox) => {
+    const mdiaBox = (0, exports.getMdiaBox)(trakBox);
+    if (!mdiaBox) {
+        return null;
+    }
+    const minfBox = mdiaBox.children.find((s) => s.type === 'regular-box' && s.boxType === 'minf');
+    if (!minfBox || minfBox.type !== 'regular-box') {
+        return null;
+    }
+    const stblBox = minfBox.children.find((s) => s.type === 'regular-box' && s.boxType === 'stbl');
+    if (!stblBox || stblBox.type !== 'regular-box') {
+        return null;
+    }
+    return stblBox;
+};
+exports.getStblBox = getStblBox;
+const getStsdBox = (trakBox) => {
+    const stblBox = (0, exports.getStblBox)(trakBox);
+    if (!stblBox || stblBox.type !== 'regular-box') {
+        return null;
+    }
+    const stsdBox = stblBox.children.find((s) => s.type === 'stsd-box');
+    return stsdBox;
+};
+exports.getStsdBox = getStsdBox;
+const getStcoBox = (trakBox) => {
+    const stblBox = (0, exports.getStblBox)(trakBox);
+    if (!stblBox || stblBox.type !== 'regular-box') {
+        return null;
+    }
+    const stcoBox = stblBox.children.find((s) => s.type === 'stco-box');
+    return stcoBox;
+};
+exports.getStcoBox = getStcoBox;
+const getStszBox = (trakBox) => {
+    const stblBox = (0, exports.getStblBox)(trakBox);
+    if (!stblBox || stblBox.type !== 'regular-box') {
+        return null;
+    }
+    const stszBox = stblBox.children.find((s) => s.type === 'stsz-box');
+    return stszBox;
+};
+exports.getStszBox = getStszBox;
+const getStscBox = (trakBox) => {
+    const stblBox = (0, exports.getStblBox)(trakBox);
+    if (!stblBox || stblBox.type !== 'regular-box') {
+        return null;
+    }
+    const stcoBox = stblBox.children.find((b) => b.type === 'stsc-box');
+    return stcoBox;
+};
+exports.getStscBox = getStscBox;

package/package.json

@@ -3,11 +3,11 @@
     "url": "https://github.com/remotion-dev/remotion/tree/main/packages/media-parser"
   },
   "name": "@remotion/media-parser",
-  "version": "4.0.192",
+  "version": "4.0.194",
   "main": "dist/index.js",
   "sideEffects": false,
   "devDependencies": {
-    "@remotion/renderer": "4.0.192"
+    "@remotion/renderer": "4.0.194"
   },
   "publishConfig": {
     "access": "public"

package/src/boxes/iso-base-media/esds/esds-descriptors.ts

@@ -0,0 +1,104 @@
+import type {BufferIterator} from '../../../buffer-iterator';
+
+type AudioObjectType = 'aac' | 'mp3' | 'unknown';
+
+type DecoderConfigDescriptor = {
+	type: 'decoder-config-descriptor';
+	objectTypeIndication: AudioObjectType;
+};
+
+const mapToObjectAudioIndicator = (num: number): AudioObjectType => {
+	// 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';
+};
+
+type SlConfigDescriptor = {
+	type: 'sl-config-descriptor';
+};
+
+type UnknownDescriptor = {
+	type: 'unknown-descriptor';
+};
+
+export type Descriptor =
+	| DecoderConfigDescriptor
+	| SlConfigDescriptor
+	| UnknownDescriptor;
+
+type DescriptorAndNext = {
+	descriptor: Descriptor | null;
+};
+
+export const processDescriptor = ({
+	iterator,
+}: {
+	iterator: BufferIterator;
+}): DescriptorAndNext => {
+	const tag = iterator.getUint8();
+
+	if (tag === 4) {
+		const size = iterator.getPaddedFourByteNumber();
+		const initialOffset = iterator.counter.getOffset();
+
+		const objectTypeIndication = iterator.getUint8();
+
+		const remaining = size - (iterator.counter.getOffset() - initialOffset);
+		iterator.discard(remaining);
+		return {
+			descriptor: {
+				type: 'decoder-config-descriptor',
+				objectTypeIndication: mapToObjectAudioIndicator(objectTypeIndication),
+			},
+		};
+	}
+
+	if (tag === 6) {
+		const size = iterator.getPaddedFourByteNumber();
+
+		iterator.discard(size);
+		return {
+			descriptor: {
+				type: 'sl-config-descriptor',
+			},
+		};
+	}
+
+	return {
+		descriptor: null,
+	};
+};
+
+export const parseDescriptors = (
+	iterator: BufferIterator,
+	maxBytes: number,
+): Descriptor[] => {
+	const descriptors: Descriptor[] = [];
+	const initialOffset = iterator.counter.getOffset();
+
+	while (
+		iterator.bytesRemaining() > 0 &&
+		iterator.counter.getOffset() - initialOffset < maxBytes
+	) {
+		const {descriptor} = processDescriptor({
+			iterator,
+		});
+
+		if (descriptor) {
+			descriptors.push(descriptor);
+		} else {
+			break;
+		}
+	}
+
+	return descriptors;
+};

package/src/boxes/iso-base-media/esds/esds.ts

@@ -0,0 +1,49 @@
+import type {BufferIterator} from '../../../buffer-iterator';
+import type {Descriptor} from './esds-descriptors';
+import {parseDescriptors} from './esds-descriptors';
+
+export interface EsdsBox {
+	type: 'esds-box';
+	version: number;
+	tag: number;
+	sizeOfInstance: number;
+	esId: number;
+	descriptors: Descriptor[];
+}
+
+export const parseEsds = ({
+	data,
+	size,
+	fileOffset,
+}: {
+	data: BufferIterator;
+	size: number;
+	fileOffset: number;
+}): EsdsBox => {
+	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 = parseDescriptors(data, remaining);
+
+	const remainingNow = size - (data.counter.getOffset() - fileOffset);
+
+	data.discard(remainingNow);
+
+	return {
+		type: 'esds-box',
+		version,
+		tag,
+		sizeOfInstance,
+		esId,
+		descriptors,
+	};
+};