@remotion/media-parser 4.0.201 → 4.0.202

package/dist/traversal.d.ts

@@ -11,9 +11,7 @@ import type { StszBox } from './boxes/iso-base-media/stsd/stsz';
 import type { SttsBox } from './boxes/iso-base-media/stsd/stts';
 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 { AudioSegment, ClusterSegment, CodecSegment, DisplayHeightSegment, DisplayWidthSegment, HeightSegment, TrackEntrySegment, TrackTypeSegment, VideoSegment, WidthSegment } from './boxes/webm/segments/track-entry';
+import type { AudioSegment, ClusterSegment, CodecIdSegment, DisplayHeightSegment, DisplayWidthSegment, HeightSegment, MainSegment, TimestampScaleSegment, TrackEntry, TrackTypeSegment, VideoSegment, WidthSegment } from './boxes/webm/segments/all-segments';
 import type { AnySegment, RegularBox } from './parse-result';
 export declare const getFtypBox: (segments: AnySegment[]) => FtypBox | null;
 export declare const getMoovBox: (segments: AnySegment[]) => MoovBox | null;
@@ -32,21 +30,25 @@ export declare const getStszBox: (trakBox: TrakBox) => StszBox | null;
 export declare const getStscBox: (trakBox: TrakBox) => StscBox | null;
 export declare const getStssBox: (trakBox: TrakBox) => StssBox | null;
 export declare const getClusterSegment: (segment: MainSegment) => ClusterSegment | null;
-export declare const getTracksSegment: (segment: MainSegment) => import("./boxes/webm/segments/tracks").TracksSegment | null;
+export declare const getTracksSegment: (segment: MainSegment) => {
+    type: "Tracks";
+    value: import("./boxes/webm/segments/all-segments").PossibleEbml[];
+    minVintWidth: number;
+} | null;
 export declare const getTimescaleSegment: (segment: MainSegment) => TimestampScaleSegment | null;
