@onjmin/dtm 0.1.67 → 0.1.69

package/dist/index.mjs

@@ -2653,54 +2653,73 @@ var createSingingVoices = (ctx, destination, options = {}) => {
       forEachSungNote(track, (note, prevVowel) => {
         items.push({ note, prevVowel });
       });
+      if (items.length === 0) return;
       const peak = Math.max(1e-4, track.volume);
-      for (const { note, prevVowel } of items) {
-        if (session !== streamSession) return;
-        while (note.startSec - (ctx.currentTime - anchorTime) > STREAM_LOOKAHEAD_SEC) {
-          await new Promise((resolve) => setTimeout(resolve, STREAM_POLL_MS));
+      const loopStartSec = opts?.loopStartSec ?? 0;
+      let loopOffsetSec = 0;
+      let pass = 0;
+      do {
+        for (const { note, prevVowel } of items) {
           if (session !== streamSession) return;
-        }
-        if (opts?.isAudible && !opts.isAudible(track)) continue;
-        const t0 = anchorTime + note.startSec;
-        if (model.renderToCache && model.scheduleCached) {
-          const renderToCache = model.renderToCache;
-          const scheduleCached = model.scheduleCached;
-          void (async () => {
-            const key = await renderToCache(
-              note.syllable,
-              prevVowel,
-              note.pitch,
-              note.durationSec * 1e3
-            );
+          if (pass > 0 && note.startSec < loopStartSec - 1e-4) {
+            continue;
+          }
+          if (opts?.loopLengthSec && opts.loopLengthSec > 0 && note.startSec >= loopStartSec + opts.loopLengthSec - 1e-4) {
+            continue;
+          }
+          const startSec = note.startSec + loopOffsetSec;
+          while (startSec - (ctx.currentTime - anchorTime) > STREAM_LOOKAHEAD_SEC) {
+            await new Promise((resolve) => setTimeout(resolve, STREAM_POLL_MS));
             if (session !== streamSession) return;
-            if (key) {
-              const delay = ctx.currentTime - t0;
-              if (delay < 0.05) {
-                scheduleCached(key, t0, peak, track.pan);
-                opts?.onScheduled?.(track, note, t0);
-              } else {
-                console.warn(
-                  `[dtm] Synthesizer late skip: ${note.syllable.kana} at ${note.startSec}s (delayed by ${delay.toFixed(3)}s)`
-                );
-                opts?.onLateSkip?.(note, delay);
+          }
+          if (opts?.isAudible && !opts.isAudible(track)) continue;
+          const t0 = anchorTime + startSec;
+          if (model.renderToCache && model.scheduleCached) {
+            const renderToCache = model.renderToCache;
+            const scheduleCached = model.scheduleCached;
+            void (async () => {
+              const key = await renderToCache(
+                note.syllable,
+                prevVowel,
+                note.pitch,
+                note.durationSec * 1e3
+              );
+              if (session !== streamSession) return;
+              if (key) {
+                const delay = ctx.currentTime - t0;
+                if (delay < 0.05) {
+                  scheduleCached(key, t0, peak, track.pan);
+                  opts?.onScheduled?.(track, note, t0);
+                } else {
+                  console.warn(
+                    `[dtm] Synthesizer late skip: ${note.syllable.kana} at ${startSec}s (delayed by ${delay.toFixed(3)}s)`
+                  );
+                  opts?.onLateSkip?.(note, delay);
+                }
               }
-            }
-          })();
+            })();
+          } else {
+            const when = t0 - ctx.currentTime;
+            model(note.syllable, {
+              trackId: "",
+              pitch: note.pitch,
+              velocity: 100,
+              volume: peak,
+              when,
+              duration: note.durationSec,
+              pan: track.pan
+            });
+            opts?.onScheduled?.(track, note, t0);
+            await new Promise((resolve) => setTimeout(resolve, 0));
+          }
+        }
+        if (opts?.loopLengthSec && opts.loopLengthSec > 0) {
+          loopOffsetSec += opts.loopLengthSec;
+          pass++;
         } else {
-          const when = t0 - ctx.currentTime;
-          model(note.syllable, {
-            trackId: "",
-            pitch: note.pitch,
-            velocity: 100,
-            volume: peak,
-            when,
-            duration: note.durationSec,
-            pan: track.pan
-          });
-          opts?.onScheduled?.(track, note, t0);
-          await new Promise((resolve) => setTimeout(resolve, 0));
+          break;
         }
-      }
+      } while (session === streamSession);
     };
     for (const track of tracks) void runTrack(track);
   };
@@ -3275,6 +3294,13 @@ var createSynth = (ctx, destination = ctx.destination, tone = {}) => {
   const wave = tone.wave ?? "square";
   const attack = tone.attack ?? 0;
   const gainScale = tone.gain ?? 1;
+  const compressor = ctx.createDynamicsCompressor();
+  compressor.threshold.value = -12;
+  compressor.knee.value = 6;
+  compressor.ratio.value = 8;
+  compressor.attack.value = 3e-3;
+  compressor.release.value = 0.15;
+  compressor.connect(destination);
   const playNote3 = (e) => {
     const osc = ctx.createOscillator();
     const gain = ctx.createGain();
@@ -3307,9 +3333,9 @@ var createSynth = (ctx, destination = ctx.destination, tone = {}) => {
       panner = ctx.createStereoPanner();
       panner.pan.value = Math.max(-1, Math.min(1, e.pan));
       gain.connect(panner);
-      panner.connect(destination);
+      panner.connect(compressor);
     } else {
-      gain.connect(destination);
+      gain.connect(compressor);
     }
     osc.start(t0);
     osc.stop(t0 + e.duration + 0.02);
@@ -3331,7 +3357,7 @@ var createSynth = (ctx, destination = ctx.destination, tone = {}) => {
       osc.frequency.exponentialRampToValueAtTime(50, t0 + 0.12);
       g2.gain.setValueAtTime(vol * 0.135, t0);
       g2.gain.exponentialRampToValueAtTime(1e-3, t0 + 0.18);
-      osc.connect(g2).connect(destination);
+      osc.connect(g2).connect(compressor);
       osc.start(t0);
       osc.stop(t0 + 0.2);
       osc.onended = () => osc.disconnect();
@@ -3350,7 +3376,7 @@ var createSynth = (ctx, destination = ctx.destination, tone = {}) => {
     const g = ctx.createGain();
     g.gain.setValueAtTime(vol * (isSnareLike ? 0.105 : 0.06), t0);
     g.gain.exponentialRampToValueAtTime(1e-3, t0 + dur);
-    src.connect(filter).connect(g).connect(destination);
+    src.connect(filter).connect(g).connect(compressor);
     src.start(t0);
     src.stop(t0 + dur);
     src.onended = () => {
@@ -3364,6 +3390,7 @@ var createSynth = (ctx, destination = ctx.destination, tone = {}) => {
 
 // src/headless-player.ts
 var STEPS_PER_BAR = 192;
+var TRACK_ID_BY_INDEX = ["melody", "submelody", "bass", "chord"];
 var playPlacements = (placements, options) => {
   const bpm = options.bpm;
   const drumPatternDict = options.drumPatterns ?? DRUM_PATTERNS;
@@ -3382,7 +3409,11 @@ var playPlacements = (placements, options) => {
       pitch: p.pitch,
       velocity: p.velocity
     }));
-    return { id: String(index), volume: masterVolume, notes };
+    return {
+      id: TRACK_ID_BY_INDEX[index] ?? `t${index}`,
+      volume: masterVolume,
+      notes
+    };
   });
   const ownsCtx = !options.audioContext;
   const ctx = options.audioContext ?? new AudioContext();
@@ -13006,12 +13037,240 @@ var mountDAW = (target, options = {}) => {
 };
 
 // src/headless-singing-player.ts
-var playSingingMML = (_mml, _options = {}) => {
-  return Promise.reject(
-    new Error(
-      "playSingingMML is not implemented yet. See implementation notes at the top of headless-singing-player.ts."
-    )
+var STEPS_PER_BEAT4 = 48;
+var STEPS_PER_BAR3 = 192;
+var TRACK_ID_BY_INDEX2 = ["melody", "submelody", "bass", "chord"];
+var playSingingMML = async (mml, options = {}) => {
+  const {
+    placements,
+    bpm: parsedBpm,
+    meta,
+    lyrics
+  } = parseMML(mml, {
+    collectLyrics: true
+  });
+  const lyricTracks = lyrics ?? /* @__PURE__ */ new Map();
+  const customVocalByKey = new Map(
+    parseCustomVocals(mml).map((d) => [d.key, d])
+  );
+  const bpm = parsedBpm ?? options.defaultBpm ?? DEFAULT_BPM;
+  const secondsPerStep = 60 / bpm / STEPS_PER_BEAT4;
+  const drumPatternDict = options.drumPatterns ?? DRUM_PATTERNS;
+  const drumPattern = meta.drum ? drumPatternDict[meta.drum] ?? null : null;
+  const drumVolume = meta.drumVolume ?? 80;
+  const trackVolume = meta.volume ?? 100;
+  let masterVolume = options.volume ?? 100;
+  const trackIndices = [...new Set(placements.map((p) => p.trackIndex))].sort(
+    (a, b) => a - b
   );
+  const seqTracks = trackIndices.map((index) => {
+    let id = 0;
+    const notes = placements.filter((p) => p.trackIndex === index).map((p) => ({
+      id: id++,
+      startStep: p.startStep,
+      durationSteps: p.durationSteps,
+      pitch: p.pitch,
+      velocity: p.velocity
+    }));
+    return {
+      id: TRACK_ID_BY_INDEX2[index] ?? `t${index}`,
+      volume: trackVolume / 100 * masterVolume,
+      notes
+    };
+  });
+  const ownsCtx = !options.audioContext;
+  const ctx = options.audioContext ?? new AudioContext();
+  const destination = options.destination ?? ctx.destination;
+  const useSynth = options.synth ?? !options.onPlayNote;
+  const synth = useSynth ? createSynth(ctx, destination) : null;
+  const pauseWhenHidden = options.pauseWhenHidden ?? ownsCtx;
+  let playing = false;
+  let destroyed = false;
+  let voices = options.singingVoices ?? null;
+  const buildStreamTracks = (fromStep) => [...lyricTracks.entries()].map(([index, lt]) => {
+    const seqTrack = seqTracks.find(
+      (t) => t.id === (TRACK_ID_BY_INDEX2[index] ?? `t${index}`)
+    );
+    const sorted = [...seqTrack?.notes ?? []].sort(
+      (a, b) => a.startStep - b.startStep
+    );
+    const gate = (lt.gate ?? DEFAULT_GATE) / 100;
+    const semis = (lt.octave ?? 0) * 12;
+    const count = Math.min(sorted.length, lt.syllables.length);
+    const notes = [];
+    for (let i = 0; i < count; i++) {
+      const n = sorted[i];
+      if (n.startStep < fromStep) continue;
+      notes.push({
+        syllable: lt.syllables[i],
+        pitch: n.pitch + semis,
+        startSec: (n.startStep - fromStep) * secondsPerStep,
+        durationSec: n.durationSteps * secondsPerStep * gate
+      });
+    }
+    return {
+      id: TRACK_ID_BY_INDEX2[index] ?? `t${index}`,
+      model: lt.model,
+      volume: vocalVolumeToGain(lt.volume ?? DEFAULT_VOCAL_VOLUME),
+      pan: panToStereo(lt.pan ?? DEFAULT_PAN),
+      notes
+    };
+  });
+  const seq = createSequencer({
+    getTracks: () => seqTracks,
+    getBpm: () => bpm,
+    getPlayStartStep: () => 0,
+    getDrumPattern: () => drumPattern,
+    getSoloTrackId: () => null,
+    getLoop: () => options.loop ?? false,
+    cues: options.cues,
+    onCue: options.onCue,
+    getAudioTime: () => ctx.currentTime,
+    onPlayNote: (e) => {
+      const namedIdx = TRACK_ID_BY_INDEX2.indexOf(
+        e.trackId
+      );
+      const trackIdx = namedIdx >= 0 ? namedIdx : Number(e.trackId);
+      if (lyricTracks.has(trackIdx)) return;
+      options.onPlayNote?.(e);
+      synth?.playNote(e);
+    },
+    onPlayDrum: (e) => {
+      const velocity = e.velocity * (drumVolume / 100) * (trackVolume / 100) * (masterVolume / 100);
+      options.onPlayDrum?.({ ...e, velocity });
+      synth?.playDrum({ ...e, velocity });
+    },
+    onTick: (step) => {
+      options.onTick?.(step);
+    },
+    onEnd: (_interrupted) => finish(),
+    stepsPerBar: STEPS_PER_BAR3
+  });
+  const finish = () => {
+    if (!playing) return;
+    playing = false;
+    voices?.stopStream();
+    options.onStop?.();
+  };
+  const onVisibilityChange = () => {
+    if (!playing) return;
+    if (document.hidden) {
+      void ctx.suspend();
+    } else if (ctx.state === "suspended") {
+      void ctx.resume();
+    }
+  };
+  if (pauseWhenHidden && typeof document !== "undefined") {
+    document.addEventListener("visibilitychange", onVisibilityChange);
+  }
+  const stop = () => {
+    if (!playing) return;
+    seq.stop();
+    finish();
+  };
+  const setVolume = (volume) => {
+    masterVolume = volume;
+    const effectiveTrackVolume = trackVolume / 100 * masterVolume;
+    for (const t of seqTracks) t.volume = effectiveTrackVolume;
+    voices?.setVolume(trackVolume / 100 * (masterVolume / 100));
+  };
+  const suspend = () => ctx.suspend();
+  const resume = () => ctx.resume();
+  const destroy = () => {
+    seq.stop();
+    playing = false;
+    destroyed = true;
+    voices?.reset();
+    if (pauseWhenHidden && typeof document !== "undefined") {
+      document.removeEventListener("visibilitychange", onVisibilityChange);
+    }
+    if (ownsCtx && ctx.state !== "closed") {
+      void ctx.close();
+    }
+  };
+  const playback = {
+    stop,
+    isPlaying: () => playing,
+    setVolume,
+    suspend,
+    resume,
+    destroy
+  };
+  playing = true;
+  try {
+    const resumes = [];
+    const r = options.onResumeAudio?.();
+    if (r) resumes.push(Promise.resolve(r));
+    if (ctx.state === "suspended") resumes.push(ctx.resume());
+    if (resumes.length > 0) await Promise.all(resumes);
+    if (!playing || destroyed) {
+      return playback;
+    }
+    if (lyricTracks.size > 0) {
+      if (!voices) {
+        voices = createSingingVoices(ctx, destination, {
+          voiceWorkerUrl: options.voiceWorkerUrl
+        });
+      }
+      if (customVocalByKey.size > 0 && voices.registerVoicebanks) {
+        voices.registerVoicebanks(
+          Object.fromEntries([...customVocalByKey].map(([k, d]) => [k, d.url]))
+        );
+      }
+      const streamTracks = buildStreamTracks(0);
+      await voices.loadModels(streamTracks.map((t) => t.model));
+      if (!playing || destroyed) {
+        return playback;
+      }
+      await voices.warm(streamTracks, PREWARM_NOTES);
+      if (!playing || destroyed) {
+        return playback;
+      }
+      let loopLengthSec;
+      let loopStartSec;
+      const loopOption = options.loop ?? false;
+      if (loopOption) {
+        let loopStartStep = 0;
+        let loopEndStep = -1;
+        if (typeof loopOption === "object") {
+          loopStartStep = loopOption.start ? resolveLoopPoint(
+            loopOption.start,
+            bpm,
+            STEPS_PER_BAR3,
+            secondsPerStep
+          ) : 0;
+          const endVal = loopOption.end ? resolveLoopPoint(
+            loopOption.end,
+            bpm,
+            STEPS_PER_BAR3,
+            secondsPerStep
+          ) : null;
+          loopEndStep = endVal !== null ? endVal : -1;
+        }
+        if (loopEndStep === -1) {
+          let maxEndStep = 0;
+          for (const p of placements) {
+            maxEndStep = Math.max(maxEndStep, p.startStep + p.durationSteps);
+          }
+          loopEndStep = maxEndStep;
+        }
+        loopStartSec = loopStartStep * secondsPerStep;
+        loopLengthSec = (loopEndStep - loopStartStep) * secondsPerStep;
+      }
+      seq.start(0);
+      voices.setVolume(trackVolume / 100 * (masterVolume / 100));
+      voices.startStream(streamTracks, seq.getStartTime(), {
+        loopLengthSec,
+        loopStartSec
+      });
+    } else {
+      seq.start(0);
+    }
+  } catch (err2) {
+    stop();
+    throw err2;
+  }
+  return playback;
 };
 
 // src/piano-roll.ts
@@ -14165,6 +14424,80 @@ var createDtmStudio = async (options = {}) => {
       onResumeAudio: resumeAudio
     });
   };
+  const playSingingMMLInstance = (mml, opts = {}) => {
+    const { placements } = parseMML(mml);
+    const trackIndices = [...new Set(placements.map((p) => p.trackIndex))].sort(
+      (a, b) => a - b
+    );
+    const isAdvancedMode = trackIndices.some((idx) => idx >= 4);
+    const playerPreset = defaultPreset;
+    void loadPreset(
+      playerPreset,
+      trackIndices.map(String),
+      isAdvancedMode ? "advanced" : "simple"
+    );
+    const playPlayerNote = (e) => {
+      const trackIdx = Number(e.trackId);
+      const role = TRACK_ROLES[trackIdx] ?? "melody";
+      let sfInst = resolveSoundFont(
+        playerPreset,
+        role,
+        isAdvancedMode ? "advanced" : "simple"
+      );
+      if (!sfInst) {
+        void loadPreset(
+          playerPreset,
+          [role],
+          isAdvancedMode ? "advanced" : "simple"
+        );
+        sfInst = resolveSoundFont(
+          playerPreset,
+          role,
+          isAdvancedMode ? "advanced" : "simple"
+        );
+      }
+      if (!sfInst) return;
+      sfInst.play({
+        ctx: audioCtx,
+        destination: masterGain,
+        pitch: e.pitch,
+        volume: e.volume,
+        when: e.when,
+        duration: e.duration
+      });
+    };
+    return playSingingMML(mml, {
+      ...opts,
+      audioContext: audioCtx,
+      destination: masterGain,
+      synth: false,
+      singingVoices,
+      onPlayNote: playPlayerNote,
+      onPlayDrum: playDrum,
+      onResumeAudio: resumeAudio
+    });
+  };
+  const playNoteEvent = (e) => {
+    const idx = Number(e.trackId);
+    const role = TRACK_ROLES[idx] ?? "melody";
+    let sfInst = resolveSoundFont(defaultPreset, role, "simple");
+    if (!sfInst) {
+      void loadPreset(defaultPreset, [role], "simple");
+      sfInst = resolveSoundFont(defaultPreset, role, "simple");
+    }
+    if (!sfInst) return;
+    sfInst.play({
+      ctx: audioCtx,
+      destination: masterGain,
+      pitch: e.pitch,
+      volume: e.volume,
+      when: e.when,
+      duration: e.duration
+    });
+  };
+  const playDrumEvent = (e) => {
+    playDrum(e);
+  };
   const playNote3 = async (options2) => {
     await listReady;
     const key = options2.instrument ? resolveNameToKey(options2.instrument) : void 0;
@@ -14270,6 +14603,9 @@ var createDtmStudio = async (options = {}) => {
     mountPlayer,
     mountChordPlayer: mountChordPlayerInstance,
     play,
+    playSingingMML: playSingingMMLInstance,
+    playNoteEvent,
+    playDrumEvent,
     playNote: playNote3,
     playChords: playChords3,
     loadPreset,
@@ -14369,6 +14705,7 @@ export {
   playNote,
   playPlacements,
   playSingingMML,
+  resolveLoopPoint,
   setBackgroundActive,
   setDrawOffset,
   shiftNotes,

package/package.json

@@ -2,7 +2,7 @@
   "author": "onjmin",
   "license": "MIT",
   "name": "@onjmin/dtm",
-  "version": "0.1.67",
+  "version": "0.1.69",
   "description": "MMLを中間言語に用いた、モバイルファーストなDAW / ピアノロール打ち込みコンポーネント",
   "homepage": "https://onjmin.github.io/dtm",
   "repository": {