@hraness/dawg 0.6.0 → 0.7.0

package/src/audio/sampler.ts

@@ -32,6 +32,7 @@ import {
   type TrackScore,
 } from "../../core/score.ts";
 import { sampleKey, type DecodedSample, type SampleBank } from "./samples.ts";
+import { seedHash } from "./dsp/rng.ts";
 import {
   barAt,
   loopSecondsOf,
@@ -46,7 +47,8 @@ import {
   type FitMap,
   type SampleWarp,
 } from "./warp.ts";
-import { fittedBuffer, windowAt } from "./fit.ts";
+import { fittedBuffer, shiftedBuffer, windowAt } from "./fit.ts";
+import { autotuneVoice } from "./autotune.ts";
 import {
   performanceTimingFor,
   tunedTiming,
@@ -106,6 +108,10 @@ export type SamplerVoice = {
   readonly cents?: NotePerformance["cents"];
   /** Half pedal: the level fades from `from` seconds. */
   readonly damp?: NotePerformance["damp"];
+  /** `fadeInTime` in output frames (0.6.1); absent is the 1 ms anti-click. */
+  readonly attack?: number;
+  /** A resampled stereo file (0.6.1): plays its own left and right. */
+  readonly stereo?: boolean;
 };
 
 /**
@@ -160,38 +166,111 @@ function noteLengthFrames(note: Note, timing: SamplerTiming): number {
 function voiceResolver(
   track: Track,
   tuning?: TuningTable,
-): (pitch: number) => { voice: string; ratio: number } | undefined {
+): (
+  pitch: number,
+  velocity: number,
+) => { voice: string; ratio: number } | undefined {
   const sampler = track.sampler!;
+  const pick = layerPicker(
+    track.id,
+    sampler.voices,
+    sampler.mode === "oneshot",
+  );
   if (sampler.mode === "oneshot") {
     const byPitch = new Map<number, string>();
     for (const [voice, slot] of samplerVoiceSlots(sampler))
       byPitch.set(slot, voice);
-    return (pitch) => {
-      const voice = byPitch.get(pitch);
+    return (pitch, velocity) => {
+      const slotted = byPitch.get(pitch);
+      if (slotted === undefined) return undefined;
+      const voice = pick(slotted, velocity);
       return voice === undefined ? undefined : { voice, ratio: 1 };
     };
   }
   // Keyed: the voice whose root is the highest at or below the pitch (a
-  // multi-sampled instrument), else the lowest root.
+  // multi-sampled instrument), else the lowest root. With velocity layers
+  // only the voices whose `vel` holds the note's velocity take part.
   const keyed = Object.entries(sampler.voices)
-    .map(([voice, ref]) => ({ voice, root: ref.root ?? 60 }))
+    .map(([voice, ref]) => ({ voice, root: ref.root ?? 60, vel: ref.vel }))
     .sort((a, b) => a.root - b.root || (a.voice < b.voice ? -1 : 1));
-  return (pitch) => {
-    let chosen = keyed[0];
-    for (const candidate of keyed)
-      if (candidate.root <= pitch) chosen = candidate;
+  return (pitch, velocity) => {
+    let chosen: (typeof keyed)[number] | undefined;
+    for (const candidate of keyed) {
+      if (!inLayer(candidate.vel, velocity)) continue;
+      if (chosen === undefined || candidate.root <= pitch) chosen = candidate;
+    }
     if (!chosen) return undefined;
-    if (!tuning)
-      return { voice: chosen.voice, ratio: 2 ** ((pitch - chosen.root) / 12) };
+    const voice = pick(chosen.voice, velocity) ?? chosen.voice;
+    if (!tuning) return { voice, ratio: 2 ** ((pitch - chosen.root) / 12) };
     const hz = tuning.hz[pitch]!;
     if (!(hz > 0)) return undefined;
     return {
-      voice: chosen.voice,
+      voice,
       ratio: hz / (440 * 2 ** ((chosen.root - 69) / 12)),
     };
   };
 }
 
+/** MIDI velocity (0..127) of a note velocity 0..1. */
+export function midiVelocity(velocity: number): number {
+  return Math.max(0, Math.min(127, Math.round(velocity * 127)));
+}
+
+function inLayer(
+  vel: readonly [number, number] | undefined,
+  velocity: number,
+): boolean {
+  if (!vel) return true;
+  const v = midiVelocity(velocity);
+  return v >= vel[0] && v <= vel[1];
+}
+
+/**
+ * Velocity layers and round robin (0.6.1, SFZ lovel/hivel and seq_length).
+ * A voice with `rr` stands for its whole group: of the group's voices that
+ * hold the note's velocity (and, keyed, share its root) the next one in
+ * name order plays. When no layer of the group holds the velocity, the
+ * nearest layer plays rather than nothing. Each group keeps its own
+ * counter in note order, starting at a turn seeded by the track id and
+ * the group, so a render is deterministic (A B A B) while two tracks
+ * with the same samples need not alternate in lockstep. A keyed voice
+ * without `rr` plays itself when its `vel` holds the velocity, else
+ * nothing; a one-shot voice without `rr` (its own pad) always plays.
+ */
+function layerPicker(
+  trackId: string,
+  voices: Readonly<Record<string, SampleRef>>,
+  oneshot: boolean,
+): (voice: string, velocity: number) => string | undefined {
+  const counters = new Map<string, number>();
+  const names = Object.keys(voices).sort();
+  return (voice, velocity) => {
+    const ref = voices[voice]!;
+    if (ref.rr === undefined)
+      return oneshot || inLayer(ref.vel, velocity) ? voice : undefined;
+    const members = names.filter((name) => {
+      const other = voices[name]!;
+      return other.rr === ref.rr && (other.root ?? 60) === (ref.root ?? 60);
+    });
+    let group = members.filter((name) => inLayer(voices[name]!.vel, velocity));
+    if (group.length === 0) {
+      const v = midiVelocity(velocity);
+      const gap = (name: string) => {
+        const vel = voices[name]!.vel!;
+        return v < vel[0] ? vel[0] - v : v - vel[1];
+      };
+      const nearest = Math.min(...members.map(gap));
+      group = members.filter((name) => gap(name) === nearest);
+    }
+    if (group.length === 0) return undefined;
+    const key = `${ref.rr}:${ref.root ?? 60}:${group.join(",")}`;
+    const turn =
+      counters.get(key) ?? seedHash(`${trackId}:${key}`) % group.length;
+    counters.set(key, turn + 1);
+    return group[turn % group.length];
+  };
+}
+
 /** Plans every voice a sampler track plays, with choke and polyphony applied. */
 export function planSamplerVoices(
   track: Track,
@@ -224,7 +303,7 @@ export function planSamplerVoices(
     voice.fade = Math.min(fade, end - voice.start);
   };
   for (const note of ordered) {
-    const resolved = resolve(note.pitch);
+    const resolved = resolve(note.pitch, note.velocity);
     if (!resolved) continue;
     // A note's cents repitch every voice, keyed or one-shot.
     const target = note.cents
@@ -256,8 +335,19 @@ export function planSamplerVoices(
       ? fitVoice(ref, decoded, note.startTick, held, timing, reach)
       : undefined;
     if (fitted === null) continue;
-    const sample = fitted?.sample ?? decoded;
-    const speed = fitted ? 1 : (ref.speed ?? 1);
+    // 0.6.1 `shift`/`formant`: a cached constant-length pitch shift of the
+    // played buffer (after any fit, so it follows fitmode).
+    const shifted = isShifted(ref)
+      ? shiftVoice(ref, fitted?.sample ?? decoded, fitted ? "fit" : "raw")
+      : undefined;
+    const sample = shifted ?? fitted?.sample ?? decoded;
+    // Live, until the cached shift is ready: a plain repitch at the shifted
+    // pitch (the length follows, like tape).
+    const repitch =
+      shifted === undefined && isShifted(ref)
+        ? 2 ** ((ref.shift ?? 0) / 12)
+        : 1;
+    const speed = fitted ? repitch : (ref.speed ?? 1) * repitch;
     const regionStart = fitted ? 0 : (ref.begin ?? 0) * sample.frames;
     const regionEnd = fitted ? sample.frames : (ref.end ?? 1) * sample.frames;
     // `fit`, `unit: "c"` and `unit: "s"` give the window a duration; the
@@ -277,7 +367,14 @@ export function planSamplerVoices(
         ? ((Math.abs(speed) * sample.sampleRate) / sampleRate) * target.ratio
         : ((regionEnd - regionStart) / (seconds * sampleRate)) * target.ratio;
     const natural = Math.max(1, Math.floor((regionEnd - regionStart) / step));
-    const release = Math.max(1, Math.round(RELEASE_SECONDS * sampleRate));
+    const release = Math.max(
+      1,
+      Math.round((ref.fadeTime ?? RELEASE_SECONDS) * sampleRate),
+    );
+    const endFade = Math.max(
+      1,
+      Math.round((ref.fadeTime ?? END_FADE_SECONDS) * sampleRate),
+    );
     const loop = ref.loop === true;
     const clipped =
       ref.clip === undefined ? held : Math.max(1, Math.floor(held * ref.clip));
@@ -294,7 +391,7 @@ export function planSamplerVoices(
       fade = release;
     } else {
       length = natural;
-      fade = Math.max(1, Math.round(END_FADE_SECONDS * sampleRate));
+      fade = endFade;
     }
     // accelerate: the rate ramps by `accelerate`× over the planned length;
     // a non-looping voice ends where the ramped read runs out (or stops).
@@ -308,7 +405,7 @@ export function planSamplerVoices(
       const until = Math.max(1, Math.floor(reach));
       if (until < length) {
         length = until;
-        fade = Math.max(1, Math.round(END_FADE_SECONDS * sampleRate));
+        fade = endFade;
       }
     }
     const loopFrom = fitted
@@ -323,9 +420,36 @@ export function planSamplerVoices(
         : ref.loopEnd * sample.frames;
     const start = noteStartFrame(note, timing);
     const performance = (note as PerformedNote).performance;
+    // 0.7 autotune: the played buffer (after fit and shift) retuned at the
+    // pitch and place it sounds; same length, so the plan above holds.
+    // Reversed voices play untuned. Absent `autotune` skips this.
+    // Timed targets tune only the frames this voice can read.
+    const reads =
+      loop || ramp !== 0 || performance?.cents
+        ? {
+            from: Math.min(regionStart, loopFrom),
+            to: Math.max(regionEnd, loopTo),
+          }
+        : {
+            from: regionStart,
+            to: Math.min(regionEnd, regionStart + length * step + 2),
+          };
+    const tuned =
+      track.autotune && speed > 0
+        ? autotuneSample(
+            timing,
+            track,
+            sample,
+            sample === decoded,
+            start,
+            regionStart,
+            step,
+            reads,
+          )
+        : { sample, from: 0 };
     const voice: SamplerVoice = {
       voice: target.voice,
-      sample,
+      sample: tuned.sample,
       startTick: note.startTick,
       start,
       end: start + length,
@@ -333,14 +457,20 @@ export function planSamplerVoices(
       step,
       reverse: speed < 0,
       loop,
-      regionStart,
-      regionEnd,
+      regionStart: regionStart - tuned.from,
+      regionEnd: regionEnd - tuned.from,
       gain: (ref.gain ?? 1) * Math.max(0, Math.min(1, note.velocity)),
       choke: ref.choke,
       loopStart: speed < 0 ? regionEnd - loopTo : loopFrom - regionStart,
       loopSpan: loopTo - loopFrom,
       ramp,
       squiz: ref.squiz ?? 1,
+      ...(ref.fadeInTime !== undefined
+        ? { attack: Math.max(1, ref.fadeInTime * sampleRate) }
+        : {}),
+      ...(ref.from !== undefined && tuned.sample.left && tuned.sample.right
+        ? { stereo: true }
+        : {}),
       ...(performance?.cents ? { cents: performance.cents } : {}),
       ...(performance?.damp ? { damp: performance.damp } : {}),
     };
@@ -433,6 +563,7 @@ function fitVoice(
     length,
   );
   if (!buffer) return null;
+  audioIds.set(buffer, key);
   const sample: DecodedSample = Object.freeze({
     sha256: decoded.sha256,
     sampleRate,
@@ -456,6 +587,100 @@ function fitVoice(
   });
 }
 
+/**
+ * The voice's sample retuned by the track's autotune (0.7), and the source
+ * frame its first frame came from (timed targets tune only `reads`). A
+ * shifted or fitted buffer keeps the file's sha256 but not its audio, so
+ * it is named by its own shift or fit key (`audioIds`).
+ */
+function autotuneSample(
+  timing: SamplerTiming,
+  track: Track,
+  sample: DecodedSample,
+  decoded: boolean,
+  start: number,
+  regionStart: number,
+  step: number,
+  reads: Readonly<{ from: number; to: number }>,
+): Readonly<{ sample: DecodedSample; from: number }> {
+  const id = decoded ? undefined : audioIds.get(sample.mono);
+  const tuned = autotuneVoice(
+    timing.score,
+    track,
+    {
+      ...(id !== undefined ? { id } : decoded ? { sha256: sample.sha256 } : {}),
+      sampleRate: sample.sampleRate,
+      mono: sample.mono,
+      // A shifted or fitted copy keeps the file's channels unshifted:
+      // only the decoded file tunes in stereo.
+      ...(decoded && sample.left && sample.right
+        ? { left: sample.left, right: sample.right }
+        : {}),
+    },
+    start / timing.sampleRate,
+    regionStart,
+    (step * timing.sampleRate) / sample.sampleRate,
+    reads,
+  );
+  if (tuned.mono === sample.mono) return { sample, from: 0 };
+  return {
+    sample: Object.freeze({
+      ...sample,
+      frames: tuned.mono.length,
+      mono: tuned.mono,
+      left: tuned.left,
+      right: tuned.right,
+    }),
+    from: tuned.from,
+  };
+}
+
+/** Shifted and fitted buffers by their own cache key (0.7 autotune ids). */
+const audioIds = new WeakMap<Float32Array, string>();
+
+/** A SampleRef with a pitch or formant shift (0.6.1). */
+export function isShifted(ref: SampleRef): boolean {
+  return (
+    (ref.shift !== undefined && ref.shift !== 0) || ref.formant !== undefined
+  );
+}
+
+/** Buffers already shifted, by the identity of the buffer they shift. */
+const shiftKeys = new WeakMap<Float32Array, string>();
+let shiftSerial = 0;
+
+/**
+ * The shifted copy of `sample` (whole buffer, same length). Returns null
+ * while a live shift is still computing (the voice stays silent).
+ */
+function shiftVoice(
+  ref: SampleRef,
+  sample: DecodedSample,
+  kind: "raw" | "fit",
+): DecodedSample | undefined {
+  // Decoded files key by content; fitted buffers (already cached by their
+  // own key) by identity.
+  let base = shiftKeys.get(sample.mono);
+  if (base === undefined) {
+    base =
+      kind === "raw"
+        ? `${sample.sha256}:${sample.sampleRate}:${sample.frames}`
+        : `fit#${(shiftSerial += 1)}`;
+    shiftKeys.set(sample.mono, base);
+  }
+  const key = `shift:${base}:${ref.shift ?? 0}:${ref.formant ?? "follow"}`;
+  const buffer = shiftedBuffer(
+    key,
+    sample.mono,
+    sample.sampleRate,
+    ref.shift ?? 0,
+    ref.formant,
+  );
+  if (!buffer) return undefined;
+  audioIds.set(buffer, key);
+  return Object.freeze({ ...sample, frames: buffer.length, mono: buffer });
+}
+
 /** Fingerprint of a position map: its length and 64 exact samples. */
 function mapPrint(map: FitMap, frames: number): string {
   const parts = [map.length.toString()];
@@ -483,6 +708,8 @@ export function renderSamplerVoices(
   voices: readonly SamplerVoice[],
   timing: SamplerTiming,
   gainAt: (tick: number) => number,
+  /** The channel a stereo voice reads (absent: every voice reads mono). */
+  channel?: "left" | "right",
 ): void {
   const { sampleRate, score, warp } = timing;
   const samplesPerTick =
@@ -491,7 +718,8 @@ export function renderSamplerVoices(
   for (const voice of voices) {
     const { sample, step, regionStart, regionEnd, reverse, loop } = voice;
     const { loopStart, loopSpan, ramp } = voice;
-    const mono = sample.mono;
+    const mono =
+      channel && voice.stereo ? (sample[channel] ?? sample.mono) : sample.mono;
     const span = regionEnd - regionStart;
     const crossfade = loop
       ? Math.min(LOOP_CROSSFADE_SECONDS * sample.sampleRate, loopSpan / 4)
@@ -549,7 +777,7 @@ export function renderSamplerVoices(
       const elapsed = index - voice.start;
       const value = squizzed ? squizzed[elapsed]! : read(elapsed);
       if (value === undefined) break;
-      let envelope = Math.min(1, elapsed / attack);
+      let envelope = Math.min(1, elapsed / (voice.attack ?? attack));
       if (index >= fadeFrom) envelope *= (voice.end - index) / voice.fade;
       const damp = voice.damp;
       if (damp && elapsed / sampleRate > damp.from)

package/src/audio/samples.ts

@@ -36,6 +36,7 @@ import {
   type TrackScore,
 } from "../../core/score.ts";
 import { GRANULAR_SOURCE_VOICE } from "../../core/granular.ts";
+import { CLIP_VOICE_PREFIX, clipSampleRef } from "../../core/clips.ts";
 import { PackError, PackStore } from "./packs.ts";
 import {
   DEFAULT_MEMORY_CACHE_BYTES,
@@ -58,6 +59,12 @@ export type DecodedSample = Readonly<{
   channels: number;
   frames: number;
   mono: Float32Array;
+  /**
+   * The two channels of a stereo file (0.6.1): a resampled ref (one with
+   * `from`) plays them as stereo. Absent for mono and multichannel files.
+   */
+  left?: Float32Array;
+  right?: Float32Array;
 }>;
 
 export type SampleProblem = Readonly<{
@@ -97,7 +104,8 @@ export function hasSamplerTracks(score: TrackScore): boolean {
       packWavetable(track) !== undefined ||
       localWavetable(track) !== undefined ||
       reverbIrSample(track) !== undefined ||
-      granularSample(track) !== undefined,
+      granularSample(track) !== undefined ||
+      (track.clips?.length ?? 0) > 0,
   );
 }
 
@@ -122,6 +130,9 @@ function trackSampleRefs(track: Track): [string, SampleRef][] {
   }
   const granular = granularSample(track);
   if (granular) refs.push([GRANULAR_SOURCE_VOICE, granular]);
+  // Audio clips (0.7) load as `clip:<id>` voices, sha256-pinned alike.
+  for (const clip of track.clips ?? [])
+    refs.push([`${CLIP_VOICE_PREFIX}${clip.id}`, clipSampleRef(clip)]);
   return refs;
 }
 
@@ -324,6 +335,20 @@ function checkShape(sampleRate: number, channels: number, frames: number) {
 }
 
 /** Average the channels; the renderer plays sampler voices in mono before pan. */
+/** A stereo file's left and right channels (nothing for other shapes). */
+export function stereoChannels(
+  pcm: PcmData,
+): { left: Float32Array; right: Float32Array } | Record<string, never> {
+  if (pcm.channels !== 2) return {};
+  const left = new Float32Array(pcm.frames);
+  const right = new Float32Array(pcm.frames);
+  for (let frame = 0; frame < pcm.frames; frame += 1) {
+    left[frame] = pcm.data[frame * 2]!;
+    right[frame] = pcm.data[frame * 2 + 1]!;
+  }
+  return { left, right };
+}
+
 export function monoMix(pcm: PcmData): Float32Array {
   if (pcm.channels === 1) return pcm.data;
   const mono = new Float32Array(pcm.frames);
@@ -603,6 +628,14 @@ export class SampleLibrary implements SampleSource {
     );
   }
 
+  /**
+   * Decodes one project file (0.7: an audio clip for pitch analysis), with
+   * the same path rules, limits and caches as a sampler voice.
+   */
+  public decodeFile(src: string): Promise<DecodedSample> {
+    return this.loadFile(src);
+  }
+
   public async load(score: TrackScore): Promise<SampleBank> {
     const voices = new Map<string, DecodedSample>();
     const problems: SampleProblem[] = [];
@@ -733,7 +766,12 @@ export class SampleLibrary implements SampleSource {
             );
           voices.set(sampleKey(track.id, voice), loaded);
         } catch (error) {
-          report("error", describeFailure(voice, src, error, this.ffmpeg));
+          // A clip whose audio is missing renders as silence with a warning;
+          // a missing instrument voice still fails the render.
+          report(
+            voice.startsWith(CLIP_VOICE_PREFIX) ? "warning" : "error",
+            describeFailure(voice, src, error, this.ffmpeg),
+          );
         }
       }
     }
@@ -896,6 +934,7 @@ export class SampleLibrary implements SampleSource {
       channels: pcm.channels,
       frames: pcm.frames,
       mono: monoMix(pcm),
+      ...stereoChannels(pcm),
     });
     this.remember(sample);
     return sample;
@@ -943,6 +982,7 @@ export class SampleLibrary implements SampleSource {
       channels: pcm.channels,
       frames: pcm.frames,
       mono: monoMix(pcm),
+      ...stereoChannels(pcm),
     });
     this.remember(sample);
     return sample;
@@ -966,7 +1006,10 @@ export class SampleLibrary implements SampleSource {
   }
 
   private remember(sample: DecodedSample): void {
-    const bytes = sample.mono.byteLength;
+    const bytes =
+      sample.mono.byteLength +
+      (sample.left?.byteLength ?? 0) +
+      (sample.right?.byteLength ?? 0);
     this.memory.set(sample.sha256, { sample, bytes });
     this.memoryBytes += bytes;
     for (const [sha, entry] of this.memory) {