@remotion/media-parser 4.0.229 → 4.0.230

package/dist/create/iso-base-media/create-iso-base-media.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createIsoBaseMedia = void 0;
+const make_header_1 = require("../../boxes/webm/make-header");
+const log_1 = require("../../log");
+const create_ftyp_1 = require("./create-ftyp");
+const mp4_header_1 = require("./mp4-header");
+const primitives_1 = require("./primitives");
+const createIsoBaseMedia = async ({ writer, onBytesProgress, onMillisecondsProgress, logLevel, }) => {
+    const header = (0, create_ftyp_1.createIsoBaseMediaFtyp)({
+        compatibleBrands: ['isom', 'iso2', 'avc1', 'mp42'],
+        majorBrand: 'isom',
+        minorBrand: 512,
+    });
+    const w = await writer.createContent();
+    await w.write(header);
+    let durationInUnits = 0;
+    const currentTracks = [];
+    const samplePositions = [];
+    const sampleChunkIndices = [];
+    const moovOffset = w.getWrittenByteCount();
+    const getPaddedMoovAtom = () => {
+        return (0, mp4_header_1.createPaddedMoovAtom)({
+            durationInUnits,
+            trackInfo: currentTracks.map((track) => {
+                var _a;
+                return {
+                    track,
+                    durationInUnits,
+                    samplePositions: (_a = samplePositions[track.trackNumber]) !== null && _a !== void 0 ? _a : [],
+                    timescale: track.timescale,
+                };
+            }),
+            timescale: 1000,
+        });
+    };
+    await w.write(getPaddedMoovAtom());
+    let mdatSize = 8;
+    const mdatSizeOffset = w.getWrittenByteCount();
+    await w.write((0, make_header_1.combineUint8Arrays)([
+        // size
+        (0, primitives_1.numberTo32BitUIntOrInt)(mdatSize),
+        // type
+        (0, primitives_1.stringsToUint8Array)('mdat'),
+    ]));
+    const updateMdatSize = async () => {
+        await w.updateDataAt(mdatSizeOffset, (0, primitives_1.numberTo32BitUIntOrInt)(mdatSize));
+        onBytesProgress(w.getWrittenByteCount());
+    };
+    const operationProm = { current: Promise.resolve() };
+    const updateMoov = async () => {
+        await w.updateDataAt(moovOffset, getPaddedMoovAtom());
+        onBytesProgress(w.getWrittenByteCount());
+    };
+    const updateDuration = (newDuration) => {
+        durationInUnits = newDuration;
+        onMillisecondsProgress(newDuration);
+    };
+    const addCodecPrivateToTrack = ({ trackNumber, codecPrivate, }) => {
+        currentTracks.forEach((track) => {
+            if (track.trackNumber === trackNumber) {
+                track.codecPrivate = codecPrivate;
+            }
+        });
+    };
+    let lastChunkWasVideo = false;
+    const addSample = async ({ chunk, trackNumber, isVideo, timescale, codecPrivate, }) => {
+        var _a, _b;
+        const position = w.getWrittenByteCount();
+        await w.write(chunk.data);
+        mdatSize += chunk.data.length;
+        onBytesProgress(w.getWrittenByteCount());
+        if (codecPrivate) {
+            addCodecPrivateToTrack({ trackNumber, codecPrivate });
+        }
+        const newDuration = Math.round((chunk.timestamp + ((_a = chunk.duration) !== null && _a !== void 0 ? _a : 0)) / 1000);
+        updateDuration(newDuration);
+        if (!samplePositions[trackNumber]) {
+            samplePositions[trackNumber] = [];
+        }
+        if (typeof sampleChunkIndices[trackNumber] === 'undefined') {
+            sampleChunkIndices[trackNumber] = 0;
+        }
+        // For video, make a new chunk if it's a keyframe
+        if (isVideo && chunk.type === 'key') {
+            sampleChunkIndices[trackNumber]++;
+        } // For audio, make a new chunk every 22 samples, that's how bbb.mp4 is encoded
+        else if (!isVideo && samplePositions[trackNumber].length % 22 === 0) {
+            sampleChunkIndices[trackNumber]++;
+        }
+        // Need to create a new chunk if the last chunk was a different type
+        else if (lastChunkWasVideo !== isVideo) {
+            sampleChunkIndices[trackNumber]++;
+        }
+        // media parser and EncodedVideoChunk returns timestamps in microseconds
+        // need to normalize the timestamps to milliseconds
+        const samplePositionToAdd = {
+            isKeyframe: chunk.type === 'key',
+            offset: position,
+            chunk: sampleChunkIndices[trackNumber],
+            cts: Math.round(chunk.cts / (1000000 / timescale)),
+            dts: Math.round(chunk.dts / (1000000 / timescale)),
+            duration: Math.round(((_b = chunk.duration) !== null && _b !== void 0 ? _b : 0) / (1000000 / timescale)),
+            size: chunk.data.length,
+        };
+        lastChunkWasVideo = isVideo;
+        samplePositions[trackNumber].push(samplePositionToAdd);
+    };
+    const addTrack = (track) => {
+        const trackNumber = currentTracks.length + 1;
+        currentTracks.push({ ...track, trackNumber });
+        return Promise.resolve({ trackNumber });
+    };
+    const waitForFinishPromises = [];
+    return {
+        save: async () => {
+            const file = await w.save();
+            return file;
+        },
+        remove: async () => {
+            await w.remove();
+        },
+        addSample: ({ chunk, trackNumber, isVideo, timescale, codecPrivate }) => {
+            operationProm.current = operationProm.current.then(() => {
+                return addSample({
+                    chunk,
+                    trackNumber,
+                    isVideo,
+                    timescale,
+                    codecPrivate,
+                });
+            });
+            return operationProm.current;
+        },
+        addTrack: (track) => {
+            operationProm.current = operationProm.current.then(() => addTrack(track));
+            return operationProm.current;
+        },
+        updateTrackSampleRate: ({ sampleRate, trackNumber }) => {
+            currentTracks.forEach((track) => {
+                if (track.trackNumber === trackNumber) {
+                    if (track.type !== 'audio') {
+                        throw new Error(`Tried to update sample rate of track ${trackNumber}, but it's not an audio track`);
+                    }
+                    track.sampleRate = sampleRate;
+                }
+            });
+        },
+        addWaitForFinishPromise: (promise) => {
+            waitForFinishPromises.push(promise);
+        },
+        async waitForFinish() {
+            log_1.Log.verbose(logLevel, 'All write operations queued. Waiting for finish...');
+            await Promise.all(waitForFinishPromises.map((p) => p()));
+            log_1.Log.verbose(logLevel, 'Cleanup tasks executed');
+            await operationProm.current;
+            await updateMoov();
+            await updateMdatSize();
+            log_1.Log.verbose(logLevel, 'All write operations done. Waiting for finish...');
+            await w.waitForFinish();
+        },
+        updateDuration: (duration) => {
+            operationProm.current = operationProm.current.then(() => updateDuration(duration));
+            return operationProm.current;
+        },
+    };
+};
+exports.createIsoBaseMedia = createIsoBaseMedia;

