@remotion/media-parser 4.0.201 → 4.0.202

package/src/boxes/webm/segments/all-segments.ts

@@ -1,3 +1,5 @@
+import type {Prettify} from '../parse-ebml';
+
 export const matroskaElements = {
 	Header: '0x1a45dfa3',
 	EBMLMaxIDLength: '0x42f2',
@@ -290,7 +292,7 @@ export const getSegmentName = (id: string) => {
 	)?.[0];
 };
 
-export const getIdForName = (name: string) => {
+export const getIdForName = (name: string): EbmlMapKey => {
 	const value = Object.entries(matroskaElements).find(
 		([key]) => key === name,
 	)?.[1];
@@ -298,7 +300,7 @@ export const getIdForName = (name: string) => {
 		throw new Error(`Could not find id for name ${name}`);
 	}
 
-	return value;
+	return value as EbmlMapKey;
 };
 
 export type MatroskaKey = keyof typeof matroskaElements;
@@ -310,10 +312,9 @@ type EbmlType = 'string';
 export type EbmlWithChildren = {
 	name: MatroskaKey;
 	type: 'children';
-	children: HeaderStructure;
 };
 
-export type EbmlWithUint8 = {
+export type EbmlWithUint = {
 	name: MatroskaKey;
 	type: 'uint';
 };
@@ -328,23 +329,23 @@ export type EbmlWithString = {
 	type: EbmlType;
 };
 
-export type EbmlWithVoid = {
+export type EbmlWithFloat = {
 	name: MatroskaKey;
-	type: 'void';
+	type: 'float';
 };
 
-export type EbmlWithFloat = {
+export type EbmlWithUint8Array = {
 	name: MatroskaKey;
-	type: 'float';
+	type: 'uint8array';
 };
 
 export type Ebml =
 	| EbmlWithString
-	| EbmlWithUint8
+	| EbmlWithUint
 	| EbmlWithChildren
-	| EbmlWithVoid
 	| EbmlWithFloat
-	| EbmlWithHexString;
+	| EbmlWithHexString
+	| EbmlWithUint8Array;
 
 export const ebmlVersion = {
 	name: 'EBMLVersion',
@@ -381,36 +382,24 @@ export const docTypeReadVersion = {
 	type: 'uint',
 } satisfies Ebml;
 
-export const voidEbml = {
+const voidEbml = {
 	name: 'Void',
-	type: 'void',
+	type: 'uint8array',
 } satisfies Ebml;
 
 export type EmblTypes = {
 	uint: number;
 	float: number;
 	string: string;
-	children: HeaderStructure;
+	children: Ebml[];
 	void: undefined;
 	'hex-string': string;
+	uint8array: Uint8Array;
 };
 
-export type HeaderStructure = Ebml[];
-
-export const matroskaHeaderStructure = [
-	ebmlVersion,
-	ebmlReadVersion,
-	ebmlMaxIdLength,
-	ebmlMaxSizeLength,
-	docType,
-	docTypeVersion,
-	docTypeReadVersion,
-] as const satisfies HeaderStructure;
-
 export const matroskaHeader = {
 	name: 'Header',
 	type: 'children',
-	children: matroskaHeaderStructure,
 } as const satisfies Ebml;
 
 export const seekId = {
@@ -426,28 +415,285 @@ export const seekPosition = {
 export const seek = {
 	name: 'Seek',
 	type: 'children',
-	children: [seekId, seekPosition],
+} as const satisfies Ebml;
+
+export const seekHead = {
+	name: 'SeekHead',
+	type: 'children',
 } as const satisfies Ebml;
 
 export const voidHeader = {
 	name: 'Void',
-	type: 'void',
+	type: 'uint8array',
+} as const satisfies Ebml;
+
+export const codecID = {
+	name: 'CodecID',
+	type: 'string',
+} as const satisfies Ebml;
+
+export const trackType = {
+	name: 'TrackType',
+	type: 'uint',
+} as const satisfies Ebml;
+
+export const widthType = {
+	name: 'PixelWidth',
+	type: 'uint',
+} as const satisfies Ebml;
+
+export const heightType = {
+	name: 'PixelHeight',
+	type: 'uint',
+} as const satisfies Ebml;
+
+export const muxingApp = {
+	name: 'MuxingApp',
+	type: 'string',
+} as const satisfies Ebml;
+
+export const duration = {
+	name: 'Duration',
+	type: 'float',
+} as const satisfies Ebml;
+
+export const timestampScale = {
+	name: 'TimestampScale',
+	type: 'uint',
+} as const satisfies Ebml;
+
+export const writingApp = {
+	name: 'WritingApp',
+	type: 'string',
+} as const satisfies Ebml;
+
+export const infoType = {
+	name: 'Info',
+	type: 'children',
+} as const satisfies Ebml;
+
+export const titleType = {
+	name: 'Title',
+	type: 'string',
+} as const satisfies Ebml;
+
+export const samplingFrequency = {
+	name: 'SamplingFrequency',
+	type: 'float',
+} as const satisfies Ebml;
+
+export const channels = {
+	name: 'Channels',
+	type: 'uint',
+} as const satisfies Ebml;
+
+export const alphaMode = {
+	name: 'AlphaMode',
+	type: 'uint',
+} as const satisfies Ebml;
+
+export const interlaced = {
+	name: 'FlagInterlaced',
+	type: 'uint',
+} as const satisfies Ebml;
+
+export const bitDepth = {
+	name: 'BitDepth',
+	type: 'uint',
+} as const satisfies Ebml;
+
+export const displayWidth = {
+	name: 'DisplayWidth',
+	type: 'uint',
+} as const satisfies Ebml;
+
+export const displayHeight = {
+	name: 'DisplayHeight',
+	type: 'uint',
+} as const satisfies Ebml;
+
+export const flagLacing = {
+	name: 'FlagLacing',
+	type: 'uint',
+} as const satisfies Ebml;
+
+export const tagSegment = {
+	name: 'Tag',
+	type: 'uint8array',
+} as const satisfies Ebml;
+
+export const tags = {
+	name: 'Tags',
+	type: 'children',
+} as const satisfies Ebml;
+
+export const trackNumber = {
+	name: 'TrackNumber',
+	type: 'uint',
 } as const satisfies Ebml;
 
-export type EbmlValue<T extends Ebml> = T extends EbmlWithUint8
-	? number
-	: T extends EbmlWithVoid
-		? undefined
-		: T extends EbmlWithString
-			? string
-			: T extends EbmlWithFloat
-				? number
-				: EbmlParsed<Ebml>[];
+export const trackUID = {
+	name: 'TrackUID',
+	type: 'hex-string',
+} as const satisfies Ebml;
+
+export const color = {
+	name: 'Colour',
+	type: 'uint8array',
+} as const satisfies Ebml;
+
+export const language = {
+	name: 'Language',
+	type: 'string',
+} as const satisfies Ebml;
+
+export const defaultDuration = {
+	name: 'DefaultDuration',
+	type: 'uint',
+} as const satisfies Ebml;
+
+export const codecPrivate = {
+	name: 'CodecPrivate',
+	type: 'uint8array',
+} as const satisfies Ebml;
+
+export const blockAdditionsSegment = {
+	name: 'BlockAdditions',
+	type: 'uint8array',
+} as const satisfies Ebml;
+
+export const maxBlockAdditionIdSegment = {
+	name: 'MaxBlockAdditionID',
+	type: 'uint',
+} as const satisfies Ebml;
+
+export const audioSegment = {
+	name: 'Audio',
+	type: 'children',
+} as const satisfies Ebml;
+
+export const videoSegment = {
+	name: 'Video',
+	type: 'children',
+} as const satisfies Ebml;
+
+export const flagDefault = {
+	name: 'FlagDefault',
+	type: 'uint8array',
+} as const satisfies Ebml;
+
+export const referenceBlock = {
+	name: 'ReferenceBlock',
+	type: 'uint',
+} as const satisfies Ebml;
+
+export const blockElement = {
+	name: 'Block',
+	type: 'uint8array',
+} as const satisfies Ebml;
+
+export const codecName = {
+	name: 'CodecName',
+	type: 'string',
+} as const satisfies Ebml;
+
+export const trackTimestampScale = {
+	name: 'TrackTimestampScale',
+	type: 'float',
+} as const satisfies Ebml;
+
+export const trackEntry = {
+	name: 'TrackEntry',
+	type: 'children',
+} as const satisfies Ebml;
+
+export const tracks = {
+	name: 'Tracks',
+	type: 'children',
+} as const satisfies Ebml;
+
+export const timestampEntry = {
+	name: 'Timestamp',
+	type: 'uint',
+} as const satisfies Ebml;
+
+export const block = {
+	name: 'Block',
+	type: 'uint8array',
+} as const satisfies Ebml;
+
+export const simpleBlock = {
+	name: 'SimpleBlock',
+	type: 'uint8array',
+} as const satisfies Ebml;
+
+export const blockGroup = {
+	name: 'BlockGroup',
+	type: 'children',
+} as const satisfies Ebml;
+
+export const segment = {
+	name: 'Segment',
+	type: 'children',
+} as const satisfies Ebml;
+
+export const cluster = {
+	name: 'Cluster',
+	type: 'children',
+} as const satisfies Ebml;
+
+export type CodecIdSegment = EbmlParsed<typeof codecID>;
+export type TrackTypeSegment = EbmlParsed<typeof trackType>;
+export type WidthSegment = EbmlParsed<typeof widthType>;
+export type HeightSegment = EbmlParsed<typeof heightType>;
+export type TimestampScaleSegment = EbmlParsed<typeof timestampScale>;
+export type DurationSegment = EbmlParsed<typeof duration>;
+export type DisplayWidthSegment = EbmlParsed<typeof displayWidth>;
+export type DisplayHeightSegment = EbmlParsed<typeof displayHeight>;
+export type TrackNumberSegment = EbmlParsed<typeof trackNumber>;
+export type AudioSegment = EbmlParsed<typeof audioSegment>;
+export type VideoSegment = EbmlParsed<typeof videoSegment>;
+export type TrackEntry = EbmlParsed<typeof trackEntry>;
+export type BlockSegment = EbmlParsed<typeof block>;
+export type SimpleBlockSegment = EbmlParsed<typeof simpleBlock>;
+export type MainSegment = EbmlParsed<typeof segment>;
+export type ClusterSegment = EbmlParsed<typeof cluster>;
+export type Tracks = EbmlParsed<typeof tracks>;
+
+export type FloatWithSize = {value: number; size: '32' | '64'};
+export type UintWithSize = {value: number; byteLength: number};
+
+export type EbmlValue<
+	T extends Ebml,
+	Child = PossibleEbml,
+> = T extends EbmlWithUint
+	? UintWithSize
+	: T extends EbmlWithString
+		? string
+		: T extends EbmlWithFloat
+			? FloatWithSize
+			: T extends EbmlWithHexString
+				? string
+				: T extends EbmlWithUint8Array
+					? Uint8Array
+					: T extends EbmlWithChildren
+						? Child[]
+						: never;
+
+export type EbmlValueOrUint8Array<T extends Ebml> =
+	| Uint8Array
+	| EbmlValue<T, PossibleEbmlOrUint8Array>;
 
 export type EbmlParsed<T extends Ebml> = {
 	type: T['name'];
 	value: EbmlValue<T>;
-	hex: string;
+	minVintWidth: number;
+};
+
+export type EbmlParsedOrUint8Array<T extends Ebml> = {
+	type: T['name'];
+	value: EbmlValueOrUint8Array<T>;
+	minVintWidth: number;
 };
 
 export const ebmlMap = {
@@ -462,50 +708,121 @@ export const ebmlMap = {
 	[matroskaElements.Void]: voidEbml,
 	[matroskaElements.Cues]: {
 		name: 'Cues',
-		type: 'void',
+		type: 'uint8array',
 	},
 	[matroskaElements.DateUTC]: {
 		name: 'DateUTC',
-		type: 'void',
-	},
-	[matroskaElements.TrackTimestampScale]: {
-		name: 'TrackTimestampScale',
-		type: 'float',
+		type: 'uint8array',
 	},
+	[matroskaElements.TrackTimestampScale]: trackTimestampScale,
 	[matroskaElements.CodecDelay]: {
 		name: 'CodecDelay',
-		type: 'void',
+		type: 'uint8array',
 	},
 	[matroskaElements.SeekPreRoll]: {
 		name: 'SeekPreRoll',
-		type: 'void',
+		type: 'uint8array',
 	},
 	[matroskaElements.DiscardPadding]: {
 		name: 'DiscardPadding',
-		type: 'void',
+		type: 'uint8array',
 	},
 	[matroskaElements.OutputSamplingFrequency]: {
 		name: 'OutputSamplingFrequency',
-		type: 'void',
-	},
-	[matroskaElements.CodecName]: {
-		name: 'CodecName',
-		type: 'void',
+		type: 'uint8array',
 	},
+	[matroskaElements.CodecName]: codecName,
 	[matroskaElements.Position]: {
 		name: 'Position',
-		type: 'void',
+		type: 'uint8array',
 	},
 	[matroskaElements.SliceDuration]: {
 		name: 'SliceDuration',
-		type: 'void',
+		type: 'uint8array',
+	},
+	[matroskaElements.SeekHead]: seekHead,
+	[matroskaElements.Seek]: seek,
+	[matroskaElements.SeekID]: seekId,
+	[matroskaElements.SeekPosition]: seekPosition,
+	[matroskaElements.Crc32]: {
+		name: 'Crc32',
+		type: 'uint8array',
+	},
+	[matroskaElements.MuxingApp]: muxingApp,
+	[matroskaElements.WritingApp]: {
+		name: 'WritingApp',
+		type: 'string',
+	},
+	[matroskaElements.SegmentUUID]: {
+		name: 'SegmentUUID',
+		type: 'string',
+	},
+	[matroskaElements.Duration]: duration,
+	[matroskaElements.CodecID]: {
+		name: 'CodecID',
+		type: 'string',
+	},
+	[matroskaElements.TrackType]: trackType,
+	[matroskaElements.PixelWidth]: widthType,
+	[matroskaElements.PixelHeight]: heightType,
+	[matroskaElements.TimestampScale]: timestampScale,
+	[matroskaElements.Info]: infoType,
+	[matroskaElements.Title]: titleType,
+	[matroskaElements.SamplingFrequency]: samplingFrequency,
+	[matroskaElements.Channels]: channels,
+	[matroskaElements.AlphaMode]: alphaMode,
+	[matroskaElements.FlagInterlaced]: interlaced,
+	[matroskaElements.BitDepth]: bitDepth,
+	[matroskaElements.DisplayHeight]: displayHeight,
+	[matroskaElements.DisplayWidth]: displayWidth,
+	[matroskaElements.FlagLacing]: flagLacing,
+	[matroskaElements.Tags]: tags,
+	[matroskaElements.Tag]: tagSegment,
+	[matroskaElements.TrackNumber]: trackNumber,
+	[matroskaElements.TrackUID]: trackUID,
+	[matroskaElements.Colour]: color,
+	[matroskaElements.Language]: language,
+	[matroskaElements.DefaultDuration]: defaultDuration,
+	[matroskaElements.CodecPrivate]: codecPrivate,
+	[matroskaElements.BlockAdditions]: blockAdditionsSegment,
+	[matroskaElements.MaxBlockAdditionID]: maxBlockAdditionIdSegment,
+	[matroskaElements.Audio]: audioSegment,
+	[matroskaElements.Video]: videoSegment,
+	[matroskaElements.FlagDefault]: flagDefault,
+	[matroskaElements.ReferenceBlock]: referenceBlock,
+	[matroskaElements.TrackEntry]: trackEntry,
+	[matroskaElements.Timestamp]: {
+		name: 'Timestamp',
+		type: 'uint',
+	},
+	[matroskaElements.Tracks]: tracks,
+	[matroskaElements.Block]: block,
+	[matroskaElements.SimpleBlock]: simpleBlock,
+	[matroskaElements.BlockGroup]: blockGroup,
+	[matroskaElements.Segment]: {
+		name: 'Segment',
+		type: 'children',
+	},
+	[matroskaElements.Cluster]: {
+		name: 'Cluster',
+		type: 'children',
 	},
 } as const satisfies Partial<Record<MatroskaElement, Ebml>>;
 
-export type PossibleEbml = {
-	[key in keyof typeof ebmlMap]: {
-		type: (typeof ebmlMap)[key]['name'];
-		value: EbmlValue<(typeof ebmlMap)[key]>;
-		hex: string;
-	};
-}[keyof typeof ebmlMap];
+export type PossibleEbml = Prettify<
+	{
+		[key in keyof typeof ebmlMap]: EbmlParsed<(typeof ebmlMap)[key]>;
+	}[keyof typeof ebmlMap]
+>;
+
+export type PossibleEbmlOrUint8Array =
+	| Prettify<
+			{
+				[key in keyof typeof ebmlMap]: EbmlParsedOrUint8Array<
+					(typeof ebmlMap)[key]
+				>;
+			}[keyof typeof ebmlMap]
+	  >
+	| Uint8Array;
+
+export type EbmlMapKey = keyof typeof ebmlMap;