libsamplerate.d.ts

declare module "@alexanderolsen/libsamplerate-js" {
  interface Options {
    converterType: number;
    wasmPath: string;
  }

  interface Module {
    simple(
      numSamples: number,
      numChannels: number,
      converterType: number,
      inputSampleRate: number,
      outputSampleRate: number,
    ): number;
  }

  export interface Src {
    simple: (dataIn: Float32Array) => Float32Array;
    full: (dataIn: Float32Array, dataOut: Float32Array | null) => Float32Array;
    destroy(): void;
    readonly sourceArray: Float32Array;
    readonly targetArray: Float32Array;
    readonly module: Module;
  }

  export const ConverterType: {
    SRC_SINC_BEST_QUALITY: number;
    SRC_SINC_MEDIUM_QUALITY: number;
    SRC_SINC_FASTEST: number;
    SRC_ZERO_ORDER_HOLD: number;
    SRC_LINEAR: number;
  };

  export const create: (
    nChannels: number,
    inputSampleRate: number,
    ouputSampleRate: number,
    options: Options,
  ) => Promise<Src>;
}

resampler.ts

import { create, ConverterType, Src } from "@alexanderolsen/libsamplerate-js";
import libsamplerateWasm from "@alexanderolsen/libsamplerate-js/dist/libsamplerate.wasm";

export class Resampler {
  private src: Src;

  constructor(src: Src) {
    this.src = src;
  }

  resample(
    inputArray: Float32Array,
    inputSampleRate: number,
    outputSampleRate: number,
  ): Float32Array {
    this.src.sourceArray.set(inputArray);

    const outputFrames = this.src.module.simple(
      inputArray.length,
      1, // number of channels
      ConverterType.SRC_SINC_FASTEST,
      inputSampleRate,
      outputSampleRate,
    );
    return this.src.targetArray.subarray(0, outputFrames);
  }
}

const resamplerPromise = new Promise<Resampler>((resolve, reject) => {
  create(1, 8000, 8000, {
    converterType: ConverterType.SRC_SINC_FASTEST,
    wasmPath: libsamplerateWasm,
  })
    .then((src) => resolve(new Resampler(src)))
    .catch(reject);
});

export function loadResampler(): Promise<Resampler> {
  return resamplerPromise;
}