@remotion/media-parser 4.0.194 → 4.0.196

package/src/parser-context.ts

@@ -0,0 +1,9 @@
+import type {ParserState} from './parser-state';
+import type {OnAudioTrack, OnVideoTrack} from './webcodec-sample-types';
+
+export type ParserContext = {
+	onAudioTrack: OnAudioTrack | null;
+	onVideoTrack: OnVideoTrack | null;
+	canSkipVideoData: boolean;
+	parserState: ParserState;
+};

package/src/parser-state.ts

@@ -0,0 +1,151 @@
+import type {OnTrackEntrySegment} from './boxes/webm/segments';
+import type {CodecSegment} from './boxes/webm/segments/track-entry';
+import {getTrackCodec} from './boxes/webm/traversal';
+import {getTrackId} from './traversal';
+import type {
+	AudioSample,
+	OnAudioSample,
+	OnVideoSample,
+	VideoSample,
+} from './webcodec-sample-types';
+
+export type InternalStats = {
+	samplesThatHadToBeQueued: number;
+};
+
+export const makeParserState = ({
+	hasAudioCallbacks,
+	hasVideoCallbacks,
+}: {
+	hasAudioCallbacks: boolean;
+	hasVideoCallbacks: boolean;
+}) => {
+	const trackEntries: Record<number, CodecSegment> = {};
+
+	const onTrackEntrySegment: OnTrackEntrySegment = (trackEntry) => {
+		const trackId = getTrackId(trackEntry);
+		if (!trackId) {
+			throw new Error('Expected track id');
+		}
+
+		if (trackEntries[trackId]) {
+			return;
+		}
+
+		const codec = getTrackCodec(trackEntry);
+		if (!codec) {
+			throw new Error('Expected codec');
+		}
+
+		trackEntries[trackId] = codec;
+	};
+
+	const videoSampleCallbacks: Record<number, OnVideoSample> = {};
+	const audioSampleCallbacks: Record<number, OnAudioSample> = {};
+
+	let samplesThatHadToBeQueued = 0;
+
+	const queuedAudioSamples: Record<number, AudioSample[]> = {};
+	const queuedVideoSamples: Record<number, VideoSample[]> = {};
+
+	const declinedTrackNumbers: number[] = [];
+
+	let timescale: number | null = null;
+
+	const getTimescale = () => {
+		if (timescale === null) {
+			throw new Error('Timescale not set');
+		}
+
+		return timescale;
+	};
+
+	const setTimescale = (newTimescale: number) => {
+		timescale = newTimescale;
+	};
+
+	return {
+		onTrackEntrySegment,
+		getTrackInfoByNumber: (id: number) => trackEntries[id],
+		registerVideoSampleCallback: async (
+			id: number,
+			callback: OnVideoSample | null,
+		) => {
+			if (callback === null) {
+				delete videoSampleCallbacks[id];
+				declinedTrackNumbers.push(id);
+				return;
+			}
+
+			videoSampleCallbacks[id] = callback;
+
+			for (const queued of queuedVideoSamples[id] ?? []) {
+				await callback(queued);
+			}
+
+			queuedVideoSamples[id] = [];
+		},
+		registerAudioSampleCallback: async (
+			id: number,
+			callback: OnAudioSample | null,
+		) => {
+			if (callback === null) {
+				delete audioSampleCallbacks[id];
+				declinedTrackNumbers.push(id);
+				return;
+			}
+
+			audioSampleCallbacks[id] = callback;
+			for (const queued of queuedAudioSamples[id] ?? []) {
+				await callback(queued);
+			}
+
+			queuedAudioSamples[id] = [];
+		},
+		onAudioSample: async (trackId: number, audioSample: AudioSample) => {
+			const callback = audioSampleCallbacks[trackId];
+			if (callback) {
+				await callback(audioSample);
+			} else {
+				if (declinedTrackNumbers.includes(trackId)) {
+					return;
+				}
+
+				if (!hasAudioCallbacks) {
+					return;
+				}
+
+				queuedAudioSamples[trackId] ??= [];
+				queuedAudioSamples[trackId].push(audioSample);
+				samplesThatHadToBeQueued++;
+			}
+		},
+		onVideoSample: async (trackId: number, videoSample: VideoSample) => {
+			const callback = videoSampleCallbacks[trackId];
+			if (callback) {
+				await callback(videoSample);
+			} else {
+				if (declinedTrackNumbers.includes(trackId)) {
+					return;
+				}
+
+				if (!hasVideoCallbacks) {
+					return;
+				}
+
+				queuedVideoSamples[trackId] ??= [];
+				queuedVideoSamples[trackId].push(videoSample);
+				samplesThatHadToBeQueued++;
+			}
+		},
+		getInternalStats: () => {
+			return {
+				samplesThatHadToBeQueued,
+			};
+		},
+		getTimescale,
+		setTimescale,
+	};
+};
+
+export type ParserState = ReturnType<typeof makeParserState>;

