@hraness/dawg 0.6.1 → 0.7.0

package/core/sections.ts

@@ -13,9 +13,19 @@
  */
 import { DRUM_VOICES, isDrumInstrument } from "./drums.ts";
 import { FX_LANES } from "./fx.ts";
+import { synthKit } from "./kits.ts";
 import { resolveString } from "./strings.ts";
 import { modalSettings, windSettings } from "./resonators.ts";
-import { slicePedals } from "./expression.ts";
+import { resolveSing } from "./sing.ts";
+import { slicePedals, type PedalEvent, type PedalState } from "./expression.ts";
+import {
+  bakeClipTime,
+  copyClipBars,
+  deleteClipBars,
+  insertClipBars,
+  sliceClips,
+  type ClipPiece,
+} from "./clips.ts";
 import {
   SCORE_LIMITS,
   withNoteCap,
@@ -23,6 +33,7 @@ import {
   TrackScore,
   isSamplerInstrument,
   wavetableOf,
+  type AudioClip,
   type AutomationPoint,
   type FormEntry,
   type Note,
@@ -32,10 +43,10 @@ import {
 } from "./score.ts";
 import {
   barStartTick,
-  bpmAtTick,
   hasTrackTime,
   normalizeSongTime,
   performedNotes,
+  timeMapFor,
   type Fermata,
   type SongTime,
   type TempoEvent,
@@ -61,6 +72,11 @@ export function sliceSongTime(
     };
   const clampBpm = (bpm: number) =>
     Math.min(SCORE_LIMITS.maxTempoBpm, Math.max(SCORE_LIMITS.minTempoBpm, bpm));
+  // The written tempo: a fermata's hold belongs to its own beat and moves
+  // with it, so it must not leak into the tempo restated at a seam.
+  const map = timeMapFor(score);
+  const bpmAtTick = (_score: TrackScore, tick: number) =>
+    map ? map.tempoAt(tick) : score.tempoBpm;
   const sorted = [...pieces].sort((a, b) => a.offset - b.offset);
   const first = sorted[0];
   const tempoBpm = clampBpm(
@@ -147,7 +163,10 @@ export function bakeTrackTime(
     () =>
       new TrackScore({
         ...score.toJSON(),
-        tracks: score.tracks.map(({ time: _time, ...track }) => track),
+        tracks: score.tracks.map((track) => {
+          const { time: _time, ...rest } = bakeClipTime(track);
+          return rest;
+        }),
         notes,
       }),
   );
@@ -394,8 +413,73 @@ export function applySectionChanges(score: TrackScore): TrackScore {
     }
     notes.push(cut);
   }
+  // Clips (0.7): a section that mutes a track silences its clips there, its
+  // variation gain scales them; a clip crossing such an edge is cut.
+  const total = Math.max(
+    score.bars,
+    ...score.sections.map((s) => s.startBar + s.bars),
+  );
+  const clipTracks = score.tracks.map((track) => {
+    if (!track.clips) return track;
+    const pieces: ClipPiece[] = [];
+    for (let bar = 0; bar < total; bar += 1) {
+      const section = sectionAtBar(score, bar);
+      pieces.push({
+        from: bar * ticks,
+        to: (bar + 1) * ticks,
+        offset: bar * ticks,
+        ...clipPieceState(section, track.id),
+      });
+    }
+    // The last bar runs on, so a clip sounding past the end is not cut.
+    if (pieces.length > 0)
+      pieces[pieces.length - 1] = {
+        ...pieces[pieces.length - 1]!,
+        to: SCORE_LIMITS.maxTick + 1,
+      };
+    const next = withClips(track, sliceClips(track.clips, pieces, score));
+    if (JSON.stringify(next.clips) !== JSON.stringify(track.clips))
+      changed = true;
+    return next;
+  });
   if (!changed) return score;
-  return new TrackScore({ ...score.toJSON(), notes, sections: [], form: [] });
+  return new TrackScore({
+    ...score.toJSON(),
+    tracks: clipTracks,
+    notes,
+    sections: [],
+    form: [],
+  });
+}
+
+/** A section's mute and variation gain for one track's clips. */
+function clipPieceState(
+  section: Section | undefined,
+  trackId: string,
+): Pick<ClipPiece, "mute" | "gain"> {
+  if (!section) return {};
+  if (section.mute?.includes(trackId)) return { mute: true };
+  const gain = section.vary?.[trackId]?.gain;
+  return gain === undefined || gain === 1 ? {} : { gain };
+}
+
+/** `track` with `clips` (absent when empty). */
+function withClips(
+  track: Track,
+  clips: readonly AudioClip[] | undefined,
+): Track {
+  const { clips: _clips, ...rest } = track;
+  return clips && clips.length > 0 ? { ...rest, clips } : rest;
+}
+
+/** A track's clips cut to `pieces` (sections, forms, windows). */
+function sliceTrackClips(
+  track: Track,
+  pieces: readonly ClipPiece[],
+  time: TrackScore,
+): Track {
+  if (!track.clips) return track;
+  return withClips(track, sliceClips(track.clips, pieces, time));
 }
 
 /**
@@ -433,9 +517,13 @@ export function sectionScore(score: TrackScore, section: Section): TrackScore {
     time: timed.time ?? null,
     bars: section.bars,
     tracks: score.tracks.map((track) =>
-      slicePedals(
-        mapAutomation(track, (points) => cropPoints(points, from, to)),
-        [{ from, to, offset: 0 }],
+      sliceTrackClips(
+        slicePedals(
+          mapAutomation(track, (points) => cropPoints(points, from, to)),
+          [{ from, to, offset: 0 }],
+        ),
+        [{ from, to, offset: 0, ...clipPieceState(section, track.id) }],
+        score,
       ),
     ),
     notes,
@@ -602,6 +690,77 @@ function checkBars(bars: number): void {
     );
 }
 
+/**
+ * The song tempo map, fermatas and pedal lanes for a ripple edit that lays
+ * `pieces` of the score end to end: they move with the music they belong
+ * to, as notes and automation do.
+ */
+function rippleTime(
+  score: TrackScore,
+  pieces: readonly { from: number; to: number; offset: number }[],
+): Readonly<{
+  tempoBpm: number;
+  time: SongTime | null;
+  pedals: (track: Track) => Track;
+}> {
+  const kept = pieces.filter((piece) => piece.to > piece.from);
+  const timed = sliceSongTime(
+    score,
+    kept.map((piece) => ({
+      ...piece,
+      to: Math.min(piece.to, SCORE_LIMITS.maxTick + 1),
+    })),
+  );
+  return {
+    tempoBpm: timed.tempoBpm,
+    time: timed.time ?? null,
+    pedals: (track) => {
+      if (!track.pedal && !track.softPedal && !track.sostenuto) return track;
+      const out: Record<string, unknown> = { ...track };
+      for (const field of ["pedal", "softPedal", "sostenuto"] as const) {
+        const events = track[field];
+        if (!events) continue;
+        const next = ripplePedal(events, kept);
+        if (next) out[field] = next;
+        else delete out[field];
+      }
+      return out as Track;
+    },
+  };
+}
+
+/**
+ * A pedal lane for `pieces` laid end to end with no lift at the seams (unlike
+ * a render slice): each piece starts in the state its source was in, and a
+ * gap left between pieces (inserted bars) holds the state before it.
+ */
+function ripplePedal(
+  events: readonly PedalEvent[],
+  pieces: readonly { from: number; to: number; offset: number }[],
+): readonly PedalEvent[] | undefined {
+  const byTick = new Map<number, PedalState>();
+  for (const { from, to, offset } of pieces) {
+    let state: PedalState = "up";
+    for (const event of events) {
+      if (event.tick > from) break;
+      state = event.state;
+    }
+    byTick.set(offset, state);
+    for (const event of events)
+      if (event.tick > from && event.tick < to)
+        byTick.set(event.tick - from + offset, event.state);
+  }
+  const out: PedalEvent[] = [];
+  let last: PedalState = "up";
+  for (const tick of [...byTick.keys()].sort((a, b) => a - b)) {
+    const state = byTick.get(tick)!;
+    if (state === last) continue;
+    out.push({ tick, state });
+    last = state;
+  }
+  return out.length > 0 ? out : undefined;
+}
+
 /** Insert `count` empty bars at `atBar`, shifting later music and sections. */
 export function insertBars(
   score: TrackScore,
@@ -613,16 +772,32 @@ export function insertBars(
   const ticks = barTicks(score);
   const at = atBar * ticks;
   const shift = count * ticks;
+  const ripple = rippleTime(score, [
+    { from: 0, to: at, offset: 0 },
+    { from: at, to: Infinity, offset: at + shift },
+  ]);
   return new TrackScore({
     ...score.toJSON(),
+    tempoBpm: ripple.tempoBpm,
+    time: ripple.time,
     bars: score.bars + count,
     tracks: score.tracks.map((track) =>
-      mapAutomation(track, (points) => insertPoints(points, at, shift)),
+      insertClipBars(
+        mapAutomation(ripple.pedals(track), (points) =>
+          insertPoints(points, at, shift),
+        ),
+        at,
+        shift,
+      ),
     ),
+    // A note's start and end stay with the music they sit in, so one held
+    // across the insertion point sounds on through the new bars.
     notes: score.notes.map((note) =>
       note.startTick >= at
         ? { ...note, startTick: note.startTick + shift }
-        : note,
+        : note.startTick + note.durationTicks > at
+          ? { ...note, durationTicks: note.durationTicks + shift }
+          : note,
     ),
     sections: score.sections.map((section) =>
       section.startBar >= atBar
@@ -640,6 +815,12 @@ export function deleteBars(
   atBar: number,
   count: number,
 ): TrackScore {
+  if (!Number.isInteger(atBar) || atBar < 0 || !Number.isInteger(count))
+    throw new ScoreValidationError(
+      `bars to delete must start at a whole bar inside the song`,
+    );
+  // Only bars inside the song can go (a section may sit past its end).
+  count = Math.min(atBar + count, score.bars) - atBar;
   if (count <= 0) return score;
   if (count >= score.bars)
     throw new ScoreValidationError("a song keeps at least one bar");
@@ -647,16 +828,21 @@ export function deleteBars(
   const at = atBar * ticks;
   const end = (atBar + count) * ticks;
   const shift = count * ticks;
+  // Each note's start and end stay with the music they sit in; the part
+  // inside the deleted bars goes, so a note running out of them keeps its
+  // tail and one running into them is cut where they start.
+  const place = (tick: number) =>
+    tick < at ? tick : tick < end ? at : tick - shift;
   const notes: Note[] = [];
   for (const note of score.notes) {
-    if (note.startTick >= end)
-      notes.push({ ...note, startTick: note.startTick - shift });
-    else if (note.startTick < at)
-      notes.push(
-        note.startTick + note.durationTicks > at
-          ? { ...note, durationTicks: at - note.startTick }
-          : note,
-      );
+    const startTick = place(note.startTick);
+    const stop = place(note.startTick + note.durationTicks);
+    if (stop <= startTick) continue;
+    notes.push(
+      startTick === note.startTick && stop - startTick === note.durationTicks
+        ? note
+        : { ...note, startTick, durationTicks: stop - startTick },
+    );
   }
   const sections: Section[] = [];
   for (const section of score.sections) {
@@ -677,11 +863,23 @@ export function deleteBars(
     }
   }
   const names = new Set(sections.map((section) => foldName(section.name)));
+  const ripple = rippleTime(score, [
+    { from: 0, to: at, offset: 0 },
+    { from: end, to: Infinity, offset: at },
+  ]);
   return new TrackScore({
     ...score.toJSON(),
+    tempoBpm: ripple.tempoBpm,
+    time: ripple.time,
     bars: score.bars - count,
     tracks: score.tracks.map((track) =>
-      mapAutomation(track, (points) => deletePoints(points, at, shift)),
+      deleteClipBars(
+        mapAutomation(ripple.pedals(track), (points) =>
+          deletePoints(points, at, shift),
+        ),
+        at,
+        end,
+      ),
     ),
     notes,
     sections,
@@ -865,6 +1063,15 @@ export function duplicateSection(
   if (options.as !== undefined && findSection(score, options.as))
     throw new ScoreValidationError(`a section named ${options.as} exists`);
   const at = options.toBar ?? section.startBar + section.bars;
+  if (
+    !Number.isInteger(at) ||
+    at < 0 ||
+    at > score.bars ||
+    (at > section.startBar && at < section.startBar + section.bars)
+  )
+    throw new ScoreValidationError(
+      `a copy of ${section.name} goes at a bar 1..${score.bars + 1} outside it`,
+    );
   const opened = insertBars(score, at, section.bars);
   const source =
     section.startBar >= at ? section.startBar + section.bars : section.startBar;
@@ -908,10 +1115,26 @@ export function copyBars(
         Math.min(note.durationTicks, from + length - note.startTick),
       ),
     }));
+  // The copied bars bring their tempo, fermatas and pedal; the music after
+  // them goes on as it was.
+  const ripple = rippleTime(score, [
+    { from: 0, to, offset: 0 },
+    { from, to: from + length, offset: to },
+    { from: to + length, to: Infinity, offset: to + length },
+  ]);
   return new TrackScore({
     ...score.toJSON(),
+    tempoBpm: ripple.tempoBpm,
+    time: ripple.time,
     tracks: score.tracks.map((track) =>
-      mapAutomation(track, (points) => copyPoints(points, from, length, to)),
+      copyClipBars(
+        mapAutomation(ripple.pedals(track), (points) =>
+          copyPoints(points, from, length, to),
+        ),
+        from,
+        length,
+        to,
+      ),
     ),
     notes: [...kept, ...copies],
   });
@@ -1235,17 +1458,38 @@ export function arrangedSlice(
 ): TrackScore {
   const ticks = barTicks(score);
   const pieces: { from: number; to: number; offset: number }[] = [];
+  // Clips (0.7) are cut per section pass; a window's own edges inside a
+  // pass (or where the form plays straight on) are seams, never cuts, so a
+  // windowed render plays them as one pass does.
+  const clipPieces: (ClipPiece & { section: Section })[] = [];
   const end = fromBar + bars;
+  let previous: FormSegment | undefined;
   for (const segment of formSegments(score)) {
     const segEnd = segment.startBar + segment.bars;
+    const before = previous;
+    previous = segment;
     if (segEnd <= fromBar || segment.startBar >= end) continue;
     const start = Math.max(segment.startBar, fromBar);
     const stop = Math.min(segEnd, end);
     const from = (segment.section.startBar + start - segment.startBar) * ticks;
-    pieces.push({
+    const piece = {
       from,
       to: from + (stop - start) * ticks,
       offset: (start - fromBar) * ticks,
+    };
+    pieces.push(piece);
+    const straight =
+      before !== undefined &&
+      before.section.startBar + before.bars === segment.section.startBar;
+    clipPieces.push({
+      ...piece,
+      section: segment.section,
+      ...(stop < segEnd ? { to: from + (segEnd - start) * ticks } : {}),
+      ...(clipPieces.length === 0 &&
+      fromBar > 0 &&
+      (start > segment.startBar || straight)
+        ? { seam: true }
+        : {}),
     });
   }
   const shift = fromBar * ticks;
@@ -1256,7 +1500,14 @@ export function arrangedSlice(
     time: timed.time ?? null,
     bars,
     tracks: score.tracks.map((track) =>
-      slicePedals(sliceLanes(track, pieces), pieces),
+      sliceTrackClips(
+        slicePedals(sliceLanes(track, pieces), pieces),
+        clipPieces.map(({ section, ...piece }) => ({
+          ...piece,
+          ...clipPieceState(section, track.id),
+        })),
+        score,
+      ),
     ),
     notes: arrangedNotes(score, fromBar, fromBar + noteBars).map((note) => ({
       ...note,
@@ -1341,7 +1592,11 @@ function laneFallback(track: Track, lane: string): number | undefined {
             ? track.modal && modalSettings(track.modal)
             : spec.effect === "wind"
               ? track.wind && windSettings(track.wind)
-              : (track.fx as Record<string, unknown> | undefined)?.[spec.effect]
+              : spec.effect === "sing"
+                ? track.sing && resolveSing(track.sing)
+                : (track.fx as Record<string, unknown> | undefined)?.[
+                    spec.effect
+                  ]
   ) as Record<string, unknown> | undefined;
   const stored = source?.[spec.param];
   return typeof stored === "number" ? stored : spec.spec.default;
@@ -1364,6 +1619,8 @@ const TOM = DRUM_VOICES.find((voice) => voice.voice === "tom")!.pitch;
 const TOMS = [50, 47, TOM] as const;
 const KICK = DRUM_VOICES.find((voice) => voice.voice === "kick")!.pitch;
 const OPEN_HAT = DRUM_VOICES.find((voice) => voice.voice === "openhat")!.pitch;
+/** GM crash 1, which calibration 1+ renders as a cymbal. */
+const CRASH = 49;
 
 /** Generator tracks, reused by later builds and drops. */
 export const GENERATOR_TRACKS = Object.freeze({
@@ -1955,7 +2212,10 @@ export type FillOptions = Readonly<{
   /** Beats the fill lasts, default 1. */
   beats?: number;
   style?: FillStyle;
-  /** Crash (open hat with kick) on the next downbeat, default on. */
+  /**
+   * Crash with kick on the next downbeat, default on: GM 49 on a
+   * calibrated song's synth kit, else an open hat.
+   */
   crash?: boolean;
 }>;
 
@@ -2000,6 +2260,12 @@ export function generateFill(
     drums = GENERATOR_TRACKS.fills;
   }
   const style = options.style ?? "toms";
+  // Sample kits and legacy songs have no cymbal voice: keep the open hat.
+  const kit = next.tracks.find((track) => track.id === drums)?.kit;
+  const crash =
+    (next.calibration ?? 0) >= 1 && (kit === undefined || synthKit(kit))
+      ? CRASH
+      : OPEN_HAT;
   const clamped: string[] = [];
   const beats = clampNote(
     options.beats ?? 1,
@@ -2030,8 +2296,8 @@ export function generateFill(
               : SNARE
             : progress < 0.25
               ? SNARE
-              : // High, mid, low tom down the fill (GM 50/47/45); the
-                // built-in kit folds all three onto its tom.
+              : // High, mid, low tom down the fill (GM 50/47/45); a
+                // calibrated song pitches them, older songs fold them.
                 TOMS[Math.min(2, Math.floor(((progress - 0.25) / 0.75) * 3))]!;
       fill.push({
         id: nextId(),
@@ -2043,7 +2309,7 @@ export function generateFill(
       });
     }
     if ((options.crash ?? true) && end < next.bars * ticks)
-      for (const pitch of [OPEN_HAT, KICK])
+      for (const pitch of [crash, KICK])
         fill.push({
           id: nextId(),
           trackId: drums,