@ugfoundation/swaralipi-js 0.1.5 → 0.2.0

package/dist/player/index.cjs

@@ -14,7 +14,9 @@ var TAALS = {
   // ষষ্ঠী
   teora: { id: "teora", numBeats: 7, bhaags: [3, 2, 2], sam: 0 },
   // টেওরা
-  teentaal: { id: "teentaal", numBeats: 16, bhaags: [4, 4, 4, 4], sam: 0, khaali: [8] }
+  teentaal: { id: "teentaal", numBeats: 16, bhaags: [4, 4, 4, 4], sam: 0, khaali: [8] },
+  aratheka: { id: "aratheka", numBeats: 16, bhaags: [4, 4, 4, 4], sam: 0, khaali: [8] }
+  // আড়াঠেকা
 };
 
 // src/player/pitch.ts
@@ -790,6 +792,269 @@ var SwaralipiPlayer = class {
   }
 };
 
+// src/player/export.ts
+function midiRange2(schedule) {
+  let lo = Infinity;
+  let hi = -Infinity;
+  for (const ev of schedule.events) {
+    for (const m of [ev.midi, ev.kan]) {
+      if (m !== null) {
+        if (m < lo) lo = m;
+        if (m > hi) hi = m;
+      }
+    }
+  }
+  return lo <= hi ? { lo, hi } : void 0;
+}
+function pickDef(id, o) {
+  const def = o.customInstruments?.[id] ?? INSTRUMENTS[id];
+  if (def === void 0) return INSTRUMENTS.harmonium;
+  if (id === "piano" && o.pianoBaseUrl) return { ...def, baseUrl: normalizeBase(o.pianoBaseUrl) };
+  if (def.local === true && !o.soundsBaseUrl) return INSTRUMENTS.harmonium;
+  return def;
+}
+function resolveTaal(doc, taal) {
+  const id = taal !== void 0 && taal !== "auto" ? taal : doc.meta.taal?.id;
+  return id !== void 0 && id in TAALS ? id : void 0;
+}
+function safeName(title) {
+  return (title ?? "").replace(/[\\/:*?"<>|]+/g, "").trim() || "swaralipi";
+}
+async function exportAudio(doc, options = {}) {
+  const Tone = await import('tone');
+  const base = options.soundsBaseUrl ?? DEFAULT_SOUNDS_BASE;
+  const format = options.format ?? "wav";
+  const channels = options.channels ?? 1;
+  const sampleRate = options.sampleRate ?? 44100;
+  const fadeOutSec = options.fadeOutSec ?? 0.4;
+  const rhythm = options.rhythm ?? "none";
+  const withMelody = options.melody ?? true;
+  const withTanpura = options.tanpura ?? false;
+  const schedule = buildSchedule(doc, { tonic: options.tonic, baseOctave: options.baseOctave });
+  const range = midiRange2(schedule);
+  const taalId = resolveTaal(doc, options.taal);
+  const variation = options.taal === void 0 || options.taal === "auto" ? doc.meta.taal?.variation : void 0;
+  const usesTabla = rhythm === "tabla" && taalId !== void 0 && SAMPLED_TAALS.has(taalId) && !!base;
+  const reqBpm = options.bpm ?? doc.meta.bpm ?? 90;
+  const bpm = usesTabla && taalId ? nearestTablaBpm(reqBpm, tablaBpms(taalId)) : reqBpm;
+  const spb = 60 / bpm;
+  const id = options.instrument ?? "piano";
+  const def = pickDef(id, options);
+  const durationSec = Math.max(schedule.totalBeats * spb + (def.release ?? 1) + fadeOutSec + 0.5, 0.5);
+  const rendered = await Tone.Offline(
+    async ({ transport }) => {
+      transport.bpm.value = bpm;
+      const master = new Tone.Gain(1).toDestination();
+      if (withMelody) {
+        const sampler = createSampler(Tone, def, base, range).connect(master);
+        for (const ev of schedule.events) {
+          if (ev.midi === null) continue;
+          const at = ev.beat * spb;
+          const dur = Math.max(ev.durationBeats * spb, 0.05);
+          if (ev.kan !== null) {
+            const name2 = midiToSampleName(ev.kan);
+            transport.scheduleOnce((t) => sampler.triggerAttackRelease(name2, spb * 0.4, t), Math.max(at - spb * 0.12, 0));
+          }
+          const name = midiToSampleName(ev.midi);
+          transport.scheduleOnce((t) => sampler.triggerAttackRelease(name, dur, t), at);
+        }
+      }
+      let tabla;
+      if (rhythm !== "none" && base) {
+        if (usesTabla && taalId) {
+          const url = tablaUrl(base, taalId, bpm, variation);
+          tabla = new Tone.Player({ url, loop: true }).connect(master);
+          tabla.sync().start(0);
+        } else {
+          const metro = createMetronome(Tone, base).connect(master);
+          const cycle = taalId !== void 0 ? TAALS[taalId].numBeats : 4;
+          let beat = 0;
+          transport.scheduleRepeat((time) => {
+            metro.volume.setValueAtTime(beat % cycle === 0 ? 0 : -8, time);
+            metro.start(time);
+            beat += 1;
+          }, spb, 0);
+        }
+      }
+      if (withTanpura && base) {
+        const tonicPc = (parseTonic(options.tonic ?? doc.meta.tonic) % 12 + 12) % 12;
+        const sa = TANPURA_PCS[tonicPc];
+        const pa = TANPURA_PCS[(tonicPc + 7) % 12];
+        const players = createTanpura(Tone, base, [sa, pa]).connect(master);
+        players.volume.value = -14;
+        const pattern = [pa, sa, sa, sa];
+        let i = 0;
+        transport.scheduleRepeat((time) => {
+          const stem = pattern[i % pattern.length];
+          if (players.has(stem)) players.player(stem).start(time);
+          i += 1;
+        }, spb * 2, 0);
+      }
+      await Tone.loaded();
+      if (tabla?.buffer?.loaded) tabla.loopEnd = quantizeLoopEnd(tabla.buffer.duration, spb);
+      if (fadeOutSec > 0) {
+        master.gain.setValueAtTime(1, Math.max(durationSec - fadeOutSec, 0));
+        master.gain.linearRampToValueAtTime(0, durationSec);
+      }
+      transport.start(0);
+    },
+    durationSec,
+    channels,
+    sampleRate
+  );
+  const chans = [];
+  for (let c = 0; c < rendered.numberOfChannels; c++) chans.push(rendered.getChannelData(c));
+  const bytes = format === "mp3" ? await encodeMp3(chans, rendered.sampleRate, options.mp3Kbps) : encodeWav(chans, rendered.sampleRate);
+  const mimeType = format === "mp3" ? "audio/mpeg" : "audio/wav";
+  return {
+    blob: new Blob([bytes], { type: mimeType }),
+    filename: `${safeName(doc.meta.title)}.${format}`,
+    mimeType,
+    durationSec: rendered.duration
+  };
+}
+function toInt16(f) {
+  const s = f < -1 ? -1 : f > 1 ? 1 : f;
+  return s < 0 ? s * 32768 : s * 32767;
+}
+function encodeWav(channels, sampleRate) {
+  const numCh = channels.length;
+  const frames = channels[0]?.length ?? 0;
+  const bytesPerSample = 2;
+  const blockAlign = numCh * bytesPerSample;
+  const dataSize = frames * blockAlign;
+  const buf = new ArrayBuffer(44 + dataSize);
+  const view = new DataView(buf);
+  const str = (off2, s) => {
+    for (let i = 0; i < s.length; i++) view.setUint8(off2 + i, s.charCodeAt(i));
+  };
+  str(0, "RIFF");
+  view.setUint32(4, 36 + dataSize, true);
+  str(8, "WAVE");
+  str(12, "fmt ");
+  view.setUint32(16, 16, true);
+  view.setUint16(20, 1, true);
+  view.setUint16(22, numCh, true);
+  view.setUint32(24, sampleRate, true);
+  view.setUint32(28, sampleRate * blockAlign, true);
+  view.setUint16(32, blockAlign, true);
+  view.setUint16(34, bytesPerSample * 8, true);
+  str(36, "data");
+  view.setUint32(40, dataSize, true);
+  let off = 44;
+  for (let f = 0; f < frames; f++) {
+    for (let c = 0; c < numCh; c++) {
+      view.setInt16(off, toInt16(channels[c][f]), true);
+      off += 2;
+    }
+  }
+  return new Uint8Array(buf);
+}
+function floatToInt16(f) {
+  const out = new Int16Array(f.length);
+  for (let i = 0; i < f.length; i++) out[i] = toInt16(f[i]);
+  return out;
+}
+function concatBytes(chunks) {
+  const total = chunks.reduce((n, c) => n + c.length, 0);
+  const out = new Uint8Array(total);
+  let off = 0;
+  for (const c of chunks) {
+    out.set(c, off);
+    off += c.length;
+  }
+  return out;
+}
+async function loadLame() {
+  try {
+    const mod = await import('@breezystack/lamejs');
+    const Mp3Encoder = mod.Mp3Encoder ?? mod.default?.Mp3Encoder;
+    if (!Mp3Encoder) throw new Error("no Mp3Encoder export");
+    return Mp3Encoder;
+  } catch {
+    throw new Error(
+      'MP3 export needs the optional peer dependency "@breezystack/lamejs" \u2014 install it, or export as WAV (format: "wav").'
+    );
+  }
+}
+async function encodeMp3(channels, sampleRate, kbps = 192) {
+  const Mp3Encoder = await loadLame();
+  const numCh = Math.min(channels.length, 2);
+  const enc = new Mp3Encoder(numCh, sampleRate, kbps);
+  const left = floatToInt16(channels[0] ?? new Float32Array());
+  const right = numCh > 1 ? floatToInt16(channels[1]) : void 0;
+  const block = 1152;
+  const out = [];
+  for (let i = 0; i < left.length; i += block) {
+    const l = left.subarray(i, i + block);
+    const chunk = right ? enc.encodeBuffer(l, right.subarray(i, i + block)) : enc.encodeBuffer(l);
+    if (chunk.length > 0) out.push(new Uint8Array(chunk));
+  }
+  const tail = enc.flush();
+  if (tail.length > 0) out.push(new Uint8Array(tail));
+  return concatBytes(out);
+}
+
+// src/player/midi.ts
+var PPQ = 480;
+function vlq(n) {
+  const out = [n & 127];
+  n >>>= 7;
+  while (n > 0) {
+    out.unshift(n & 127 | 128);
+    n >>>= 7;
+  }
+  return out;
+}
+function utf8(s) {
+  return [...new TextEncoder().encode(s)];
+}
+function u32be(n) {
+  return [n >>> 24 & 255, n >>> 16 & 255, n >>> 8 & 255, n & 255];
+}
+function encodeMidi(schedule, opts) {
+  const raw = [];
+  for (const ev of schedule.events) {
+    if (ev.midi === null) continue;
+    const start = Math.round(ev.beat * PPQ);
+    const end = Math.max(Math.round((ev.beat + ev.durationBeats) * PPQ), start + 1);
+    if (ev.kan !== null) {
+      const kOn = Math.max(start - Math.round(0.12 * PPQ), 0);
+      raw.push({ tick: kOn, on: true, note: ev.kan, vel: 70 });
+      raw.push({ tick: start, on: false, note: ev.kan, vel: 0 });
+    }
+    raw.push({ tick: start, on: true, note: ev.midi, vel: 100 });
+    raw.push({ tick: end, on: false, note: ev.midi, vel: 0 });
+  }
+  raw.sort((a, b) => a.tick - b.tick || Number(a.on) - Number(b.on));
+  const track = [];
+  if (opts.name) track.push(...vlq(0), 255, 3, ...vlq(utf8(opts.name).length), ...utf8(opts.name));
+  const usPerBeat = Math.round(6e7 / opts.bpm);
+  track.push(...vlq(0), 255, 81, 3, usPerBeat >> 16 & 255, usPerBeat >> 8 & 255, usPerBeat & 255);
+  let last = 0;
+  for (const e of raw) {
+    track.push(...vlq(e.tick - last), e.on ? 144 : 128, e.note & 127, e.vel & 127);
+    last = e.tick;
+  }
+  track.push(...vlq(0), 255, 47, 0);
+  const header = [77, 84, 104, 100, ...u32be(6), 0, 0, 0, 1, PPQ >> 8 & 255, PPQ & 255];
+  const trackChunk = [77, 84, 114, 107, ...u32be(track.length), ...track];
+  return new Uint8Array([...header, ...trackChunk]);
+}
+function safeName2(title) {
+  return (title ?? "").replace(/[\\/:*?"<>|]+/g, "").trim() || "swaralipi";
+}
+function exportMidi(doc, options = {}) {
+  const schedule = buildSchedule(doc, { tonic: options.tonic, baseOctave: options.baseOctave });
+  const bpm = options.bpm ?? doc.meta.bpm ?? 90;
+  const bytes = encodeMidi(schedule, { bpm, name: options.name ?? doc.meta.title });
+  return {
+    blob: new Blob([bytes], { type: "audio/midi" }),
+    filename: `${safeName2(doc.meta.title)}.mid`,
+    mimeType: "audio/midi"
+  };
+}
+
 exports.DEFAULT_SOUNDS_BASE = DEFAULT_SOUNDS_BASE;
 exports.INSTRUMENTS = INSTRUMENTS;
 exports.OCTAVE_OFFSET = OCTAVE_OFFSET;
@@ -801,6 +1066,11 @@ exports.TABLA_BPMS = TABLA_BPMS;
 exports.TABLA_VARIATIONS = TABLA_VARIATIONS;
 exports.TONEJS_INSTRUMENTS_BASE = TONEJS_INSTRUMENTS_BASE;
 exports.buildSchedule = buildSchedule;
+exports.encodeMidi = encodeMidi;
+exports.encodeMp3 = encodeMp3;
+exports.encodeWav = encodeWav;
+exports.exportAudio = exportAudio;
+exports.exportMidi = exportMidi;
 exports.instrumentSampleUrl = instrumentSampleUrl;
 exports.midiToSampleName = midiToSampleName;
 exports.nearestTablaBpm = nearestTablaBpm;