@remotion/media-parser 4.0.201 → 4.0.204

package/src/get-duration.ts

@@ -1,43 +1,49 @@
+import {getSamplePositionsFromTrack} from './boxes/iso-base-media/get-sample-positions-from-track';
+import type {TrakBox} from './boxes/iso-base-media/trak/trak';
+import type {DurationSegment} from './boxes/webm/segments/all-segments';
+import {getTracks} from './get-tracks';
 import type {AnySegment} from './parse-result';
-import {getMoovBox, getMvhdBox} from './traversal';
+import type {ParserState} from './parser-state';
+import {getMoofBox, getMoovBox, getMvhdBox} from './traversal';
 
 const getDurationFromMatroska = (segments: AnySegment[]): number | null => {
-	const mainSegment = segments.find((s) => s.type === 'main-segment');
-	if (!mainSegment || mainSegment.type !== 'main-segment') {
+	const mainSegment = segments.find((s) => s.type === 'Segment');
+	if (!mainSegment || mainSegment.type !== 'Segment') {
 		return null;
 	}
 
-	const {children} = mainSegment;
+	const {value: children} = mainSegment;
 	if (!children) {
 		return null;
 	}
 
-	const infoSegment = children.find((s) => s.type === 'info-segment');
+	const infoSegment = children.find((s) => s.type === 'Info');
 
 	const relevantBoxes = [
-		...mainSegment.children,
-		...(infoSegment && infoSegment.type === 'info-segment'
-			? infoSegment.children
-			: []),
+		...mainSegment.value,
+		...(infoSegment && infoSegment.type === 'Info' ? infoSegment.value : []),
 	];
 
-	const timestampScale = relevantBoxes.find(
-		(s) => s.type === 'timestamp-scale-segment',
-	);
-	if (!timestampScale || timestampScale.type !== 'timestamp-scale-segment') {
+	const timestampScale = relevantBoxes.find((s) => s.type === 'TimestampScale');
+	if (!timestampScale || timestampScale.type !== 'TimestampScale') {
 		return null;
 	}
 
-	const duration = relevantBoxes.find((s) => s.type === 'duration-segment');
-	if (!duration || duration.type !== 'duration-segment') {
+	const duration = relevantBoxes.find(
+		(s) => s.type === 'Duration',
+	) as DurationSegment;
+	if (!duration || duration.type !== 'Duration') {
 		return null;
 	}
 
-	return (duration.duration / timestampScale.timestampScale) * 1000;
+	return (duration.value.value / timestampScale.value.value) * 1000;
 };
 
-export const getDuration = (boxes: AnySegment[]): number | null => {
-	const matroskaBox = boxes.find((b) => b.type === 'main-segment');
+export const getDuration = (
+	boxes: AnySegment[],
+	parserState: ParserState,
+): number | null => {
+	const matroskaBox = boxes.find((b) => b.type === 'Segment');
 	if (matroskaBox) {
 		return getDurationFromMatroska(boxes);
 	}
@@ -47,6 +53,7 @@ export const getDuration = (boxes: AnySegment[]): number | null => {
 		return null;
 	}
 
+	const moofBox = getMoofBox(boxes);
 	const mvhdBox = getMvhdBox(moovBox);
 
 	if (!mvhdBox) {
@@ -57,12 +64,39 @@ export const getDuration = (boxes: AnySegment[]): number | null => {
 		throw new Error('Expected mvhd-box');
 	}
 
-	return mvhdBox.durationInSeconds;
+	if (mvhdBox.durationInSeconds > 0) {
+		return mvhdBox.durationInSeconds;
+	}
+
+	const tracks = getTracks(boxes, parserState);
+	const allTracks = [
+		...tracks.videoTracks,
+		...tracks.audioTracks,
+		...tracks.otherTracks,
+	];
+	const allSamples = allTracks.map((t) => {
+		const {timescale: ts} = t;
+		const samplePositions = getSamplePositionsFromTrack(
+			t.trakBox as TrakBox,
+			moofBox,
+		);
+
+		const highest = samplePositions
+			?.map((sp) => (sp.cts + sp.duration) / ts)
+			.reduce((a, b) => Math.max(a, b), 0);
+		return highest ?? 0;
+	});
+	const highestTimestamp = Math.max(...allSamples);
+	return highestTimestamp;
 };
 
-export const hasDuration = (boxes: AnySegment[]): boolean => {
+export const hasDuration = (
+	boxes: AnySegment[],
+	parserState: ParserState,
+): boolean => {
 	try {
-		return getDuration(boxes) !== null;
+		const duration = getDuration(boxes, parserState);
+		return getDuration(boxes, parserState) !== null && duration !== 0;
 	} catch (err) {
 		return false;
 	}

package/src/get-tracks.ts

@@ -1,8 +1,8 @@
 import {makeBaseMediaTrack} from './boxes/iso-base-media/make-track';
 import type {MoovBox} from './boxes/iso-base-media/moov/moov';
+import type {TrakBox} from './boxes/iso-base-media/trak/trak';
 import {getTracksFromMatroska} from './boxes/webm/get-ready-tracks';
 import {getMainSegment} from './boxes/webm/traversal';
-import type {SamplePosition} from './get-sample-positions';
 import type {AnySegment} from './parse-result';
 import type {ParserState} from './parser-state';
 import {getMoovBox, getMvhdBox, getTracksSegment, getTraks} from './traversal';
@@ -14,7 +14,6 @@ type SampleAspectRatio = {
 
 export type VideoTrack = {
 	type: 'video';
-	samplePositions: SamplePosition[] | null;
 	trackId: number;
 	description: Uint8Array | undefined;
 	timescale: number;
@@ -27,24 +26,25 @@ export type VideoTrack = {
 	codedWidth: number;
 	codedHeight: number;
 	rotation: number;
+	trakBox: TrakBox | null;
 };
 
 export type AudioTrack = {
 	type: 'audio';
-	samplePositions: SamplePosition[] | null;
 	trackId: number;
 	timescale: number;
 	codec: string;
 	numberOfChannels: number;
 	sampleRate: number;
 	description: Uint8Array | undefined;
+	trakBox: TrakBox | null;
 };
 
 export type OtherTrack = {
 	type: 'other';
-	samplePositions: SamplePosition[] | null;
 	trackId: number;
 	timescale: number;
+	trakBox: TrakBox | null;
 };
 
 export type Track = VideoTrack | AudioTrack | OtherTrack;
@@ -89,8 +89,8 @@ export const getTracks = (
 	const audioTracks: AudioTrack[] = [];
 	const otherTracks: OtherTrack[] = [];
 
-	const mainSegment = segments.find((s) => s.type === 'main-segment');
-	if (mainSegment && mainSegment.type === 'main-segment') {
+	const mainSegment = segments.find((s) => s.type === 'Segment');
+	if (mainSegment && mainSegment.type === 'Segment') {
 		const matroskaTracks = getTracksFromMatroska(
 			mainSegment,
 			state.getTimescale(),

package/src/get-video-codec.ts

@@ -76,39 +76,37 @@ export const getVideoCodec = (boxes: AnySegment[]): KnownVideoCodecs | null => {
 		}
 	}
 
-	const mainSegment = boxes.find((b) => b.type === 'main-segment');
-	if (!mainSegment || mainSegment.type !== 'main-segment') {
+	const mainSegment = boxes.find((b) => b.type === 'Segment');
+	if (!mainSegment || mainSegment.type !== 'Segment') {
 		return null;
 	}
 
-	const tracksSegment = mainSegment.children.find(
-		(b) => b.type === 'tracks-segment',
-	);
-	if (!tracksSegment || tracksSegment.type !== 'tracks-segment') {
+	const tracksSegment = mainSegment.value.find((b) => b.type === 'Tracks');
+	if (!tracksSegment || tracksSegment.type !== 'Tracks') {
 		return null;
 	}
 
-	for (const track of tracksSegment.children) {
-		if (track.type === 'track-entry-segment') {
-			const trackType = track.children.find((b) => b.type === 'codec-segment');
-			if (trackType && trackType.type === 'codec-segment') {
-				if (trackType.codec === 'V_VP8') {
+	for (const track of tracksSegment.value) {
+		if (track.type === 'TrackEntry') {
+			const trackType = track.value.find((b) => b.type === 'CodecID');
+			if (trackType && trackType.type === 'CodecID') {
+				if (trackType.value === 'V_VP8') {
 					return 'vp8';
 				}
 
-				if (trackType.codec === 'V_VP9') {
+				if (trackType.value === 'V_VP9') {
 					return 'vp9';
 				}
 
-				if (trackType.codec === 'V_AV1') {
+				if (trackType.value === 'V_AV1') {
 					return 'av1';
 				}
 
-				if (trackType.codec === 'V_MPEG4/ISO/AVC') {
+				if (trackType.value === 'V_MPEG4/ISO/AVC') {
 					return 'h264';
 				}
 
-				if (trackType.codec === 'V_MPEGH/ISO/HEVC') {
+				if (trackType.value === 'V_MPEGH/ISO/HEVC') {
 					return 'h265';
 				}
 			}

package/src/has-all-info.ts

@@ -45,7 +45,7 @@ export const hasAllInfo = (
 		}
 
 		if (key === 'durationInSeconds') {
-			return hasDuration(parseResult.segments);
+			return hasDuration(parseResult.segments, state);
 		}
 
 		if (

package/src/parse-media.ts

@@ -52,6 +52,11 @@ export const parseMedia: ParseMedia = async ({
 		onAudioTrack: onAudioTrack ?? null,
 		onVideoTrack: onVideoTrack ?? null,
 		parserState: state,
+		nullifySamples: !(
+			typeof process !== 'undefined' &&
+			typeof process.env !== 'undefined' &&
+			process.env.KEEP_SAMPLES === 'true'
+		),
 	};
 
 	while (parseResult === null || parseResult.status === 'incomplete') {
@@ -72,7 +77,7 @@ export const parseMedia: ParseMedia = async ({
 
 			iterator = getArrayBufferIterator(
 				result.value,
-				contentLength ?? undefined,
+				contentLength ?? 1_000_000_000,
 			);
 		}
 
@@ -144,7 +149,7 @@ export const parseMedia: ParseMedia = async ({
 	}
 
 	if (fields?.durationInSeconds) {
-		returnValue.durationInSeconds = getDuration(parseResult.segments);
+		returnValue.durationInSeconds = getDuration(parseResult.segments, state);
 	}
 
 	if (fields?.fps) {

package/src/parse-result.ts

@@ -19,8 +19,11 @@ import type {StsdBox} from './boxes/iso-base-media/stsd/stsd';
 import type {StssBox} from './boxes/iso-base-media/stsd/stss';
 import type {StszBox} from './boxes/iso-base-media/stsd/stsz';
 import type {SttsBox} from './boxes/iso-base-media/stsd/stts';
+import type {TfdtBox} from './boxes/iso-base-media/tfdt';
+import type {TfhdBox} from './boxes/iso-base-media/tfhd';
 import type {TkhdBox} from './boxes/iso-base-media/tkhd';
 import type {TrakBox} from './boxes/iso-base-media/trak/trak';
+import type {TrunBox} from './boxes/iso-base-media/trun';
 import type {VoidBox} from './boxes/iso-base-media/void-box';
 import type {MatroskaSegment} from './boxes/webm/segments';
 
@@ -56,7 +59,10 @@ export type IsoBaseMediaBox =
 	| PaspBox
 	| CttsBox
 	| Av1CBox
-	| ColorParameterBox;
+	| TrunBox
+	| ColorParameterBox
+	| TfdtBox
+	| TfhdBox;
 
 export type AnySegment = MatroskaSegment | IsoBaseMediaBox;
 

package/src/parser-context.ts

@@ -6,4 +6,5 @@ export type ParserContext = {
 	onVideoTrack: OnVideoTrack | null;
 	canSkipVideoData: boolean;
 	parserState: ParserState;
+	nullifySamples: boolean;
 };

package/src/parser-state.ts

@@ -40,8 +40,8 @@ export const makeParserState = ({
 		const trackTimescale = getTrackTimestampScale(trackEntry);
 
 		trackEntries[trackId] = {
-			codec: codec.codec,
-			trackTimescale,
+			codec: codec.value,
+			trackTimescale: trackTimescale?.value ?? null,
 		};
 	};
 

package/src/samples-from-moof.ts

@@ -0,0 +1,101 @@
+import type {SamplePosition} from './get-sample-positions';
+import type {AnySegment, IsoBaseMediaBox} from './parse-result';
+import {getTfdtBox, getTfhdBox, getTrunBoxes} from './traversal';
+
+const getSamplesFromTraf = (
+	trafSegment: IsoBaseMediaBox,
+	moofOffset: number,
+): SamplePosition[] => {
+	if (trafSegment.type !== 'regular-box' || trafSegment.boxType !== 'traf') {
+		throw new Error('Expected traf-box');
+	}
+
+	const tfhdBox = getTfhdBox(trafSegment);
+	const defaultSampleDuration = tfhdBox?.defaultSampleDuration ?? null;
+	const defaultSampleSize = tfhdBox?.defaultSampleSize ?? null;
+	const defaultSampleFlags = tfhdBox?.defaultSampleFlags ?? null;
+
+	const tfdtBox = getTfdtBox(trafSegment);
+	const trunBoxes = getTrunBoxes(trafSegment);
+
+	let time = 0;
+	let offset = 0;
+
+	let dataOffset = 0;
+
+	const samples: SamplePosition[] = [];
+
+	for (const trunBox of trunBoxes) {
+		let i = -1;
+
+		if (dataOffset === 0 && trunBox.dataOffset) {
+			dataOffset = trunBox.dataOffset;
+		}
+
+		for (const sample of trunBox.samples) {
+			i++;
+			const duration = sample.sampleDuration ?? defaultSampleDuration;
+			if (duration === null) {
+				throw new Error('Expected duration');
+			}
+
+			const size = sample.sampleSize ?? defaultSampleSize;
+			if (size === null) {
+				throw new Error('Expected size');
+			}
+
+			const isFirstSample = i === 0;
+			const sampleFlags = sample.sampleFlags
+				? sample.sampleFlags
+				: isFirstSample && trunBox.firstSampleFlags !== null
+					? trunBox.firstSampleFlags
+					: defaultSampleFlags;
+			if (sampleFlags === null) {
+				throw new Error('Expected sample flags');
+			}
+
+			const keyframe = !((sampleFlags >> 16) & 0x1);
+
+			const dts = time + (tfdtBox?.baseMediaDecodeTime ?? 0);
+
+			const samplePosition: SamplePosition = {
+				offset: offset + (moofOffset ?? 0) + (dataOffset ?? 0),
+				dts,
+				cts: dts,
+				duration,
+				isKeyframe: keyframe,
+				size,
+			};
+			samples.push(samplePosition);
+			offset += size;
+			time += duration;
+		}
+	}
+
+	return samples;
+};
+
+export const getSamplesFromMoof = ({
+	moofBox,
+	trackId,
+}: {
+	moofBox: AnySegment;
+	trackId: number;
+}) => {
+	if (moofBox.type !== 'regular-box') {
+		throw new Error('Expected moof-box');
+	}
+
+	const trafs = moofBox.children.filter(
+		(c) => c.type === 'regular-box' && c.boxType === 'traf',
+	) as IsoBaseMediaBox[];
+
+	const mapped = trafs.map((traf) => {
+		const tfhdBox = getTfhdBox(traf);
+
+		return tfhdBox?.trackId === trackId
+			? getSamplesFromTraf(traf, moofBox.offset)
+			: [];
+	});
+	return mapped.flat(1);
+};

package/src/test/create-matroska.test.ts

@@ -1,29 +1,121 @@
-import {RenderInternals} from '@remotion/renderer';
+/* eslint-disable padding-line-between-statements */
+/* eslint-disable max-depth */
 import {expect, test} from 'bun:test';
-import {makeMatroskaHeader} from '../boxes/webm/make-header';
-import {
-	matroskaHeader,
-	seek,
-	seekId,
+import {combineUint8Arrays, makeMatroskaBytes} from '../boxes/webm/make-header';
+import {parseEbml} from '../boxes/webm/parse-ebml';
+import type {MatroskaSegment} from '../boxes/webm/segments';
+import type {
+	MainSegment,
+	TrackEntry,
 } from '../boxes/webm/segments/all-segments';
+import {getArrayBufferIterator} from '../buffer-iterator';
+import {nodeReader} from '../from-node';
+import {parseMedia} from '../parse-media';
+import type {AnySegment} from '../parse-result';
+import type {ParserContext} from '../parser-context';
+import {makeParserState} from '../parser-state';
 
-test('Should make Matroska header that is same as input', async () => {
-	const exampleVideo = RenderInternals.exampleVideos.matroskaMp3;
-	const file = await Bun.file(exampleVideo).arrayBuffer();
+const state = makeParserState({
+	hasAudioCallbacks: false,
+	hasVideoCallbacks: false,
+	signal: undefined,
+});
 
-	const headerInput = new Uint8Array(file.slice(0, 0x28));
+const options: ParserContext = {
+	canSkipVideoData: true,
+	onAudioTrack: null,
+	onVideoTrack: null,
+	parserState: state,
+	nullifySamples: false,
+};
 
-	const headerOutput = makeMatroskaHeader(matroskaHeader, {
-		DocType: 'matroska',
-		DocTypeVersion: 4,
-		DocTypeReadVersion: 2,
-		EBMLMaxIDLength: 4,
-		EBMLMaxSizeLength: 8,
-		EBMLReadVersion: 1,
-		EBMLVersion: 1,
+test('Should make Matroska header that is same as input', async () => {
+	const headerOutput = makeMatroskaBytes({
+		type: 'Header',
+		minVintWidth: 1,
+		value: [
+			{
+				type: 'EBMLVersion',
+				value: {value: 1, byteLength: 1},
+				minVintWidth: 1,
+			},
+			{
+				type: 'EBMLReadVersion',
+				value: {value: 1, byteLength: 1},
+				minVintWidth: 1,
+			},
+			{
+				type: 'EBMLMaxIDLength',
+				value: {value: 4, byteLength: 1},
+				minVintWidth: 1,
+			},
+			{
+				type: 'EBMLMaxSizeLength',
+				value: {value: 8, byteLength: 1},
+				minVintWidth: 1,
+			},
+			{
+				type: 'DocType',
+				value: 'webm',
+				minVintWidth: 1,
+			},
+			{
+				type: 'DocTypeVersion',
+				value: {value: 4, byteLength: 1},
+				minVintWidth: 1,
+			},
+			{
+				type: 'DocTypeReadVersion',
+				value: {value: 2, byteLength: 1},
+				minVintWidth: 1,
+			},
+		],
 	});
 
-	expect(headerInput).toEqual(headerOutput);
+	const iterator = getArrayBufferIterator(headerOutput, headerOutput.length);
+	const parsed = await parseEbml(iterator, options);
+
+	expect(parsed).toEqual({
+		type: 'Header',
+		minVintWidth: 1,
+		value: [
+			{
+				type: 'EBMLVersion',
+				value: {value: 1, byteLength: 1},
+				minVintWidth: 1,
+			},
+			{
+				type: 'EBMLReadVersion',
+				value: {value: 1, byteLength: 1},
+				minVintWidth: 1,
+			},
+			{
+				type: 'EBMLMaxIDLength',
+				value: {value: 4, byteLength: 1},
+				minVintWidth: 1,
+			},
+			{
+				type: 'EBMLMaxSizeLength',
+				value: {value: 8, byteLength: 1},
+				minVintWidth: 1,
+			},
+			{
+				type: 'DocType',
+				value: 'webm',
+				minVintWidth: 1,
+			},
+			{
+				type: 'DocTypeVersion',
+				value: {value: 4, byteLength: 1},
+				minVintWidth: 1,
+			},
+			{
+				type: 'DocTypeReadVersion',
+				value: {value: 2, byteLength: 1},
+				minVintWidth: 1,
+			},
+		],
+	});
 });
 
 test('Should be able to create SeekIdBox', async () => {
@@ -31,7 +123,11 @@ test('Should be able to create SeekIdBox', async () => {
 		await Bun.file('vp8-segments/56-0x53ab').arrayBuffer(),
 	);
 
-	const custom = makeMatroskaHeader(seekId, '0x1549a966');
+	const custom = makeMatroskaBytes({
+		type: 'SeekID',
+		value: '0x1549a966',
+		minVintWidth: 1,
+	});
 	expect(custom).toEqual(file);
 });
 
@@ -39,10 +135,128 @@ test('Should be able to create Seek', async () => {
 	const file = new Uint8Array(
 		await Bun.file('vp8-segments/53-0x4dbb').arrayBuffer(),
 	);
+	const parsed = await parseEbml(getArrayBufferIterator(file, null), options);
+	expect(parsed).toEqual({
+		type: 'Seek',
+		value: [
+			{
+				type: 'SeekID',
+				value: '0x1549a966',
+				minVintWidth: 1,
+			},
+			{
+				type: 'SeekPosition',
+				value: {value: 0x40, byteLength: 1},
+				minVintWidth: 1,
+			},
+		],
+		minVintWidth: 1,
+	});
+
+	const custom = makeMatroskaBytes(parsed);
+	expect(custom).toEqual(file);
+});
+
+test('Should parse seekHead', async () => {
+	const file = new Uint8Array(
+		await Bun.file('vp8-segments/2165155-0x114d9b74').arrayBuffer(),
+	);
+
+	const seekPosition = makeMatroskaBytes({
+		type: 'SeekPosition',
+		value: {value: 3911, byteLength: 2},
+		minVintWidth: 1,
+	});
 
-	const custom = makeMatroskaHeader(seek, {
-		SeekID: '0x1549a966',
-		SeekPosition: 0x40,
+	const custom = makeMatroskaBytes({
+		type: 'SeekHead',
+		value: [
+			{
+				type: 'Seek',
+				value: [
+					{
+						type: 'SeekID',
+						value: '0x1f43b675',
+						minVintWidth: 1,
+					},
+					seekPosition,
+				],
+				minVintWidth: 1,
+			},
+		],
+		minVintWidth: 1,
 	});
 	expect(custom).toEqual(file);
+
+	const iterator = getArrayBufferIterator(file, file.length);
+	const parsed = await parseEbml(iterator, options);
+
+	expect(parsed).toEqual({
+		minVintWidth: 1,
+		type: 'SeekHead',
+		value: [
+			{
+				minVintWidth: 1,
+				type: 'Seek',
+				value: [
+					{minVintWidth: 1, type: 'SeekID', value: '0x1f43b675'},
+					{
+						minVintWidth: 1,
+						type: 'SeekPosition',
+						value: {value: 3911, byteLength: 2},
+					},
+				],
+			},
+		],
+	});
+});
+
+const parseWebm = async (str: string) => {
+	const {boxes} = await parseMedia({
+		src: str,
+		fields: {
+			boxes: true,
+		},
+		reader: nodeReader,
+	});
+	return boxes;
+};
+
+const stringifyWebm = (boxes: AnySegment[]) => {
+	const buffers: Uint8Array[] = [];
+	for (const box of boxes) {
+		const bytes = makeMatroskaBytes(box as MatroskaSegment);
+		buffers.push(bytes);
+	}
+
+	const combined = combineUint8Arrays(buffers);
+	return combined;
+};
+
+test('Can we disassemble a Matroska file and assembled it again', async () => {
+	process.env.KEEP_SAMPLES = 'true';
+
+	const parsed = await parseWebm('input.webm');
+
+	const segment = parsed.find((s) => s.type === 'Segment') as MainSegment;
+	const tracks = segment.value.flatMap((s) =>
+		s.type === 'Tracks' ? s.value.filter((a) => a.type === 'TrackEntry') : [],
+	);
+	for (const track of tracks as TrackEntry[]) {
+		for (const child of track.value) {
+			if (child.type === 'Video') {
+				for (const attribute of child.value) {
+					if (attribute.type === 'DisplayHeight') {
+						attribute.value.value *= 2;
+					}
+				}
+			}
+		}
+	}
+
+	const bytes = await Bun.file('input.webm').arrayBuffer();
+	expect(stringifyWebm(parsed).byteLength).toEqual(
+		new Uint8Array(bytes).byteLength,
+	);
+	process.env.KEEP_SAMPLES = 'false';
 });