@remotion/media-parser 4.0.201 → 4.0.204

package/src/traversal.ts

@@ -9,23 +9,26 @@ 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 {MainSegment} from './boxes/webm/segments/main';
-import type {TimestampScaleSegment} from './boxes/webm/segments/timestamp-scale';
+import type {TrunBox} from './boxes/iso-base-media/trun';
 import type {
 	AudioSegment,
 	ClusterSegment,
-	CodecSegment,
+	CodecIdSegment,
 	DisplayHeightSegment,
 	DisplayWidthSegment,
 	HeightSegment,
-	TrackEntrySegment,
+	MainSegment,
+	TimestampScaleSegment,
+	TrackEntry,
 	TrackTypeSegment,
 	VideoSegment,
 	WidthSegment,
-} from './boxes/webm/segments/track-entry';
-import type {AnySegment, RegularBox} from './parse-result';
+} from './boxes/webm/segments/all-segments';
+import type {AnySegment, IsoBaseMediaBox, RegularBox} from './parse-result';
 
 export const getFtypBox = (segments: AnySegment[]): FtypBox | null => {
 	const ftypBox = segments.find((s) => s.type === 'ftyp-box');
@@ -45,6 +48,18 @@ export const getMoovBox = (segments: AnySegment[]): MoovBox | null => {
 	return moovBox;
 };
 
+export const getMoofBox = (main: AnySegment[]): IsoBaseMediaBox | null => {
+	const moofBox = main.find(
+		(s) => s.type === 'regular-box' && s.boxType === 'moof',
+	);
+
+	if (!moofBox || moofBox.type !== 'regular-box') {
+		return null;
+	}
+
+	return moofBox;
+};
+
 export const getMvhdBox = (moovBox: MoovBox): MvhdBox | null => {
 	const mvHdBox = moovBox.children.find((s) => s.type === 'mvhd-box');
 
@@ -239,21 +254,59 @@ export const getStssBox = (trakBox: TrakBox): StssBox | null => {
 	return stssBox;
 };
 
+export const getTfdtBox = (segment: IsoBaseMediaBox): TfdtBox | null => {
+	if (segment.type !== 'regular-box' || segment.boxType !== 'traf') {
+		throw new Error('Expected traf-box');
+	}
+
+	const tfhdBox = segment.children.find((c) => c.type === 'tfdt-box');
+
+	if (!tfhdBox || tfhdBox.type !== 'tfdt-box') {
+		throw new Error('Expected tfhd-box');
+	}
+
+	return tfhdBox;
+};
+
+export const getTfhdBox = (segment: IsoBaseMediaBox): TfhdBox | null => {
+	if (segment.type !== 'regular-box' || segment.boxType !== 'traf') {
+		throw new Error('Expected traf-box');
+	}
+
+	const tfhdBox = segment.children.find(
+		(c) => c.type === 'tfhd-box',
+	) as TfhdBox;
+
+	if (!tfhdBox || tfhdBox.type !== 'tfhd-box') {
+		throw new Error('Expected tfhd-box');
+	}
+
+	return tfhdBox;
+};
+
+export const getTrunBoxes = (segment: IsoBaseMediaBox): TrunBox[] => {
+	if (segment.type !== 'regular-box' || segment.boxType !== 'traf') {
+		throw new Error('Expected traf-box');
+	}
+
+	const trunBoxes = segment.children.filter((c) => c.type === 'trun-box');
+
+	return trunBoxes as TrunBox[];
+};
+
 export const getClusterSegment = (
 	segment: MainSegment,
 ): ClusterSegment | null => {
-	const clusterSegment = segment.children.find(
-		(b) => b.type === 'cluster-segment',
-	) as ClusterSegment | undefined;
+	const clusterSegment = segment.value.find((b) => b.type === 'Cluster') as
+		| ClusterSegment
+		| undefined;
 
 	return clusterSegment ?? null;
 };
 
 export const getTracksSegment = (segment: MainSegment) => {
-	const tracksSegment = segment.children.find(
-		(b) => b.type === 'tracks-segment',
-	);
-	if (!tracksSegment || tracksSegment.type !== 'tracks-segment') {
+	const tracksSegment = segment.value.find((b) => b.type === 'Tracks');
+	if (!tracksSegment || tracksSegment.type !== 'Tracks') {
 		return null;
 	}
 
@@ -263,139 +316,120 @@ export const getTracksSegment = (segment: MainSegment) => {
 export const getTimescaleSegment = (
 	segment: MainSegment,
 ): TimestampScaleSegment | null => {
-	const infoSegment = segment.children.find((b) => b.type === 'info-segment');
+	const infoSegment = segment.value.find((b) => b.type === 'Info');
 
-	if (!infoSegment || infoSegment.type !== 'info-segment') {
+	if (!infoSegment || infoSegment.type !== 'Info') {
 		return null;
 	}
 
-	const timescale = infoSegment.children.find(
-		(b) => b.type === 'timestamp-scale-segment',
-	);
+	const timescale = infoSegment.value.find((b) => b.type === 'TimestampScale');
 
-	if (!timescale || timescale.type !== 'timestamp-scale-segment') {
+	if (!timescale || timescale.type !== 'TimestampScale') {
 		return null;
 	}
 
-	return timescale;
+	return timescale as TimestampScaleSegment;
 };
 
-export const getVideoSegment = (
-	track: TrackEntrySegment,
-): VideoSegment | null => {
-	const videoSegment = track.children.find((b) => b.type === 'video-segment');
-	if (!videoSegment || videoSegment.type !== 'video-segment') {
+export const getVideoSegment = (track: TrackEntry): VideoSegment | null => {
+	const videoSegment = track.value.find((b) => b.type === 'Video');
+	if (!videoSegment || videoSegment.type !== 'Video') {
 		return null;
 	}
 
 	return videoSegment ?? null;
 };
 
-export const getAudioSegment = (
-	track: TrackEntrySegment,
-): AudioSegment | null => {
-	const audioSegment = track.children.find((b) => b.type === 'audio-segment');
-	if (!audioSegment || audioSegment.type !== 'audio-segment') {
+export const getAudioSegment = (track: TrackEntry): AudioSegment | null => {
+	const audioSegment = track.value.find((b) => b.type === 'Audio');
+	if (!audioSegment || audioSegment.type !== 'Audio') {
 		return null;
 	}
 
 	return audioSegment ?? null;
 };
 
-export const getSampleRate = (track: TrackEntrySegment): number | null => {
+export const getSampleRate = (track: TrackEntry): number | null => {
 	const audioSegment = getAudioSegment(track);
 	if (!audioSegment) {
 		return null;
 	}
 
-	const samplingFrequency = audioSegment.children.find(
-		(b) => b.type === 'sampling-frequency-segment',
+	const samplingFrequency = audioSegment.value.find(
+		(b) => b.type === 'SamplingFrequency',
 	);
 
-	if (
-		!samplingFrequency ||
-		samplingFrequency.type !== 'sampling-frequency-segment'
-	) {
+	if (!samplingFrequency || samplingFrequency.type !== 'SamplingFrequency') {
 		return null;
 	}
 
-	return samplingFrequency.samplingFrequency;
+	return samplingFrequency.value.value;
 };
 
-export const getNumberOfChannels = (track: TrackEntrySegment): number => {
+export const getNumberOfChannels = (track: TrackEntry): number => {
 	const audioSegment = getAudioSegment(track);
 	if (!audioSegment) {
 		throw new Error('Could not find audio segment');
 	}
 
-	const channels = audioSegment.children.find(
-		(b) => b.type === 'channels-segment',
-	);
+	const channels = audioSegment.value.find((b) => b.type === 'Channels');
 
-	if (!channels || channels.type !== 'channels-segment') {
+	if (!channels || channels.type !== 'Channels') {
 		return 1;
 	}
 
-	return channels.channels;
+	return channels.value.value;
 };
 
-export const getBitDepth = (track: TrackEntrySegment): number | null => {
+export const getBitDepth = (track: TrackEntry): number | null => {
 	const audioSegment = getAudioSegment(track);
 	if (!audioSegment) {
 		return null;
 	}
 
-	const bitDepth = audioSegment.children.find(
-		(b) => b.type === 'bit-depth-segment',
-	);
+	const bitDepth = audioSegment.value.find((b) => b.type === 'BitDepth');
 
-	if (!bitDepth || bitDepth.type !== 'bit-depth-segment') {
+	if (!bitDepth || bitDepth.type !== 'BitDepth') {
 		return null;
 	}
 
-	return bitDepth.bitDepth;
+	return bitDepth.value.value;
 };
 
-export const getPrivateData = (track: TrackEntrySegment): Uint8Array | null => {
-	const privateData = track.children.find(
-		(b) => b.type === 'codec-private-segment',
-	);
+export const getPrivateData = (track: TrackEntry): Uint8Array | null => {
+	const privateData = track.value.find((b) => b.type === 'CodecPrivate');
 
-	if (!privateData || privateData.type !== 'codec-private-segment') {
+	if (!privateData || privateData.type !== 'CodecPrivate') {
 		return null;
 	}
 
-	return privateData.codecPrivateData;
+	return privateData.value;
 };
 
-export const getWidthSegment = (
-	track: TrackEntrySegment,
-): WidthSegment | null => {
+export const getWidthSegment = (track: TrackEntry): WidthSegment | null => {
 	const videoSegment = getVideoSegment(track);
 	if (!videoSegment) {
 		return null;
 	}
 
-	const width = videoSegment.children.find((b) => b.type === 'width-segment');
+	const width = videoSegment.value.find((b) => b.type === 'PixelWidth');
 
-	if (!width || width.type !== 'width-segment') {
+	if (!width || width.type !== 'PixelWidth') {
 		return null;
 	}
 
 	return width;
 };
 
-export const getHeightSegment = (
-	track: TrackEntrySegment,
-): HeightSegment | null => {
+export const getHeightSegment = (track: TrackEntry): HeightSegment | null => {
 	const videoSegment = getVideoSegment(track);
 	if (!videoSegment) {
 		return null;
 	}
 
-	const height = videoSegment.children.find((b) => b.type === 'height-segment');
+	const height = videoSegment.value.find((b) => b.type === 'PixelHeight');
 
-	if (!height || height.type !== 'height-segment') {
+	if (!height || height.type !== 'PixelHeight') {
 		return null;
 	}
 
@@ -403,18 +437,18 @@ export const getHeightSegment = (
 };
 
 export const getDisplayWidthSegment = (
-	track: TrackEntrySegment,
+	track: TrackEntry,
 ): DisplayWidthSegment | null => {
 	const videoSegment = getVideoSegment(track);
 	if (!videoSegment) {
 		return null;
 	}
 
-	const displayWidth = videoSegment.children.find(
-		(b) => b.type === 'display-width-segment',
+	const displayWidth = videoSegment.value.find(
+		(b) => b.type === 'DisplayWidth',
 	);
 
-	if (!displayWidth || displayWidth.type !== 'display-width-segment') {
+	if (!displayWidth || displayWidth.type !== 'DisplayWidth') {
 		return null;
 	}
 
@@ -422,18 +456,18 @@ export const getDisplayWidthSegment = (
 };
 
 export const getDisplayHeightSegment = (
-	track: TrackEntrySegment,
+	track: TrackEntry,
 ): DisplayHeightSegment | null => {
 	const videoSegment = getVideoSegment(track);
 	if (!videoSegment) {
 		return null;
 	}
 
-	const displayHeight = videoSegment.children.find(
-		(b) => b.type === 'display-height-segment',
+	const displayHeight = videoSegment.value.find(
+		(b) => b.type === 'DisplayHeight',
 	);
 
-	if (!displayHeight || displayHeight.type !== 'display-height-segment') {
+	if (!displayHeight || displayHeight.type !== 'DisplayHeight') {
 		return null;
 	}
 
@@ -441,30 +475,28 @@ export const getDisplayHeightSegment = (
 };
 
 export const getTrackTypeSegment = (
-	track: TrackEntrySegment,
+	track: TrackEntry,
 ): TrackTypeSegment | null => {
-	const trackType = track.children.find((b) => b.type === 'track-type-segment');
-	if (!trackType || trackType.type !== 'track-type-segment') {
+	const trackType = track.value.find((b) => b.type === 'TrackType');
+	if (!trackType || trackType.type !== 'TrackType') {
 		return null;
 	}
 
 	return trackType;
 };
 
-export const getTrackId = (track: TrackEntrySegment): number => {
-	const trackId = track.children.find((b) => b.type === 'track-number-segment');
-	if (!trackId || trackId.type !== 'track-number-segment') {
+export const getTrackId = (track: TrackEntry): number => {
+	const trackId = track.value.find((b) => b.type === 'TrackNumber');
+	if (!trackId || trackId.type !== 'TrackNumber') {
 		throw new Error('Expected track number segment');
 	}
 
-	return trackId.trackNumber;
+	return trackId.value.value;
 };
 
-export const getCodecSegment = (
-	track: TrackEntrySegment,
-): CodecSegment | null => {
-	const codec = track.children.find((b) => b.type === 'codec-segment');
-	if (!codec || codec.type !== 'codec-segment') {
+export const getCodecSegment = (track: TrackEntry): CodecIdSegment | null => {
+	const codec = track.value.find((b) => b.type === 'CodecID');
+	if (!codec || codec.type !== 'CodecID') {
 		return null;
 	}