@libraz/libsonare 1.2.3 → 1.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@libraz/libsonare",
-  "version": "1.2.3",
+  "version": "1.3.1",
   "type": "module",
   "packageManager": "yarn@4.15.0",
   "description": "Audio analysis library for music information retrieval",
@@ -32,6 +32,7 @@
     "build": "yarn build:js && yarn build:wasm",
     "build:wasm": "mkdir -p build-wasm/em-cache && EM_CACHE=$PWD/build-wasm/em-cache emcmake cmake -S ../.. -B build-wasm -DBUILD_WASM=ON -DBUILD_MASTERING=ON -DCMAKE_BUILD_TYPE=Release && EM_CACHE=$PWD/build-wasm/em-cache cmake --build build-wasm && node scripts/write-rt-module-variant.mjs",
     "bench:wasm:isp": "mkdir -p build-wasm-bench/em-cache /tmp/libsonare-wasm-bench && EM_CACHE=$PWD/build-wasm-bench/em-cache emcmake cmake -S ../.. -B build-wasm-bench -DBUILD_WASM=ON -DBUILD_MASTERING=ON -DBUILD_BENCH=ON -DBUILD_TESTING=OFF -DBUILD_CLI=OFF -DCMAKE_BUILD_TYPE=Release && EM_CACHE=$PWD/build-wasm-bench/em-cache cmake --build build-wasm-bench --target sonare_mastering_isp_bench && cp build-wasm-bench/bin/sonare_mastering_isp_bench.js /tmp/libsonare-wasm-bench/sonare_mastering_isp_bench.cjs && cp build-wasm-bench/bin/sonare_mastering_isp_bench.wasm /tmp/libsonare-wasm-bench/sonare_mastering_isp_bench.wasm && node /tmp/libsonare-wasm-bench/sonare_mastering_isp_bench.cjs",
+    "bench:wasm:phase-vocoder": "mkdir -p build-wasm-bench/em-cache /tmp/libsonare-wasm-bench && EM_CACHE=$PWD/build-wasm-bench/em-cache emcmake cmake -S ../.. -B build-wasm-bench -DBUILD_WASM=ON -DBUILD_BENCH=ON -DBUILD_TESTING=OFF -DBUILD_CLI=OFF -DCMAKE_BUILD_TYPE=Release && EM_CACHE=$PWD/build-wasm-bench/em-cache cmake --build build-wasm-bench --target sonare_phase_vocoder_streaming_bench && cp build-wasm-bench/bin/sonare_phase_vocoder_streaming_bench.js /tmp/libsonare-wasm-bench/sonare_phase_vocoder_streaming_bench.cjs && cp build-wasm-bench/bin/sonare_phase_vocoder_streaming_bench.wasm /tmp/libsonare-wasm-bench/sonare_phase_vocoder_streaming_bench.wasm && node /tmp/libsonare-wasm-bench/sonare_phase_vocoder_streaming_bench.cjs",
     "build:js": "find dist -maxdepth 1 -type f \\( -name 'chunk-*.js' -o -name 'chunk-*.js.map' -o -name '*-*.d.ts' \\) -delete 2>/dev/null; tsup",
     "clean": "rm -rf dist build-wasm LICENSE",
     "lint": "biome check src/ tests/",

package/src/analysis_helpers.ts

