@remotion/media-parser 4.0.231 → 4.0.232

package/dist/create/wav/create-wav.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWav = void 0;
+const log_1 = require("../../log");
+const numberTo32BiIntLittleEndian = (num) => {
+    return new Uint8Array([
+        num & 0xff,
+        (num >> 8) & 0xff,
+        (num >> 16) & 0xff,
+        (num >> 24) & 0xff,
+    ]);
+};
+const numberTo16BitLittleEndian = (num) => {
+    return new Uint8Array([num & 0xff, (num >> 8) & 0xff]);
+};
+const BIT_DEPTH = 16;
+const BYTES_PER_SAMPLE = BIT_DEPTH / 8;
+const createWav = async ({ filename, logLevel, onBytesProgress, onMillisecondsProgress, writer, }) => {
+    const w = await writer.createContent({ filename, mimeType: 'audio/wav' });
+    await w.write(new Uint8Array([0x52, 0x49, 0x46, 0x46])); // "RIFF"
+    const sizePosition = w.getWrittenByteCount();
+    await w.write(new Uint8Array([0x00, 0x00, 0x00, 0x00])); // Remaining size
+    await w.write(new Uint8Array([0x57, 0x41, 0x56, 0x45])); // "WAVE"
+    await w.write(new Uint8Array([0x66, 0x6d, 0x74, 0x20])); // "fmt "
+    await w.write(new Uint8Array([0x10, 0x00, 0x00, 0x00])); // fmt chunk size = 16
+    await w.write(new Uint8Array([0x01, 0x00])); // Audio format (PCM) = 1, set 3 if float32 would be true
+    const channelNumPosition = w.getWrittenByteCount();
+    await w.write(new Uint8Array([0x01, 0x00])); // Number of channels = 1
+    const sampleRatePosition = w.getWrittenByteCount();
+    await w.write(new Uint8Array([0x0, 0x0, 0x00, 0x00])); // Sample rate
+    const byteRatePosition = w.getWrittenByteCount();
+    await w.write(new Uint8Array([0x0, 0x0, 0x00, 0x00])); // Byte rate
+    const blockAlignPosition = w.getWrittenByteCount();
+    await w.write(new Uint8Array([0x00, 0x00])); // Block align
+    await w.write(numberTo16BitLittleEndian(BIT_DEPTH)); // Bits per sample
+    await w.write(new Uint8Array([0x64, 0x61, 0x74, 0x61])); // "data"
+    const dataSizePosition = w.getWrittenByteCount();
+    await w.write(new Uint8Array([0x00, 0x00, 0x00, 0x00])); // Remaining size
+    const operationProm = { current: Promise.resolve() };
+    const updateSize = async () => {
+        const size = w.getWrittenByteCount() - sizePosition - 4;
+        await w.updateDataAt(sizePosition, numberTo32BiIntLittleEndian(size));
+        const dataSize = w.getWrittenByteCount() - dataSizePosition - 4;
+        await w.updateDataAt(dataSizePosition, numberTo32BiIntLittleEndian(dataSize));
+    };
+    const updateChannelNum = async (numberOfChannels) => {
+        await w.updateDataAt(channelNumPosition, new Uint8Array([numberOfChannels, 0x00]));
+    };
+    const updateSampleRate = async (sampleRate) => {
+        await w.updateDataAt(sampleRatePosition, numberTo32BiIntLittleEndian(sampleRate));
+    };
+    const updateByteRate = async ({ sampleRate, numberOfChannels, }) => {
+        await w.updateDataAt(byteRatePosition, numberTo32BiIntLittleEndian(sampleRate * numberOfChannels + BYTES_PER_SAMPLE));
+    };
+    const updateBlockAlign = async (numberOfChannels) => {
+        await w.updateDataAt(blockAlignPosition, new Uint8Array(numberTo16BitLittleEndian(numberOfChannels * BYTES_PER_SAMPLE)));
+    };
+    const addSample = async (chunk) => {
+        var _a;
+        log_1.Log.verbose(logLevel, 'Adding sample', chunk);
+        await w.write(chunk.data);
+        onMillisecondsProgress((chunk.timestamp + ((_a = chunk.duration) !== null && _a !== void 0 ? _a : 0)) / 1000);
+        onBytesProgress(w.getWrittenByteCount());
+    };
+    const waitForFinishPromises = [];
+    return {
+        save: () => {
+            return w.save();
+        },
+        remove: () => {
+            return w.remove();
+        },
+        addSample: ({ chunk, trackNumber }) => {
+            if (trackNumber !== 1) {
+                throw new Error('Only one track supported for WAV');
+            }
+            operationProm.current = operationProm.current.then(() => addSample(chunk));
+            return operationProm.current;
+        },
+        updateTrackSampleRate: () => {
+            throw new Error('updateTrackSampleRate() not implemented for WAV encoder');
+        },
+        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()));
+            await operationProm.current;
+            await updateSize();
+            await w.waitForFinish();
+        },
+        addTrack: async (track) => {
+            if (track.type !== 'audio') {
+                throw new Error('Only audio tracks supported for WAV');
+            }
+            await updateChannelNum(track.numberOfChannels);
+            await updateSampleRate(track.sampleRate);
+            await updateByteRate({
+                sampleRate: track.sampleRate,
+                numberOfChannels: track.numberOfChannels,
+            });
+            await updateBlockAlign(track.numberOfChannels);
+            return Promise.resolve({ trackNumber: 1 });
+        },
+    };
+};
+exports.createWav = createWav;

