@remotion/webcodecs 4.0.244 → 4.0.246

package/dist/create/matroska/color.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMatroskaColorBytes = void 0;
+const truthy_1 = require("../../truthy");
+const matroska_utils_1 = require("./matroska-utils");
+const makeMatroskaColorBytes = ({ transferCharacteristics, matrixCoefficients, primaries, fullRange, }) => {
+    const rangeValue = transferCharacteristics && 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 = transferCharacteristics === 'bt709'
+        ? 1
+        : transferCharacteristics === 'smpte170m'
+            ? 6
+            : transferCharacteristics === '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, matroska_utils_1.makeMatroskaBytes)({
+        type: 'Colour',
+        minVintWidth: null,
+        value: [
+            transferChracteristicsValue === 2
+                ? null
+                : {
+                    type: 'TransferCharacteristics',
+                    value: {
+                        value: transferChracteristicsValue,
+                        byteLength: null,
+                    },
+                    minVintWidth: null,
+                },
+            matrixCoefficientsValue === 2
+                ? null
+                : {
+                    type: 'MatrixCoefficients',
+                    value: {
+                        value: matrixCoefficientsValue,
+                        byteLength: null,
+                    },
+                    minVintWidth: null,
+                },
+            primariesValue === 2
+                ? null
+                : {
+                    type: 'Primaries',
+                    value: {
+                        value: primariesValue,
+                        byteLength: null,
+                    },
+                    minVintWidth: null,
+                },
+            {
+                type: 'Range',
+                value: {
+                    value: rangeValue,
+                    byteLength: null,
+                },
+                minVintWidth: null,
+            },
+        ].filter(truthy_1.truthy),
+    });
+};
+exports.makeMatroskaColorBytes = makeMatroskaColorBytes;

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

@@ -0,0 +1,2 @@
+import type { MediaFn, MediaFnGeneratorInput } from '../media-fn';
+export declare const createMatroskaMedia: ({ writer, onBytesProgress, onMillisecondsProgress, filename, logLevel, progressTracker, }: MediaFnGeneratorInput) => Promise<MediaFn>;