-export declare const getVideoSegment: (track: TrackEntrySegment) => VideoSegment | null;
-export declare const getAudioSegment: (track: TrackEntrySegment) => AudioSegment | null;
-export declare const getSampleRate: (track: TrackEntrySegment) => number | null;
-export declare const getNumberOfChannels: (track: TrackEntrySegment) => number;
-export declare const getBitDepth: (track: TrackEntrySegment) => number | null;
-export declare const getPrivateData: (track: TrackEntrySegment) => Uint8Array | null;
-export declare const getWidthSegment: (track: TrackEntrySegment) => WidthSegment | null;
-export declare const getHeightSegment: (track: TrackEntrySegment) => HeightSegment | null;
-export declare const getDisplayWidthSegment: (track: TrackEntrySegment) => DisplayWidthSegment | null;
-export declare const getDisplayHeightSegment: (track: TrackEntrySegment) => DisplayHeightSegment | null;
-export declare const getTrackTypeSegment: (track: TrackEntrySegment) => TrackTypeSegment | null;
-export declare const getTrackId: (track: TrackEntrySegment) => number;
-export declare const getCodecSegment: (track: TrackEntrySegment) => CodecSegment | null;
+export declare const getVideoSegment: (track: TrackEntry) => VideoSegment | null;
+export declare const getAudioSegment: (track: TrackEntry) => AudioSegment | null;
+export declare const getSampleRate: (track: TrackEntry) => number | null;
+export declare const getNumberOfChannels: (track: TrackEntry) => number;
+export declare const getBitDepth: (track: TrackEntry) => number | null;
+export declare const getPrivateData: (track: TrackEntry) => Uint8Array | null;
+export declare const getWidthSegment: (track: TrackEntry) => WidthSegment | null;
+export declare const getHeightSegment: (track: TrackEntry) => HeightSegment | null;
+export declare const getDisplayWidthSegment: (track: TrackEntry) => DisplayWidthSegment | null;
+export declare const getDisplayHeightSegment: (track: TrackEntry) => DisplayHeightSegment | null;
+export declare const getTrackTypeSegment: (track: TrackEntry) => TrackTypeSegment | null;
+export declare const getTrackId: (track: TrackEntry) => number;
+export declare const getCodecSegment: (track: TrackEntry) => CodecIdSegment | null;
 export declare const hasSkippedMdatProcessing: (anySegment: AnySegment[]) => {
     skipped: false;
     fileOffset?: undefined;

package/dist/traversal.js

@@ -151,41 +151,41 @@ const getStssBox = (trakBox) => {
 };
 exports.getStssBox = getStssBox;
 const getClusterSegment = (segment) => {
-    const clusterSegment = segment.children.find((b) => b.type === 'cluster-segment');
+    const clusterSegment = segment.value.find((b) => b.type === 'Cluster');
     return clusterSegment !== null && clusterSegment !== void 0 ? clusterSegment : null;
 };
 exports.getClusterSegment = getClusterSegment;
 const getTracksSegment = (segment) => {
-    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;
     }
     return tracksSegment;
 };
 exports.getTracksSegment = getTracksSegment;
 const getTimescaleSegment = (segment) => {
-    const infoSegment = segment.children.find((b) => b.type === 'info-segment');
-    if (!infoSegment || infoSegment.type !== 'info-segment') {
+    const infoSegment = segment.value.find((b) => b.type === 'Info');
+    if (!infoSegment || infoSegment.type !== 'Info') {
         return null;
     }
-    const timescale = infoSegment.children.find((b) => b.type === 'timestamp-scale-segment');
-    if (!timescale || timescale.type !== 'timestamp-scale-segment') {
+    const timescale = infoSegment.value.find((b) => b.type === 'TimestampScale');
+    if (!timescale || timescale.type !== 'TimestampScale') {
         return null;
     }
     return timescale;
 };
 exports.getTimescaleSegment = getTimescaleSegment;
 const getVideoSegment = (track) => {
-    const videoSegment = track.children.find((b) => b.type === 'video-segment');
-    if (!videoSegment || videoSegment.type !== 'video-segment') {
+    const videoSegment = track.value.find((b) => b.type === 'Video');
+    if (!videoSegment || videoSegment.type !== 'Video') {
         return null;
     }
     return videoSegment !== null && videoSegment !== void 0 ? videoSegment : null;
 };
 exports.getVideoSegment = getVideoSegment;
 const getAudioSegment = (track) => {
-    const audioSegment = track.children.find((b) => b.type === 'audio-segment');
-    if (!audioSegment || audioSegment.type !== 'audio-segment') {
+    const audioSegment = track.value.find((b) => b.type === 'Audio');
+    if (!audioSegment || audioSegment.type !== 'Audio') {
         return null;
     }
     return audioSegment !== null && audioSegment !== void 0 ? audioSegment : null;
@@ -196,12 +196,11 @@ const getSampleRate = (track) => {
     if (!audioSegment) {
         return null;
     }
-    const samplingFrequency = audioSegment.children.find((b) => b.type === 'sampling-frequency-segment');
-    if (!samplingFrequency ||
-        samplingFrequency.type !== 'sampling-frequency-segment') {
+    const samplingFrequency = audioSegment.value.find((b) => b.type === 'SamplingFrequency');
+    if (!samplingFrequency || samplingFrequency.type !== 'SamplingFrequency') {
         return null;
     }
-    return samplingFrequency.samplingFrequency;
+    return samplingFrequency.value.value;
 };
 exports.getSampleRate = getSampleRate;
 const getNumberOfChannels = (track) => {
@@ -209,11 +208,11 @@ const getNumberOfChannels = (track) => {
     if (!audioSegment) {
         throw new Error('Could not find audio segment');
     }
-    const channels = audioSegment.children.find((b) => b.type === 'channels-segment');
-    if (!channels || channels.type !== 'channels-segment') {
+    const channels = audioSegment.value.find((b) => b.type === 'Channels');
+    if (!channels || channels.type !== 'Channels') {
         return 1;
     }
-    return channels.channels;
+    return channels.value.value;
 };
 exports.getNumberOfChannels = getNumberOfChannels;
 const getBitDepth = (track) => {
@@ -221,19 +220,19 @@ const getBitDepth = (track) => {
     if (!audioSegment) {
         return null;
     }
-    const bitDepth = audioSegment.children.find((b) => b.type === 'bit-depth-segment');
-    if (!bitDepth || bitDepth.type !== 'bit-depth-segment') {
+    const bitDepth = audioSegment.value.find((b) => b.type === 'BitDepth');
+    if (!bitDepth || bitDepth.type !== 'BitDepth') {
         return null;
     }
-    return bitDepth.bitDepth;
+    return bitDepth.value.value;
 };
 exports.getBitDepth = getBitDepth;
 const getPrivateData = (track) => {
-    const privateData = track.children.find((b) => b.type === 'codec-private-segment');
-    if (!privateData || privateData.type !== 'codec-private-segment') {
+    const privateData = track.value.find((b) => b.type === 'CodecPrivate');
+    if (!privateData || privateData.type !== 'CodecPrivate') {
         return null;
     }
-    return privateData.codecPrivateData;
+    return privateData.value;
 };
 exports.getPrivateData = getPrivateData;
 const getWidthSegment = (track) => {
@@ -241,8 +240,8 @@ const getWidthSegment = (track) => {
     if (!videoSegment) {
         return null;
     }
-    const width = videoSegment.children.find((b) => b.type === 'width-segment');
-    if (!width || width.type !== 'width-segment') {
+    const width = videoSegment.value.find((b) => b.type === 'PixelWidth');
+    if (!width || width.type !== 'PixelWidth') {
         return null;
     }
     return width;
@@ -253,8 +252,8 @@ const getHeightSegment = (track) => {
     if (!videoSegment) {
         return null;
     }
-    const height = videoSegment.children.find((b) => b.type === 'height-segment');
-    if (!height || height.type !== 'height-segment') {
+    const height = videoSegment.value.find((b) => b.type === 'PixelHeight');
+    if (!height || height.type !== 'PixelHeight') {
         return null;
     }
     return height;
@@ -265,8 +264,8 @@ const getDisplayWidthSegment = (track) => {
     if (!videoSegment) {
         return null;
     }
-    const displayWidth = videoSegment.children.find((b) => b.type === 'display-width-segment');
-    if (!displayWidth || displayWidth.type !== 'display-width-segment') {
+    const displayWidth = videoSegment.value.find((b) => b.type === 'DisplayWidth');
+    if (!displayWidth || displayWidth.type !== 'DisplayWidth') {
         return null;
     }
     return displayWidth;
@@ -277,32 +276,32 @@ const getDisplayHeightSegment = (track) => {
     if (!videoSegment) {
         return null;
     }
-    const displayHeight = videoSegment.children.find((b) => b.type === 'display-height-segment');
-    if (!displayHeight || displayHeight.type !== 'display-height-segment') {
+    const displayHeight = videoSegment.value.find((b) => b.type === 'DisplayHeight');
+    if (!displayHeight || displayHeight.type !== 'DisplayHeight') {
         return null;
     }
     return displayHeight;
 };
 exports.getDisplayHeightSegment = getDisplayHeightSegment;
 const getTrackTypeSegment = (track) => {
-    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;
 };
 exports.getTrackTypeSegment = getTrackTypeSegment;
 const getTrackId = (track) => {
-    const trackId = track.children.find((b) => b.type === 'track-number-segment');
-    if (!trackId || trackId.type !== 'track-number-segment') {
+    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;
 };
 exports.getTrackId = getTrackId;
 const getCodecSegment = (track) => {
-    const codec = track.children.find((b) => b.type === 'codec-segment');
-    if (!codec || codec.type !== 'codec-segment') {
+    const codec = track.value.find((b) => b.type === 'CodecID');
+    if (!codec || codec.type !== 'CodecID') {
         return null;
     }
     return codec;

package/dist/writers/web-fs.d.ts

@@ -0,0 +1,2 @@
+import type { WriterInterface } from './writer';
+export declare const webFsWriter: WriterInterface;

package/dist/writers/web-fs.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webFsWriter = void 0;
+const createContent = async () => {
+    const directoryHandle = await navigator.storage.getDirectory();
+    const fileHandle = await directoryHandle.getFileHandle('out.web', {
+        create: true,
+    });
+    const f = await fileHandle.getFile();
+    const writable = await fileHandle.createWritable();
+    return {
+        write: async (arr) => {
+            await writable.write(arr);
+        },
+        save: async () => {
+            const picker = await window.showSaveFilePicker({
+                suggestedName: `${Math.random().toString().replace('.', '')}.webm`,
+            });
+            const pickerWriteable = await picker.createWritable();
+            const stream = f.stream();
+            await stream.pipeTo(pickerWriteable);
+            await writable.close();
+        },
+    };
+};
+exports.webFsWriter = {
+    createContent,
+};

package/dist/writers/writer.d.ts

@@ -0,0 +1,9 @@
+type Writer = {
+    write: (arr: Uint8Array) => Promise<void>;
+    save: () => Promise<void>;
+};
+type CreateContent = () => Promise<Writer>;
+export type WriterInterface = {
+    createContent: CreateContent;
+};
+export {};

package/dist/writers/writer.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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.201",
+  "version": "4.0.202",
   "main": "dist/index.js",
   "sideEffects": false,
   "devDependencies": {
-    "@remotion/renderer": "4.0.201"
+    "@remotion/renderer": "4.0.202"
   },
   "publishConfig": {
     "access": "public"

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

@@ -59,7 +59,7 @@ export const parseMvhd = ({
 	const durationInSeconds = durationInUnits / timeScale;
 
 	const rateArray = iterator.getSlice(4);
-	const rateView = getArrayBufferIterator(rateArray);
+	const rateView = getArrayBufferIterator(rateArray, rateArray.length);
 	const rate =
 		rateView.getInt8() * 10 +
 		rateView.getInt8() +
@@ -67,7 +67,7 @@ export const parseMvhd = ({
 		rateView.getInt8() * 0.01;
 
 	const volumeArray = iterator.getSlice(2);
-	const volumeView = getArrayBufferIterator(volumeArray);
+	const volumeView = getArrayBufferIterator(volumeArray, volumeArray.length);
 
 	const volume = volumeView.getInt8() + volumeView.getInt8() * 0.1;
 

package/src/boxes/iso-base-media/stsd/keys.ts

@@ -6,7 +6,7 @@ export interface KeysBox extends BaseBox {
 }
 
 export const parseKeys = (data: Uint8Array, offset: number): KeysBox => {
-	const iterator = getArrayBufferIterator(data);
+	const iterator = getArrayBufferIterator(data, data.byteLength);
 	const size = iterator.getUint32();
 	if (size !== data.byteLength) {
 		throw new Error(`Expected keys size of ${data.byteLength}, got ${size}`);

package/src/boxes/webm/av1-codec-private.ts

@@ -5,7 +5,7 @@ export const parseAv1PrivateData = (
 	data: Uint8Array,
 	colrAtom: ColorParameterBox | null,
 ) => {
-	const iterator = getArrayBufferIterator(data);
+	const iterator = getArrayBufferIterator(data, data.byteLength);
 	iterator.startReadingBits();
 	if (iterator.getBits(1) !== 1) {
 		iterator.destroy();

package/src/boxes/webm/description.ts

@@ -1,12 +1,12 @@
 import {getArrayBufferIterator} from '../../buffer-iterator';
 import {getCodecSegment, getPrivateData} from '../../traversal';
-import type {TrackEntrySegment} from './segments/track-entry';
+import type {TrackEntry} from './segments/all-segments';
 
 export const getAudioDescription = (
-	track: TrackEntrySegment,
+	track: TrackEntry,
 ): undefined | Uint8Array => {
 	const codec = getCodecSegment(track);
-	if (!codec || codec.codec !== 'A_VORBIS') {
+	if (!codec || codec.value !== 'A_VORBIS') {
 		return undefined;
 	}
 
@@ -59,7 +59,10 @@ export const getAudioDescription = (
 
 	const vorbisBooks = privateData.slice(offset);
 
-	const bufferIterator = getArrayBufferIterator(vorbisInfo.slice(0));
+	const bufferIterator = getArrayBufferIterator(
+		vorbisInfo.slice(0),
+		vorbisInfo.length,
+	);
 
 	// type
 	bufferIterator.getUint8();

package/src/boxes/webm/ebml.ts

@@ -32,10 +32,9 @@ export const measureEBMLVarInt = (value: number) => {
 	throw new Error('EBML VINT size not supported ' + value);
 };
 
-export const getVariableInt = (
-	value: number,
-	width: number = measureEBMLVarInt(value),
-) => {
+export const getVariableInt = (value: number, minWidth: number | null) => {
+	const width = Math.max(measureEBMLVarInt(value), minWidth ?? 0);
+
 	switch (width) {
 		case 1:
 			return new Uint8Array([(1 << 7) | value]);
@@ -72,6 +71,27 @@ export const getVariableInt = (
 				value >> 8,
 				value,
 			]);
+		case 7:
+			return new Uint8Array([
+				(1 << 1) | ((value / 2 ** 48) & 0x1),
+				(value / 2 ** 40) | 0,
+				(value / 2 ** 32) | 0,
+				value >> 24,
+				value >> 16,
+				value >> 8,
+				value,
+			]);
+		case 8:
+			return new Uint8Array([
+				(1 << 0) | ((value / 2 ** 56) & 0x1),
+				(value / 2 ** 48) | 0,
+				(value / 2 ** 40) | 0,
+				(value / 2 ** 32) | 0,
+				value >> 24,
+				value >> 16,
+				value >> 8,
+				value,
+			]);
 		default:
 			throw new Error('Bad EBML VINT size ' + width);
 	}

package/src/boxes/webm/get-ready-tracks.ts

@@ -1,7 +1,7 @@
 import type {Track} from '../../get-tracks';
 import {getTracksSegment} from '../../traversal';
 import {getTrack} from './get-track';
-import type {MainSegment} from './segments/main';
+import type {MainSegment} from './segments/all-segments';
 
 export const getTracksFromMatroska = (
 	segment: MainSegment,
@@ -14,12 +14,12 @@ export const getTracksFromMatroska = (
 
 	const tracks: Track[] = [];
 
-	for (const trackEntrySegment of tracksSegment.children) {
-		if (trackEntrySegment.type === 'crc32-segment') {
+	for (const trackEntrySegment of tracksSegment.value) {
+		if (trackEntrySegment.type === 'Crc32') {
 			continue;
 		}
 
-		if (trackEntrySegment.type !== 'track-entry-segment') {
+		if (trackEntrySegment.type !== 'TrackEntry') {
 			throw new Error('Expected track entry segment');
 		}
 

package/src/boxes/webm/get-sample-from-block.ts

@@ -0,0 +1,125 @@
+import {getArrayBufferIterator} from '../../buffer-iterator';
+import type {ParserContext} from '../../parser-context';
+import type {AudioSample, VideoSample} from '../../webcodec-sample-types';
+import type {BlockSegment, SimpleBlockSegment} from './segments/all-segments';
+import {matroskaElements} from './segments/all-segments';
+import {parseBlockFlags} from './segments/block-simple-block-flags';
+
+type SampleResult =
+	| {
+			type: 'video-sample';
+			videoSample: VideoSample;
+	  }
+	| {
+			type: 'audio-sample';
+			audioSample: AudioSample;
+	  }
+	| {
+			type: 'partial-video-sample';
+			partialVideoSample: Omit<VideoSample, 'type'>;
+	  }
+	| {
+			type: 'no-sample';
+	  };
+
+export const getSampleFromBlock = (
+	ebml: BlockSegment | SimpleBlockSegment,
+	parserContext: ParserContext,
+	offset: number,
+): SampleResult => {
+	const iterator = getArrayBufferIterator(ebml.value, ebml.value.length);
+	const trackNumber = iterator.getVint();
+	if (trackNumber === null) {
+		throw new Error('Not enough data to get track number, should not happen');
+	}
+
+	const timecodeRelativeToCluster = iterator.getUint16();
+
+	const {keyframe} = parseBlockFlags(
+		iterator,
+		ebml.type === 'SimpleBlock'
+			? matroskaElements.SimpleBlock
+			: matroskaElements.Block,
+	);
+
+	const {codec, trackTimescale} =
+		parserContext.parserState.getTrackInfoByNumber(trackNumber);
+
+	const clusterOffset =
+		parserContext.parserState.getTimestampOffsetForByteOffset(offset);
+
+	const timescale = parserContext.parserState.getTimescale();
+
+	if (clusterOffset === undefined) {
+		throw new Error('Could not find offset for byte offset ' + offset);
+	}
+
+	// https://github.com/hubblec4/Matroska-Chapters-Specs/blob/master/notes.md/#timestampscale
+	// The TimestampScale Element is used to calculate the Raw Timestamp of a Block. The timestamp is obtained by adding the Block's timestamp to the Cluster's Timestamp Element, and then multiplying that result by the TimestampScale. The result will be the Block's Raw Timestamp in nanoseconds.
+	const timecodeInNanoSeconds =
+		(timecodeRelativeToCluster + clusterOffset) *
+		timescale *
+		(trackTimescale ?? 1);
+
+	// Timecode should be in microseconds
+	const timecodeInMicroseconds = timecodeInNanoSeconds / 1000;
+
+	if (!codec) {
+		throw new Error(`Could not find codec for track ${trackNumber}`);
+	}
+
+	const remainingNow = ebml.value.length - (iterator.counter.getOffset() - 0);
+
+	if (codec.startsWith('V_')) {
+		const partialVideoSample: Omit<VideoSample, 'type'> = {
+			data: iterator.getSlice(remainingNow),
+			cts: null,
+			dts: null,
+			duration: undefined,
+			trackId: trackNumber,
+			timestamp: timecodeInMicroseconds,
+		};
+
+		if (keyframe === null) {
+			iterator.destroy();
+
+			return {
+				type: 'partial-video-sample',
+				partialVideoSample,
+			};
+		}
+
+		const sample: VideoSample = {
+			...partialVideoSample,
+			type: keyframe ? 'key' : 'delta',
+		};
+
+		iterator.destroy();
+
+		return {
+			type: 'video-sample',
+			videoSample: sample,
+		};
+	}
+
+	if (codec.startsWith('A_')) {
+		const audioSample: AudioSample = {
+			data: iterator.getSlice(remainingNow),
+			trackId: trackNumber,
+			timestamp: timecodeInMicroseconds,
+			type: 'key',
+		};
+
+		iterator.destroy();
+
+		return {
+			type: 'audio-sample',
+			audioSample,
+		};
+	}
+
+	iterator.destroy();
+	return {
+		type: 'no-sample',
+	};
+};