@remotion/media-parser 4.0.206 → 4.0.207

package/dist/create/create-media.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMedia = void 0;
+const ebml_1 = require("../boxes/webm/ebml");
+const make_header_1 = require("../boxes/webm/make-header");
+const all_segments_1 = require("../boxes/webm/segments/all-segments");
+const cluster_segment_1 = require("./cluster-segment");
+const matroska_header_1 = require("./matroska-header");
+const matroska_info_1 = require("./matroska-info");
+const matroska_segment_1 = require("./matroska-segment");
+const matroska_trackentry_1 = require("./matroska-trackentry");
+const createMedia = async (writer) => {
+    var _a, _b, _c, _d;
+    const header = (0, matroska_header_1.makeMatroskaHeader)();
+    const w = await writer.createContent();
+    await w.write(header.bytes);
+    const matroskaInfo = (0, matroska_info_1.makeMatroskaInfo)({
+        timescale: 1000000,
+        // TODO: Hardcoded
+        duration: 2658,
+    });
+    const currentTracks = [];
+    const matroskaTracks = (0, matroska_trackentry_1.makeMatroskaTracks)(currentTracks);
+    const matroskaSegment = (0, matroska_segment_1.createMatroskaSegment)([
+        matroskaInfo,
+        ...matroskaTracks,
+    ]);
+    const durationOffset = ((_b = (_a = matroskaSegment.offsets.children[0].children.find((c) => c.field === 'Duration')) === null || _a === void 0 ? void 0 : _a.offset) !== null && _b !== void 0 ? _b : 0) + w.getWrittenByteCount();
+    const tracksOffset = ((_d = (_c = matroskaSegment.offsets.children.find((o) => o.field === 'Tracks')) === null || _c === void 0 ? void 0 : _c.offset) !== null && _d !== void 0 ? _d : 0) + w.getWrittenByteCount();
+    if (!durationOffset) {
+        throw new Error('could not get duration offset');
+    }
+    if (!tracksOffset) {
+        throw new Error('could not get tracks offset');
+    }
+    await w.write(matroskaSegment.bytes);
+    const cluster = (0, cluster_segment_1.createClusterSegment)();
+    const clusterVIntPosition = w.getWrittenByteCount() +
+        cluster.offsets.offset +
+        (0, make_header_1.matroskaToHex)(all_segments_1.matroskaElements.Cluster).byteLength;
+    let clusterSize = cluster.bytes.byteLength;
+    await w.write(cluster.bytes);
+    const addSample = async (chunk, trackNumber) => {
+        const arr = new Uint8Array(chunk.byteLength);
+        chunk.copyTo(arr);
+        const simpleBlock = (0, cluster_segment_1.makeSimpleBlock)({
+            bytes: arr,
+            invisible: false,
+            keyframe: chunk.type === 'key',
+            lacing: 0,
+            trackNumber,
+            // TODO: Maybe this is bad, because it's in microseconds, but should be in timescale
+            // Maybe it only works by coincidence
+            timecodeRelativeToCluster: Math.round(chunk.timestamp / 1000),
+        });
+        clusterSize += simpleBlock.byteLength;
+        await w.updateDataAt(clusterVIntPosition, (0, ebml_1.getVariableInt)(clusterSize, cluster_segment_1.CLUSTER_MIN_VINT_WIDTH));
+        await w.write(simpleBlock);
+    };
+    const updateDuration = async (newDuration) => {
+        const blocks = (0, make_header_1.padMatroskaBytes)({
+            type: 'Duration',
+            value: {
+                value: newDuration,
+                size: '64',
+            },
+            minVintWidth: null,
+        }, 
+        // TODO: That's too much padding
+        1000);
+        await w.updateDataAt(durationOffset, (0, make_header_1.combineUint8Arrays)(blocks.map((b) => b.bytes)));
+    };
+    const addTrack = async (track) => {
+        currentTracks.push(track);
+        const newTracks = (0, matroska_trackentry_1.makeMatroskaTracks)(currentTracks);
+        await w.updateDataAt(tracksOffset, (0, make_header_1.combineUint8Arrays)(newTracks.map((b) => b.bytes)));
+    };
+    let operationProm = Promise.resolve();
+    const waitForFinishPromises = [];
+    return {
+        save: async () => {
+            await w.save();
+        },
+        addSample: (chunk, trackNumber) => {
+            operationProm = operationProm.then(() => addSample(chunk, trackNumber));
+            return operationProm;
+        },
+        updateDuration: (duration) => {
+            operationProm = operationProm.then(() => updateDuration(duration));
+            return operationProm;
+        },
+        addTrack: (track) => {
+            const trackNumber = currentTracks.length + 1;
+            const bytes = track.type === 'video'
+                ? (0, matroska_trackentry_1.makeMatroskaVideoTrackEntryBytes)({ ...track, trackNumber })
+                : (0, matroska_trackentry_1.makeMatroskaAudioTrackEntryBytes)({ ...track, trackNumber });
+            operationProm = operationProm.then(() => addTrack(bytes));
+            return operationProm.then(() => ({ trackNumber }));
+        },
+        addWaitForFinishPromise: (promise) => {
+            waitForFinishPromises.push(promise);
+        },
+        async waitForFinish() {
+            await Promise.all(waitForFinishPromises.map((p) => p()));
+        },
+    };
+};
+exports.createMedia = createMedia;