@@ -0,0 +1,152 @@
+import type {
+  AnalysisResult,
+  ChordAnalysisResult,
+  ChordDetectionOptions,
+  ChordQuality,
+  KeyCandidate,
+  KeyDetectionOptions,
+  KeyProfileName,
+  PitchClass,
+  SectionType,
+} from './public_types';
+import { KeyProfile as KeyProfileValues, Mode } from './public_types';
+import type {
+  WasmAnalysisResult,
+  WasmChordAnalysisResult,
+  WasmKeyCandidateResult,
+} from './sonare.js';
+
+export function convertKeyCandidate(wasm: WasmKeyCandidateResult): KeyCandidate {
+  return {
+    key: {
+      root: wasm.key.root as PitchClass,
+      mode: wasm.key.mode as Mode,
+      confidence: wasm.key.confidence,
+      name: wasm.key.name,
+      shortName: wasm.key.shortName,
+    },
+    correlation: wasm.correlation,
+  };
+}
+
+export function keyModeValues(modes: KeyDetectionOptions['modes'] | undefined): number[] {
+  if (!modes) {
+    return [];
+  }
+  if (modes === 'major-minor') {
+    return [Mode.Major, Mode.Minor];
+  }
+  if (modes === 'all' || modes === 'modal') {
+    return [
+      Mode.Major,
+      Mode.Minor,
+      Mode.Dorian,
+      Mode.Phrygian,
+      Mode.Lydian,
+      Mode.Mixolydian,
+      Mode.Locrian,
+    ];
+  }
+  const names = {
+    major: Mode.Major,
+    minor: Mode.Minor,
+    dorian: Mode.Dorian,
+    phrygian: Mode.Phrygian,
+    lydian: Mode.Lydian,
+    mixolydian: Mode.Mixolydian,
+    locrian: Mode.Locrian,
+  } as const;
+  return modes.map((mode) => (typeof mode === 'number' ? mode : names[mode]));
+}
+
+export function keyProfileValue(profile: KeyDetectionOptions['profile'] | undefined): number {
+  if (profile === undefined) {
+    return -1;
+  }
+  if (typeof profile === 'number') {
+    return profile;
+  }
+  const names: Record<KeyProfileName, number> = {
+    ks: KeyProfileValues.KrumhanslSchmuckler,
+    krumhansl: KeyProfileValues.KrumhanslSchmuckler,
+    temperley: KeyProfileValues.Temperley,
+    shaath: KeyProfileValues.Shaath,
+    keyfinder: KeyProfileValues.Shaath,
+    'faraldo-edmt': KeyProfileValues.FaraldoEDMT,
+    edmt: KeyProfileValues.FaraldoEDMT,
+    'faraldo-edma': KeyProfileValues.FaraldoEDMA,
+    edma: KeyProfileValues.FaraldoEDMA,
+    'faraldo-edmm': KeyProfileValues.FaraldoEDMM,
+    edmm: KeyProfileValues.FaraldoEDMM,
+    'bellman-budge': KeyProfileValues.BellmanBudge,
+    bellman: KeyProfileValues.BellmanBudge,
+  };
+  return names[profile];
+}
+
+export function convertChordAnalysisResult(wasm: WasmChordAnalysisResult): ChordAnalysisResult {
+  return {
+    chords: wasm.chords.map((c) => ({
+      root: c.root as PitchClass,
+      bass: c.bass as PitchClass,
+      quality: c.quality as ChordQuality,
+      start: c.start,
+      end: c.end,
+      confidence: c.confidence,
+      name: c.name,
+    })),
+  };
+}
+
+export function chordChromaMethodValue(method: ChordDetectionOptions['chromaMethod']): number {
+  if (method === 'stft') {
+    return 0;
+  }
+  if (method === 'nnls') {
+    return 1;
+  }
+  throw new Error(`Invalid chord chroma method: ${method}`);
+}
+
+export function convertAnalysisResult(wasm: WasmAnalysisResult): AnalysisResult {
+  const beatTimes = new Float32Array(wasm.beats.length);
+  for (let i = 0; i < wasm.beats.length; i++) {
+    beatTimes[i] = wasm.beats[i].time;
+  }
+  return {
+    bpm: wasm.bpm,
+    bpmConfidence: wasm.bpmConfidence,
+    key: {
+      root: wasm.key.root as PitchClass,
+      mode: wasm.key.mode as Mode,
+      confidence: wasm.key.confidence,
+      name: wasm.key.name,
+      shortName: wasm.key.shortName,
+    },
+    timeSignature: wasm.timeSignature,
+    beatTimes,
+    beats: wasm.beats,
+    chords: wasm.chords.map((c) => ({
+      root: c.root as PitchClass,
+      bass: c.bass as PitchClass,
+      quality: c.quality as ChordQuality,
+      start: c.start,
+      end: c.end,
+      confidence: c.confidence,
+      name: c.name,
+    })),
+    sections: wasm.sections.map((s) => ({
+      type: s.type as SectionType,
+      start: s.start,
+      end: s.end,
+      energyLevel: s.energyLevel,
+      confidence: s.confidence,
+      name: s.name,
+    })),
+    timbre: wasm.timbre,
+    dynamics: wasm.dynamics,
+    rhythm: wasm.rhythm,
+    melody: wasm.melody,
+    form: wasm.form,
+  };
+}

package/src/audio.ts