package/dist/create/iso-base-media/create-mdia.d.ts

@@ -0,0 +1,5 @@
+export declare const createMdia: ({ mdhd, hdlr, minf, }: {
+    mdhd: Uint8Array;
+    hdlr: Uint8Array;
+    minf: Uint8Array;
+}) => Uint8Array;

package/dist/create/iso-base-media/create-mdia.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMdia = void 0;
+const make_header_1 = require("../../boxes/webm/make-header");
+const primitives_1 = require("./primitives");
+const createMdia = ({ mdhd, hdlr, minf, }) => {
+    return (0, primitives_1.addSize)((0, make_header_1.combineUint8Arrays)([
+        // type
+        (0, primitives_1.stringsToUint8Array)('mdia'),
+        // mdhd
+        mdhd,
+        // hdlr
+        hdlr,
+        // minf
+        minf,
+    ]));
+};
+exports.createMdia = createMdia;

package/dist/create/iso-base-media/create-moov.d.ts

@@ -0,0 +1,5 @@
+export declare const createMoov: ({ mvhd, traks, udta, }: {
+    mvhd: Uint8Array;
+    traks: Uint8Array[];
+    udta: Uint8Array;
+}) => Uint8Array;

package/dist/create/iso-base-media/create-moov.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMoov = void 0;
+const make_header_1 = require("../../boxes/webm/make-header");
+const primitives_1 = require("./primitives");
+const createMoov = ({ mvhd, traks, udta, }) => {
+    return (0, primitives_1.addSize)((0, make_header_1.combineUint8Arrays)([
+        // type
+        (0, primitives_1.stringsToUint8Array)('moov'),
+        // moov atom
+        mvhd,
+        // traks
+        ...traks,
+        // udta
+        udta,
+    ]));
+};
+exports.createMoov = createMoov;

package/dist/create/iso-base-media/create-mvhd.d.ts

@@ -0,0 +1,10 @@
+export declare const createMvhd: ({ timescale, durationInUnits, rate, volume, nextTrackId, matrix, creationTime, modificationTime, }: {
+    timescale: number;
+    durationInUnits: number;
+    rate: number;
+    volume: number;
+    nextTrackId: number;
+    matrix: number[];
+    creationTime: number | null;
+    modificationTime: number | null;
+}) => Uint8Array;