package/dist/create/matroska-header.d.ts

@@ -0,0 +1 @@
+export declare const makeMatroskaHeader: () => import("../boxes/webm/segments/all-segments").BytesAndOffset;

package/dist/create/matroska-header.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMatroskaHeader = void 0;
+const make_header_1 = require("../boxes/webm/make-header");
+const makeMatroskaHeader = () => {
+    return (0, make_header_1.makeMatroskaBytes)({
+        type: 'Header',
+        value: [
+            {
+                minVintWidth: null,
+                type: 'EBMLVersion',
+                value: {
+                    value: 1,
+                    byteLength: null,
+                },
+            },
+            {
+                minVintWidth: null,
+                type: 'EBMLReadVersion',
+                value: {
+                    value: 1,
+                    byteLength: null,
+                },
+            },
+            {
+                type: 'EBMLMaxIDLength',
+                value: {
+                    byteLength: null,
+                    value: 4,
+                },
+                minVintWidth: null,
+            },
+            {
+                type: 'EBMLMaxSizeLength',
+                value: {
+                    byteLength: null,
+                    value: 8,
+                },
+                minVintWidth: null,
+            },
+            {
+                type: 'DocType',
+                value: 'webm',
+                minVintWidth: null,
+            },
+            {
+                type: 'DocTypeVersion',
+                value: {
+                    byteLength: null,
+                    value: 4,
+                },
+                minVintWidth: null,
+            },
+            {
+                type: 'DocTypeReadVersion',
+                value: {
+                    byteLength: null,
+                    value: 2,
+                },
+                minVintWidth: null,
+            },
+        ],
+        minVintWidth: null,
+    });
+};
+exports.makeMatroskaHeader = makeMatroskaHeader;

package/dist/create/matroska-info.d.ts

@@ -0,0 +1,4 @@
+export declare const makeMatroskaInfo: ({ timescale, duration, }: {
+    timescale: number;
+    duration: number;
+}) => import("../boxes/webm/segments/all-segments").BytesAndOffset;

package/dist/create/matroska-info.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMatroskaInfo = void 0;
+const make_header_1 = require("../boxes/webm/make-header");
+const makeMatroskaInfo = ({ timescale, duration, }) => {
+    return (0, make_header_1.makeMatroskaBytes)({
+        type: 'Info',
+        value: [
+            {
+                type: 'TimestampScale',
+                value: {
+                    value: timescale,
+                    byteLength: null,
+                },
+                minVintWidth: null,
+            },
+            {
+                type: 'MuxingApp',
+                value: '@remotion/media-parser',
+                minVintWidth: null,
+            },
+            {
+                type: 'WritingApp',
+                value: '@remotion/media-parser',
+                minVintWidth: null,
+            },
+            ...(0, make_header_1.padMatroskaBytes)({
+                type: 'Duration',
+                value: {
+                    value: duration,
+                    size: '64',
+                },
+                minVintWidth: null,
+            }, 
+            // TODO: That's too much padding
+            1000),
+        ],
+        minVintWidth: null,
+    });
+};
+exports.makeMatroskaInfo = makeMatroskaInfo;

