takomusic 1.2.0

package/lib/dynamics.mf

@@ -0,0 +1,141 @@
+// Dynamics functions for TakoMusic
+// Volume and velocity control over time
+
+import { clip, lerp } from "./utils.mf";
+
+// Crescendo - gradually increase velocity
+export proc crescendo(notes, durs, startVel, endVel) {
+  const count = len(notes);
+  for (i in 0..count) {
+    const t = i / (count - 1);
+    const vel = floor(lerp(startVel, endVel, t));
+    note(notes[i], durs[i], clip(vel, 1, 127));
+  }
+}
+
+// Decrescendo (diminuendo) - gradually decrease velocity
+export proc decrescendo(notes, durs, startVel, endVel) {
+  crescendo(notes, durs, startVel, endVel);
+}
+
+// Crescendo with uniform duration
+export proc crescendoUniform(notes, dur, startVel, endVel) {
+  const count = len(notes);
+  for (i in 0..count) {
+    const t = i / (count - 1);
+    const vel = floor(lerp(startVel, endVel, t));
+    note(notes[i], dur, clip(vel, 1, 127));
+  }
+}
+
+// Decrescendo with uniform duration
+export proc decrescendoUniform(notes, dur, startVel, endVel) {
+  crescendoUniform(notes, dur, startVel, endVel);
+}
+
+// Apply accent pattern to notes
+// pattern: array of booleans, true = accented
+export proc accentPattern(notes, pattern, dur, baseVel, accentVel) {
+  for (i in 0..len(notes)) {
+    const patIdx = i % len(pattern);
+    let vel = baseVel;
+    if (pattern[patIdx]) {
+      vel = accentVel;
+    }
+    note(notes[i], dur, clip(vel, 1, 127));
+  }
+}
+
+// Sforzando - sudden strong accent then immediate drop
+export proc sforzando(pitch, dur, peakVel, sustainVel) {
+  const attackDur = dur / 8;
+  const sustainDur = dur * 7/8;
+  note(pitch, attackDur, clip(peakVel, 1, 127));
+  note(pitch, sustainDur, clip(sustainVel, 1, 127));
+}
+
+// Forte-piano - loud attack immediately soft
+export proc fortePiano(pitch, dur, forteVel, pianoVel) {
+  const attackDur = dur / 16;
+  const sustainDur = dur * 15/16;
+  note(pitch, attackDur, clip(forteVel, 1, 127));
+  note(pitch, sustainDur, clip(pianoVel, 1, 127));
+}
+
+// Rinforzando - reinforced accent
+export proc rinforzando(pitch, dur, vel) {
+  const accentedVel = clip(vel + 25, 1, 127);
+  note(pitch, dur, accentedVel);
+}
+
+// Swell - crescendo then decrescendo (messa di voce)
+export proc swell(pitch, dur, minVel, maxVel, steps) {
+  const halfSteps = floor(steps / 2);
+  const stepDur = dur / steps;
+
+  // Crescendo half
+  for (i in 0..halfSteps) {
+    const t = i / halfSteps;
+    const vel = floor(lerp(minVel, maxVel, t));
+    note(pitch, stepDur, clip(vel, 1, 127));
+  }
+
+  // Decrescendo half
+  for (i in 0..steps - halfSteps) {
+    const t = i / (steps - halfSteps);
+    const vel = floor(lerp(maxVel, minVel, t));
+    note(pitch, stepDur, clip(vel, 1, 127));
+  }
+}
+
+// Hairpin crescendo using CC expression
+export proc hairpinCresc(startVal, endVal, dur) {
+  const ticks = durToTicks(dur);
+  const steps = 16;
+
+  for (i in 0..=steps) {
+    const t = i / steps;
+    const val = floor(lerp(startVal, endVal, t));
+    const tick = floor(ticks * t);
+    atTick(tick);
+    expression(clip(val, 0, 127));
+  }
+}
+
+// Hairpin decrescendo using CC expression
+export proc hairpinDecresc(startVal, endVal, dur) {
+  hairpinCresc(startVal, endVal, dur);
+}
+
+// Subito forte - suddenly loud
+export proc subitoForte(pitch, dur) {
+  note(pitch, dur, 112);
+}
+
+// Subito piano - suddenly soft
+export proc subitoPiano(pitch, dur) {
+  note(pitch, dur, 50);
+}
+
+// Morendo - dying away (decreasing velocity and slowing)
+export proc morendo(notes, baseDur, startVel) {
+  const count = len(notes);
+  for (i in 0..count) {
+    const t = i / count;
+    const vel = floor(startVel * (1 - t * 0.8));
+    const dur = baseDur * (1 + t * 0.5);
+    note(notes[i], dur, clip(vel, 1, 127));
+  }
+}
+
+// Perdendosi - fading away to nothing
+export proc perdendosi(notes, baseDur, startVel) {
+  const count = len(notes);
+  for (i in 0..count) {
+    const t = i / count;
+    const vel = floor(startVel * (1 - t));
+    if (vel > 0) {
+      note(notes[i], baseDur, clip(vel, 1, 127));
+    }
+  }
+}

