.

src/audio/piano-sampler.ts

@@ -1,4 +1,4 @@
-import { appConfig } from '../config';
+import type { GardenAudioEngineConfig } from '../config';
 import { clamp, clamp01 } from '../utils/clamp';
 import { GardenAudioConfig } from './garden-audio-config';
 import { GardenAudioGraph } from './garden-audio-graph';
@@ -12,6 +12,7 @@ export class PianoSampler {
 
   public constructor(
     private readonly config: GardenAudioConfig,
+    private readonly engineConfig: GardenAudioEngineConfig,
     private readonly graph: GardenAudioGraph
   ) {}
 
@@ -51,31 +52,39 @@ export class PianoSampler {
     lowpassHz = this.config.piano.lowpassHz,
   }: PianoNote): void {
     const { context, eventBus, delayInput } = this.graph;
-    if (!context || !eventBus || this.samples.length === 0) {
+    if (!context || !eventBus) {
       return;
     }
 
     const sample = this.findNearestSample(midi);
     if (!sample) {
+      this.playFallbackPluck({
+        midi,
+        velocity,
+        startTime,
+        durationSeconds,
+        pan,
+        delaySend,
+        lowpassHz,
+      });
       return;
     }
 
     const scheduledStart = Math.max(
-      context.currentTime + appConfig.audioEngine.piano.scheduleAheadSeconds,
+      context.currentTime + this.engineConfig.piano.scheduleAheadSeconds,
       startTime
     );
     const noteVelocity = clamp01(velocity);
     const noteGainValue = Math.max(
-      appConfig.audioEngine.piano.minGain,
+      this.engineConfig.piano.minGain,
       this.config.piano.gain * noteVelocity
     );
     const sustainSeconds =
       this.config.piano.sustainSeconds *
-      (appConfig.audioEngine.piano.sustainBase +
-        noteVelocity * appConfig.audioEngine.piano.sustainVelocityRange);
+      (this.engineConfig.piano.sustainBase +
+        noteVelocity * this.engineConfig.piano.sustainVelocityRange);
     const sustainAt =
-      scheduledStart +
-      Math.max(appConfig.audioEngine.piano.minDurationSeconds, durationSeconds);
+      scheduledStart + Math.max(this.engineConfig.piano.minDurationSeconds, durationSeconds);
     const releaseAt = sustainAt + sustainSeconds;
     const releaseSeconds = this.config.piano.releaseSeconds;
     const stopAt = releaseAt + releaseSeconds;
@@ -90,20 +99,18 @@ export class PianoSampler {
       const oldest = this.activeVoices.shift();
       oldest?.gain.gain.cancelScheduledValues(scheduledStart);
       oldest?.gain.gain.setTargetAtTime(
-        appConfig.audioEngine.piano.minGain,
+        this.engineConfig.piano.minGain,
         scheduledStart,
-        appConfig.audioEngine.piano.voiceStealFadeSeconds
-      );
-      oldest?.source.stop(
-        scheduledStart + appConfig.audioEngine.piano.voiceStealStopSeconds
+        this.engineConfig.piano.voiceStealFadeSeconds
       );
+      oldest?.source.stop(scheduledStart + this.engineConfig.piano.voiceStealStopSeconds);
     }
 
     source.buffer = sample.buffer;
     source.playbackRate.setValueAtTime(
       Math.pow(
         2,
-        (midi - sample.midi) / appConfig.audioEngine.piano.pitchSemitonesPerOctave
+        (midi - sample.midi) / this.engineConfig.piano.pitchSemitonesPerOctave
       ),
       scheduledStart
     );
@@ -111,30 +118,30 @@ export class PianoSampler {
     filter.frequency.setValueAtTime(
       clamp(
         lowpassHz,
-        appConfig.audioEngine.piano.lowpassMinHz,
-        appConfig.audioEngine.piano.lowpassMaxHz
+        this.engineConfig.piano.lowpassMinHz,
+        this.engineConfig.piano.lowpassMaxHz
       ),
       scheduledStart
     );
-    filter.Q.value = appConfig.audioEngine.piano.filterQ;
-    gain.gain.setValueAtTime(appConfig.audioEngine.piano.minGain, scheduledStart);
+    filter.Q.value = this.engineConfig.piano.filterQ;
+    gain.gain.setValueAtTime(this.engineConfig.piano.minGain, scheduledStart);
     gain.gain.exponentialRampToValueAtTime(
       noteGainValue,
-      scheduledStart + appConfig.audioEngine.piano.gainAttackSeconds
+      scheduledStart + this.engineConfig.piano.gainAttackSeconds
     );
     gain.gain.setTargetAtTime(
       Math.max(
-        appConfig.audioEngine.piano.minGain,
+        this.engineConfig.piano.minGain,
         noteGainValue * this.config.piano.sustainLevel
       ),
       sustainAt,
       Math.max(
-        appConfig.audioEngine.piano.minFadeSeconds,
-        sustainSeconds * appConfig.audioEngine.piano.sustainBase
+        this.engineConfig.piano.minFadeSeconds,
+        sustainSeconds * this.engineConfig.piano.sustainBase
       )
     );
     gain.gain.setTargetAtTime(
-      appConfig.audioEngine.piano.minGain,
+      this.engineConfig.piano.minGain,
       releaseAt,
       releaseSeconds
     );
@@ -153,7 +160,7 @@ export class PianoSampler {
     }
 
     source.start(scheduledStart);
-    source.stop(stopAt + appConfig.audioEngine.piano.tailStopExtraSeconds);
+    source.stop(stopAt + this.engineConfig.piano.tailStopExtraSeconds);
     this.activeVoices.push({ gain, source, startAt: scheduledStart, stopAt });
 
     source.addEventListener(
@@ -170,41 +177,6 @@ export class PianoSampler {
     );
   }
 
-  public fadeActive(
-    now: number,
-    fadeSeconds = appConfig.audioEngine.piano.defaultFadeSeconds
-  ): void {
-    this.activeVoices.forEach((voice) => {
-      voice.gain.gain.cancelScheduledValues(now);
-      if (voice.startAt > now) {
-        voice.gain.gain.setValueAtTime(appConfig.audioEngine.piano.minGain, now);
-        voice.stopAt = now;
-        try {
-          voice.source.stop(now);
-        } catch {
-          // The source may already have a stop time scheduled.
-        }
-        return;
-      }
-
-      const stopAt = Math.min(voice.stopAt, now + fadeSeconds);
-      voice.gain.gain.setTargetAtTime(
-        appConfig.audioEngine.piano.minGain,
-        now,
-        Math.max(
-          appConfig.audioEngine.piano.minFadeSeconds,
-          fadeSeconds * appConfig.audioEngine.piano.fadeTimeConstantRatio
-        )
-      );
-      voice.stopAt = stopAt;
-      try {
-        voice.source.stop(stopAt);
-      } catch {
-        // The source may already have a stop time scheduled.
-      }
-    });
-  }
-
   public reset(): void {
     this.sampleLoadPromise = null;
     this.samples = [];
@@ -224,4 +196,90 @@ export class PianoSampler {
   private trimActiveVoices(now: number): void {
     this.activeVoices = this.activeVoices.filter((voice) => voice.stopAt > now);
   }
+
+  private playFallbackPluck({
+    midi,
+    velocity,
+    startTime,
+    durationSeconds,
+    pan,
+    delaySend = 0,
+    lowpassHz = this.config.piano.lowpassHz,
+  }: PianoNote): void {
+    const { context, eventBus, delayInput } = this.graph;
+    if (!context || !eventBus) {
+      return;
+    }
+
+    const scheduledStart = Math.max(
+      context.currentTime + this.engineConfig.piano.scheduleAheadSeconds,
+      startTime
+    );
+    const oscillator = context.createOscillator();
+    const filter = context.createBiquadFilter();
+    const gain = context.createGain();
+    const panner = context.createStereoPanner();
+    let sendGain: GainNode | null = null;
+    const noteVelocity = clamp01(velocity);
+    const noteGainValue = Math.max(
+      this.engineConfig.piano.minGain,
+      this.config.piano.gain * noteVelocity * 0.42
+    );
+    const releaseAt =
+      scheduledStart + Math.max(this.engineConfig.piano.minDurationSeconds, durationSeconds);
+    const stopAt = releaseAt + this.config.piano.releaseSeconds;
+
+    oscillator.type = 'triangle';
+    oscillator.frequency.setValueAtTime(
+      440 * Math.pow(2, (midi - 69) / appConfig.audioEngine.piano.pitchSemitonesPerOctave),
+      scheduledStart
+    );
+    filter.type = 'lowpass';
+    filter.frequency.setValueAtTime(
+      clamp(
+        lowpassHz * 0.72,
+        this.engineConfig.piano.lowpassMinHz,
+        this.engineConfig.piano.lowpassMaxHz
+      ),
+      scheduledStart
+    );
+    filter.Q.value = this.engineConfig.piano.filterQ;
+    gain.gain.setValueAtTime(this.engineConfig.piano.minGain, scheduledStart);
+    gain.gain.exponentialRampToValueAtTime(
+      noteGainValue,
+      scheduledStart + this.engineConfig.piano.gainAttackSeconds
+    );
+    gain.gain.setTargetAtTime(
+      this.engineConfig.piano.minGain,
+      releaseAt,
+      this.config.piano.releaseSeconds
+    );
+    panner.pan.setValueAtTime(clamp(pan, -1, 1), scheduledStart);
+
+    oscillator.connect(filter);
+    filter.connect(gain);
+    gain.connect(panner);
+    panner.connect(eventBus);
+
+    if (delayInput && delaySend > 0) {
+      sendGain = context.createGain();
+      sendGain.gain.value = delaySend * 0.5;
+      panner.connect(sendGain);
+      sendGain.connect(delayInput);
+    }
+
+    oscillator.start(scheduledStart);
+    oscillator.stop(stopAt + this.engineConfig.piano.tailStopExtraSeconds);
+    oscillator.addEventListener(
+      'ended',
+      () => {
+        oscillator.disconnect();
+        filter.disconnect();
+        gain.disconnect();
+        panner.disconnect();
+        sendGain?.disconnect();
+      },
+      { once: true }
+    );
+  }
 }