package/dist/emit-available-info.d.ts

@@ -1,9 +1,9 @@
 import type { AllParseMediaFields, Options, ParseMediaCallbacks, ParseMediaFields, ParseMediaResult } from './options';
-import type { ParseResult } from './parse-result';
+import type { ParseResult, Structure } from './parse-result';
 import type { ParserState } from './parser-state';
 export declare const emitAvailableInfo: ({ hasInfo, parseResult, moreFields, state, returnValue, contentLength, name, }: {
     hasInfo: Record<keyof Options<ParseMediaFields>, boolean>;
-    parseResult: ParseResult | null;
+    parseResult: ParseResult<Structure> | null;
     moreFields: ParseMediaCallbacks<AllParseMediaFields>;
     state: ParserState;
     returnValue: ParseMediaResult<AllParseMediaFields>;

package/dist/emit-available-info.js

@@ -12,10 +12,12 @@ const emitAvailableInfo = ({ hasInfo, parseResult, moreFields, state, returnValu
     var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
     const keys = Object.keys(hasInfo);
     for (const key of keys) {
-        if (key === 'boxes') {
-            if (parseResult && hasInfo.boxes && returnValue.boxes === undefined) {
-                (_a = moreFields.onBoxes) === null || _a === void 0 ? void 0 : _a.call(moreFields, parseResult.segments);
-                returnValue.boxes = parseResult.segments;
+        if (key === 'structure') {
+            if (parseResult &&
+                hasInfo.structure &&
+                returnValue.structure === undefined) {
+                (_a = moreFields.onStructure) === null || _a === void 0 ? void 0 : _a.call(moreFields, parseResult.segments);
+                returnValue.structure = parseResult.segments;
             }
             continue;
         }

package/dist/esm/from-node.mjs

@@ -1,6 +1,7 @@
 // src/readers/from-node.ts
 import { createReadStream } from "fs";
 import { stat } from "node:fs/promises";
+import { sep } from "path";
 import { Readable } from "stream";
 var nodeReader = {
   read: async (src, range, signal) => {
@@ -32,7 +33,7 @@ var nodeReader = {
         }
       },
       contentLength: stats.size,
-      name: src.split("/").pop(),
+      name: src.split(sep).pop(),
       supportsContentRange: true
     };
   },