@kano/stem-daw 0.1.0

package/dist/workers/daw-stem-processor.js

@@ -0,0 +1,228 @@
+const FADE_SAMPLES = 480;
+const MUTE_FADE = 64;
+class DAWStemProcessor extends AudioWorkletProcessor {
+  channels = [];
+  numChannels = 0;
+  bufferLength = 0;
+  playing = false;
+  readPos = 0;
+  // fractional sample position in native buffer
+  speed = 1;
+  // fallback uniform speed (used when no bar map)
+  globalRate = 1;
+  // global playback rate multiplier
+  // Per-bar speed map: sorted by sampleStart ascending.
+  barMap = [];
+  barMapIdx = 0;
+  // Per-bar pitch map: 1:1 with barMap, each entry is the pitchFactor for that bar.
+  // Sent to the main thread at each bar crossing for relay to Rubberband.
+  pitchMap = [];
+  // Mute regions: sorted by sampleStart. Audio in these ranges outputs silence.
+  muteRegions = [];
+  // Fade state
+  fadeGain = 0;
+  fadeTarget = 0;
+  fadeStep = 0;
+  constructor() {
+    super();
+    this.port.onmessage = (e) => {
+      const { type } = e.data;
+      switch (type) {
+        case "load-buffer": {
+          this.channels = e.data.channels;
+          this.numChannels = this.channels.length;
+          this.bufferLength = this.numChannels > 0 ? this.channels[0].length : 0;
+          this.readPos = 0;
+          this.playing = false;
+          this.fadeGain = 0;
+          this.fadeTarget = 0;
+          break;
+        }
+        case "dump-buffer": {
+          this.channels = [];
+          this.numChannels = 0;
+          this.bufferLength = 0;
+          this.playing = false;
+          this.readPos = 0;
+          this.fadeGain = 0;
+          this.fadeTarget = 0;
+          this.barMapIdx = 0;
+          break;
+        }
+        case "patch-buffer": {
+          const patch = e.data.channels;
+          const offset = e.data.sampleOffset | 0;
+          for (let ch = 0; ch < patch.length; ch++) {
+            const dst = this.channels[ch];
+            if (!dst) continue;
+            const src = patch[ch];
+            const remaining = dst.length - offset;
+            if (remaining <= 0) continue;
+            const copyLen = src.length <= remaining ? src.length : remaining;
+            if (copyLen === src.length) {
+              dst.set(src, offset);
+            } else {
+              dst.set(src.subarray(0, copyLen), offset);
+            }
+          }
+          break;
+        }
+        case "load-bar-map": {
+          this.barMap = e.data.entries;
+          this.barMapIdx = 0;
+          break;
+        }
+        case "load-pitch-map": {
+          const entries = e.data.entries;
+          this.pitchMap = entries.map((e2) => e2.pitchFactor);
+          break;
+        }
+        case "load-mute-regions": {
+          this.muteRegions = e.data.regions;
+          break;
+        }
+        case "play": {
+          this.playing = true;
+          this.fadeTarget = 1;
+          this.fadeStep = 1 / FADE_SAMPLES;
+          break;
+        }
+        case "pause": {
+          this.fadeTarget = 0;
+          this.fadeStep = 1 / FADE_SAMPLES;
+          break;
+        }
+        case "seek": {
+          this.readPos = e.data.position;
+          this.barMapIdx = this.findBarIndex(this.readPos);
+          if (this.playing) {
+            this.fadeGain = 0;
+            this.fadeTarget = 1;
+            this.fadeStep = 1 / FADE_SAMPLES;
+          }
+          break;
+        }
+        case "set-speed": {
+          this.speed = e.data.speed;
+          break;
+        }
+        case "set-global-rate": {
+          this.globalRate = e.data.rate;
+          break;
+        }
+        case "stop": {
+          this.playing = false;
+          this.readPos = 0;
+          this.fadeGain = 0;
+          this.fadeTarget = 0;
+          this.barMapIdx = 0;
+          break;
+        }
+      }
+    };
+  }
+  /** Binary search to find which bar entry the given sample position falls in */
+  findBarIndex(pos) {
+    const map = this.barMap;
+    if (map.length === 0) return 0;
+    let lo = 0, hi = map.length - 1;
+    while (lo < hi) {
+      const mid = lo + hi + 1 >> 1;
+      if (map[mid].sampleStart <= pos) lo = mid;
+      else hi = mid - 1;
+    }
+    return lo;
+  }
+  /** Check if a sample position falls inside any mute region, with short crossfade */
+  muteGainAt(pos) {
+    for (let i = 0; i < this.muteRegions.length; i++) {
+      const r = this.muteRegions[i];
+      if (pos >= r.sampleStart && pos < r.sampleEnd) {
+        const distIn = pos - r.sampleStart;
+        const distOut = r.sampleEnd - pos;
+        if (distIn < MUTE_FADE) return distIn / MUTE_FADE;
+        if (distOut < MUTE_FADE) return distOut / MUTE_FADE;
+        return 0;
+      }
+    }
+    return 1;
+  }
+  /** Send the pre-computed pitch factor to the main thread for relay to Rubberband.
+   *  Includes sampleOffset (where in the 128-sample block the bar boundary fell)
+   *  and audioTime so the pitch worklet can align its delay precisely. */
+  sendPitchForBar(barIdx, sampleOffset) {
+    if (barIdx >= this.pitchMap.length) return;
+    const factor = this.pitchMap[barIdx];
+    if (factor === void 0) return;
+    this.port.postMessage({
+      type: "pitch-for-bar",
+      barIndex: barIdx,
+      pitchFactor: factor,
+      sampleOffset,
+      audioTime: currentTime
+    });
+  }
+  /** Get the effective speed for the current readPos, using bar map if available.
+   *  sampleOffset is the current position within the output block (0..127). */
+  currentSpeed(sampleOffset) {
+    if (this.barMap.length === 0) {
+      return this.speed * this.globalRate;
+    }
+    while (this.barMapIdx < this.barMap.length - 1 && this.readPos >= this.barMap[this.barMapIdx + 1].sampleStart) {
+      this.barMapIdx++;
+      this.port.postMessage({ type: "bar-changed", barIndex: this.barMapIdx, sampleOffset, audioTime: currentTime });
+      this.sendPitchForBar(this.barMapIdx, sampleOffset);
+    }
+    return this.barMap[this.barMapIdx].speed * this.globalRate;
+  }
+  process(_inputs, outputs) {
+    const output = outputs[0];
+    if (!output || output.length === 0) return true;
+    const blockSize = output[0].length;
+    const outChannels = output.length;
+    if (this.bufferLength === 0 || !this.playing && this.fadeGain === 0) {
+      for (let ch = 0; ch < outChannels; ch++) {
+        output[ch].fill(0);
+      }
+      return true;
+    }
+    const hasMuteRegions = this.muteRegions.length > 0;
+    for (let i = 0; i < blockSize; i++) {
+      if (this.fadeGain < this.fadeTarget) {
+        this.fadeGain = Math.min(this.fadeGain + this.fadeStep, 1);
+      } else if (this.fadeGain > this.fadeTarget) {
+        this.fadeGain = Math.max(this.fadeGain - this.fadeStep, 0);
+        if (this.fadeGain === 0 && this.fadeTarget === 0) {
+          this.playing = false;
+        }
+      }
+      const pos = this.readPos;
+      const intPos = Math.floor(pos);
+      const frac = pos - intPos;
+      if (intPos >= 0 && intPos < this.bufferLength) {
+        const mg = hasMuteRegions ? this.muteGainAt(pos) : 1;
+        const gain = this.fadeGain * mg;
+        if (gain === 0) {
+          for (let ch = 0; ch < outChannels; ch++) output[ch][i] = 0;
+        } else {
+          for (let ch = 0; ch < outChannels; ch++) {
+            const srcCh = ch < this.numChannels ? ch : 0;
+            const buf = this.channels[srcCh];
+            const s0 = buf[intPos];
+            const s1 = intPos + 1 < this.bufferLength ? buf[intPos + 1] : s0;
+            output[ch][i] = (s0 + frac * (s1 - s0)) * gain;
+          }
+        }
+      } else {
+        for (let ch = 0; ch < outChannels; ch++) {
+          output[ch][i] = 0;
+        }
+      }
+      if (this.playing) {
+        this.readPos += this.currentSpeed(i);
+      }
+    }
+    return true;
+  }
+}
+registerProcessor("daw-stem-processor", DAWStemProcessor);

package/dist/workers/manifest.json

@@ -0,0 +1,10 @@
+{
+  "version": 1,
+  "worklets": [
+    "daw-stem-processor.js",
+    "realtime-pitch-shift-processor.js",
+    "phase-vocoder3.js",
+    "buffer-player-processor-202602.lavv8e32-ts.js",
+    "analysis-worker.js"
+  ]
+}