package/dist/create/matroska-segment.d.ts

@@ -0,0 +1,2 @@
+import type { BytesAndOffset } from '../boxes/webm/segments/all-segments';
+export declare const createMatroskaSegment: (children: BytesAndOffset[]) => BytesAndOffset;

package/dist/create/matroska-segment.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMatroskaSegment = void 0;
+const make_header_1 = require("../boxes/webm/make-header");
+const createMatroskaSegment = (children) => {
+    return (0, make_header_1.makeMatroskaBytes)({
+        type: 'Segment',
+        value: children,
+        minVintWidth: 8,
+    });
+};
+exports.createMatroskaSegment = createMatroskaSegment;

package/dist/create/matroska-trackentry.d.ts

@@ -0,0 +1,32 @@
+import type { BytesAndOffset } from '../boxes/webm/segments/all-segments';
+export type MatroskaColorParams = {
+    transferChracteristics: 'bt709' | 'smpte170m' | 'iec61966-2-1' | null;
+    matrixCoefficients: 'bt709' | 'bt470bg' | 'rgb' | 'smpte170m' | null;
+    primaries: 'bt709' | 'smpte170m' | 'bt470bg' | null;
+    fullRange: boolean | null;
+};
+export declare const makeMatroskaColorBytes: ({ transferChracteristics, matrixCoefficients, primaries, fullRange, }: MatroskaColorParams) => BytesAndOffset;
+export declare const makeMatroskaVideoBytes: ({ color, width, height, }: {
+    color: MatroskaColorParams;
+    width: number;
+    height: number;
+}) => BytesAndOffset;
+export type MakeTrackAudio = {
+    trackNumber: number;
+    codecId: string;
+    numberOfChannels: number;
+    sampleRate: number;
+    type: 'audio';
+};
+export type MakeTrackVideo = {
+    color: MatroskaColorParams;
+    width: number;
+    height: number;
+    defaultDuration: number;
+    trackNumber: number;
+    codecId: string;
+    type: 'video';
+};
+export declare const makeMatroskaAudioTrackEntryBytes: ({ trackNumber, codecId, numberOfChannels: audioChannels, sampleRate, }: MakeTrackAudio) => BytesAndOffset;
+export declare const makeMatroskaVideoTrackEntryBytes: ({ color, width, height, defaultDuration, trackNumber, codecId, }: MakeTrackVideo) => BytesAndOffset;
+export declare const makeMatroskaTracks: (tracks: BytesAndOffset[]) => BytesAndOffset[];

package/dist/create/matroska-trackentry.js

