@mediabunny/mp3-encoder 1.6.1

package/dist/modules/src/encode.worker.d.ts

@@ -0,0 +1,9 @@
+/*!
+ * Copyright (c) 2025-present, Vanilagy and contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+export {};
+//# sourceMappingURL=encode.worker.d.ts.map

package/dist/modules/src/encode.worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encode.worker.d.ts","sourceRoot":"","sources":["../../../src/encode.worker.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG"}

package/dist/modules/src/encode.worker.js

@@ -0,0 +1,152 @@
+"use strict";
+/*!
+ * Copyright (c) 2025-present, Vanilagy and contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const lame_1 = __importDefault(require("../build/lame"));
+let module;
+let lamePtr;
+let storedNumberOfChannels;
+let storedSampleRate;
+let storedBitrate;
+let needsReset = false;
+let initLame;
+let encodeSamples;
+let flushLame;
+let closeLame;
+let inputSlice = null;
+let outputSlice = null;
+const init = async (numberOfChannels, sampleRate, bitrate) => {
+    storedNumberOfChannels = numberOfChannels;
+    storedSampleRate = sampleRate;
+    storedBitrate = bitrate;
+    module = (await (0, lame_1.default)());
+    // Set up the functions
+    initLame = module.cwrap('init_lame', 'number', ['number', 'number', 'number']);
+    encodeSamples = module.cwrap('encode_samples', 'number', ['number', 'number', 'number', 'number', 'number', 'number']);
+    flushLame = module.cwrap('flush_lame', 'number', ['number', 'number', 'number']);
+    closeLame = module.cwrap('close_lame', null, ['number']);
+    lamePtr = initLame(numberOfChannels, sampleRate, bitrate);
+};
+const reset = () => {
+    closeLame(lamePtr);
+    lamePtr = initLame(storedNumberOfChannels, storedSampleRate, storedBitrate);
+};
+const encode = (audioData, numberOfFrames) => {
+    if (needsReset) {
+        reset();
+        needsReset = false;
+    }
+    const audioBytes = new Uint8Array(audioData);
+    const sizePerChannel = audioBytes.length / storedNumberOfChannels;
+    inputSlice = maybeGrowSlice(inputSlice, audioBytes.length);
+    module.HEAPU8.set(audioBytes, inputSlice.ptr);
+    const requiredOutputSize = Math.ceil(1.25 * numberOfFrames + 7200);
+    outputSlice = maybeGrowSlice(outputSlice, requiredOutputSize);
+    const bytesWritten = encodeSamples(lamePtr, inputSlice.ptr, inputSlice.ptr + (storedNumberOfChannels - 1) * sizePerChannel, numberOfFrames, outputSlice.ptr, requiredOutputSize);
+    const result = module.HEAPU8.slice(outputSlice.ptr, outputSlice.ptr + bytesWritten);
+    return result.buffer;
+};
+const flush = () => {
+    if (needsReset) {
+        reset();
+        needsReset = false;
+    }
+    const requiredOutputSize = 7200;
+    outputSlice = maybeGrowSlice(outputSlice, requiredOutputSize);
+    const bytesWritten = flushLame(lamePtr, outputSlice.ptr, requiredOutputSize);
+    const result = module.HEAPU8.slice(outputSlice.ptr, outputSlice.ptr + bytesWritten);
+    needsReset = true; // After a flush, the encoder must be prepared to start a new encoding process
+    return result.buffer;
+};
+/** Either returns the existing slice, or allocates a new one if there's no existing slice or it was too small. */
+const maybeGrowSlice = (slice, requiredSize) => {
+    if (!slice || slice.size < requiredSize) {
+        if (slice) {
+            module._free(slice.ptr);
+        }
+        return {
+            ptr: module._malloc(requiredSize),
+            size: requiredSize,
+        };
+    }
+    return slice;
+};
+const onMessage = (data) => {
+    const { id, command } = data;
+    const handleCommand = async () => {
+        try {
+            let result;
+            const transferables = [];
+            switch (command.type) {
+                case 'init':
+                    {
+                        await init(command.data.numberOfChannels, command.data.sampleRate, command.data.bitrate);
+                        result = { success: true };
+                    }
+                    ;
+                    break;
+                case 'encode':
+                    {
+                        const encodedData = encode(command.data.audioData, command.data.numberOfFrames);
+                        result = { encodedData };
+                        transferables.push(encodedData);
+                    }
+                    ;
+                    break;
+                case 'flush':
+                    {
+                        const flushedData = flush();
+                        result = { flushedData };
+                        transferables.push(flushedData);
+                    }
+                    ;
+                    break;
+            }
+            const response = {
+                id,
+                success: true,
+                data: result,
+            };
+            sendMessage(response, transferables);
+        }
+        catch (error) {
+            const response = {
+                id,
+                success: false,
+                error,
+            };
+            sendMessage(response);
+        }
+    };
+    void handleCommand();
+};
+const sendMessage = (data, transferables) => {
+    if (parentPort) {
+        parentPort.postMessage(data, transferables ?? []);
+    }
+    else {
+        self.postMessage(data, { transfer: transferables ?? [] });
+    }
+};
+let parentPort = null;
+if (typeof self === 'undefined') {
+    // We're in Node.js (or a runtime that mimics it)
+    const workerModule = 'worker_threads';
+    // eslint-disable-next-line @stylistic/max-len
+    // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
+    parentPort = require(workerModule).parentPort;
+}
+if (parentPort) {
+    parentPort.on('message', onMessage);
+}
+else {
+    self.addEventListener('message', event => onMessage(event.data));
+}