package/lib/expression.mf

@@ -0,0 +1,221 @@
+// Expression functions for TakoMusic
+// Pitch bend, modulation, and expressive techniques
+
+import { clip, lerp } from "./utils.mf";
+
+// Vibrato using pitch bend
+// depth: semitones (e.g., 0.5 for half semitone)
+// rate: oscillations per beat
+export proc vibrato(pitch, dur, depth, rate) {
+  const ticks = durToTicks(dur);
+  const cycles = floor(rate * 4);
+  const steps = cycles * 8;
+  const stepTicks = floor(ticks / steps);
+
+  // Play the note
+  note(pitch, dur);
+
+  // Apply pitch bend oscillation
+  at(cursor());
+  advanceTick(-ticks);
+
+  for (i in 0..steps) {
+    const phase = (i % 8) / 8;
+    let bend = 0;
+
+    // Sine-like approximation
+    if (phase < 0.25) {
+      bend = phase * 4;
+    } else {
+      if (phase < 0.75) {
+        bend = 1 - (phase - 0.25) * 4;
+      } else {
+        bend = -1 + (phase - 0.75) * 4;
+      }
+    }
+
+    const bendVal = floor(8192 + bend * depth * 4096);
+    pitchBend(clip(bendVal, 0, 16383));
+    advanceTick(stepTicks);
+  }
+
+  // Reset pitch bend
+  pitchBend(8192);
+}
+
+// Simple vibrato (fewer parameters)
+export proc vibratoSimple(pitch, dur) {
+  vibrato(pitch, dur, 0.3, 5);
+}
+
+// Portamento / glide between two pitches
+export proc portamento(fromPitch, toPitch, dur) {
+  const fromMidi = pitchMidi(fromPitch);
+  const toMidi = pitchMidi(toPitch);
+  const semitones = toMidi - fromMidi;
+  const ticks = durToTicks(dur);
+  const steps = 16;
+  const stepTicks = floor(ticks / steps);
+
+  // Start from the first pitch
+  note(fromPitch, dur);
+
+  // Glide using pitch bend
+  at(cursor());
+  advanceTick(-ticks);
+
+  for (i in 0..=steps) {
+    const t = i / steps;
+    const bendSemitones = semitones * t;
+    const bendVal = floor(8192 + bendSemitones * 4096 / 2);
+    pitchBend(clip(bendVal, 0, 16383));
+    advanceTick(stepTicks);
+  }
+
+  // Reset
+  pitchBend(8192);
+}
+
+// Bend up to pitch
+export proc bendUp(pitch, dur, semitones) {
+  const ticks = durToTicks(dur);
+  const steps = 8;
+  const stepTicks = floor(ticks / steps);
+
+  // Start with bend down
+  pitchBend(floor(8192 - semitones * 4096 / 2));
+  note(pitch, dur);
+
+  // Bend up to normal
+  at(cursor());
+  advanceTick(-ticks);
+
+  for (i in 0..=steps) {
+    const t = i / steps;
+    const bendVal = floor(8192 - semitones * (1 - t) * 4096 / 2);
+    pitchBend(clip(bendVal, 0, 16383));
+    advanceTick(stepTicks);
+  }
+
+  pitchBend(8192);
+}
+
+// Bend down from pitch
+export proc bendDown(pitch, dur, semitones) {
+  const ticks = durToTicks(dur);
+  const steps = 8;
+  const stepTicks = floor(ticks / steps);
+
+  note(pitch, dur);
+
+  at(cursor());
+  advanceTick(-ticks);
+
+  for (i in 0..=steps) {
+    const t = i / steps;
+    const bendVal = floor(8192 - semitones * t * 4096 / 2);
+    pitchBend(clip(bendVal, 0, 16383));
+    advanceTick(stepTicks);
+  }
+
+  pitchBend(8192);
+}
+
+// Scoop - quick bend up into note
+export proc scoop(pitch, dur, semitones) {
+  bendUp(pitch, dur, semitones);
+}
+
+// Fall - bend down at end of note
+export proc fall(pitch, dur, semitones) {
+  const mainDur = dur * 3/4;
+  const fallDur = dur * 1/4;
+
+  note(pitch, mainDur);
+
+  const ticks = durToTicks(fallDur);
+  const steps = 4;
+  const stepTicks = floor(ticks / steps);
+
+  for (i in 0..=steps) {
+    const t = i / steps;
+    const bendVal = floor(8192 - semitones * t * 4096 / 2);
+    pitchBend(clip(bendVal, 0, 16383));
+    advanceTick(stepTicks);
+  }
+
+  pitchBend(8192);
+}
+
+// Modulation wheel automation
+export proc modulationSwell(startVal, peakVal, dur) {
+  const ticks = durToTicks(dur);
+  const halfTicks = floor(ticks / 2);
+  const steps = 8;
+
+  // Increase
+  for (i in 0..=steps) {
+    const t = i / steps;
+    const val = floor(lerp(startVal, peakVal, t));
+    atTick(floor(halfTicks * t));
+    modulation(clip(val, 0, 127));
+  }
+
+  // Decrease
+  for (i in 0..=steps) {
+    const t = i / steps;
+    const val = floor(lerp(peakVal, startVal, t));
+    atTick(halfTicks + floor(halfTicks * t));
+    modulation(clip(val, 0, 127));
+  }
+}
+
+// Breath controller (CC2)
+export proc breathController(startVal, endVal, dur) {
+  const ticks = durToTicks(dur);
+  const steps = 16;
+
+  for (i in 0..=steps) {
+    const t = i / steps;
+    const val = floor(lerp(startVal, endVal, t));
+    atTick(floor(ticks * t));
+    cc(2, clip(val, 0, 127));
+  }
+}
+
+// Tremolo using modulation
+export proc tremoloMod(pitch, dur, depth, rate) {
+  const ticks = durToTicks(dur);
+  const cycles = floor(rate * 4);
+  const steps = cycles * 4;
+  const stepTicks = floor(ticks / steps);
+
+  note(pitch, dur);
+
+  at(cursor());
+  advanceTick(-ticks);
+
+  for (i in 0..steps) {
+    const phase = (i % 4) / 4;
+    let val = 0;
+
+    if (phase < 0.5) {
+      val = floor(depth * phase * 2);
+    } else {
+      val = floor(depth * (1 - (phase - 0.5) * 2));
+    }
+
+    modulation(clip(val, 0, 127));
+    advanceTick(stepTicks);
+  }
+
+  modulation(0);
+}
+
+// Legato transition between notes
+export proc legatoSlide(fromPitch, toPitch, dur, slideDur) {
+  const mainDur = dur - slideDur;
+
+  note(fromPitch, mainDur);
+  portamento(fromPitch, toPitch, slideDur);
+}