package/src/reader.ts

@@ -3,10 +3,10 @@ type ReadResult = {
 	contentLength: number | null;
 };
 type ReadContent = (
-	src: string,
+	src: string | File,
 	range: [number, number] | number | null,
 ) => Promise<ReadResult>;
-type GetLength = (src: string) => Promise<number>;
+type GetLength = (src: string | File) => Promise<number>;
 
 export type ReaderInterface = {
 	read: ReadContent;

package/src/test/aspect-ratio.test.ts

@@ -0,0 +1,42 @@
+import {expect, test} from 'bun:test';
+import {
+	applyAspectRatios,
+	getDisplayAspectRatio,
+} from '../get-sample-aspect-ratio';
+
+test('Should calculate sample aspect ratio', () => {
+	const displayAspectRatio = getDisplayAspectRatio({
+		sampleAspectRatio: {
+			denominator: 177,
+			numerator: 56,
+		},
+		nativeDimensions: {
+			width: 1280,
+			height: 720,
+		},
+	});
+
+	expect(displayAspectRatio).toEqual({
+		numerator: 896,
+		denominator: 1593,
+	});
+
+	const applied = applyAspectRatios({
+		dimensions: {
+			width: 1280,
+			height: 720,
+		},
+		sampleAspectRatio: {
+			numerator: 56,
+			denominator: 177,
+		},
+		displayAspectRatio: {
+			numerator: 896,
+			denominator: 1593,
+		},
+	});
+	expect(applied).toEqual({
+		width: 405,
+		height: 720,
+	});
+});

package/src/test/av1.test.ts

@@ -0,0 +1,108 @@
+import {RenderInternals} from '@remotion/renderer';
+import {expect, test} from 'bun:test';
+import {nodeReader} from '../from-node';
+import {trakBoxContainsVideo} from '../get-fps';
+import {getAv1CBox} from '../get-sample-aspect-ratio';
+import {parseMedia} from '../parse-media';
+import {getMoovBox, getTraks} from '../traversal';
+
+test('AV1 in MP4', async () => {
+	const parsed = await parseMedia({
+		src: RenderInternals.exampleVideos.av1mp4,
+		fields: {
+			durationInSeconds: true,
+			fps: true,
+			videoCodec: true,
+			tracks: true,
+			audioCodec: true,
+			dimensions: true,
+			rotation: true,
+			boxes: true,
+		},
+		reader: nodeReader,
+	});
+
+	const moovBox = getMoovBox(parsed.boxes);
+	if (!moovBox) {
+		throw new Error('No moov box');
+	}
+
+	const traks = getTraks(moovBox).filter((t) => trakBoxContainsVideo(t))[0];
+	const avc1Box = getAv1CBox(traks);
+	expect(avc1Box).toEqual({
+		type: 'av1C-box',
+		privateData: new Uint8Array([
+			129, 8, 12, 0, 10, 11, 0, 0, 0, 66, 171, 191, 195, 119, 111, 228, 1,
+		]),
+	});
+	expect(avc1Box).toBeTruthy();
+
+	expect(parsed.durationInSeconds).toBe(10);
+	expect(parsed.fps).toBe(30);
+	expect(parsed.videoCodec).toBe('av1');
+	expect(parsed.videoTracks[0].codec).toEqual('av01.0.08M.08');
+	// This is true, there are no audio tracks
+	expect(parsed.audioTracks).toEqual([]);
+	expect(parsed.audioCodec).toEqual(null);
+	expect(parsed.dimensions).toEqual({
+		width: 1920,
+		height: 1080,
+	});
+	expect(parsed.rotation).toBe(0);
+});
+
+test('AV1 in MP4 with colr atom', async () => {
+	let tracks = 0;
+	let samples = 0;
+
+	const parsed = await parseMedia({
+		src: RenderInternals.exampleVideos.av1mp4WithColr,
+		fields: {
+			durationInSeconds: true,
+			fps: true,
+			videoCodec: true,
+			tracks: true,
+			audioCodec: true,
+			dimensions: true,
+			rotation: true,
+			boxes: true,
+		},
+		reader: nodeReader,
+		onVideoTrack: () => {
+			tracks++;
+			return () => {
+				samples++;
+			};
+		},
+	});
+
+	const moovBox = getMoovBox(parsed.boxes);
+	if (!moovBox) {
+		throw new Error('No moov box');
+	}
+
+	const traks = getTraks(moovBox).filter((t) => trakBoxContainsVideo(t))[0];
+	const avc1Box = getAv1CBox(traks);
+	expect(avc1Box).toEqual({
+		type: 'av1C-box',
+		privateData: new Uint8Array([
+			129, 8, 12, 0, 10, 14, 0, 0, 0, 66, 171, 191, 195, 118, 0, 8, 8, 8, 8, 32,
+		]),
+	});
+	expect(avc1Box).toBeTruthy();
+
+	expect(parsed.durationInSeconds).toBe(1);
+	expect(parsed.fps).toBe(25);
+	expect(parsed.videoCodec).toBe('av1');
+	expect(parsed.videoTracks[0].codec).toEqual('av01.0.08M.08');
+	// This is true, there are no audio tracks
+	expect(parsed.audioTracks).toEqual([]);
+	expect(parsed.audioCodec).toEqual(null);
+	expect(parsed.dimensions).toEqual({
+		width: 1920,
+		height: 1080,
+	});
+	expect(parsed.rotation).toBe(0);
+	expect(tracks).toBe(1);
+	expect(samples).toBe(25);
+});

package/src/test/duration.test.ts

@@ -4,31 +4,15 @@ import {nodeReader} from '../from-node';
 import {parseMedia} from '../parse-media';
 
 test('Should get duration of video', async () => {
-	const parsed = await parseMedia(
-		RenderInternals.exampleVideos.framer24fps,
-		{
+	const parsed = await parseMedia({
+		src: RenderInternals.exampleVideos.framer24fps,
+		fields: {
 			durationInSeconds: true,
 			dimensions: true,
 		},
-		nodeReader,
-	);
+		reader: nodeReader,
+	});
 
 	expect(parsed.durationInSeconds).toBe(4.167);
 	expect(parsed.dimensions).toEqual({width: 1080, height: 1080});
 });
-
-test('Should get duration of HEVC video', async () => {
-	const parsed = await parseMedia(
-		RenderInternals.exampleVideos.iphonehevc,
-		{durationInSeconds: true, dimensions: true, fps: true},
-		nodeReader,
-	);
-
-	expect(parsed.durationInSeconds).toBe(3.4);
-	// TODO: Should apply rotation matrix to get the correct dimensions
-	expect(parsed.dimensions).toEqual({
-		width: 1920,
-		height: 1080,
-	});
-	expect(parsed.fps).toEqual(30);
-});