Merge pull request #22 from ryohey/fix-0tick

Fix 0-tick problem

Author: ryohey

lib/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ryohey/wavelet",
-  "version": "0.7.4",
+  "version": "0.7.5",
   "description": "A wavetable synthesizer that never stops the UI thread created by AudioWorklet.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

lib/src/SynthEvent.ts

@@ -2,16 +2,21 @@ import { AnyChannelEvent } from "midifile-ts"
 import { AmplitudeEnvelopeParameter } from "./processor/AmplitudeEnvelope"
 import { DistributiveOmit } from "./types"
 
-export interface SampleLoop {
-  start: number
-  end: number
-}
+export type SampleLoop =
+  | {
+      type: "no_loop"
+    }
+  | {
+      type: "loop_continuous" | "loop_sustain"
+      start: number
+      end: number
+    }
 
 export interface SampleParameter {
   name: string
   sampleID: number
   pitch: number
-  loop: SampleLoop | null
+  loop: SampleLoop
   sampleStart: number
   sampleEnd: number
   sampleRate: number

lib/src/processor/AmplitudeEnvelope.ts

@@ -1,12 +1,14 @@
 export interface AmplitudeEnvelopeParameter {
   attackTime: number
+  holdTime: number
   decayTime: number
   sustainLevel: number
   releaseTime: number
 }
 
 enum EnvelopePhase {
   attack,
+  hold,
   decay,
   sustain,
   release,
@@ -18,7 +20,10 @@ const forceStopReleaseTime = 0.1
 
 export class AmplitudeEnvelope {
   private readonly parameter: AmplitudeEnvelopeParameter
-  private phase = EnvelopePhase.attack
+  private _phase = EnvelopePhase.stopped
+  private isNoteOff = false
+  private phaseTime = 0
+  private decayLevel = 0 // amplitude level at the end of decay phase
   private lastAmplitude = 0
   private readonly sampleRate: number
 
@@ -27,69 +32,99 @@ export class AmplitudeEnvelope {
     this.sampleRate = sampleRate
   }
 
+  private get phase() {
+    return this._phase
+  }
+
+  private set phase(phase: EnvelopePhase) {
+    if (this._phase === phase) {
+      return
+    }
+    this._phase = phase
+    this.phaseTime = 0
+  }
+
   noteOn() {
     this.phase = EnvelopePhase.attack
+    this.isNoteOff = false
+    this.phaseTime = 0
+    this.decayLevel = this.parameter.sustainLevel
   }
 
   noteOff() {
-    if (this.phase !== EnvelopePhase.forceStop) {
-      this.phase = EnvelopePhase.release
-    }
+    this.isNoteOff = true
   }
 
   // Rapidly decrease the volume. This method ignores release time parameter
   forceStop() {
     this.phase = EnvelopePhase.forceStop
   }
 
-  getAmplitude(bufferSize: number): number {
-    const { attackTime, decayTime, sustainLevel, releaseTime } = this.parameter
+  calculateAmplitude(bufferSize: number): number {
+    const { attackTime, holdTime, decayTime, sustainLevel, releaseTime } =
+      this.parameter
     const { sampleRate } = this
 
+    if (
+      this.isNoteOff &&
+      (this.phase === EnvelopePhase.decay ||
+        this.phase === EnvelopePhase.sustain)
+    ) {
+      this.phase = EnvelopePhase.release
+      this.decayLevel = this.lastAmplitude
+    }
+
     // Attack
     switch (this.phase) {
       case EnvelopePhase.attack: {
         const amplificationPerFrame =
           (1 / (attackTime * sampleRate)) * bufferSize
         const value = this.lastAmplitude + amplificationPerFrame
         if (value >= 1) {
-          this.phase = EnvelopePhase.decay
-          this.lastAmplitude = 1
+          this.phase = EnvelopePhase.hold
           return 1
         }
-        this.lastAmplitude = value
         return value
       }
+      case EnvelopePhase.hold: {
+        if (this.phaseTime >= holdTime) {
+          this.phase = EnvelopePhase.decay
+        }
+        return this.lastAmplitude
+      }
       case EnvelopePhase.decay: {
-        const attenuationPerFrame = (1 / (decayTime * sampleRate)) * bufferSize
-        const value = this.lastAmplitude - attenuationPerFrame
-        if (value <= sustainLevel) {
+        const attenuationDecibel = linearToDecibel(sustainLevel / 1)
+        const value = logAttenuation(
+          1.0,
+          attenuationDecibel,
+          decayTime,
+          this.phaseTime
+        )
+        if (this.phaseTime > decayTime) {
           if (sustainLevel <= 0) {
             this.phase = EnvelopePhase.stopped
-            this.lastAmplitude = 0
             return 0
           } else {
             this.phase = EnvelopePhase.sustain
-            this.lastAmplitude = sustainLevel
             return sustainLevel
           }
         }
-        this.lastAmplitude = value
         return value
       }
       case EnvelopePhase.sustain: {
         return sustainLevel
       }
       case EnvelopePhase.release: {
-        const attenuationPerFrame =
-          (1 / (releaseTime * sampleRate)) * bufferSize
-        const value = this.lastAmplitude - attenuationPerFrame
-        if (value <= 0) {
+        const value = logAttenuation(
+          this.decayLevel,
+          -100, // -100dB means almost silence
+          releaseTime,
+          this.phaseTime
+        )
+        if (this.phaseTime > releaseTime || value <= 0) {
           this.phase = EnvelopePhase.stopped
-          this.lastAmplitude = 0
           return 0
         }
-        this.lastAmplitude = value
         return value
       }
       case EnvelopePhase.forceStop: {
@@ -98,10 +133,8 @@ export class AmplitudeEnvelope {
         const value = this.lastAmplitude - attenuationPerFrame
         if (value <= 0) {
           this.phase = EnvelopePhase.stopped
-          this.lastAmplitude = 0
           return 0
         }
-        this.lastAmplitude = value
         return value
       }
       case EnvelopePhase.stopped: {
@@ -110,7 +143,32 @@ export class AmplitudeEnvelope {
     }
   }
 
+  getAmplitude(bufferSize: number): number {
+    const value = this.calculateAmplitude(bufferSize)
+    this.lastAmplitude = value
+    this.phaseTime += bufferSize / sampleRate
+    return value
+  }
+
   get isPlaying() {
     return this.phase !== EnvelopePhase.stopped
   }
 }
+
+// An exponential decay function. It attenuates the value of decibel over the duration time.
+function logAttenuation(
+  fromLevel: number,
+  attenuationDecibel: number,
+  duration: number,
+  time: number
+): number {
+  return fromLevel * decibelToLinear((attenuationDecibel / duration) * time)
+}
+
+function linearToDecibel(value: number): number {
+  return 20 * Math.log10(value)
+}
+
+function decibelToLinear(value: number): number {
+  return Math.pow(10, value / 20)
+}

lib/src/processor/SynthProcessorCore.ts

@@ -95,7 +95,7 @@ export class SynthProcessorCore {
     for (const sample of samples) {
       const oscillator = new WavetableOscillator(sample, this.sampleRate)
 
-      const volume = velocity / 0x80
+      const volume = velocity / 127
       oscillator.noteOn(pitch, volume)
 
       if (state.oscillators[pitch] === undefined) {
@@ -151,12 +151,12 @@ export class SynthProcessorCore {
 
   setMainVolume(channel: number, value: number) {
     const state = this.getChannelState(channel)
-    state.volume = value / 0x80
+    state.volume = value / 127
   }
 
   expression(channel: number, value: number) {
     const state = this.getChannelState(channel)
-    state.expression = value / 0x80
+    state.expression = value / 127
   }
 
   allSoundsOff(channel: number) {
@@ -210,7 +210,7 @@ export class SynthProcessorCore {
 
   modulation(channel: number, value: number) {
     const state = this.getChannelState(channel)
-    state.modulation = value / 0x80
+    state.modulation = value / 127
   }
 
   resetChannel(channel: number) {
@@ -248,12 +248,5 @@ export class SynthProcessorCore {
         })
       }
     }
-
-    // master volume
-    const masterVolume = 0.3
-    for (let i = 0; i < outputs[0].length; ++i) {
-      outputs[0][i] *= masterVolume
-      outputs[1][i] *= masterVolume
-    }
   }
 }

lib/src/processor/WavetableOscillator.ts

@@ -64,7 +64,7 @@ export class WavetableOscillator {
 
     const speed =
       (this.baseSpeed * this.speed * this.sample.sampleRate) / this.sampleRate
-    const volume = this.velocity * this.volume * this.sample.volume
+    const volume = (this.velocity * this.volume) ** 2 * this.sample.volume
 
     // zero to pi/2
     const panTheta =
@@ -86,7 +86,11 @@ export class WavetableOscillator {
       const advancedIndex = this.sampleIndex + modulatedSpeed
       let loopIndex: number | null = null
 
-      if (this.sample.loop !== null && advancedIndex >= this.sample.loop.end) {
+      if (
+        (this.sample.loop.type === "loop_continuous" ||
+          (this.sample.loop.type === "loop_sustain" && !this._isNoteOff)) &&
+        advancedIndex >= this.sample.loop.end
+      ) {
         loopIndex =
           this.sample.loop.start + (advancedIndex - Math.floor(advancedIndex))
       }

lib/src/soundfont/getInstrumentZones.ts

@@ -0,0 +1,22 @@
+import {
+  createGeneraterObject,
+  getInstrumentGenerators,
+  ParseResult,
+} from "@ryohey/sf2parser"
+
+export function getInstrumentZones(parsed: ParseResult, instrumentID: number) {
+  const instrumentGenerators = getInstrumentGenerators(parsed, instrumentID)
+  const zones = instrumentGenerators.map(createGeneraterObject)
+
+  // If the first zone does not have sampleID, it is a global instrument zone.
+  let globalZone: any | undefined
+  const firstInstrumentZone = zones[0]
+  if (firstInstrumentZone.sampleID === undefined) {
+    globalZone = zones[0]
+  }
+
+  return {
+    zones: zones.filter((zone) => zone.sampleID !== undefined),
+    globalZone,
+  }
+}

lib/src/soundfont/getPresetZones.ts

@@ -2,8 +2,8 @@ import { GeneratorParams } from "@ryohey/sf2parser"
 import { GeneratorList } from "@ryohey/sf2parser/bin/Structs"
 
 export function getPresetZones(generators: GeneratorList[]) {
-  let instrumentsGlobal: Partial<GeneratorParams> = {}
-  const instruments: (Partial<GeneratorParams> & { instrument: number })[] = []
+  let globalZone: Partial<GeneratorParams> = {}
+  const zones: (Partial<GeneratorParams> & { instrument: number })[] = []
   let params: Partial<GeneratorParams> = {}
   let zoneCount = 0
 
@@ -16,21 +16,21 @@ export function getPresetZones(generators: GeneratorList[]) {
 
     // keyRange or velRange must be the first of zone
     if (type === "keyRange" || type === "velRange") {
-      if (zoneCount === 1 && instruments.length === 0) {
+      if (zoneCount === 1 && zones.length === 0) {
         // treat previous zone as global zone if it is the first zone and not ended with instrument
-        instrumentsGlobal = params
+        globalZone = params
       }
       params = {}
       zoneCount++
     }
 
     // instrument must be the last of zone
     if (type === "instrument") {
-      instruments.push({ ...params, instrument: gen.value as number })
+      zones.push({ ...params, instrument: gen.value as number })
     }
 
     params[type] = gen.value
   }
 
-  return { instruments, instrumentsGlobal }
+  return { zones, globalZone }
 }