@@ -0,0 +1,266 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMatroskaTracks = exports.makeMatroskaVideoTrackEntryBytes = exports.makeMatroskaAudioTrackEntryBytes = exports.makeMatroskaVideoBytes = exports.makeMatroskaColorBytes = void 0;
+const make_header_1 = require("../boxes/webm/make-header");
+const makeMatroskaColorBytes = ({ transferChracteristics, matrixCoefficients, primaries, fullRange, }) => {
+    const rangeValue = transferChracteristics && matrixCoefficients
+        ? 3
+        : fullRange === true
+            ? 2
+            : fullRange === false
+                ? 1
+                : 0;
+    // https://datatracker.ietf.org/doc/draft-ietf-cellar-matroska/
+    // 5.1.4.1.28.27
+    const primariesValue = primaries === 'bt709'
+        ? 1
+        : primaries === 'smpte170m'
+            ? 6
+            : primaries === 'bt470bg'
+                ? 5
+                : 2;
+    const transferChracteristicsValue = transferChracteristics === 'bt709'
+        ? 1
+        : transferChracteristics === 'smpte170m'
+            ? 6
+            : transferChracteristics === 'iec61966-2-1'
+                ? 13
+                : 2;
+    if (matrixCoefficients === 'rgb') {
+        throw new Error('Cannot encode Matroska in RGB');
+    }
+    const matrixCoefficientsValue = matrixCoefficients === 'bt709'
+        ? 1
+        : matrixCoefficients === 'bt470bg'
+            ? 5
+            : matrixCoefficients === 'smpte170m'
+                ? 6
+                : 2;
+    return (0, make_header_1.makeMatroskaBytes)({
+        type: 'Colour',
+        minVintWidth: null,
+        value: [
+            {
+                type: 'TransferCharacteristics',
+                value: {
+                    value: transferChracteristicsValue,
+                    byteLength: null,
+                },
+                minVintWidth: null,
+            },
+            {
+                type: 'MatrixCoefficients',
+                value: {
+                    value: matrixCoefficientsValue,
+                    byteLength: null,
+                },
+                minVintWidth: null,
+            },
+            {
+                type: 'Primaries',
+                value: {
+                    value: primariesValue,
+                    byteLength: null,
+                },
+                minVintWidth: null,
+            },
+            {
+                type: 'Range',
+                value: {
+                    value: rangeValue,
+                    byteLength: null,
+                },
+                minVintWidth: null,
+            },
+        ],
+    });
+};
+exports.makeMatroskaColorBytes = makeMatroskaColorBytes;
+const makeMatroskaVideoBytes = ({ color, width, height, }) => {
+    return (0, make_header_1.makeMatroskaBytes)({
+        type: 'Video',
+        value: [
+            {
+                type: 'PixelWidth',
+                value: {
+                    value: width,
+                    byteLength: null,
+                },
+                minVintWidth: null,
+            },
+            {
+                type: 'PixelHeight',
+                value: {
+                    value: height,
+                    byteLength: null,
+                },
+                minVintWidth: null,
+            },
+            {
+                type: 'FlagInterlaced',
+                value: {
+                    // https://datatracker.ietf.org/doc/draft-ietf-cellar-matroska/
+                    // 5.1.4.1.28.1.
+                    value: 2, // 2 - progressive, no interlaced
+                    byteLength: null,
+                },
+                minVintWidth: null,
+            },
+            (0, exports.makeMatroskaColorBytes)(color),
+        ],
+        minVintWidth: null,
+    });
+};
+exports.makeMatroskaVideoBytes = makeMatroskaVideoBytes;
+const makeMatroskaAudioTrackEntryBytes = ({ trackNumber, codecId, numberOfChannels: audioChannels, sampleRate, }) => {
+    return (0, make_header_1.makeMatroskaBytes)({
+        type: 'TrackEntry',
+        minVintWidth: null,
+        value: [
+            {
+                type: 'TrackNumber',
+                value: {
+                    value: trackNumber,
+                    byteLength: null,
+                },
+                minVintWidth: null,
+            },
+            {
+                type: 'TrackUID',
+                value: '0x188FEB95C8EFABA',
+                minVintWidth: null,
+            },
+            {
+                type: 'TrackType',
+                value: {
+                    value: 2,
+                    byteLength: null,
+                },
+                minVintWidth: null,
+            },
+            {
+                type: 'TrackTimestampScale',
+                value: {
+                    value: 1,
+                    size: '64',
+                },
+                minVintWidth: null,
+            },
+            {
+                type: 'CodecID',
+                value: codecId,
+                minVintWidth: null,
+            },
+            {
+                type: 'Audio',
+                value: [
+                    {
+                        type: 'Channels',
+                        minVintWidth: null,
+                        value: {
+                            value: audioChannels,
+                            byteLength: null,
+                        },
+                    },
+                    {
+                        type: 'SamplingFrequency',
+                        minVintWidth: null,
+                        value: {
+                            value: sampleRate,
+                            size: '64',
+                        },
+                    },
+                    {
+                        type: 'BitDepth',
+                        minVintWidth: null,
+                        value: {
+                            value: 32,
+                            byteLength: null,
+                        },
+                    },
+                ],
+                minVintWidth: null,
+            },
+        ],
+    });
+};
+exports.makeMatroskaAudioTrackEntryBytes = makeMatroskaAudioTrackEntryBytes;
+const makeMatroskaVideoTrackEntryBytes = ({ color, width, height, defaultDuration, trackNumber, codecId, }) => {
+    return (0, make_header_1.makeMatroskaBytes)({
+        type: 'TrackEntry',
+        minVintWidth: null,
+        value: [
+            {
+                type: 'TrackNumber',
+                value: {
+                    value: trackNumber,
+                    byteLength: null,
+                },
+                minVintWidth: null,
+            },
+            {
+                type: 'TrackUID',
+                value: '0xab2171012bb9020a',
+                minVintWidth: null,
+            },
+            {
+                type: 'FlagLacing',
+                value: {
+                    value: 0,
+                    byteLength: null,
+                },
+                minVintWidth: null,
+            },
+            {
+                type: 'Language',
+                value: 'und',
+                minVintWidth: null,
+            },
+            {
+                type: 'FlagDefault',
+                value: {
+                    value: 0,
+                    byteLength: null,
+                },
+                minVintWidth: null,
+            },
+            {
+                type: 'CodecID',
+                value: codecId,
+                minVintWidth: null,
+            },
+            {
+                type: 'TrackType',
+                value: {
+                    value: 1, // 'video'
+                    byteLength: null,
+                },
+                minVintWidth: null,
+            },
+            {
+                type: 'DefaultDuration',
+                value: {
+                    value: defaultDuration,
+                    byteLength: null,
+                },
+                minVintWidth: null,
+            },
+            (0, exports.makeMatroskaVideoBytes)({
+                color,
+                width,
+                height,
+            }),
+        ],
+    });
+};
+exports.makeMatroskaVideoTrackEntryBytes = makeMatroskaVideoTrackEntryBytes;
+const makeMatroskaTracks = (tracks) => {
+    return (0, make_header_1.padMatroskaBytes)((0, make_header_1.makeMatroskaBytes)({
+        type: 'Tracks',
+        value: tracks,
+        minVintWidth: null,
+    }), 
+    // TODO: That's too much padding
+    1000);
+};
+exports.makeMatroskaTracks = makeMatroskaTracks;