package/dist/create/iso-base-media/create-mvhd.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMvhd = void 0;
+const to_date_1 = require("../../boxes/iso-base-media/to-date");
+const make_header_1 = require("../../boxes/webm/make-header");
+const primitives_1 = require("./primitives");
+const createMvhd = ({ timescale, durationInUnits, rate, volume, nextTrackId, matrix, creationTime, modificationTime, }) => {
+    if (matrix.length !== 9) {
+        throw new Error('Matrix must be 9 elements long');
+    }
+    const content = (0, make_header_1.combineUint8Arrays)([
+        // type
+        (0, primitives_1.stringsToUint8Array)('mvhd'),
+        // version
+        new Uint8Array([0]),
+        // flags
+        new Uint8Array([0, 0, 0]),
+        // creation time
+        creationTime === null
+            ? (0, primitives_1.numberTo32BitUIntOrInt)(0)
+            : (0, primitives_1.numberTo32BitUIntOrInt)((0, to_date_1.fromUnixTimestamp)(creationTime)),
+        // modification time
+        modificationTime === null
+            ? (0, primitives_1.numberTo32BitUIntOrInt)(0)
+            : (0, primitives_1.numberTo32BitUIntOrInt)((0, to_date_1.fromUnixTimestamp)(modificationTime)),
+        // timescale
+        (0, primitives_1.numberTo32BitUIntOrInt)(timescale),
+        // duration in units, 32bit for version 0
+        (0, primitives_1.numberTo32BitUIntOrInt)(durationInUnits),
+        // rate
+        (0, primitives_1.floatTo16Point1632Bit)(rate),
+        // volume
+        (0, primitives_1.floatTo16Point16_16Bit)(volume),
+        // reserved
+        new Uint8Array([0, 0]),
+        // reserved
+        new Uint8Array([0, 0, 0, 0]),
+        // reserved
+        new Uint8Array([0, 0, 0, 0]),
+        (0, primitives_1.serializeMatrix)(matrix),
+        // predefined
+        (0, make_header_1.combineUint8Arrays)(new Array(6).fill(new Uint8Array([0, 0, 0, 0]))),
+        // next track id
+        (0, primitives_1.numberTo32BitUIntOrInt)(nextTrackId),
+    ]);
+    return (0, primitives_1.addSize)(content);
+};
+exports.createMvhd = createMvhd;

package/dist/create/iso-base-media/create-trak.d.ts

@@ -0,0 +1,4 @@
+export declare const createTrak: ({ tkhd, mdia, }: {
+    tkhd: Uint8Array;
+    mdia: Uint8Array;
+}) => Uint8Array;

package/dist/create/iso-base-media/create-trak.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTrak = void 0;
+const make_header_1 = require("../../boxes/webm/make-header");
+const truthy_1 = require("../../truthy");
+const primitives_1 = require("./primitives");
+const createTrak = ({ tkhd, mdia, }) => {
+    return (0, primitives_1.addSize)((0, make_header_1.combineUint8Arrays)([
+        // name
+        (0, primitives_1.stringsToUint8Array)('trak'),
+        // tkhd
+        tkhd,
+        // mdia
+        mdia,
+    ].filter(truthy_1.truthy)));
+};
+exports.createTrak = createTrak;

package/dist/create/iso-base-media/create-udta.d.ts

@@ -0,0 +1 @@
+export declare const createUdta: (children: Uint8Array) => Uint8Array;

package/dist/create/iso-base-media/create-udta.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUdta = void 0;
+const make_header_1 = require("../../boxes/webm/make-header");
+const primitives_1 = require("./primitives");
+const createUdta = (children) => {
+    return (0, primitives_1.addSize)((0, make_header_1.combineUint8Arrays)([
+        // type
+        (0, primitives_1.stringsToUint8Array)('udta'),
+        // children
+        children,
+    ]));
+};
+exports.createUdta = createUdta;

package/dist/create/iso-base-media/create-url.d.ts

@@ -0,0 +1 @@
+export declare const createUrlAtom: () => Uint8Array;

package/dist/create/iso-base-media/create-url.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUrlAtom = void 0;
+const make_header_1 = require("../../boxes/webm/make-header");
+const primitives_1 = require("./primitives");
+const createUrlAtom = () => {
+    return (0, primitives_1.addSize)((0, make_header_1.combineUint8Arrays)([
+        // type
+        (0, primitives_1.stringsToUint8Array)('url '),
+        // version
+        new Uint8Array([0]),
+        // flags
+        new Uint8Array([0, 0, 1]),
+    ]));
+};
+exports.createUrlAtom = createUrlAtom;

package/dist/create/iso-base-media/example-stts.d.ts

@@ -0,0 +1,3 @@
+import type { SamplePosition } from '../../get-sample-positions';
+export declare const exampleVideoSamplePositions: SamplePosition[];
+export declare const exampleAudioSamplePositions: SamplePosition[];