@remotion/webcodecs 4.0.245 → 4.0.246

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

@@ -0,0 +1,110 @@
+"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, progressTracker, }) => {
+    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));
+            progressTracker.updateTrackProgress(trackNumber, chunk.timestamp);
+            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);
+            progressTracker.registerTrack(1);
+            return Promise.resolve({ trackNumber: 1 });
+        },
+    };
+};
+exports.createWav = createWav;

package/dist/create/with-resolvers.d.ts

@@ -0,0 +1,10 @@
+export declare const withResolvers: <T>() => {
+    promise: Promise<T>;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: any) => void;
+};
+export declare const withResolversAndWaitForReturn: <T>() => {
+    getPromiseToImmediatelyReturn: () => Promise<T>;
+    reject: (reason: unknown) => void;
+    resolve: (value: T | PromiseLike<T>) => void;
+};

package/dist/create/with-resolvers.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withResolversAndWaitForReturn = exports.withResolvers = void 0;
+const withResolvers = function () {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    return { promise, resolve: resolve, reject: reject };
+};
+exports.withResolvers = withResolvers;
+const withResolversAndWaitForReturn = () => {
+    const { promise, reject, resolve } = (0, exports.withResolvers)();
+    const { promise: returnPromise, resolve: resolveReturn } = (0, exports.withResolvers)();
+    return {
+        getPromiseToImmediatelyReturn: () => {
+            resolveReturn(undefined);
+            return promise;
+        },
+        reject: (reason) => {
+            returnPromise.then(() => reject(reason));
+        },
+        resolve,
+    };
+};
+exports.withResolversAndWaitForReturn = withResolversAndWaitForReturn;

package/dist/esm/buffer.mjs

@@ -0,0 +1,74 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+
+// src/writers/buffer-implementation/writer.ts
+var createContent = ({ filename, mimeType }) => {
+  const buf = new ArrayBuffer(0, {
+    maxByteLength: 2000000000
+  });
+  if (!buf.resize) {
+    throw new Error("Could not create buffer writer");
+  }
+  const write = (newData) => {
+    const oldLength = buf.byteLength;
+    const newLength = oldLength + newData.byteLength;
+    buf.resize(newLength);
+    const newArray = new Uint8Array(buf);
+    newArray.set(newData, oldLength);
+  };
+  const updateDataAt = (position, newData) => {
+    const newArray = new Uint8Array(buf);
+    newArray.set(newData, position);
+  };
+  let writPromise = Promise.resolve();
+  let removed = false;
+  const writer = {
+    write: (arr) => {
+      writPromise = writPromise.then(() => write(arr));
+      return writPromise;
+    },
+    save: () => {
+      if (removed) {
+        return Promise.reject(new Error("Already called .remove() on the result"));
+      }
+      const arr = new Uint8Array(buf);
+      return Promise.resolve(new File([arr.slice()], filename, { type: mimeType }));
+    },
+    remove() {
+      removed = true;
+      return Promise.resolve();
+    },
+    getWrittenByteCount: () => buf.byteLength,
+    updateDataAt: (position, newData) => {
+      writPromise = writPromise.then(() => updateDataAt(position, newData));
+      return writPromise;
+    },
+    waitForFinish: async () => {
+      await writPromise;
+    }
+  };
+  return Promise.resolve(writer);
+};
+
+// src/writers/buffer.ts
+var bufferWriter = {
+  createContent
+};
+export {
+  bufferWriter
+};