package/dist/get-audio-codec.d.ts

@@ -14,7 +14,7 @@ export declare const getNumberOfChannelsFromTrak: (trak: TrakBox) => number | nu
 export declare const getSampleRate: (trak: TrakBox) => number | null;
 export declare const getAudioCodecFromTrak: (trak: TrakBox) => AudioCodecInfo | null;
 export declare const getAudioCodecFromIso: (moov: MoovBox) => AudioCodecInfo | null;
-export declare const getAudioCodecFromMatroska: (mainSegment: MainSegment) => "vorbis" | "opus" | "mp3" | "aac" | "pcm" | null;
+export declare const getAudioCodecFromMatroska: (mainSegment: MainSegment) => "aac" | "mp3" | "opus" | "pcm" | "vorbis" | null;
 export declare const getAudioCodecStringFromTrak: (trak: TrakBox) => {
     codecString: string;
     description: Uint8Array | undefined;

package/dist/index.d.ts

@@ -1,2 +1,7 @@
+export { AudioTrack, OtherTrack, Track, VideoTrack } from './get-tracks';
 export { parseMedia } from './parse-media';
 export { AudioSample, OnAudioSample, OnAudioTrack, OnVideoSample, OnVideoTrack, VideoSample, } from './webcodec-sample-types';
+export type { MediaFn } from './create/create-media';
+export declare const MediaParserInternals: {
+    createMedia: (writer: import("./writers/writer").WriterInterface) => Promise<import("./create/create-media").MediaFn>;
+};

package/dist/index.js

@@ -1,5 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseMedia = void 0;
+exports.MediaParserInternals = exports.parseMedia = void 0;
+const create_media_1 = require("./create/create-media");
 var parse_media_1 = require("./parse-media");
 Object.defineProperty(exports, "parseMedia", { enumerable: true, get: function () { return parse_media_1.parseMedia; } });
+exports.MediaParserInternals = {
+    createMedia: create_media_1.createMedia,
+};

package/dist/options.d.ts

@@ -2,7 +2,7 @@ import type { Dimensions } from './get-dimensions';
 import type { AudioTrack, VideoTrack } from './get-tracks';
 import type { AnySegment } from './parse-result';
 import type { InternalStats } from './parser-state';
-import type { ReaderInterface } from './reader';
+import type { ReaderInterface } from './readers/reader';
 import type { OnAudioTrack, OnVideoTrack } from './webcodec-sample-types';
 export type KnownVideoCodecs = 'h264' | 'h265' | 'vp8' | 'vp9' | 'av1' | 'prores';
 export type KnownAudioCodecs = 'aac' | 'mp3' | 'aiff' | 'opus' | 'pcm' | 'vorbis' | 'unknown';

package/dist/parse-media.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMedia = void 0;
 const buffer_iterator_1 = require("./buffer-iterator");
-const from_fetch_1 = require("./from-fetch");
 const get_audio_codec_1 = require("./get-audio-codec");
 const get_dimensions_1 = require("./get-dimensions");
 const get_duration_1 = require("./get-duration");
@@ -12,6 +11,7 @@ const get_video_codec_1 = require("./get-video-codec");
 const has_all_info_1 = require("./has-all-info");
 const parse_video_1 = require("./parse-video");
 const parser_state_1 = require("./parser-state");
+const from_fetch_1 = require("./readers/from-fetch");
 const parseMedia = async ({ src, fields, reader: readerInterface = from_fetch_1.fetchReader, onAudioTrack, onVideoTrack, signal, }) => {
     const state = (0, parser_state_1.makeParserState)({
         hasAudioCallbacks: onAudioTrack !== null,

package/dist/readers/from-fetch.d.ts

@@ -0,0 +1,2 @@
+import type { ReaderInterface } from './reader';
+export declare const fetchReader: ReaderInterface;

package/dist/readers/from-fetch.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchReader = void 0;
+exports.fetchReader = {
+    read: async (src, range, signal) => {
+        if (typeof src !== 'string') {
+            throw new Error('src must be a string when using `fetchReader`');
+        }
+        const resolvedUrl = typeof window !== 'undefined' && typeof window.location !== 'undefined'
+            ? new URL(src, window.location.origin).toString()
+            : src;
+        if (!resolvedUrl.startsWith('https://') &&
+            !resolvedUrl.startsWith('http://')) {
+            return Promise.reject(new Error(resolvedUrl +
+                ' is not a URL - needs to start with http:// or https://. If you want to read a local file, pass `nodeReader` to parseMedia().'));
+        }
+        const res = await fetch(resolvedUrl, {
+            headers: range === null
+                ? {}
+                : typeof range === 'number'
+                    ? {
+                        Range: `bytes=${range}`,
+                    }
+                    : {
+                        Range: `bytes=${`${range[0]}-${range[1]}`}`,
+                    },
+            signal,
+            // Disable Next.js caching
+            cache: 'no-store',
+        });
+        if (res.status.toString().startsWith('4') ||
+            res.status.toString().startsWith('5')) {
+            throw new Error(`Server returned status code ${res.status} for ${src}`);
+        }
+        if (!res.body) {
+            throw new Error('No body');
+        }
+        const length = res.headers.get('content-length');
+        const contentLength = length === null ? null : parseInt(length, 10);
+        const reader = res.body.getReader();
+        if (signal) {
+            signal.addEventListener('abort', () => {
+                reader.cancel();
+            }, { once: true });
+        }
+        return { reader, contentLength };
+    },
+    getLength: async (src) => {
+        if (typeof src !== 'string') {
+            throw new Error('src must be a string when using `fetchReader`');
+        }
+        const res = await fetch(src, {
+            method: 'HEAD',
+        });
+        if (!res.body) {
+            throw new Error('No body');
+        }
+        const length = res.headers.get('content-length');
+        if (!length) {
+            throw new Error('No content-length');
+        }
+        return parseInt(length, 10);
+    },
+};

package/dist/readers/from-node.d.ts

@@ -0,0 +1,2 @@
+import type { ReaderInterface } from './reader';
+export declare const nodeReader: ReaderInterface;