@k13engineering/rubberband 0.0.6 → 0.0.8

package/dist/lib/index.d.ts

@@ -1,10 +1,12 @@
+import { type TRubberbandOptions } from "./options.js";
 type TRubberbandAudioData = {
     planes: Float32Array[];
 };
-declare const createRubberbandWrapper: ({ sampleRate, channelCount, maxBufferSizeInFrames }: {
+declare const createRubberbandWrapper: ({ sampleRate, channelCount, maxBufferSizeInFrames, options }: {
     sampleRate: number;
     channelCount: number;
     maxBufferSizeInFrames: number;
+    options: Partial<TRubberbandOptions>;
 }) => {
     requestPitchScale: ({ pitchScale }: {
         pitchScale: number;
@@ -16,6 +18,7 @@ declare const createRubberbandWrapper: ({ sampleRate, channelCount, maxBufferSiz
     process: ({ audioData }: {
         audioData: TRubberbandAudioData;
     }) => void;
+    end: () => void;
     available: () => number;
     latencyInSamples: () => number;
     retrieve: ({ sampleCount }: {

package/dist/lib/index.js

@@ -1,5 +1,6 @@
 import { RubberBandInterface } from "rubberband-wasm";
 import { loadRubberbandWasm } from "./rubberband.js";
+import { optionsToBitmask, /*type TRubberbandOptions */} from "./options.js";
 
 /*type TRubberbandAudioData = {
   planes: Float32Array[];
@@ -10,18 +11,21 @@ const rubberbandWasm = await loadRubberbandWasm();
 const wasm = await WebAssembly.compile(rubberbandWasm);
 const rubberbandApi = await RubberBandInterface.initialize(wasm);
 
-const OptionProcessRealTime = 1;
-
+// eslint-disable-next-line max-statements
 const createRubberbandWrapper = ({
   sampleRate,
   channelCount,
-  maxBufferSizeInFrames
+  maxBufferSizeInFrames,
+  options
 }/*: {
   sampleRate: number;
   channelCount: number;
   maxBufferSizeInFrames: number;
+  options: Partial<TRubberbandOptions>;
 }*/) => {
 
+  let ended = false;
+
   const channelArrayPtr = rubberbandApi.malloc(channelCount * 4);
   const channelDataPtrs/*: number[]*/ = [];
   for (let channel = 0; channel < channelCount; channel += 1) {
@@ -30,7 +34,12 @@ const createRubberbandWrapper = ({
     rubberbandApi.memWritePtr(channelArrayPtr + channel * 4, bufferPtr);
   }
 
-  const rb = rubberbandApi.rubberband_new(sampleRate, channelCount, OptionProcessRealTime, 1, 1);
+  const optionsBitmask = optionsToBitmask({ options });
+  const rb = rubberbandApi.rubberband_new(sampleRate, channelCount, optionsBitmask, 1, 1);
+
+  if (rb === 0) {
+    throw Error("failed to create rubberband instance");
+  }
 
   const requestPitchScale = ({ pitchScale }/*: { pitchScale: number }*/) => {
     rubberbandApi.rubberband_set_pitch_scale(rb, pitchScale);
@@ -45,6 +54,9 @@ const createRubberbandWrapper = ({
   };
 
   const process = ({ audioData }/*: { audioData: TRubberbandAudioData }*/) => {
+    if (ended) {
+      throw Error("already ended");
+    }
 
     const firstPlane = audioData.planes[0];
     const sampleCount = firstPlane.length;
@@ -66,6 +78,15 @@ const createRubberbandWrapper = ({
     rubberbandApi.rubberband_process(rb, channelArrayPtr, sampleCount, 0);
   };
 
+  const end = () => {
+    if (ended) {
+      throw Error("already ended");
+    }
+
+    ended = true;
+    rubberbandApi.rubberband_process(rb, channelArrayPtr, 0, 1);
+  };
+
   const available = ()/*: number*/ => {
     return rubberbandApi.rubberband_available(rb);
   };
@@ -117,6 +138,7 @@ const createRubberbandWrapper = ({
     requestTimeRatio,
     samplesRequired,
     process,
+    end,
     available,
     latencyInSamples,
     retrieve

package/dist/lib/options.d.ts

@@ -0,0 +1,19 @@
+type TRubberbandOptions = {
+    processMode: "realtime" | "offline";
+    stretchMode: "elastic" | "precise";
+    transientsMode: "crisp" | "mixed" | "smooth";
+    detectorMode: "compound" | "percussive" | "soft";
+    phaseMode: "laminar" | "independent";
+    threadingMode: "auto" | "never" | "always";
+    windowMode: "standard" | "short" | "long";
+    smoothing: boolean;
+    formantMode: "shifted" | "preserved";
+    pitchMode: "highspeed" | "highquality" | "highconsistency";
+    channelMode: "apart" | "together";
+    engineMode: "faster" | "finer";
+};
+declare const optionsToBitmask: ({ options }: {
+    options: Partial<TRubberbandOptions>;
+}) => number;
+export { optionsToBitmask };
+export type { TRubberbandOptions };

package/dist/lib/options.js

@@ -0,0 +1,95 @@
+const OptionProcessOffline = 0x00000000;
+const OptionProcessRealTime = 0x00000001;
+const OptionStretchElastic = 0x00000000;
+const OptionStretchPrecise = 0x00000010;
+const OptionTransientsCrisp = 0x00000000;
+const OptionTransientsMixed = 0x00000100;
+const OptionTransientsSmooth = 0x00000200;
+const OptionDetectorCompound = 0x00000000;
+const OptionDetectorPercussive = 0x00000400;
+const OptionDetectorSoft = 0x00000800;
+const OptionPhaseLaminar = 0x00000000;
+const OptionPhaseIndependent = 0x00002000;
+const OptionThreadingAuto = 0x00000000;
+const OptionThreadingNever = 0x00010000;
+const OptionThreadingAlways = 0x00020000;
+const OptionWindowStandard = 0x00000000;
+const OptionWindowShort = 0x00100000;
+const OptionWindowLong = 0x00200000;
+const OptionSmoothingOff = 0x00000000;
+const OptionSmoothingOn = 0x00800000;
+const OptionFormantShifted = 0x00000000;
+const OptionFormantPreserved = 0x01000000;
+const OptionPitchHighSpeed = 0x00000000;
+const OptionPitchHighQuality = 0x02000000;
+const OptionPitchHighConsistency = 0x04000000;
+const OptionChannelsApart = 0x00000000;
+const OptionChannelsTogether = 0x10000000;
+const OptionEngineFaster = 0x00000000;
+const OptionEngineFiner = 0x20000000;
+
+/*type TRubberbandOptions = {
+  processMode: "realtime" | "offline";
+  stretchMode: "elastic" | "precise";
+  transientsMode: "crisp" | "mixed" | "smooth";
+  detectorMode: "compound" | "percussive" | "soft";
+  phaseMode: "laminar" | "independent";
+  threadingMode: "auto" | "never" | "always";
+  windowMode: "standard" | "short" | "long";
+  smoothing: boolean;
+  formantMode: "shifted" | "preserved";
+  pitchMode: "highspeed" | "highquality" | "highconsistency";
+  channelMode: "apart" | "together";
+  engineMode: "faster" | "finer";
+};*/
+
+// eslint-disable-next-line max-statements
+const optionsToBitmask = ({ options }/*: { options: Partial<TRubberbandOptions> }*/)/*: number*/ => {
+  let bitmask = 0;
+
+  const addIf = ({ condition, value }/*: { condition: boolean; value: number }*/) => {
+    if (condition) {
+      bitmask |= value;
+    }
+  };
+
+  addIf({ condition: options.processMode === "realtime", value: OptionProcessRealTime });
+  addIf({ condition: options.processMode === "offline", value: OptionProcessOffline });
+  addIf({ condition: options.stretchMode === "elastic", value: OptionStretchElastic });
+  addIf({ condition: options.stretchMode === "precise", value: OptionStretchPrecise });
+  addIf({ condition: options.transientsMode === "mixed", value: OptionTransientsMixed });
+  addIf({ condition: options.transientsMode === "crisp", value: OptionTransientsCrisp });
+  addIf({ condition: options.transientsMode === "smooth", value: OptionTransientsSmooth });
+  addIf({ condition: options.detectorMode === "compound", value: OptionDetectorCompound });
+  addIf({ condition: options.detectorMode === "percussive", value: OptionDetectorPercussive });
+  addIf({ condition: options.detectorMode === "soft", value: OptionDetectorSoft });
+  addIf({ condition: options.phaseMode === "laminar", value: OptionPhaseLaminar });
+  addIf({ condition: options.phaseMode === "independent", value: OptionPhaseIndependent });
+  addIf({ condition: options.threadingMode === "auto", value: OptionThreadingAuto });
+  addIf({ condition: options.threadingMode === "never", value: OptionThreadingNever });
+  addIf({ condition: options.threadingMode === "always", value: OptionThreadingAlways });
+  addIf({ condition: options.windowMode === "standard", value: OptionWindowStandard });
+  addIf({ condition: options.windowMode === "short", value: OptionWindowShort });
+  addIf({ condition: options.windowMode === "long", value: OptionWindowLong });
+  addIf({ condition: options.smoothing === false, value: OptionSmoothingOff });
+  addIf({ condition: options.smoothing === true, value: OptionSmoothingOn });
+  addIf({ condition: options.formantMode === "preserved", value: OptionFormantPreserved });
+  addIf({ condition: options.formantMode === "shifted", value: OptionFormantShifted });
+  addIf({ condition: options.pitchMode === "highspeed", value: OptionPitchHighSpeed });
+  addIf({ condition: options.pitchMode === "highquality", value: OptionPitchHighQuality });
+  addIf({ condition: options.pitchMode === "highconsistency", value: OptionPitchHighConsistency });
+  addIf({ condition: options.channelMode === "apart", value: OptionChannelsApart });
+  addIf({ condition: options.channelMode === "together", value: OptionChannelsTogether });
+  addIf({ condition: options.engineMode === "faster", value: OptionEngineFaster });
+  addIf({ condition: options.engineMode === "finer", value: OptionEngineFiner });
+
+  return bitmask;
+};
+
+export {
+  optionsToBitmask
+};
+
+/*export type {
+  TRubberbandOptions
+};*/

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.0.6",
+  "version": "0.0.8",
   "name": "@k13engineering/rubberband",
   "type": "module",
   "description": "Rubberband wrapper for Node.js",