@k13engineering/rubberband 0.0.2 → 0.0.3

package/dist/lib/index.d.ts

@@ -0,0 +1,27 @@
+type TRubberbandAudioData = {
+    planes: Float32Array[];
+};
+declare const createRubberbandWrapper: ({ sampleRate, channelCount, maxBufferSizeInFrames }: {
+    sampleRate: number;
+    channelCount: number;
+    maxBufferSizeInFrames: number;
+}) => {
+    requestPitchScale: ({ pitchScale }: {
+        pitchScale: number;
+    }) => void;
+    requestTimeRatio: ({ timeRatio }: {
+        timeRatio: number;
+    }) => void;
+    samplesRequired: () => any;
+    process: ({ audioData }: {
+        audioData: TRubberbandAudioData;
+    }) => void;
+    available: () => number;
+    latencyInSamples: () => number;
+    retrieve: ({ sampleCount }: {
+        sampleCount: number;
+    }) => TRubberbandAudioData;
+};
+type TRubberbandWrapper = ReturnType<typeof createRubberbandWrapper>;
+export { createRubberbandWrapper };
+export type { TRubberbandWrapper };

package/dist/lib/index.js

@@ -0,0 +1,125 @@
+import { RubberBandInterface } from "rubberband-wasm";
+import { loadRubberbandWasm } from "./rubberband.js";
+
+/*type TRubberbandAudioData = {
+  planes: Float32Array[];
+};*/
+
+const rubberbandWasm = await loadRubberbandWasm();
+
+const wasm = await WebAssembly.compile(rubberbandWasm);
+const rubberbandApi = await RubberBandInterface.initialize(wasm);
+
+const OptionProcessRealTime = 1;
+
+const createRubberbandWrapper = ({
+  sampleRate,
+  channelCount,
+  maxBufferSizeInFrames
+}/*: {
+  sampleRate: number;
+  channelCount: number;
+  maxBufferSizeInFrames: number;
+}*/) => {
+
+  const channelArrayPtr = rubberbandApi.malloc(channelCount * 4);
+  const channelDataPtrs/*: number[]*/ = [];
+  for (let channel = 0; channel < channelCount; channel += 1) {
+    const bufferPtr = rubberbandApi.malloc(maxBufferSizeInFrames * 4);
+    channelDataPtrs.push(bufferPtr);
+    rubberbandApi.memWritePtr(channelArrayPtr + channel * 4, bufferPtr);
+  }
+
+  const rb = rubberbandApi.rubberband_new(sampleRate, channelCount, OptionProcessRealTime, 1, 1);
+
+  const requestPitchScale = ({ pitchScale }/*: { pitchScale: number }*/) => {
+    rubberbandApi.rubberband_set_pitch_scale(rb, pitchScale);
+  };
+
+  const requestTimeRatio = ({ timeRatio }/*: { timeRatio: number }*/) => {
+    rubberbandApi.rubberband_set_time_ratio(rb, timeRatio);
+  };
+
+  const samplesRequired = () => {
+    return rubberbandApi.rubberband_get_samples_required(rb);
+  };
+
+  const process = ({ audioData }/*: { audioData: TRubberbandAudioData }*/) => {
+
+    const firstPlane = audioData.planes[0];
+    const sampleCount = firstPlane.length;
+
+    audioData.planes.forEach((plane, channelIndex) => {
+
+      if (plane.length > maxBufferSizeInFrames) {
+        throw new Error("plane length exceeds max buffer size");
+      }
+
+      const channelDataPtr = channelDataPtrs[channelIndex];
+      rubberbandApi.memWrite(channelDataPtr, plane);
+    });
+
+    rubberbandApi.rubberband_process(rb, channelArrayPtr, sampleCount, 0);
+  };
+
+  const available = ()/*: number*/ => {
+    return rubberbandApi.rubberband_available(rb);
+  };
+
+  const latencyInSamples = ()/*: number*/ => {
+    return rubberbandApi.rubberband_get_latency(rb);
+  };
+
+  // eslint-disable-next-line complexity
+  const retrieve = ({ sampleCount }/*: { sampleCount: number }*/)/*: TRubberbandAudioData*/ => {
+
+    if (sampleCount > maxBufferSizeInFrames) {
+      throw Error(`requested sample count ${sampleCount} exceeds max buffer size ${maxBufferSizeInFrames}`);
+    }
+
+    if (sampleCount > available()) {
+      throw Error(`look before you leap: requested ${sampleCount} samples but only ${available()} available`);
+    }
+
+    const samplesReceived = rubberbandApi.rubberband_retrieve(rb, channelArrayPtr, sampleCount);
+
+    if (samplesReceived > sampleCount) {
+      throw Error("BUG: received more samples than requested");
+    }
+
+    if (samplesReceived < sampleCount) {
+      throw Error("BUG: received fewer samples than requested");
+    }
+
+    let planes/*: Float32Array[]*/ = [];
+
+    channelDataPtrs.forEach((channelDataPtr) => {
+      const plane = rubberbandApi.memReadF32(channelDataPtr, samplesReceived);
+      planes = [...planes, plane];
+    });
+
+    return {
+      planes
+    };
+  };
+
+  return {
+    requestPitchScale,
+    requestTimeRatio,
+    samplesRequired,
+    process,
+    available,
+    latencyInSamples,
+    retrieve
+  };
+};
+
+/*type TRubberbandWrapper = ReturnType<typeof createRubberbandWrapper>;*/
+
+export {
+  createRubberbandWrapper
+};
+
+/*export type {
+  TRubberbandWrapper
+};*/

package/dist/lib/rubberband.d.ts

@@ -0,0 +1,2 @@
+declare const loadRubberbandWasm: () => unknown;
+export { loadRubberbandWasm };

package/dist/lib/rubberband.js

@@ -0,0 +1,14 @@
+/* c8 ignore start */
+import { loadAsBlob } from "esm-resource";
+
+const loadRubberbandWasm = async () => {
+  const rubberbandBlob = await loadAsBlob({ importMeta: import.meta, filepath: "../../node_modules/rubberband-wasm/dist/rubberband.wasm" });
+  const rubberbandWasmArrayBuffer = await rubberbandBlob.arrayBuffer();
+  const rubberbandWasm = new Uint8Array(rubberbandWasmArrayBuffer);
+  return rubberbandWasm;
+};
+
+export {
+  loadRubberbandWasm
+};
+/* c8 ignore end */

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.0.2",
+  "version": "0.0.3",
   "name": "@k13engineering/rubberband",
   "type": "module",
   "description": "Rubberband wrapper for Node.js",
@@ -17,7 +17,10 @@
     "npm-check-updates": "^19.3.1",
     "typescript-eslint": "^8.53.0"
   },
-  "dependencies": {},
+  "dependencies": {
+    "esm-resource": "^0.0.3",
+    "rubberband-wasm": "^3.3.0"
+  },
   "publishConfig": {
     "access": "public"
   },