@libraz/libsonare 1.4.1 → 1.5.1

package/src/mastering_repair.ts

@@ -0,0 +1,161 @@
+import { getSonareModule } from './module_state';
+
+function requireModule() {
+  return getSonareModule();
+}
+
+// ============================================================================
+// Mastering repair (declick, denoise_classical, declip, decrackle, dehum,
+// dereverb_classical, trim_silence) — hand-written bindings.
+// ============================================================================
+
+/** Options for `masteringRepairDeclick`. */
+export interface DeclickOptions {
+  threshold?: number;
+  neighborRatio?: number;
+  maxClickSamples?: number;
+  lpcOrder?: number;
+  residualRatio?: number;
+}
+
+/** Algorithms accepted by `masteringRepairDenoiseClassical`. */
+export type DenoiseClassicalMode = 'logMmse' | 'mmseStsa' | 'spectralSubtraction';
+
+/** Noise PSD estimators accepted by `masteringRepairDenoiseClassical`. */
+export type DenoiseClassicalNoiseEstimator = 'quantile' | 'mcra' | 'imcra';
+
+/** Options for `masteringRepairDenoiseClassical`. */
+export interface DenoiseClassicalOptions {
+  mode?: DenoiseClassicalMode;
+  noiseEstimator?: DenoiseClassicalNoiseEstimator;
+  nFft?: number;
+  hopLength?: number;
+  ddAlpha?: number;
+  gainFloor?: number;
+  overSubtraction?: number;
+  spectralFloor?: number;
+  noiseEstimationQuantile?: number;
+  speechPresenceGain?: boolean;
+  gainSmoothing?: boolean;
+}
+
+/** Offline LPC-based declicker. */
+export function masteringRepairDeclick(
+  samples: Float32Array,
+  sampleRate: number,
+  options: DeclickOptions = {},
+): Float32Array {
+  return requireModule().masteringRepairDeclick(samples, sampleRate, options);
+}
+
+/** Offline STFT-domain classical denoiser (LogMMSE / MMSE-STSA / SpectralSubtraction). */
+export function masteringRepairDenoiseClassical(
+  samples: Float32Array,
+  sampleRate: number,
+  options: DenoiseClassicalOptions = {},
+): Float32Array {
+  return requireModule().masteringRepairDenoiseClassical(samples, sampleRate, options);
+}
+
+/** Options for `masteringRepairDeclip`. */
+export interface DeclipOptions {
+  clipThreshold?: number;
+  lpcOrder?: number;
+  iterations?: number;
+  lpcBlend?: number;
+}
+
+/** Algorithms accepted by `masteringRepairDecrackle`. */
+export type DecrackleMode = 'median' | 'waveletShrinkage';
+
+/** Options for `masteringRepairDecrackle`. */
+export interface DecrackleOptions {
+  threshold?: number;
+  mode?: DecrackleMode;
+  levels?: number;
+}
+
+/** Options for `masteringRepairDehum`. */
+export interface DehumOptions {
+  fundamentalHz?: number;
+  harmonics?: number;
+  q?: number;
+  adaptive?: boolean;
+  searchRangeHz?: number;
+  adaptation?: number;
+  frameSize?: number;
+  pllBandwidth?: number;
+}
+
+/** Options for `masteringRepairDereverbClassical`. */
+export interface DereverbClassicalOptions {
+  threshold?: number;
+  attenuation?: number;
+  nFft?: number;
+  hopLength?: number;
+  t60Sec?: number;
+  lateDelayMs?: number;
+  overSubtraction?: number;
+  spectralFloor?: number;
+  wpeEnabled?: boolean;
+  wpeIterations?: number;
+  wpeTaps?: number;
+  wpeStrength?: number;
+}
+
+/** Trimming modes accepted by `masteringRepairTrimSilence`. */
+export type TrimSilenceMode = 'peak' | 'lufsGated';
+
+/** Options for `masteringRepairTrimSilence`. */
+export interface TrimSilenceOptions {
+  threshold?: number;
+  paddingSamples?: number;
+  mode?: TrimSilenceMode;
+  gateLufs?: number;
+  windowMs?: number;
+}
+
+/** Offline LPC-based declipper. */
+export function masteringRepairDeclip(
+  samples: Float32Array,
+  sampleRate: number,
+  options: DeclipOptions = {},
+): Float32Array {
+  return requireModule().masteringRepairDeclip(samples, sampleRate, options);
+}
+
+/** Offline crackle suppressor (median or wavelet-shrinkage). */
+export function masteringRepairDecrackle(
+  samples: Float32Array,
+  sampleRate: number,
+  options: DecrackleOptions = {},
+): Float32Array {
+  return requireModule().masteringRepairDecrackle(samples, sampleRate, options);
+}
+
+/** Offline mains-hum remover. */
+export function masteringRepairDehum(
+  samples: Float32Array,
+  sampleRate: number,
+  options: DehumOptions = {},
+): Float32Array {
+  return requireModule().masteringRepairDehum(samples, sampleRate, options);
+}
+
+/** Offline classical dereverberator (spectral subtraction + optional WPE). */
+export function masteringRepairDereverbClassical(
+  samples: Float32Array,
+  sampleRate: number,
+  options: DereverbClassicalOptions = {},
+): Float32Array {
+  return requireModule().masteringRepairDereverbClassical(samples, sampleRate, options);
+}
+
+/** Offline silence trimmer (peak threshold or LUFS-gated). */
+export function masteringRepairTrimSilence(
+  samples: Float32Array,
+  sampleRate: number,
+  options: TrimSilenceOptions = {},
+): Float32Array {
+  return requireModule().masteringRepairTrimSilence(samples, sampleRate, options);
+}

