20210626-midi.tidal

setcps (170/60/4)

myRate = 128

-- First, you can start sending MIDI clock messages, 48 per cycle, like this:
p "midiclock" $ midicmd "midiClock*96" # s "ableton"

-- Your MIDI device should then adjust its BPM to Tidal's cps. Then it's worth sending a 'stop' message like this:
once $ midicmd "stop" # s "ableton"

-- and then finally a start message to start the MIDI clock at the right time. The following sends a start message every fourth cycle:
p "midictl" $ midicmd "start/4" # s "ableton"
-- p "midictl" $ midicmd "start" # s "ableton"

-- Once everything's started and in sync, it's probably best to stop sending the start messages to avoid glitching:
p "midictl" $ silence

p "sync-test"
  -- $ slow 2
  $ every 5 (skip) -- 0.25
  $ every 17 (0.75 <~)
  $ every 12 (0.5 <~)
  -- $ sound "mspFM(2, 8)"
  -- $ sound "bd(4, 8)"
  $ sound "bd(5, 8)"
  -- $ sound "hh"
  -- $ sound "[bd, hh] bd bd bd"
  # gain 0.75
  # speed "0.4 0.45 0.3"
  # sustain (range 0.001 0.09 (slow 128 (cosine)))
  -- # legato 1
  # djf 0.33
  # orbit out1


p "sync-test" silence

solo "sync-test"
unsolo "sync-test"