package/dist/modules/src/index.d.ts

@@ -0,0 +1,26 @@
+/*!
+ * Copyright (c) 2025-present, Vanilagy and contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+/**
+ * Registers the LAME MP3 encoder, which Mediabunny will then use automatically when applicable. Make sure to call this
+ * function before starting any encoding task.
+ *
+ * Preferably, wrap the call in a condition to avoid overriding any native MP3 encoder:
+ *
+ * ```ts
+ * import { canEncodeAudio } from 'mediabunny';
+ * import { registerMp3Encoder } from '@mediabunny/mp3-encoder';
+ *
+ * if (!(await canEncodeAudio('mp3'))) {
+ *     registerMp3Encoder();
+ * }
+ * ```
+ *
+ * @public
+ */
+export declare const registerMp3Encoder: () => void;
+//# sourceMappingURL=index.d.ts.map

package/dist/modules/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAqLH;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,kBAAkB,YAE9B,CAAC"}

package/dist/modules/src/index.js

@@ -0,0 +1,185 @@
+"use strict";
+/*!
+ * Copyright (c) 2025-present, Vanilagy and contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerMp3Encoder = void 0;
+const mediabunny_1 = require("mediabunny");
+const mp3_misc_1 = require("../../../shared/mp3-misc");
+// @ts-expect-error An esbuild plugin handles this, TypeScript doesn't need to understand
+const encode_worker_1 = __importDefault(require("./encode.worker"));
+class Mp3Encoder extends mediabunny_1.CustomAudioEncoder {
+    constructor() {
+        super(...arguments);
+        this.worker = null;
+        this.nextMessageId = 0;
+        this.pendingMessages = new Map();
+        this.buffer = new Uint8Array(2 ** 16);
+        this.currentBufferOffset = 0;
+        this.currentTimestamp = 0;
+        this.chunkMetadata = {};
+    }
+    static supports(codec, config) {
+        return codec === 'mp3'
+            && (config.numberOfChannels === 1 || config.numberOfChannels === 2)
+            && (config.sampleRate === 32000 || config.sampleRate === 44100 || config.sampleRate === 48000);
+    }
+    async init() {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+        this.worker = (await (0, encode_worker_1.default)()); // The actual encoding takes place in this worker
+        const onMessage = (data) => {
+            const pending = this.pendingMessages.get(data.id);
+            assert(pending !== undefined);
+            this.pendingMessages.delete(data.id);
+            if (data.success) {
+                pending.resolve(data.data);
+            }
+            else {
+                pending.reject(data.error);
+            }
+        };
+        if (this.worker.addEventListener) {
+            this.worker.addEventListener('message', event => onMessage(event.data));
+        }
+        else {
+            const nodeWorker = this.worker;
+            nodeWorker.on('message', onMessage);
+        }
+        assert(this.config.bitrate);
+        await this.sendCommand({
+            type: 'init',
+            data: {
+                numberOfChannels: this.config.numberOfChannels,
+                sampleRate: this.config.sampleRate,
+                bitrate: this.config.bitrate,
+            },
+        });
+        this.chunkMetadata = {
+            decoderConfig: {
+                codec: 'mp3',
+                numberOfChannels: this.config.numberOfChannels,
+                sampleRate: this.config.sampleRate,
+            },
+        };
+    }
+    async encode(audioSample) {
+        const sizePerChannel = audioSample.allocationSize({
+            format: 's16-planar',
+            planeIndex: 0,
+        });
+        const requiredBytes = audioSample.numberOfChannels * sizePerChannel;
+        const audioData = new ArrayBuffer(requiredBytes);
+        const audioBytes = new Uint8Array(audioData);
+        for (let i = 0; i < audioSample.numberOfChannels; i++) {
+            audioSample.copyTo(audioBytes.subarray(i * sizePerChannel), {
+                format: 's16-planar', // LAME wants it in this format
+                planeIndex: i,
+            });
+        }
+        const result = await this.sendCommand({
+            type: 'encode',
+            data: {
+                audioData,
+                numberOfFrames: audioSample.numberOfFrames,
+            },
+        }, [audioData]);
+        assert('encodedData' in result);
+        this.digestOutput(new Uint8Array(result.encodedData));
+    }
+    async flush() {
+        const result = await this.sendCommand({ type: 'flush' });
+        assert('flushedData' in result);
+        this.digestOutput(new Uint8Array(result.flushedData));
+    }
+    close() {
+        this.worker?.terminate();
+    }
+    /**
+     * LAME returns data in chunks, but a chunk doesn't need to contain a full MP3 frame. Therefore, we must accumulate
+     * these chunks and extract the MP3 frames only when they're complete.
+     */
+    digestOutput(bytes) {
+        const requiredBufferSize = this.currentBufferOffset + bytes.length;
+        if (requiredBufferSize > this.buffer.length) {
+            // Grow the buffer to the required size
+            const newSize = 1 << Math.ceil(Math.log2(requiredBufferSize));
+            const newBuffer = new Uint8Array(newSize);
+            newBuffer.set(this.buffer);
+            this.buffer = newBuffer;
+        }
+        this.buffer.set(bytes, this.currentBufferOffset);
+        this.currentBufferOffset = requiredBufferSize;
+        let pos = 0;
+        while (pos <= this.currentBufferOffset - mp3_misc_1.FRAME_HEADER_SIZE) {
+            const word = new DataView(this.buffer.buffer).getUint32(pos, false);
+            const header = (0, mp3_misc_1.readFrameHeader)(word, { pos, fileSize: null });
+            if (!header) {
+                break;
+            }
+            const fits = header.totalSize <= this.currentBufferOffset - pos;
+            if (!fits) {
+                // The frame isn't complete yet
+                break;
+            }
+            const data = this.buffer.slice(pos, pos + header.totalSize);
+            const duration = header.audioSamplesInFrame / header.sampleRate;
+            this.onPacket(new mediabunny_1.EncodedPacket(data, 'key', this.currentTimestamp, duration), this.chunkMetadata);
+            if (this.currentTimestamp === 0) {
+                this.chunkMetadata = {}; // Mimic WebCodecs-like behavior
+            }
+            this.currentTimestamp += duration;
+            pos += header.totalSize;
+        }
+        if (pos > 0) {
+            // Shift the data
+            this.buffer.set(this.buffer.subarray(pos, this.currentBufferOffset), 0);
+            this.currentBufferOffset -= pos;
+        }
+    }
+    sendCommand(command, transferables) {
+        return new Promise((resolve, reject) => {
+            const id = this.nextMessageId++;
+            this.pendingMessages.set(id, { resolve, reject });
+            assert(this.worker);
+            if (transferables) {
+                this.worker.postMessage({ id, command }, transferables);
+            }
+            else {
+                this.worker.postMessage({ id, command });
+            }
+        });
+    }
+}
+/**
+ * Registers the LAME MP3 encoder, which Mediabunny will then use automatically when applicable. Make sure to call this
+ * function before starting any encoding task.
+ *
+ * Preferably, wrap the call in a condition to avoid overriding any native MP3 encoder:
+ *
+ * ```ts
+ * import { canEncodeAudio } from 'mediabunny';
+ * import { registerMp3Encoder } from '@mediabunny/mp3-encoder';
+ *
+ * if (!(await canEncodeAudio('mp3'))) {
+ *     registerMp3Encoder();
+ * }
+ * ```
+ *
+ * @public
+ */
+const registerMp3Encoder = () => {
+    (0, mediabunny_1.registerEncoder)(Mp3Encoder);
+};
+exports.registerMp3Encoder = registerMp3Encoder;
+function assert(x) {
+    if (!x) {
+        throw new Error('Assertion failed.');
+    }
+}