package/lib/genres.mf

@@ -0,0 +1,348 @@
+// Genre-specific patterns for TakoMusic
+// Common rhythm and accompaniment patterns by genre
+
+// Bossa Nova guitar pattern
+export proc bossaNovaGuitar(chordNotes, dur) {
+  const eighth = dur / 2;
+
+  // Classic bossa pattern: bass on 1, chord on 'and' of 1, etc.
+  note(chordNotes[0], eighth);          // bass
+  chord(slice(chordNotes, 1, len(chordNotes)), eighth);  // chord
+  rest(eighth);
+  chord(chordNotes, eighth);
+  rest(eighth);
+  chord(chordNotes, eighth);
+  note(chordNotes[0], eighth);
+  chord(slice(chordNotes, 1, len(chordNotes)), eighth);
+}
+
+// Bossa Nova drum pattern
+export proc bossaNovaDrums(dur, bars) {
+  const eighth = dur / 2;
+
+  for (bar in 0..bars) {
+    // Rim click pattern
+    for (beat in 0..8) {
+      if (beat == 2 || beat == 5) {
+        drum(snare, eighth);
+      } else {
+        drum(hhc, eighth);
+      }
+    }
+  }
+}
+
+// Funk guitar/keyboard stab
+export proc funkStab(chordNotes, dur) {
+  const sixteenth = dur / 4;
+
+  // Classic funk pattern with ghost notes
+  chord(chordNotes, sixteenth, 100);
+  rest(sixteenth);
+  chord(chordNotes, sixteenth, 60);
+  rest(sixteenth);
+  rest(sixteenth);
+  chord(chordNotes, sixteenth, 100);
+  rest(sixteenth);
+  chord(chordNotes, sixteenth, 70);
+}
+
+// Funk drum pattern
+export proc funkDrums(dur, bars) {
+  const sixteenth = dur / 4;
+
+  for (bar in 0..bars) {
+    for (beat in 0..16) {
+      // Kick pattern
+      if (beat == 0 || beat == 6 || beat == 10) {
+        drum(kick, sixteenth);
+      }
+
+      // Snare on 2 and 4 with ghost notes
+      if (beat == 4 || beat == 12) {
+        drum(snare, sixteenth, 100);
+      }
+      if (beat == 3 || beat == 7 || beat == 11 || beat == 15) {
+        drum(snare, sixteenth, 40);
+      }
+
+      // Hi-hat
+      if (beat % 2 == 0) {
+        drum(hhc, sixteenth);
+      }
+
+      // Fill gaps with rest
+      if (beat == 1 || beat == 2 || beat == 5 || beat == 8 || beat == 9 || beat == 13 || beat == 14) {
+        rest(sixteenth);
+      }
+    }
+  }
+}
+
+// Reggae skank (offbeat chords)
+export proc reggaeSkank(chordNotes, dur, bars) {
+  const eighth = dur / 2;
+
+  for (bar in 0..bars) {
+    for (beat in 0..8) {
+      if (beat % 2 == 1) {
+        chord(chordNotes, eighth, 90);
+      } else {
+        rest(eighth);
+      }
+    }
+  }
+}
+
+// Reggae one drop drum pattern
+export proc reggaeOneDrop(dur, bars) {
+  const eighth = dur / 2;
+
+  for (bar in 0..bars) {
+    for (beat in 0..8) {
+      // Kick and snare together on 3
+      if (beat == 4) {
+        drum(kick, eighth);
+        drum(snare, eighth);
+      }
+
+      // Hi-hat on every eighth
+      drum(hhc, eighth);
+    }
+  }
+}
+
+// EDM four-on-the-floor kick
+export proc fourOnFloor(dur, bars) {
+  for (bar in 0..bars) {
+    for (beat in 0..4) {
+      drum(kick, dur);
+    }
+  }
+}
+
+// EDM offbeat hi-hat
+export proc offbeatHiHat(dur, bars) {
+  const eighth = dur / 2;
+
+  for (bar in 0..bars) {
+    for (beat in 0..8) {
+      if (beat % 2 == 1) {
+        drum(hho, eighth);
+      } else {
+        rest(eighth);
+      }
+    }
+  }
+}
+
+// EDM buildup (increasing hi-hat density)
+export proc edmBuildup(bars) {
+  const sixteenth = 1/16;
+
+  for (bar in 0..bars) {
+    const density = floor(4 + bar * 4);
+    for (i in 0..16) {
+      if (i % floor(16 / density) == 0) {
+        drum(hhc, sixteenth);
+      } else {
+        rest(sixteenth);
+      }
+    }
+  }
+}
+
+// Rock drum beat
+export proc rockBeat(dur, bars) {
+  const eighth = dur / 2;
+
+  for (bar in 0..bars) {
+    for (beat in 0..8) {
+      // Kick on 1 and 3
+      if (beat == 0 || beat == 4) {
+        drum(kick, eighth);
+      }
+
+      // Snare on 2 and 4
+      if (beat == 2 || beat == 6) {
+        drum(snare, eighth);
+      }
+
+      // Constant hi-hat
+      drum(hhc, eighth);
+
+      if (beat == 1 || beat == 3 || beat == 5 || beat == 7) {
+        rest(eighth);
+      }
+    }
+  }
+}
+
+// Rock power chord riff pattern
+export proc powerChordRiff(root, dur) {
+  const eighth = dur / 2;
+  const pwr = [root, transpose(root, 7)];
+
+  chord(pwr, eighth, 100);
+  chord(pwr, eighth, 100);
+  rest(eighth);
+  chord(pwr, eighth, 80);
+  rest(dur);
+  chord(pwr, dur, 100);
+}
+
+// Shuffle/blues pattern
+export proc shuffleBeat(dur, bars) {
+  const triplet = dur / 3;
+
+  for (bar in 0..bars) {
+    for (beat in 0..4) {
+      // Kick on 1 and 3
+      if (beat == 0 || beat == 2) {
+        drum(kick, triplet * 2);
+        drum(hhc, triplet);
+      } else {
+        // Snare on 2 and 4
+        drum(snare, triplet * 2);
+        drum(hhc, triplet);
+      }
+    }
+  }
+}
+
+// Jazz ride pattern
+export proc jazzRide(dur, bars) {
+  const triplet = dur / 3;
+
+  for (bar in 0..bars) {
+    for (beat in 0..4) {
+      drum(ride, triplet * 2);
+      drum(ride, triplet);
+    }
+  }
+}
+
+// Jazz walking bass style
+export proc jazzWalk(scale, dur, bars) {
+  for (bar in 0..bars) {
+    for (beat in 0..4) {
+      const idx = (bar * 4 + beat) % len(scale);
+      note(transpose(scale[idx], -12), dur);
+    }
+  }
+}
+
+// Latin tumbao bass pattern
+export proc tumbaoBass(root, fifth, dur) {
+  const eighth = dur / 2;
+
+  rest(eighth);
+  note(transpose(root, -12), eighth);
+  rest(eighth);
+  note(transpose(fifth, -12), eighth);
+  note(transpose(root, -12), eighth);
+  rest(eighth);
+  rest(eighth);
+  note(transpose(fifth, -12), eighth);
+}
+
+// Salsa clave (son clave 3-2)
+export proc salsaClave(dur, bars) {
+  const eighth = dur / 2;
+
+  for (bar in 0..floor(bars / 2)) {
+    // 3 side
+    drum(hhc, eighth);
+    rest(eighth);
+    rest(eighth);
+    drum(hhc, eighth);
+    rest(eighth);
+    rest(eighth);
+    drum(hhc, eighth);
+    rest(eighth);
+
+    // 2 side
+    rest(eighth);
+    rest(eighth);
+    drum(hhc, eighth);
+    rest(eighth);
+    drum(hhc, eighth);
+    rest(eighth);
+    rest(eighth);
+    rest(eighth);
+  }
+}
+
+// Disco beat
+export proc discoBeat(dur, bars) {
+  const eighth = dur / 2;
+
+  for (bar in 0..bars) {
+    for (beat in 0..8) {
+      // Four on the floor
+      if (beat % 2 == 0) {
+        drum(kick, eighth);
+      }
+
+      // Open hi-hat on offbeats
+      if (beat % 2 == 1) {
+        drum(hho, eighth);
+      }
+
+      // Snare on 2 and 4
+      if (beat == 2 || beat == 6) {
+        drum(snare, eighth);
+      }
+    }
+  }
+}
+
+// Hip-hop boom bap beat
+export proc boomBap(dur, bars) {
+  const sixteenth = dur / 4;
+
+  for (bar in 0..bars) {
+    for (beat in 0..16) {
+      // Kick pattern
+      if (beat == 0 || beat == 5 || beat == 10) {
+        drum(kick, sixteenth);
+      }
+
+      // Snare on 2 and 4
+      if (beat == 4 || beat == 12) {
+        drum(snare, sixteenth);
+      }
+
+      // Hi-hat
+      if (beat % 2 == 0) {
+        drum(hhc, sixteenth);
+      }
+
+      // Rest for gaps
+      if (beat == 1 || beat == 2 || beat == 3 || beat == 6 || beat == 7 || beat == 8 || beat == 9 || beat == 11 || beat == 13 || beat == 14 || beat == 15) {
+        rest(sixteenth);
+      }
+    }
+  }
+}
+
+// Trap hi-hat rolls
+export proc trapHiHats(dur, bars) {
+  const thirtysecond = dur / 8;
+
+  for (bar in 0..bars) {
+    for (beat in 0..4) {
+      // Regular hits with occasional rolls
+      if (beat == 2) {
+        // Roll on beat 3
+        for (i in 0..8) {
+          drum(hhc, thirtysecond);
+        }
+      } else {
+        for (i in 0..4) {
+          drum(hhc, dur / 4);
+        }
+      }
+    }
+  }
+}