p "granny"
  -- $ sometimesBy 0.1 (|+ speed 0.2)
  -- $ sometimesBy 0.1 (# n 1)
  -- $ sometimesBy 0.15 (# n 3)
  $ slow 12
  -- $ striateBy "16" (1/16)
  $ sound "atmos:1"
  -- $ sound "loops-msp:2"
  -- $ sound "msp:0"
  # speed (range 0.6 0.72 (slow 8 (cosine)))
  -- # djf (range 0.1 0.82 (slow 16 (rand)))
  -- # hpf (range 50 100 (slow 16 (rand)))
  -- # distort (range 0.01 0.08 (slow 16 (rand)))
  -- # octer 0.1
  -- # phaserrate 0.05
  -- # phaserdepth 0.1
  # gain 0.7
  -- # orbit out8
  # orbit out1

p "granny" silence

solo "granny"
unsolo "granny"

d1 silence

d1 $ slow 4 $ striate 3 $ sound "numbers:0 numbers:1 numbers:2 numbers:3"

d1 $ slow 4 $ chop 3 $ sound "numbers:0 numbers:1 numbers:2 numbers:3"


-- Backbone --------------------------------------------------------------------
do
  unmute "rytm"
  unmute "rytm-midi"
  unmute "rytm-2"
  unmute "rytm-2-midi"
  unmute "rytm-5"
  unmute "ana4-1"
  unmute "ana4-2"
  unmute "ana4-3"
  unmute "ana4-4"
  unmute "spectral-002"

do
  mute "rytm"
  mute "sync-test"
  mute "rytm-midi"
  mute "rytm-2"
  mute "rytm-2-midi"
  mute "rytm-5"
  mute "ana4-1"
  mute "ana4-2"
  mute "ana4-3"
  mute "ana4-4"
  mute "spectral-002"

-- Percussion ------------------------------------------------------------------
do
  -- resetCycles
  unmute "sync-test"
  unmute "riser"
  unmute "pulse-sub"
  unmute "hat-half"
  unmute "hat-fast"
  unmute "clicker"
  unmute "snares-170"
  unmute "soundboi"
  unmute "east-perc"
  unmute "breakz-1"
  unmute "hard-snares"

do
  mute "main"
  mute "sync-test"
  mute "riser"
  mute "pulser"
  mute "pulse-sub"
  mute "hat-half"
  mute "hat-fast"
  mute "clicker"
  mute "snares-170"
  mute "live-snares"
  mute "soundboi"
  mute "east-perc"
  mute "breakz-1"
  mute "hard-snares"


unsolo "rytm"
solo "riser"
solo "pulser"
solo "hat-half"
unsolo "hat-fast"
unsolo "clicker"
unsolo "snares-170"
unsolo "east-perc"
unsolo "break"
solo "hard-snares"
unsolo "ana4-1"
unsolo "ana4-4"

mute "pulse-sub"

mute "sq-bass"

mute "hat-half"

unmute "hat-fast"

mute "hard-snares"

mute "riser"

mute "clicker"

mute "snares-170"

mute "east-perc"

mute "spectral-001"

unmute "spectral-002"

mute "ana4-1"
unmute "ana4-4"

p "rytm" silence

unmute "rytm"

solo "rytm"

unsolo "rytm"

p "ana4-1" silence

unmute "ana4-3"
solo "ana4-3"
unsolo "ana4-3"


do
  -- let structure = "1 <1 1 [0 1]> 1 1 0 0 1 0 0 1 0 0 1/3 0 0 0"
  let structure = "t(1,8)"
  let structure1 = structure
  let structure2 = "t(4,8)"
  let structure3 = "1 <1 0 [1 0 1 0]> 1 1 0 0 1 1 0 1 0 0 1/3 0 1 0"
  let structure4 = "t(8,8)"
  let structure5 = "t(16,8)"
  let structure6 = "t(32,8)"
  --
  let pattern = (every 5 inv structure)
  let pattern1 = structure1
  let pattern2 = (every 5 inv structure2)
  let pattern3 = (every 8 inv structure3)
  let pattern4 = (every 5 inv structure4)
  let pattern5 = (every 5 inv structure5)
  let pattern6 = structure6
  --
  let track = midichan
  --
  do -- RYTM -------------------------------------------------------------------
    p "rytm"
      $ slow 23
      -- $ every 3 (skip)
      $ sound "rytm"
      # track "[0, 5]"
      # note "c3"
      |+ note "<0 0 0 0 2>"
  do -- RYTM MIDI --------------------------------------------------------------
    p "rytm-midi"
      $ sound "rytm"
      # track "[0, 5]"
      # stack [
          ccn 28 # ccv (range 23 46 (slow 64 (sine))) -- sample start
          ,ccn 29 # ccv (range 0 23 (slow 64 (cosine))) -- sample end
          ,ccn 74 # ccv (range 0 127 (slow 64 (cosine))) -- filter freq
          ,ccn 16 # ccv "120 0 0 0 0 0 105 0 0 0 95 0 0 0 0 0"
      ]
  do -- HECTOR -----------------------------------------------------------------
    p "rytm-2"
      $ slow 22
      -- $ slow 3
      $ sound "rytm"
      # track "1"
      # note "c3"
      |+ note "<0 0 0 0 2>"
  do -- HECTOR MIDI ------------------------------------------------------------
    p "rytm-2-midi"
      $ sound "rytm"
      # track "1"
      # stack [
          ccn 74 # ccv (range 60 110 (slow 30 (cosine))) -- filter freq
          -- ccn 74 # ccv 40 -- filter freq
      ]
  do -- BASS -------------------------------------------------------------------
    p "rytm-5"
      $ slow 25
      $ sound "rytm" # track "[4]"
      # note "c3"
      |+ note "<0 0 0 0 2>"
  do -- ANA4 1 SIREN -----------------------------------------------------------
    let silence = "~"
    p "ana4-1"
      $ slow 36
      $ sound "ana4"
      # track 0
      |+ note "<0 0 0 0 2>"


  do -- ANA4 2 NOIZ ------------------------------------------------------------
    let silence = "~"
    p "ana4-2"
      $ press
      $ seqPLoop [
         (00, 01, sound "ana4" # track 1)
        ,(01, 16, sound "~" # track 1)
      ]
      # sustain 0.9
      |+ note "<0>"
  do -- ANA4 3 STABBER ---------------------------------------------------------
    let modSpeed = 16
    -- Amp Attack
    -- let ampEnvAttackMod    = (range 12 00 ((slow (modSpeed) $ cosine)))
    let ampEnvAttackMod    = 0
    -- Amp Sustain
    -- let ampEnvSustainMod   = (range 00 30 ((slow (modSpeed/2) $ cosine)))
    let ampEnvSustainMod   = 0
    -- Amp Release
    -- let ampEnvReleaseMod   = (range 71 120 ((slow (modSpeed*2) $ cosine)))
    let ampEnvReleaseMod   = 71
    -- Filter Attack
    let filterEnvAttackMod = (range 05 100 ((slow modSpeed $ cosine)))
    -- let filterEnvAttackMod = 35
    -- FX
    -- let delaySendMod = (range 40 10 ((slow modSpeed $ cosine)))
    -- let reverbSendMod = (range 40 10 ((slow modSpeed $ cosine)))
    -- MIDI
    let midiControl = stack [
                       ccn 104 # ccv ampEnvAttackMod
                      ,ccn 106 # ccv ampEnvSustainMod
                      ,ccn 107 # ccv ampEnvReleaseMod
                      ,ccn 108 # ccv filterEnvAttackMod
                     ]
    let midiControl2 = stack [
                       ccn 104 # ccv (ampEnvAttackMod)
                      ,ccn 106 # ccv (range 40 70 ((slow (modSpeed) $ cosine)))
                      ,ccn 107 # ccv (range 71 30 ((slow (modSpeed) $ cosine)))
                      ,ccn 108 # ccv filterEnvAttackMod
                     ]
    let silence = "~"
    p "ana4-3"
      $ slow 2
      $ every 3 (slow 1)
      $ seqPLoop [
         -- (00, 16, struct "t(3,8)" $ sound "ana4" # midiControl  # track 2)
         (00, 16, struct pattern1 $ sound "ana4" # midiControl  # track 2)
        ,(16, 20, struct pattern2 $ sound "ana4" # midiControl2 # track 2)
        ,(20, 36, struct pattern3 $ sound "ana4" # midiControl  # track 2)
        ,(36, 40, struct pattern4 $ sound "ana4" # midiControl  # track 2)
        ,(40, 43, struct pattern5 $ sound "ana4" # midiControl  # track 2)
        ,(43, 44, struct pattern6 $ sound "ana4" # midiControl2  # track 2)
      ]
      # note
        (
          (
            scale "chromatic"
            $ "d5 d5/3 d5 d5 <d5 d5/2 d5 a5*3> d5 <d5 ds5 d5> f5/3"
          )
        )
      |+ note "<0 0 3 -2>"
  do -- ANA4 4 FM BASS ---------------------------------------------------------
    let silence = "~"
    p "ana4-4"
      $ slow 2
      $ every 3 (slow 1)
      $ sometimesBy 0.1 skip
      $ seqPLoop [
         -- (00, 16, struct "t(3,8)" $ sound "ana4" # track 3)
         (00, 16, struct pattern1 $ sound "ana4" # track 3)
        ,(16, 20, struct pattern2 $ sound "ana4" # track 3)
        ,(20, 36, struct pattern3 $ sound "ana4" # track 3)
        ,(36, 40, struct pattern4 $ sound "ana4" # track 3)
        ,(40, 43, struct pattern5 $ sound "ana4" # track 3)
        ,(43, 44, struct pattern6 $ sound "ana4" # track 3)
      ]
      # note
        (
          (
            scale "chromatic"
            $ "d5 d5/3 d5 d5 <d5 d5/2 d5 a5*3> d5 <d5 ds5 d5> f5/3"
          )
        )
      |+ note "<0 0 3 -2>"