package/dist/create/matroska/create-matroska-media.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMatroskaMedia = void 0;
+const media_parser_1 = require("@remotion/media-parser");
+const cluster_1 = require("./cluster");
+const make_duration_with_padding_1 = require("./make-duration-with-padding");
+const matroska_cues_1 = require("./matroska-cues");
+const matroska_header_1 = require("./matroska-header");
+const matroska_info_1 = require("./matroska-info");
+const matroska_seek_1 = require("./matroska-seek");
+const matroska_segment_1 = require("./matroska-segment");
+const matroska_trackentry_1 = require("./matroska-trackentry");
+const matroska_utils_1 = require("./matroska-utils");
+const { matroskaElements } = media_parser_1.MediaParserInternals;
+const timescale = 1000000;
+const createMatroskaMedia = async ({ writer, onBytesProgress, onMillisecondsProgress, filename, logLevel, progressTracker, }) => {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const header = (0, matroska_header_1.makeMatroskaHeader)();
+    const w = await writer.createContent({ filename, mimeType: 'video/webm' });
+    await w.write(header.bytes);
+    const matroskaInfo = (0, matroska_info_1.makeMatroskaInfo)({
+        timescale,
+    });
+    const currentTracks = [];
+    const seeks = [];
+    const cues = [];
+    const trackNumbers = [];
+    const matroskaSegment = (0, matroska_segment_1.createMatroskaSegment)([
+        ...(0, matroska_seek_1.createMatroskaSeekHead)(seeks),
+        matroskaInfo,
+        ...(0, matroska_trackentry_1.makeMatroskaTracks)(currentTracks),
+    ]);
+    const infoSegment = matroskaSegment.offsets.children.find((o) => o.field === 'Info');
+    const durationOffset = ((_b = (_a = infoSegment === null || infoSegment === void 0 ? void 0 : infoSegment.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();
+    const seekHeadOffset = ((_f = (_e = matroskaSegment.offsets.children.find((o) => o.field === 'SeekHead')) === null || _e === void 0 ? void 0 : _e.offset) !== null && _f !== void 0 ? _f : 0) + w.getWrittenByteCount();
+    const infoOffset = ((_g = infoSegment === null || infoSegment === void 0 ? void 0 : infoSegment.offset) !== null && _g !== void 0 ? _g : 0) + w.getWrittenByteCount();
+    if (!seekHeadOffset) {
+        throw new Error('could not get seek offset');
+    }
+    if (!durationOffset) {
+        throw new Error('could not get duration offset');
+    }
+    if (!tracksOffset) {
+        throw new Error('could not get tracks offset');
+    }
+    if (!infoOffset) {
+        throw new Error('could not get tracks offset');
+    }
+    seeks.push({
+        hexString: matroskaElements.Info,
+        byte: infoOffset - seekHeadOffset,
+    });
+    seeks.push({
+        hexString: matroskaElements.Tracks,
+        byte: tracksOffset - seekHeadOffset,
+    });
+    const updateSeekWrite = async () => {
+        const updatedSeek = (0, matroska_seek_1.createMatroskaSeekHead)(seeks);
+        await w.updateDataAt(seekHeadOffset, (0, matroska_utils_1.combineUint8Arrays)(updatedSeek.map((b) => b.bytes)));
+        onBytesProgress(w.getWrittenByteCount());
+    };
+    const segmentOffset = w.getWrittenByteCount();
+    const updateSegmentSize = async (size) => {
+        const data = (0, matroska_utils_1.getVariableInt)(size, matroska_segment_1.MATROSKA_SEGMENT_MIN_VINT_WIDTH);
+        await w.updateDataAt(segmentOffset + (0, matroska_utils_1.matroskaToHex)(matroskaElements.Segment).byteLength, data);
+        onBytesProgress(w.getWrittenByteCount());
+    };
+    await w.write(matroskaSegment.bytes);
+    const clusterOffset = w.getWrittenByteCount();
+    let currentCluster = await (0, cluster_1.makeCluster)({
+        writer: w,
+        clusterStartTimestamp: 0,
+        timescale,
+        logLevel,
+    });
+    seeks.push({
+        hexString: matroskaElements.Cluster,
+        byte: clusterOffset - seekHeadOffset,
+    });
+    const getClusterOrMakeNew = async ({ chunk, isVideo, }) => {
+        // In Safari, samples can arrive out of order, e.g public/bigbuckbunny.mp4
+        // Therefore, only updating track number progress if it is a keyframe
+        // to allow for timestamps to be lower than the previous one
+        var _a, _b;
+        progressTracker.setPossibleLowestTimestamp(Math.min(chunk.timestamp, (_a = chunk.cts) !== null && _a !== void 0 ? _a : Infinity, (_b = chunk.dts) !== null && _b !== void 0 ? _b : Infinity));
+        const smallestProgress = progressTracker.getSmallestProgress();
+        if (!currentCluster.shouldMakeNewCluster({
+            newT: smallestProgress,
+            isVideo,
+            chunk,
+        })) {
+            return { cluster: currentCluster, isNew: false, smallestProgress };
+        }
+        currentCluster = await (0, cluster_1.makeCluster)({
+            writer: w,
+            clusterStartTimestamp: smallestProgress,
+            timescale,
+            logLevel,
+        });
+        return { cluster: currentCluster, isNew: true, smallestProgress };
+    };
+    const updateDuration = async (newDuration) => {
+        const blocks = (0, make_duration_with_padding_1.makeDurationWithPadding)(newDuration);
+        await w.updateDataAt(durationOffset, blocks.bytes);
+        onBytesProgress(w.getWrittenByteCount());
+    };
+    const addSample = async ({ chunk, trackNumber, isVideo, }) => {
+        var _a;
+        const { cluster, isNew, smallestProgress } = await getClusterOrMakeNew({
+            chunk,
+            isVideo,
+        });
+        const newDuration = Math.round((chunk.timestamp + ((_a = chunk.duration) !== null && _a !== void 0 ? _a : 0)) / 1000);
+        await updateDuration(newDuration);
+        const { timecodeRelativeToCluster } = await cluster.addSample(chunk, trackNumber);
+        if (isNew) {
+            const newCluster = w.getWrittenByteCount();
+            cues.push({
+                time: (0, cluster_1.timestampToClusterTimestamp)(smallestProgress, timescale) +
+                    timecodeRelativeToCluster,
+                clusterPosition: newCluster - seekHeadOffset,
+                trackNumber,
+            });
+        }
+        if (chunk.type === 'key') {
+            progressTracker.updateTrackProgress(trackNumber, chunk.timestamp);
+        }
+        onBytesProgress(w.getWrittenByteCount());
+        onMillisecondsProgress(newDuration);
+    };
+    const addTrack = async (track) => {
+        currentTracks.push(track);
+        const newTracks = (0, matroska_trackentry_1.makeMatroskaTracks)(currentTracks);
+        progressTracker.registerTrack(track.trackNumber);
+        await w.updateDataAt(tracksOffset, (0, matroska_utils_1.combineUint8Arrays)(newTracks.map((b) => b.bytes)));
+    };
+    const operationProm = { current: Promise.resolve() };
+    const waitForFinishPromises = [];
+    return {
+        updateTrackSampleRate: ({ sampleRate, trackNumber }) => {
+            currentTracks.forEach((track) => {
+                if (track.trackNumber === trackNumber) {
+                    if (track.type !== 'audio') {
+                        throw new Error('track is not audio');
+                    }
+                    track.sampleRate = sampleRate;
+                }
+            });
+        },
+        save: () => {
+            return w.save();
+        },
+        remove: async () => {
+            await w.remove();
+        },
+        addSample: ({ chunk, trackNumber, isVideo }) => {
+            operationProm.current = operationProm.current.then(() => addSample({ chunk, trackNumber, isVideo }));
+            return operationProm.current;
+        },
+        addTrack: (track) => {
+            const trackNumber = currentTracks.length + 1;
+            operationProm.current = operationProm.current.then(() => addTrack({ ...track, trackNumber }));
+            trackNumbers.push(trackNumber);
+            return operationProm.current.then(() => ({ trackNumber }));
+        },
+        addWaitForFinishPromise: (promise) => {
+            waitForFinishPromises.push(promise);
+        },
+        async waitForFinish() {
+            await Promise.all(waitForFinishPromises.map((p) => p()));
+            await operationProm.current;
+            seeks.push({
+                hexString: matroskaElements.Cues,
+                byte: w.getWrittenByteCount() - seekHeadOffset,
+            });
+            await updateSeekWrite();
+            await w.write((0, matroska_cues_1.createMatroskaCues)(cues).bytes);
+            await w.waitForFinish();
+            const segmentSize = w.getWrittenByteCount() -
+                segmentOffset -
+                (0, matroska_utils_1.matroskaToHex)(matroskaElements.Segment).byteLength -
+                matroska_segment_1.MATROSKA_SEGMENT_MIN_VINT_WIDTH;
+            await updateSegmentSize(segmentSize);
+        },
+    };
+};
+exports.createMatroskaMedia = createMatroskaMedia;

package/dist/create/matroska/make-duration-with-padding.d.ts

@@ -0,0 +1 @@
+export declare const makeDurationWithPadding: (newDuration: number) => import("./matroska-utils").BytesAndOffset;

package/dist/create/matroska/make-duration-with-padding.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeDurationWithPadding = void 0;
+const matroska_utils_1 = require("./matroska-utils");
+const makeDurationWithPadding = (newDuration) => {
+    return (0, matroska_utils_1.makeMatroskaBytes)({
+        type: 'Duration',
+        value: {
+            value: newDuration,
+            size: '64',
+        },
+        minVintWidth: 8,
+    });
+};
+exports.makeDurationWithPadding = makeDurationWithPadding;

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

@@ -0,0 +1,6 @@
+export type Cue = {
+    time: number;
+    clusterPosition: number;
+    trackNumber: number;
+};
+export declare const createMatroskaCues: (cues: Cue[]) => import("./matroska-utils").BytesAndOffset;

package/dist/create/matroska/matroska-cues.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMatroskaCues = void 0;
+const matroska_utils_1 = require("./matroska-utils");
+const createMatroskaCues = (cues) => {
+    return (0, matroska_utils_1.makeMatroskaBytes)({
+        type: 'Cues',
+        minVintWidth: null,
+        value: cues.map((cue) => {
+            return {
+                type: 'CuePoint',
+                value: [
+                    {
+                        type: 'CueTime',
+                        minVintWidth: null,
+                        value: {
+                            value: cue.time,
+                            byteLength: null,
+                        },
+                    },
+                    {
+                        type: 'CueTrackPositions',
+                        value: [
+                            {
+                                type: 'CueTrack',
+                                minVintWidth: null,
+                                value: {
+                                    value: cue.trackNumber,
+                                    byteLength: null,
+                                },
+                            },
+                            {
+                                type: 'CueClusterPosition',
+                                minVintWidth: null,
+                                value: {
+                                    value: cue.clusterPosition,
+                                    byteLength: null,
+                                },
+                            },
+                        ],
+                        minVintWidth: null,
+                    },
+                ],
+                minVintWidth: null,
+            };
+        }),
+    });
+};
+exports.createMatroskaCues = createMatroskaCues;

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

@@ -0,0 +1 @@
+export declare const makeMatroskaHeader: () => import("./matroska-utils").BytesAndOffset;

package/dist/create/matroska/matroska-header.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMatroskaHeader = void 0;
+const matroska_utils_1 = require("./matroska-utils");
+const makeMatroskaHeader = () => {
+    return (0, matroska_utils_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/matroska-info.d.ts

@@ -0,0 +1,3 @@
+export declare const makeMatroskaInfo: ({ timescale }: {
+    timescale: number;
+}) => import("./matroska-utils").BytesAndOffset;

package/dist/create/matroska/matroska-info.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMatroskaInfo = void 0;
+const make_duration_with_padding_1 = require("./make-duration-with-padding");
+const matroska_utils_1 = require("./matroska-utils");
+const makeMatroskaInfo = ({ timescale }) => {
+    return (0, matroska_utils_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_duration_with_padding_1.makeDurationWithPadding)(0),
+        ],
+        minVintWidth: null,
+    });
+};
+exports.makeMatroskaInfo = makeMatroskaInfo;

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

@@ -0,0 +1,6 @@
+import type { MatroskaElement } from '@remotion/media-parser';
+export type Seek = {
+    hexString: MatroskaElement;
+    byte: number;
+};
+export declare const createMatroskaSeekHead: (seeks: Seek[]) => import("./matroska-utils").BytesAndOffset[];

package/dist/create/matroska/matroska-seek.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMatroskaSeekHead = void 0;
+const matroska_utils_1 = require("./matroska-utils");
+const createMatroskaSeekHead = (seeks) => {
+    return (0, matroska_utils_1.padMatroskaBytes)((0, matroska_utils_1.makeMatroskaBytes)({
+        type: 'SeekHead',
+        minVintWidth: null,
+        value: seeks.map((seek) => {
+            return {
+                type: 'Seek',
+                minVintWidth: null,
+                value: [
+                    {
+                        type: 'SeekID',
+                        minVintWidth: null,
+                        value: seek.hexString,
+                    },
+                    {
+                        type: 'SeekPosition',
+                        minVintWidth: null,
+                        value: {
+                            value: seek.byte,
+                            byteLength: null,
+                        },
+                    },
+                ],
+            };
+        }),
+    }), 200);
+};
+exports.createMatroskaSeekHead = createMatroskaSeekHead;

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

@@ -0,0 +1,3 @@
+import type { BytesAndOffset } from './matroska-utils';
+export declare const MATROSKA_SEGMENT_MIN_VINT_WIDTH = 8;
+export declare const createMatroskaSegment: (children: BytesAndOffset[]) => BytesAndOffset;

package/dist/create/matroska/matroska-segment.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMatroskaSegment = exports.MATROSKA_SEGMENT_MIN_VINT_WIDTH = void 0;
+const matroska_utils_1 = require("./matroska-utils");
+exports.MATROSKA_SEGMENT_MIN_VINT_WIDTH = 8;
+const createMatroskaSegment = (children) => {
+    return (0, matroska_utils_1.makeMatroskaBytes)({
+        type: 'Segment',
+        value: children,
+        minVintWidth: exports.MATROSKA_SEGMENT_MIN_VINT_WIDTH,
+    });
+};
+exports.createMatroskaSegment = createMatroskaSegment;

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

@@ -0,0 +1,10 @@
+import type { VideoTrackColorParams } from '@remotion/media-parser';
+import type { MakeTrackAudio, MakeTrackVideo } from '../make-track-info';
+export declare const makeMatroskaVideoBytes: ({ color, width, height, }: {
+    color: VideoTrackColorParams;
+    width: number;
+    height: number;
+}) => import("./matroska-utils").BytesAndOffset;
+export declare const makeMatroskaAudioTrackEntryBytes: ({ trackNumber, codec, numberOfChannels, sampleRate, codecPrivate, }: MakeTrackAudio) => import("./matroska-utils").BytesAndOffset;
+export declare const makeMatroskaVideoTrackEntryBytes: ({ color, width, height, trackNumber, codec, codecPrivate, }: MakeTrackVideo) => import("./matroska-utils").BytesAndOffset;
+export declare const makeMatroskaTracks: (tracks: (MakeTrackAudio | MakeTrackVideo)[]) => import("./matroska-utils").BytesAndOffset[];