@onjmin/dtm 0.1.0 → 0.1.4

package/dist/voice-worker.js

@@ -0,0 +1,382 @@
+"use strict";
+(() => {
+  // node_modules/.pnpm/@onjmin+koe@1.0.3/node_modules/@onjmin/koe/dist/index.js
+  var MAGIC = 1263486208;
+  function parseKoeHeader(headerBytes) {
+    const view = new DataView(headerBytes);
+    if (view.byteLength < 8 || view.getUint32(0, false) !== MAGIC) {
+      throw new Error("Not a .koe file (bad magic)");
+    }
+    return { jsonLength: view.getUint32(4, true) };
+  }
+  var pcmBase = (jsonLength) => 8 + jsonLength;
+  var BlobVoiceSource = class {
+    constructor(blob, base) {
+      this.blob = blob;
+      this.base = base;
+    }
+    blob;
+    base;
+    readBytes(offset, length) {
+      const start = this.base + offset;
+      return this.blob.slice(start, start + length).arrayBuffer();
+    }
+  };
+  var RangeVoiceSource = class {
+    constructor(url, base) {
+      this.url = url;
+      this.base = base;
+    }
+    url;
+    base;
+    async readBytes(offset, length) {
+      const start = this.base + offset;
+      const res = await fetch(this.url, {
+        headers: { Range: `bytes=${start}-${start + length - 1}` }
+      });
+      if (!res.ok && res.status !== 206) {
+        throw new Error(`.koe range request failed: ${res.status}`);
+      }
+      return res.arrayBuffer();
+    }
+  };
+  async function rangeFetch(url, start, length) {
+    const res = await fetch(url, {
+      headers: { Range: `bytes=${start}-${start + length - 1}` }
+    });
+    if (!res.ok && res.status !== 206)
+      throw new Error(`.koe fetch failed: ${res.status}`);
+    return res.arrayBuffer();
+  }
+  var VoiceBank = class _VoiceBank {
+    constructor(manifest, source) {
+      this.manifest = manifest;
+      this.source = source;
+    }
+    manifest;
+    source;
+    /**
+     * Parse a .koe archive header + manifest and bind a lazy PCM source.
+     * @param koe a Blob/File of the .koe archive, or a URL (served with Range support)
+     */
+    static async load(koe) {
+      if (typeof koe === "string") {
+        const header2 = await rangeFetch(koe, 0, 8);
+        const { jsonLength: jsonLength2 } = parseKoeHeader(header2);
+        const json2 = await rangeFetch(koe, 8, jsonLength2);
+        const manifest2 = JSON.parse(new TextDecoder().decode(json2));
+        return new _VoiceBank(
+          manifest2,
+          new RangeVoiceSource(koe, pcmBase(jsonLength2))
+        );
+      }
+      const header = await koe.slice(0, 8).arrayBuffer();
+      const { jsonLength } = parseKoeHeader(header);
+      const json = await koe.slice(8, 8 + jsonLength).arrayBuffer();
+      const manifest = JSON.parse(new TextDecoder().decode(json));
+      return new _VoiceBank(
+        manifest,
+        new BlobVoiceSource(koe, pcmBase(jsonLength))
+      );
+    }
+    /** True if the bank contains a phoneme under this alias. */
+    has(phoneme) {
+      return this.manifest.phonemes[phoneme] !== void 0;
+    }
+    /**
+     * Raw Int16 PCM bytes (48 kHz / mono) for a phoneme, or null if unknown.
+     * The returned ArrayBuffer is freshly allocated and safe to transfer to a
+     * worker / AudioWorklet.
+     */
+    async readPcmBytes(phoneme) {
+      const entry = this.manifest.phonemes[phoneme];
+      if (!entry) return null;
+      return this.source.readBytes(entry.offset, entry.length * 2);
+    }
+    /**
+     * A phoneme's PCM as a Float64Array normalised to [-1, 1], or null if unknown.
+     * Intended for external analysis / resynthesis such as the WORLD vocoder.
+     */
+    async getPcm(phoneme) {
+      const buf = await this.readPcmBytes(phoneme);
+      if (!buf) return null;
+      const int16 = new Int16Array(buf);
+      const f64 = new Float64Array(int16.length);
+      for (let i = 0; i < int16.length; i++) f64[i] = int16[i] / 32768;
+      return f64;
+    }
+  };
+  var WORLDLINE_SAMPLE_RATE = 48e3;
+  var MIN_WORLDLINE_SAMPLES = 4096;
+  var SYNTH_REQ_SIZE = 120;
+  var WL_FRAME_MS = 10;
+  var samplesToMs = (samples) => samples / WORLDLINE_SAMPLE_RATE * 1e3;
+  function leadInFromEntry(entry) {
+    return {
+      preMs: samplesToMs(entry.pre || 0),
+      consonantMs: samplesToMs(entry.consonant || 0)
+    };
+  }
+  var moduleCache = /* @__PURE__ */ new Map();
+  function injectScript(src) {
+    return new Promise((resolve, reject) => {
+      const existing = document.querySelector(
+        `script[data-koe-worldline="${src}"]`
+      );
+      if (existing) {
+        resolve();
+        return;
+      }
+      const s = document.createElement("script");
+      s.src = src;
+      s.dataset.koeWorldline = src;
+      s.onload = () => resolve();
+      s.onerror = () => reject(new Error(`worldline: failed to load ${src}`));
+      document.head.appendChild(s);
+    });
+  }
+  function loadWasm(scriptUrl) {
+    const cached = moduleCache.get(scriptUrl);
+    if (cached) return cached;
+    const baseUrl = scriptUrl.slice(0, scriptUrl.lastIndexOf("/") + 1);
+    const instantiate = () => {
+      const factory = globalThis.WorldlineModule;
+      if (!factory)
+        throw new Error(
+          "worldline: WorldlineModule global was not defined by the script"
+        );
+      return factory({ locateFile: (f) => baseUrl + f });
+    };
+    let promise;
+    if (typeof document !== "undefined") {
+      promise = injectScript(scriptUrl).then(instantiate);
+    } else if (typeof globalThis.importScripts === "function") {
+      promise = Promise.resolve().then(() => {
+        globalThis.importScripts(scriptUrl);
+        return instantiate();
+      });
+    } else {
+      return Promise.reject(
+        new Error(
+          "Worldline.load requires a DOM or a classic Web Worker (importScripts) to load worldline.js"
+        )
+      );
+    }
+    moduleCache.set(scriptUrl, promise);
+    return promise;
+  }
+  var Worldline = class _Worldline {
+    constructor(wasm) {
+      this.wasm = wasm;
+    }
+    wasm;
+    sampleRate = WORLDLINE_SAMPLE_RATE;
+    /**
+     * Load + instantiate the worldline WASM module (deduped per scriptUrl).
+     *
+     * Works on the main thread (loads via `<script>`) and inside a classic Web
+     * Worker (loads via `importScripts`), so the heavy synthesis can run
+     * off-thread. The matching `worldline.wasm` is fetched next to scriptUrl.
+     */
+    static async load(options) {
+      return new _Worldline(await loadWasm(options.scriptUrl));
+    }
+    /**
+     * Render one note to Float32 PCM at 48 kHz.
+     *
+     * The output buffer is laid out as [lead-in/consonant ≈ preMs][vowel ≈
+     * durationMs], rendered from sample offset 0 (no leading silence). The vowel
+     * onset (the "beat") sits at ≈ preMs into the buffer, so a sequencer should
+     * place the buffer at `beatTime − preMs` and may trim/crossfade the lead-in.
+     *
+     * No internal crossfade is applied — apply fades externally.
+     *
+     * @returns Float32 PCM, or null when `pcm` is shorter than
+     *          {@link MIN_WORLDLINE_SAMPLES} (too short for stable F0 analysis).
+     */
+    renderNote(params) {
+      const { pcm, pitch, durationMs, preMs, consonantMs, tempo = 120 } = params;
+      if (!pcm || pcm.length < MIN_WORLDLINE_SAMPLES) return null;
+      const WL = this.wasm;
+      const FS = WORLDLINE_SAMPLE_RATE;
+      const midiNote = Math.round(69 + 12 * Math.log2(pitch / 440));
+      const posMs = 0;
+      const reqLen = preMs + durationMs;
+      const cutMs = WL_FRAME_MS * 2;
+      const ps = WL._PhraseSynthNew();
+      if (!ps) return null;
+      const reqPtr = WL._malloc(SYNTH_REQ_SIZE);
+      if (!reqPtr) {
+        WL._PhraseSynthDelete(ps);
+        return null;
+      }
+      const samplePtr = WL._malloc(pcm.length * 8);
+      if (!samplePtr) {
+        WL._free(reqPtr);
+        WL._PhraseSynthDelete(ps);
+        return null;
+      }
+      WL.HEAPF64.set(pcm, samplePtr >> 3);
+      const sv = (off, val, type) => WL.setValue(reqPtr + off, val, type);
+      sv(0, FS, "i32");
+      sv(4, pcm.length, "i32");
+      sv(8, samplePtr, "*");
+      sv(12, 0, "i32");
+      sv(16, 0, "*");
+      sv(20, midiNote, "i32");
+      sv(24, 100, "double");
+      sv(32, 0, "double");
+      sv(40, reqLen, "double");
+      sv(48, consonantMs, "double");
+      sv(56, cutMs, "double");
+      sv(64, 100, "double");
+      sv(72, 0, "double");
+      sv(80, tempo, "double");
+      sv(88, 0, "i32");
+      sv(92, 0, "*");
+      sv(96, 0, "i32");
+      sv(100, 0, "i32");
+      sv(104, 100, "i32");
+      sv(108, 0, "i32");
+      sv(112, 0, "i32");
+      sv(116, 100, "i32");
+      WL._PhraseSynthAddRequest(ps, reqPtr, posMs, 0, reqLen, 0, 0, 0);
+      WL._free(samplePtr);
+      WL._free(reqPtr);
+      const totalMs = posMs + reqLen + WL_FRAME_MS * 2;
+      const nFrames = Math.ceil(totalMs / WL_FRAME_MS) + 4;
+      const f0Arr = new Float64Array(nFrames).fill(pitch);
+      const gArr = new Float64Array(nFrames).fill(0.5);
+      const tArr = new Float64Array(nFrames).fill(0.5);
+      const bArr = new Float64Array(nFrames).fill(0.5);
+      const vArr = new Float64Array(nFrames).fill(1);
+      const f0Ptr = WL._malloc(nFrames * 8);
+      const gPtr = WL._malloc(nFrames * 8);
+      const tPtr = WL._malloc(nFrames * 8);
+      const bPtr = WL._malloc(nFrames * 8);
+      const vPtr = WL._malloc(nFrames * 8);
+      if (!f0Ptr || !gPtr || !tPtr || !bPtr || !vPtr) {
+        if (f0Ptr) WL._free(f0Ptr);
+        if (gPtr) WL._free(gPtr);
+        if (tPtr) WL._free(tPtr);
+        if (bPtr) WL._free(bPtr);
+        if (vPtr) WL._free(vPtr);
+        WL._PhraseSynthDelete(ps);
+        return null;
+      }
+      WL.HEAPF64.set(f0Arr, f0Ptr >> 3);
+      WL.HEAPF64.set(gArr, gPtr >> 3);
+      WL.HEAPF64.set(tArr, tPtr >> 3);
+      WL.HEAPF64.set(bArr, bPtr >> 3);
+      WL.HEAPF64.set(vArr, vPtr >> 3);
+      WL._PhraseSynthSetCurves(
+        ps,
+        f0Ptr,
+        gPtr,
+        tPtr,
+        bPtr,
+        vPtr,
+        nFrames,
+        WL_FRAME_MS
+      );
+      WL._free(f0Ptr);
+      WL._free(gPtr);
+      WL._free(tPtr);
+      WL._free(bPtr);
+      WL._free(vPtr);
+      const yPtrPtr = WL._malloc(4);
+      if (!yPtrPtr) {
+        WL._PhraseSynthDelete(ps);
+        return null;
+      }
+      const outLen = WL._PhraseSynthSynth(ps, yPtrPtr, 0);
+      const yPtr = WL.getValue(yPtrPtr, "*");
+      const audio = outLen > 0 ? new Float32Array(WL.HEAPF32.buffer, yPtr, outLen).slice() : null;
+      WL._free(yPtrPtr);
+      WL._PhraseSynthDelete(ps);
+      return audio;
+    }
+  };
+
+  // src/voice-worker.ts
+  var KOE_SAMPLE_RATE = 48e3;
+  var midiToFreq = (m) => 440 * 2 ** ((m - 69) / 12);
+  var wself = globalThis;
+  var bank = null;
+  var worldline = null;
+  var pcmCache = /* @__PURE__ */ new Map();
+  var getPcm = (alias) => {
+    let p = pcmCache.get(alias);
+    if (!p) {
+      p = bank.getPcm(alias);
+      pcmCache.set(alias, p);
+    }
+    return p;
+  };
+  var renderAlias = async (alias, pitch, durationMs) => {
+    if (!bank) return null;
+    const pcm = await getPcm(alias);
+    if (!pcm || pcm.length === 0) return null;
+    const entry = bank.manifest.phonemes[alias];
+    const lead = leadInFromEntry(entry);
+    const targetHz = midiToFreq(pitch);
+    if (worldline) {
+      const audio = worldline.renderNote({
+        pcm,
+        pitch: targetHz,
+        durationMs,
+        ...lead
+      });
+      if (audio) return { pcm: audio, preSec: lead.preMs / 1e3, rate: 1 };
+    }
+    const rate = entry.pitch > 0 ? targetHz / entry.pitch : 1;
+    return {
+      pcm: Float32Array.from(pcm),
+      preSec: entry.pre / KOE_SAMPLE_RATE / rate,
+      rate
+    };
+  };
+  wself.onmessage = async (ev) => {
+    const msg = ev.data;
+    if (msg.type === "init") {
+      try {
+        bank = await VoiceBank.load(msg.koe);
+        worldline = msg.lightweight ? null : await Worldline.load({ scriptUrl: msg.worldlineScriptUrl }).catch(
+          () => null
+        );
+        wself.postMessage({
+          type: "ready",
+          aliases: Object.keys(bank.manifest.phonemes)
+        });
+      } catch (err) {
+        wself.postMessage({
+          type: "error",
+          message: String(err?.message ?? err)
+        });
+      }
+      return;
+    }
+    if (msg.type === "render") {
+      const { id, alias, pitch, durationMs } = msg;
+      try {
+        const out = await renderAlias(alias, pitch, durationMs);
+        if (out) {
+          wself.postMessage(
+            {
+              type: "rendered",
+              id,
+              pcm: out.pcm,
+              preSec: out.preSec,
+              rate: out.rate
+            },
+            [out.pcm.buffer]
+          );
+        } else {
+          wself.postMessage({ type: "rendered", id, pcm: null });
+        }
+      } catch {
+        wself.postMessage({ type: "rendered", id, pcm: null });
+      }
+    }
+  };
+})();

package/package.json

@@ -2,7 +2,7 @@
   "author": "onjmin",
   "license": "MIT",
   "name": "@onjmin/dtm",
-  "version": "0.1.0",
+  "version": "0.1.4",
   "description": "MMLを中間言語に用いた、モバイルファーストなDAW / ピアノロール打ち込みコンポーネント",
   "homepage": "https://onjmin.github.io/dtm",
   "repository": {
@@ -48,12 +48,15 @@
     "rimraf": "6.0.1",
     "tsup": "8.5.0",
     "tsx": "4.20.6",
-    "typedoc": "0.28.4",
+    "typedoc": "0.28.19",
     "typescript": "5.8.3"
   },
+  "dependencies": {
+    "@onjmin/koe": "1.0.3"
+  },
   "scripts": {
     "dev": "rimraf dist && tsup && biome format src --write && tsx demo/server.ts",
-    "build": "rimraf dist && tsup && biome check src && biome format src --write",
+    "build": "rimraf dist && tsup && biome format src --write",
     "patch": "pnpm version patch",
     "publish-dangerous-dont-use-this-command": "pnpm publish --access public"
   }