wavify-audiobuffer 1.0.0

package/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+Copyright (c) 2015 Jam3
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
+OR OTHER DEALINGS IN THE SOFTWARE.
+

package/README.md

@@ -0,0 +1,55 @@
+# wavify-audiobuffer
+
+[![npm-tag](https://img.shields.io/badge/npm-1.0.0-green?logo=npm)](https://www.npmjs.com/package/wavify-audiobuffer) [![git-tag](https://img.shields.io/badge/github-repo-blue?logo=github)](https://github.com/tucsok007/wavify-audiobuffer)
+
+Encodes the contents of an [AudioBuffer](https://developer.mozilla.org/en-US/docs/Web/API/AudioBuffer) from the WebAudio API as WAVE. Supports 16-bit PCM, 24bit PCM and 32-bit float data.
+
+This project is a fork and extension/rewrite of the [audiobuffer-to-wav](https://www.npmjs.com/audiobuffer-to-wav) npm library.
+
+The package is designed to work in both web, Node.js, and Embedded environments, considering that the web audio api is available or polyfilled.
+
+## Installation:
+
+```sh
+npm i wavify-audiobuffer
+```
+
+## Usage:
+
+#### `arrayBuffer = wavifyBuffer(audioBuffer, {...options})`
+
+Encodes the [AudioBuffer](https://developer.mozilla.org/en-US/docs/Web/API/AudioBuffer) instance as WAV, returning a new array buffer. Interleaves multi-channel data, if necessary.
+
+By default, the function exports with 16-bit PCM.
+
+You can optionally specify 24 or 32-bit bit depth.
+
+## Example(s):
+
+```typescript
+import { wavifyBuffer } from "wavify-audiobuffer";
+
+fetch("https://www.example.audio/track.mp3")
+  .then((response) => {
+    if (!response.ok) {
+      throw new Error("Couldn't fetch the track data.");
+    } else {
+      return response.arrayBuffer();
+    }
+  })
+  .then((arrayBuffer) => {
+    audioContext.decodeAudioData(arrayBuffer, (audioBuffer) => {
+      const waveData = wavifyBuffer(audioBuffer, { bitDepth: 24 });
+      //consume the waveData buffer
+    });
+  })
+  .catch((error) => {
+    //handle errors
+  });
+```
+
+See [this example](./examples/example.ts) for an example of loading an MP3, decoding it, and re-encoding it as a WAV file (in Node.js).
+
+## License:
+
+This project is licensed under the terms of MIT, please see the [LICENSE.md](./LICENSE.md) file for details.

package/index.d.ts

@@ -0,0 +1,15 @@
+declare enum WaveFormat {
+    WAVE_FORMAT_PCM = 1,
+    WAVE_FORMAT_EXTENSIBLE = 65279,
+    WAVE_FORMAT_IEEE_FLOAT = 3
+}
+declare const waveFormatTagsByBitDepth: {
+    16: WaveFormat;
+    24: WaveFormat;
+    32: WaveFormat;
+};
+interface IWavEncodeOptions {
+    bitDepth: keyof typeof waveFormatTagsByBitDepth;
+}
+export default function wavifyBuffer(audioBuffer: AudioBuffer, options?: IWavEncodeOptions): ArrayBuffer;
+export {};

package/index.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = wavifyBuffer;
+const utils_1 = require("./utils");
+const PCM_RIFF_HEADER_SIZE = 36;
+const PCM_FMT_SUBCHUNK_SIZE_EXCLUDING_SUBCHUNK_HEADER = 16;
+var WaveFormat;
+(function (WaveFormat) {
+    WaveFormat[WaveFormat["WAVE_FORMAT_PCM"] = 1] = "WAVE_FORMAT_PCM";
+    WaveFormat[WaveFormat["WAVE_FORMAT_EXTENSIBLE"] = 65279] = "WAVE_FORMAT_EXTENSIBLE";
+    WaveFormat[WaveFormat["WAVE_FORMAT_IEEE_FLOAT"] = 3] = "WAVE_FORMAT_IEEE_FLOAT";
+})(WaveFormat || (WaveFormat = {}));
+const waveFormatTagsByBitDepth = {
+    16: WaveFormat.WAVE_FORMAT_PCM,
+    24: WaveFormat.WAVE_FORMAT_PCM,
+    32: WaveFormat.WAVE_FORMAT_IEEE_FLOAT,
+};
+const defaultOptions = {
+    bitDepth: 16,
+};
+function wavifyBuffer(audioBuffer, options = defaultOptions) {
+    if (!audioBuffer) {
+        throw new Error("Please provide an AudioBuffer object.");
+    }
+    const samples = (0, utils_1.getInterleavedChannelDataByAudioBuffer)(audioBuffer);
+    return encodeWave(samples, audioBuffer.sampleRate, audioBuffer.numberOfChannels, options.bitDepth);
+}
+function getWaveFormatTagByBitDepth(bitDepth) {
+    return waveFormatTagsByBitDepth[bitDepth];
+}
+function encodeWave(samples, sampleRate, numberOfChannels, bitDepth) {
+    const bytesPerSample = bitDepth / 8;
+    const blockAlign = numberOfChannels * bytesPerSample;
+    const buffer = new ArrayBuffer(44 + samples.length * bytesPerSample);
+    const view = new DataView(buffer);
+    /* RIFF identifier */
+    writeStringAsUint8Chunks(view, 0, "RIFF");
+    /* RIFF chunk length */
+    view.setUint32(4, PCM_RIFF_HEADER_SIZE + samples.length * bytesPerSample, true);
+    /* RIFF type */
+    writeStringAsUint8Chunks(view, 8, "WAVE");
+    /* format chunk identifier */
+    writeStringAsUint8Chunks(view, 12, "fmt ");
+    /* format chunk length */
+    view.setUint32(16, PCM_FMT_SUBCHUNK_SIZE_EXCLUDING_SUBCHUNK_HEADER, true);
+    /* sample format (raw) */
+    view.setUint16(20, getWaveFormatTagByBitDepth(bitDepth), true);
+    /* channel count */
+    view.setUint16(22, numberOfChannels, true);
+    /* sample rate */
+    view.setUint32(24, sampleRate, true);
+    /* byte rate (sample rate * block align) */
+    view.setUint32(28, sampleRate * blockAlign, true);
+    /* block align (channel count * bytes per sample) */
+    view.setUint16(32, blockAlign, true);
+    /* bits per sample */
+    view.setUint16(34, bitDepth, true);
+    /* data chunk identifier */
+    writeStringAsUint8Chunks(view, 36, "data");
+    /* data chunk length */
+    view.setUint32(40, samples.length * bytesPerSample, true);
+    switch (bitDepth) {
+        case 16:
+            writeFloat32To16BitPCM(view, 44, samples);
+            break;
+        case 24:
+            writeFloat32To24BitPCM(view, 44, samples);
+            break;
+        case 32:
+            writeFloat32(view, 44, samples);
+            break;
+    }
+    return buffer;
+}
+function setUint24LittleEndian(view) {
+    return function (offset, value) {
+        view.setUint8(offset, value & ~0xffffff00);
+        view.setUint16(offset + 1, value >> 8, true);
+    };
+}
+function writeStringAsUint8Chunks(view, offset, value) {
+    for (let index = 0; index < value.length; index++) {
+        view.setUint8(offset + index, value.charCodeAt(index));
+    }
+}
+function writeFloat32(output, offset, input) {
+    for (let index = 0; index < input.length; index++, offset += 4) {
+        output.setFloat32(offset, input[index], true);
+    }
+}
+function writeFloat32To24BitPCM(output, offset, input) {
+    const writeToView = setUint24LittleEndian(output);
+    for (let index = 0; index < input.length; index++, offset += 3) {
+        let s = Math.max(-1, Math.min(1, input[index]));
+        writeToView(offset, s < 0 ? s * 0x800000 : s * 0x7fffff);
+    }
+}
+function writeFloat32To16BitPCM(output, offset, input) {
+    for (let index = 0; index < input.length; index++, offset += 2) {
+        let s = Math.max(-1, Math.min(1, input[index]));
+        output.setInt16(offset, s < 0 ? s * 0x8000 : s * 0x7fff, true);
+    }
+}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "wavify-audiobuffer",
+  "version": "1.0.0",
+  "description": "convert an AudioBuffer to .wav format",
+  "main": "index.js",
+  "license": "MIT",
+  "author": {
+    "name": "Clio Orgyán",
+    "url": "https://github.com/tucsok007"
+  },
+  "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "node-web-audio-api": "^2.0.0",
+    "ts-jest": "^29.4.11",
+    "typescript": "^6.0.3"
+  },
+  "scripts": {
+    "rebuild": "sh cleanup.sh && sh build.sh",
+    "test": "set NODE_OPTIONS=--experimental-vm-modules && jest --coverage"
+  },
+  "keywords": [
+    "convert",
+    "AudioBuffer",
+    "to",
+    "wav",
+    "format",
+    "for",
+    "browser",
+    "webaudio",
+    "web audio",
+    "audio",
+    "buffer",
+    "conversion",
+    "formats",
+    "fmt",
+    "riff",
+    "wave",
+    "sound"
+  ],
+  "files": [
+    "*.d.ts",
+    "*.js",
+    "LICENSE.md",
+    "README.md",
+    "package.json"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/tucsok007/wavify-audiobuffer.git"
+  },
+  "homepage": "https://github.com/tucsok007/wavify-audiobuffer",
+  "bugs": {
+    "url": "https://github.com/tucsok007/wavify-audiobuffer/issues"
+  }
+}

package/utils.d.ts

@@ -0,0 +1 @@
+export declare const getInterleavedChannelDataByAudioBuffer: (audioBuffer: AudioBuffer) => Float32Array<ArrayBuffer>;

package/utils.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInterleavedChannelDataByAudioBuffer = void 0;
+const getInterleavedChannelDataByAudioBuffer = (audioBuffer) => {
+    if (!audioBuffer ||
+        (!!audioBuffer.numberOfChannels && audioBuffer.numberOfChannels == 0)) {
+        throw new Error("Please provide an AudioBuffer object with at least 1 channel.");
+    }
+    const channels = [];
+    for (let channelIndex = 0; channelIndex < audioBuffer.numberOfChannels; channelIndex++) {
+        channels.push(audioBuffer.getChannelData(channelIndex));
+    }
+    return interleaveChannelData(...channels);
+};
+exports.getInterleavedChannelDataByAudioBuffer = getInterleavedChannelDataByAudioBuffer;
+function interleaveChannelData(...channels) {
+    if (channels.length < 2) {
+        return channels[0];
+    }
+    const numberOfChannels = channels.length;
+    const channelLength = channels[0].length;
+    const result = new Float32Array(channelLength * numberOfChannels);
+    for (let frame = 0; frame < channelLength; frame++) {
+        for (let channelIndex = 0; channelIndex < numberOfChannels; channelIndex++) {
+            result[frame * numberOfChannels + channelIndex] =
+                channels[channelIndex][frame];
+        }
+    }
+    return result;
+}