@@ -0,0 +1,493 @@
+import type { VoiceChangeOptions } from './effects_mastering';
+import {
+  harmonic,
+  hpss,
+  masterAudio,
+  mastering,
+  masteringChain,
+  masteringProcess,
+  normalize,
+  noteStretch,
+  percussive,
+  pitchCorrectToMidi,
+  pitchShift,
+  timeStretch,
+  voiceChange,
+} from './effects_mastering';
+import {
+  chroma,
+  lufs,
+  melSpectrogram,
+  mfcc,
+  momentaryLufs,
+  nnlsChroma,
+  onsetEnvelope,
+  pitchPyin,
+  pitchYin,
+  resample,
+  rmsEnergy,
+  shortTermLufs,
+  spectralBandwidth,
+  spectralCentroid,
+  spectralFlatness,
+  spectralRolloff,
+  stft,
+  stftDb,
+  trim,
+  zeroCrossingRate,
+} from './features';
+import { getSonareModule } from './module_state';
+import type {
+  AnalysisResult,
+  ChordAnalysisResult,
+  ChordDetectionOptions,
+  ChromaResult,
+  HpssResult,
+  Key,
+  KeyCandidate,
+  KeyDetectionOptions,
+  LufsResult,
+  MasteringChainConfig,
+  MasteringChainResult,
+  MasteringOptions,
+  MasteringPreset,
+  MasteringProcessorParams,
+  MasteringResult,
+  MelSpectrogramResult,
+  MfccResult,
+  Mode,
+  NoteStretchOptions,
+  PitchClass,
+  PitchResult,
+  SoloProcessor,
+  StftResult,
+} from './public_types';
+import {
+  analyze,
+  analyzeWithProgress,
+  chordFunctionalAnalysis,
+  detectBeats,
+  detectBpm,
+  detectChords,
+  detectDownbeats,
+  detectKey,
+  detectKeyCandidates,
+  detectOnsets,
+} from './quick_analysis';
+import type { ProgressCallback, WasmNnlsChromaResult } from './sonare.js';
+
+// ============================================================================
+// Audio Class
+// ============================================================================
+
+type BrowserDecodeContext = Pick<BaseAudioContext, 'decodeAudioData' | 'sampleRate'>;
+
+export interface BrowserAudioDecodeOptions {
+  /**
+   * AudioContext/OfflineAudioContext used for browser codec fallback. Its
+   * `sampleRate` becomes the returned Audio sample rate.
+   */
+  audioContext?: BrowserDecodeContext;
+  /**
+   * Factory used when `audioContext` is omitted. `targetSampleRate` is passed
+   * through so browsers that honor AudioContextOptions decode directly at that
+   * rate.
+   */
+  createAudioContext?: (options?: AudioContextOptions) => BrowserDecodeContext;
+  /**
+   * Requested fallback decode rate when this helper creates the context. If the
+   * browser ignores it or a context is supplied, no extra resampling is applied.
+   */
+  targetSampleRate?: number;
+}
+
+function encodedBytesToArrayBuffer(bytes: Uint8Array): ArrayBuffer {
+  const copy = new Uint8Array(bytes.byteLength);
+  copy.set(bytes);
+  return copy.buffer;
+}
+
+function getBrowserAudioContextFactory():
+  | ((options?: AudioContextOptions) => BrowserDecodeContext)
+  | undefined {
+  const root = globalThis as typeof globalThis & {
+    AudioContext?: new (options?: AudioContextOptions) => BaseAudioContext;
+    webkitAudioContext?: new (options?: AudioContextOptions) => BaseAudioContext;
+  };
+  const Ctor = root.AudioContext ?? root.webkitAudioContext;
+  return Ctor ? (options?: AudioContextOptions) => new Ctor(options) : undefined;
+}
+
+function audioBufferToMono(buffer: AudioBuffer): Float32Array {
+  const samples = new Float32Array(buffer.length);
+  if (buffer.numberOfChannels <= 0) {
+    return samples;
+  }
+  if (buffer.numberOfChannels === 1) {
+    samples.set(buffer.getChannelData(0));
+    return samples;
+  }
+  for (let channel = 0; channel < buffer.numberOfChannels; channel++) {
+    const data = buffer.getChannelData(channel);
+    for (let i = 0; i < buffer.length; i++) {
+      samples[i] += data[i] / buffer.numberOfChannels;
+    }
+  }
+  return samples;
+}
+
+async function closeCreatedContext(context: BrowserDecodeContext): Promise<void> {
+  const maybeClosable = context as BrowserDecodeContext & { close?: () => Promise<void> };
+  if (maybeClosable.close) {
+    await maybeClosable.close();
+  }
+}
+
+/**
+ * Wrapper around audio data that exposes all analysis and feature functions as instance methods.
+ *
+ * @example
+ * ```typescript
+ * import { init, Audio } from '@libraz/libsonare';
+ *
+ * await init();
+ *
+ * const audio = Audio.fromBuffer(samples, 44100);
+ * console.log('BPM:', audio.detectBpm());
+ * console.log('Key:', audio.detectKey().name);
+ *
+ * const mel = audio.melSpectrogram();
+ * ```
+ */
+export class Audio {
+  private _samples: Float32Array;
+  private _sampleRate: number;
+
+  private constructor(samples: Float32Array, sampleRate: number) {
+    this._samples = samples;
+    this._sampleRate = sampleRate;
+  }
+
+  /**
+   * Create an Audio instance from raw sample data.
+   *
+   * @param samples - Mono float samples.
+   * @param sampleRate - Sample rate in Hz (default `48000`, matching the
+   *   Node/Python surfaces).
+   */
+  static fromBuffer(samples: Float32Array, sampleRate = 48000): Audio {
+    return new Audio(samples, sampleRate);
+  }
+
+  /**
+   * Create an Audio instance by decoding audio bytes in memory.
+   *
+   * @param bytes - Encoded audio bytes such as WAV or MP3.
+   */
+  static fromMemory(bytes: Uint8Array): Audio {
+    const decoded = getSonareModule().audioFromMemory(bytes);
+    return new Audio(decoded.samples, decoded.sampleRate);
+  }
+
+  /**
+   * Decode audio bytes with the native WASM decoder first, then fall back to the
+   * browser codec stack (`AudioContext.decodeAudioData`) for formats such as
+   * AAC, OGG, and FLAC when available. Browser-decoded multi-channel audio is
+   * mixed down to mono to match the `Audio` wrapper contract.
+   */
+  static async fromMemoryWithBrowserFallback(
+    bytes: Uint8Array,
+    options: BrowserAudioDecodeOptions = {},
+  ): Promise<Audio> {
+    try {
+      return Audio.fromMemory(bytes);
+    } catch (nativeError) {
+      let createdContext = false;
+      const contextFactory = options.createAudioContext ?? getBrowserAudioContextFactory();
+      const context =
+        options.audioContext ??
+        contextFactory?.(
+          options.targetSampleRate ? { sampleRate: options.targetSampleRate } : undefined,
+        );
+
+      if (!context) {
+        throw new Error(
+          `Audio.fromMemory failed and browser decodeAudioData is unavailable: ${
+            nativeError instanceof Error ? nativeError.message : String(nativeError)
+          }`,
+        );
+      }
+
+      createdContext = !options.audioContext;
+      try {
+        const decoded = await context.decodeAudioData(encodedBytesToArrayBuffer(bytes));
+        return new Audio(audioBufferToMono(decoded), decoded.sampleRate || context.sampleRate);
+      } catch (fallbackError) {
+        throw new Error(
+          `Audio.fromMemory failed and browser decodeAudioData fallback failed: ${
+            fallbackError instanceof Error ? fallbackError.message : String(fallbackError)
+          }`,
+        );
+      } finally {
+        if (createdContext) {
+          await closeCreatedContext(context);
+        }
+      }
+    }
+  }
+
+  /** The raw audio samples. */
+  get data(): Float32Array {
+    return this._samples;
+  }
+
+  /** Number of samples. */
+  get length(): number {
+    return this._samples.length;
+  }
+
+  /** Sample rate in Hz. */
+  get sampleRate(): number {
+    return this._sampleRate;
+  }
+
+  /** Duration in seconds. */
+  get duration(): number {
+    return this._samples.length / this._sampleRate;
+  }
+
+  // -- Analysis --
+
+  detectBpm(): number {
+    return detectBpm(this._samples, this._sampleRate);
+  }
+
+  detectKey(options: KeyDetectionOptions = {}): Key {
+    return detectKey(this._samples, this._sampleRate, options);
+  }
+
+  detectKeyCandidates(options: KeyDetectionOptions = {}): KeyCandidate[] {
+    return detectKeyCandidates(this._samples, this._sampleRate, options);
+  }
+
+  detectOnsets(): Float32Array {
+    return detectOnsets(this._samples, this._sampleRate);
+  }
+
+  detectBeats(): Float32Array {
+    return detectBeats(this._samples, this._sampleRate);
+  }
+
+  detectDownbeats(): Float32Array {
+    return detectDownbeats(this._samples, this._sampleRate);
+  }
+
+  detectChords(options: ChordDetectionOptions = {}): ChordAnalysisResult {
+    return detectChords(this._samples, this._sampleRate, options);
+  }
+
+  chordFunctionalAnalysis(
+    keyRoot: PitchClass,
+    keyMode: Mode,
+    options: ChordDetectionOptions = {},
+  ): string[] {
+    return chordFunctionalAnalysis(this._samples, keyRoot, keyMode, this._sampleRate, options);
+  }
+
+  analyze(): AnalysisResult {
+    return analyze(this._samples, this._sampleRate);
+  }
+
+  analyzeWithProgress(onProgress: ProgressCallback): AnalysisResult {
+    return analyzeWithProgress(this._samples, this._sampleRate, onProgress);
+  }
+
+  // -- Effects --
+
+  hpss(kernelHarmonic = 31, kernelPercussive = 31): HpssResult {
+    return hpss(this._samples, this._sampleRate, kernelHarmonic, kernelPercussive);
+  }
+
+  harmonic(): Float32Array {
+    return harmonic(this._samples, this._sampleRate);
+  }
+
+  percussive(): Float32Array {
+    return percussive(this._samples, this._sampleRate);
+  }
+
+  timeStretch(rate: number): Float32Array {
+    return timeStretch(this._samples, this._sampleRate, rate);
+  }
+
+  pitchShift(semitones: number): Float32Array {
+    return pitchShift(this._samples, this._sampleRate, semitones);
+  }
+
+  pitchCorrectToMidi(currentMidi = 69.0, targetMidi = 69.0): Float32Array {
+    return pitchCorrectToMidi(this._samples, this._sampleRate, currentMidi, targetMidi);
+  }
+
+  noteStretch(options: NoteStretchOptions = {}): Float32Array {
+    return noteStretch(this._samples, this._sampleRate, options);
+  }
+
+  voiceChange(options: VoiceChangeOptions = {}): Float32Array {
+    return voiceChange(this._samples, this._sampleRate, options);
+  }
+
+  normalize(targetDb = 0.0): Float32Array {
+    return normalize(this._samples, this._sampleRate, targetDb);
+  }
+
+  mastering(options: MasteringOptions = {}): MasteringResult {
+    return mastering(this._samples, this._sampleRate, options);
+  }
+
+  masteringChain(config: MasteringChainConfig): MasteringChainResult {
+    return masteringChain(this._samples, this._sampleRate, config);
+  }
+
+  masterAudio(
+    presetName: MasteringPreset = 'pop',
+    overrides: Record<string, number | boolean> | null = null,
+  ): MasteringChainResult {
+    return masterAudio(this._samples, this._sampleRate, presetName, overrides ?? {});
+  }
+
+  masteringProcess(
+    processorName: SoloProcessor,
+    params: MasteringProcessorParams = {},
+  ): MasteringResult {
+    return masteringProcess(processorName, this._samples, this._sampleRate, params);
+  }
+
+  trim(thresholdDb = -60.0): Float32Array {
+    return trim(this._samples, this._sampleRate, thresholdDb);
+  }
+
+  // -- Features --
+
+  stft(nFft = 2048, hopLength = 512): StftResult {
+    return stft(this._samples, this._sampleRate, nFft, hopLength);
+  }
+
+  stftDb(nFft = 2048, hopLength = 512): { nBins: number; nFrames: number; db: Float32Array } {
+    return stftDb(this._samples, this._sampleRate, nFft, hopLength);
+  }
+
+  melSpectrogram(
+    nFft = 2048,
+    hopLength = 512,
+    nMels = 128,
+    fmin = 0,
+    fmax = 0,
+    htk = false,
+  ): MelSpectrogramResult {
+    return melSpectrogram(this._samples, this._sampleRate, nFft, hopLength, nMels, fmin, fmax, htk);
+  }
+
+  mfcc(
+    nFft = 2048,
+    hopLength = 512,
+    nMels = 128,
+    nMfcc = 20,
+    fmin = 0,
+    fmax = 0,
+    htk = false,
+  ): MfccResult {
+    return mfcc(this._samples, this._sampleRate, nFft, hopLength, nMels, nMfcc, fmin, fmax, htk);
+  }
+
+  chroma(nFft = 2048, hopLength = 512): ChromaResult {
+    return chroma(this._samples, this._sampleRate, nFft, hopLength);
+  }
+
+  nnlsChroma(): WasmNnlsChromaResult {
+    return nnlsChroma(this._samples, this._sampleRate);
+  }
+
+  onsetEnvelope(nFft = 2048, hopLength = 512, nMels = 128): Float32Array {
+    return onsetEnvelope(this._samples, this._sampleRate, nFft, hopLength, nMels);
+  }
+
+  lufs(): LufsResult {
+    return lufs(this._samples, this._sampleRate);
+  }
+
+  momentaryLufs(): Float32Array {
+    return momentaryLufs(this._samples, this._sampleRate);
+  }
+
+  shortTermLufs(): Float32Array {
+    return shortTermLufs(this._samples, this._sampleRate);
+  }
+
+  spectralCentroid(nFft = 2048, hopLength = 512): Float32Array {
+    return spectralCentroid(this._samples, this._sampleRate, nFft, hopLength);
+  }
+
+  spectralBandwidth(nFft = 2048, hopLength = 512): Float32Array {
+    return spectralBandwidth(this._samples, this._sampleRate, nFft, hopLength);
+  }
+
+  spectralRolloff(nFft = 2048, hopLength = 512, rollPercent = 0.85): Float32Array {
+    return spectralRolloff(this._samples, this._sampleRate, nFft, hopLength, rollPercent);
+  }
+
+  spectralFlatness(nFft = 2048, hopLength = 512): Float32Array {
+    return spectralFlatness(this._samples, this._sampleRate, nFft, hopLength);
+  }
+
+  zeroCrossingRate(frameLength = 2048, hopLength = 512): Float32Array {
+    return zeroCrossingRate(this._samples, this._sampleRate, frameLength, hopLength);
+  }
+
+  rmsEnergy(frameLength = 2048, hopLength = 512): Float32Array {
+    return rmsEnergy(this._samples, this._sampleRate, frameLength, hopLength);
+  }
+
+  pitchYin(
+    frameLength = 2048,
+    hopLength = 512,
+    fmin = 65.0,
+    fmax = 2093.0,
+    threshold = 0.3,
+    fillNa = false,
+  ): PitchResult {
+    return pitchYin(
+      this._samples,
+      this._sampleRate,
+      frameLength,
+      hopLength,
+      fmin,
+      fmax,
+      threshold,
+      fillNa,
+    );
+  }
+
+  pitchPyin(
+    frameLength = 2048,
+    hopLength = 512,
+    fmin = 65.0,
+    fmax = 2093.0,
+    threshold = 0.3,
+    fillNa = false,
+  ): PitchResult {
+    return pitchPyin(
+      this._samples,
+      this._sampleRate,
+      frameLength,
+      hopLength,
+      fmin,
+      fmax,
+      threshold,
+      fillNa,
+    );
+  }
+
+  resample(targetSr: number): Float32Array {
+    return resample(this._samples, this._sampleRate, targetSr);
+  }
+}