package/dist/modules/src/shared.d.ts

@@ -0,0 +1,40 @@
+/*!
+ * Copyright (c) 2025-present, Vanilagy and contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+export type WorkerCommand = {
+    type: 'init';
+    data: {
+        numberOfChannels: number;
+        sampleRate: number;
+        bitrate: number;
+    };
+} | {
+    type: 'encode';
+    data: {
+        audioData: ArrayBuffer;
+        numberOfFrames: number;
+    };
+} | {
+    type: 'flush';
+};
+export type WorkerResponseData = {
+    success: boolean;
+} | {
+    encodedData: ArrayBuffer;
+} | {
+    flushedData: ArrayBuffer;
+};
+export type WorkerResponse = {
+    id: number;
+} & ({
+    success: true;
+    data: WorkerResponseData;
+} | {
+    success: false;
+    error: unknown;
+});
+//# sourceMappingURL=shared.d.ts.map

package/dist/modules/src/shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../src/shared.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,MAAM,MAAM,aAAa,GAAG;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE;QACL,gBAAgB,EAAE,MAAM,CAAC;QACzB,UAAU,EAAE,MAAM,CAAC;QACnB,OAAO,EAAE,MAAM,CAAC;KAChB,CAAC;CACF,GAAG;IACH,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,EAAE;QACL,SAAS,EAAE,WAAW,CAAC;QACvB,cAAc,EAAE,MAAM,CAAC;KACvB,CAAC;CACF,GAAG;IACH,IAAI,EAAE,OAAO,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAChC,OAAO,EAAE,OAAO,CAAC;CACjB,GAAG;IACH,WAAW,EAAE,WAAW,CAAC;CACzB,GAAG;IACH,WAAW,EAAE,WAAW,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC5B,EAAE,EAAE,MAAM,CAAC;CACX,GAAG,CAAC;IACJ,OAAO,EAAE,IAAI,CAAC;IACd,IAAI,EAAE,kBAAkB,CAAC;CACzB,GAAG;IACH,OAAO,EAAE,KAAK,CAAC;IACf,KAAK,EAAE,OAAO,CAAC;CACf,CAAC,CAAC"}

package/dist/modules/src/shared.js

@@ -0,0 +1,9 @@
+"use strict";
+/*!
+ * Copyright (c) 2025-present, Vanilagy and contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@mediabunny/mp3-encoder",
+  "author": "Vanilagy",
+  "version": "1.6.1",
+  "description": "MP3 encoder extension for Mediabunny, based on LAME.",
+  "main": "./dist/bundles/mediabunny-mp3-encoder.mjs",
+  "module": "./dist/bundles/mediabunny-mp3-encoder.mjs",
+  "types": "./dist/modules/src/index.d.ts",
+  "exports": {
+    "types": "./dist/modules/src/index.d.ts",
+    "import": "./dist/bundles/mediabunny-mp3-encoder.mjs",
+    "require": "./dist/bundles/mediabunny-mp3-encoder.mjs"
+  },
+  "files": [
+    "README.md",
+    "package.json",
+    "LICENSE",
+    "dist",
+    "src"
+  ],
+  "sideEffects": false,
+  "license": "MPL-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Vanilagy/mediabunny.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Vanilagy/mediabunny/issues"
+  },
+  "homepage": "https://mediabunny.dev/",
+  "funding": {
+    "type": "individual",
+    "url": "https://github.com/sponsors/Vanilagy"
+  },
+  "peerDependencies": {
+    "mediabunny": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/emscripten": "^1.40.1"
+  },
+  "keywords": [
+    "mp3",
+    "encoding",
+    "codec",
+    "mediabunny",
+    "lame",
+    "browser",
+    "wasm",
+    "polyfill"
+  ]
+}