package/src/mixer.ts

@@ -522,6 +522,14 @@ export class Mixer {
     return this.mixer.tailSamples();
   }
 
+  /**
+   * Reported latency (samples) of the compiled mixer graph, for aligning
+   * dry/wet material. Lazily compiles the routing graph if the topology is dirty.
+   */
+  latencySamples(): number {
+    return this.mixer.latencySamples();
+  }
+
   /**
    * Drain delayed / tail audio by processing a zero-input block of `numSamples`
    * frames after the host stops feeding strip inputs. Returns the mixed stereo

package/src/mixing_oneshot.ts

@@ -0,0 +1,54 @@
+import { getSonareModule } from './module_state';
+import type { MixOptions, MixResult } from './public_types';
+
+function requireModule() {
+  return getSonareModule();
+}
+
+export function mixingScenePresetNames(): string[] {
+  return Array.from(requireModule().mixingScenePresetNames());
+}
+
+/**
+ * Get a built-in mixing scene preset serialized as JSON. This is the canonical
+ * name shared with the Node and Python bindings; the returned JSON loads
+ * directly into a {@link Mixer} via {@link Mixer.fromSceneJson}.
+ *
+ * @param presetName - Preset name (see {@link mixingScenePresetNames})
+ * @returns Scene JSON string
+ */
+export function mixingScenePresetJson(presetName: string): string {
+  return requireModule().mixingScenePresetJson(presetName);
+}
+
+/**
+ * One-shot stereo mix of multiple strips through the routing graph + master bus.
+ *
+ * Each returned per-strip meter reflects only this single one-shot block. The
+ * integrating-meter fields (`momentaryLufs`, `shortTermLufs`, `integratedLufs`
+ * and the true-peak fields) require sustained streaming to populate; on a short
+ * one-shot mix they read the -120 dB floor sentinel. Drive a streaming
+ * {@link Mixer} block-by-block if you need meaningful loudness/true-peak
+ * readings.
+ *
+ * @param leftChannels - Per-strip left input buffers (all the same length)
+ * @param rightChannels - Per-strip right input buffers (all the same length)
+ * @param sampleRate - Sample rate in Hz
+ * @param options - Per-strip mix options (trim, fader, pan, width, mute)
+ */
+export function mixStereo(
+  leftChannels: Float32Array[],
+  rightChannels: Float32Array[],
+  sampleRate = 48000,
+  options: MixOptions = {},
+): MixResult {
+  if (leftChannels.length === 0 || leftChannels.length !== rightChannels.length) {
+    throw new Error('leftChannels and rightChannels must have the same non-zero length.');
+  }
+  return requireModule().mixStereo(
+    leftChannels,
+    rightChannels,
+    sampleRate,
+    options as Record<string, unknown>,
+  );
+}

package/src/module_state.ts

@@ -65,8 +65,7 @@ function makeSonareError(raw: SonareModule, thrown: number): SonareError {
  * {@link SonareError}. Only function-valued
  * members are wrapped, and the wrapper is cached per member so repeated access
  * stays cheap; non-function members (typed-array heap views, etc.) pass through
- * unchanged. The dedicated realtime `sonare-rt` module is separate and is not
- * affected by this wrapper.
+ * unchanged.
  */
 function wrapModuleErrors(raw: SonareModule): SonareModule {
   const cache = new Map<PropertyKey, unknown>();