package/src/codes.ts

@@ -0,0 +1,56 @@
+import type { AutomationCurve, MeterTap, PanLaw, PanMode, SendTiming } from './public_types';
+
+export function automationCurveCode(curve: AutomationCurve): number {
+  switch (curve) {
+    case 'linear':
+      return 0;
+    case 'exponential':
+      return 1;
+    case 'hold':
+      return 2;
+    case 's-curve':
+      return 3;
+    default:
+      throw new Error(`Invalid automation curve: ${curve}`);
+  }
+}
+
+export function panLawCode(panLaw: PanLaw | number): number {
+  if (typeof panLaw === 'number') {
+    return panLaw;
+  }
+  switch (panLaw) {
+    case 'const4.5dB':
+      return 1;
+    case 'const6dB':
+      return 2;
+    case 'linear0dB':
+      return 3;
+    default:
+      return 0;
+  }
+}
+
+export function panModeCode(panMode: PanMode | number): number {
+  if (typeof panMode === 'number') {
+    return panMode;
+  }
+  switch (panMode) {
+    case 'stereoPan':
+    case 'stereo-pan':
+      return 1;
+    case 'dualPan':
+    case 'dual-pan':
+      return 2;
+    default:
+      return 0;
+  }
+}
+
+export function meterTapCode(tap: MeterTap | number): number {
+  return tap === 'preFader' || tap === 0 ? 0 : 1;
+}
+
+export function sendTimingCode(timing: SendTiming | number): number {
+  return timing === 'preFader' || timing === 0 ? 0 : 1;
+}