(ns com.aurellem.run.music

   (:use (com.aurellem.gb saves gb-driver util constants

                          items vbm characters money

                          rlm-assembly))

   (:use (com.aurellem.run util title save-corruption

                           bootstrap-0 bootstrap-1))

   (:require clojure.string)

   (:import [com.aurellem.gb.gb_driver SaveState])

   (:import java.io.File))

 

 (def third-kind

   (File. "/home/r/proj/midi/third-kind.mid"))

 

 (def pony

   (File. "/home/r/proj/vba-clojure/music/pony-title.mid"))

 

 (def sync-test

   (File. "/home/r/proj/vba-clojure/music/sync-test.mid"))

 

 

 (defn raw-midi-text [#^File midi-file]

   (:out 

    (clojure.java.shell/sh

     "midicsv"

     (.getCanonicalPath midi-file)

     "-")))

 

 (def command-line #"^(\d+), (\d+), ([^,]+)(.*)$")

 

 (defmulti parse-command :command)

 

 (defn discard-args [command] (dissoc command :args))

 

 (defmethod parse-command :Start_track

   [command] (discard-args command))

 

 (defmethod parse-command :End_track

   [command] (discard-args command))

 

 (defmethod parse-command :default

   [command] command)

 

 (defn parse-number-list

   [number-list-str]

   (map #(Integer/parseInt %)

        (clojure.string/split number-list-str #", ")))

 

 (defmethod parse-command :Tempo

   [command]

   (update-in command [:args] #(Integer/parseInt %)))

 

 (defn parse-midi-note-list

   [midi-note-list-str]

   (let [[channel note velocity]

         (parse-number-list midi-note-list-str)]

     {:channel channel :note note :velocity velocity}))

 

 (defmethod parse-command :Note_on_c

   [command]

   (update-in command [:args] parse-midi-note-list))

 

 (defmethod parse-command :Note_off_c

   [command]

   (update-in command [:args] parse-midi-note-list))

 

 (defmethod parse-command :Header

   [command]

   (let [args (:args command)

         [format num-tracks division] (parse-number-list args)]

     (assoc command :args

            {:format format

             :num-tracks num-tracks

             :division division})))

         

 (defmethod parse-command :Program_c

   [command]

   (let [args (:args command)

         [channel program-num] (parse-number-list args)]

     (assoc command :args

            {:channel channel

             :program-num program-num})))

 

 (defn parse-midi [#^File midi-file]

   (map

    (comp parse-command

          (fn [line]

            (let [[[_ channel time command args]]

                  (re-seq command-line line)]

              {:channel (Integer/parseInt channel)

               :time (Integer/parseInt time)

               :command (keyword command)

               :args (apply str (drop 2 args))})))

    (drop-last

     (clojure.string/split-lines

      (raw-midi-text midi-file)))))

   

 (def music-base new-kernel)

 

 (defn store [n address]

   (flatten

    [0xF5

     0xE5

     

     0x3E

     n

     

     0x21

     (reverse (disect-bytes-2 address))

 

     0x77

     

     0xE1

     0xF1]))

 

 (defn infinite-loop []

   [0x18 0xFE])

 

 (def divider-register 0xFF04)

 

 (defrecord Bit-Note [frequency volume duration duty])

 

 (defn clear-music-registers []

   (flatten

    [(store (Integer/parseInt "00000000" 2) 0xFF10) ;; sweep

     (store (Integer/parseInt "00000000" 2) 0xFF11) ;; pattern duty

     (store (Integer/parseInt "00000000" 2) 0xFF12) ;; volume

     (store (Integer/parseInt "00000000" 2) 0xFF13) ;; frequency-low

     (store (Integer/parseInt "00000000" 2) 0xFF14) ;; frequency-high

 

     (store (Integer/parseInt "00000000" 2) 0xFF16) ;; pattern duty 000000

     (store (Integer/parseInt "00000000" 2) 0xFF17) ;; volume 0000

     (store (Integer/parseInt "00000000" 2) 0xFF18) ;; frequency-low

     (store (Integer/parseInt "00000000" 2) 0xFF19) ;; 00000 frequency-high

 

     (store (Integer/parseInt "00000000" 2) 0xFF1A)

     (store (Integer/parseInt "00000000" 2) 0xFF1B)

     (store (Integer/parseInt "00000000" 2) 0xFF1C)

     (store (Integer/parseInt "00000000" 2) 0xFF1D)

     (store (Integer/parseInt "00000000" 2) 0xFF1E)

 

     (store (Integer/parseInt "00000000" 2) 0xFF20) ;; length

     (store (Integer/parseInt "00000000" 2) 0xFF21) ;; volume

     (store (Integer/parseInt "00000000" 2) 0xFF22) ;; noise-frequency

     (store (Integer/parseInt "00000000" 2) 0xFF23) ;; control

     ]))

 

 

 ;; mini-midi syntax

 

 ;; codes

 ;; note-code == 0x00

 ;; change-duty-code = 0x01

 ;; silence-code = 0x02

 

 ;; silence format

 ;;  2 bytes

 ;;  [silence-code (0x02)]

 ;;  [duration-8-bits]

 

 ;; note data format

 ;;  4 bytes

 ;;  [note-code (0x00)]

 ;;  [volume-4-bits 0 frequency-high-3-bits]

 ;;  [frequengy-low-8-bits]

 ;;  [duration-8-bits]

 

 ;; change-duty-format

 ;;  2 bytes

 ;;  [change-duty-code (0x01)]

 ;;  [new-duty]

 

 (def note-code 0x00)

 (def change-duty-code 0x01)

 (def silence-code 0x02)

 

 (defn do-message

   "Read the message which starts at the current value of HL and do

    what it says. Duration is left in A, and HL is advanced

    appropraitely."

   ([] (do-message 0x16 1))

   ([sound-base-address wave-duty]

      (assert (<= 0 wave-duty 3))

      (let [switch

            [0x2A ;; load message code into A, increment HL

             

             ;; switch on message

             0xFE

             note-code

             

             0x20

             :note-length]

 

            play-note

            [0x3E ;; set wave-duty

             (bit-shift-left wave-duty 6)

             0xE0

             sound-base-address

             0x2A   ;; load volume/frequency-high info

             0xF5   ;; push A

             0xE6

             (Integer/parseInt "11110000" 2) ;; volume mask

             0xE0

             (inc sound-base-address) ;;0x17   ;; set volume

             0xF1   ;; pop A

             0xE6

             (Integer/parseInt "00000111" 2) ;; frequency-high mask

             0xE0   

             (+ 3 sound-base-address) ;;0x19   ;; set frequency-high

             

             0x2A   ;; load frequency low-bits

             0xE0

             (+ 2 sound-base-address) ;;0x18   ;; set frequency-low-bits

             0x2A]]   ;; load duration

        (replace

         {:note-length (count play-note)}

         (concat switch play-note)))))

 

 ;; (defn play-note

 ;;   "Play the note referenced by HL in the appropiate channel.

 ;;    Leaves desired-duration in A."

 

 ;;   [0x2A   ;; load volume/frequency-high info

 ;;    0xF5   ;; push A

 ;;    0xE6

 ;;    (Integer/parseInt "11110000" 2) ;; volume mask

 ;;    0xE0

 ;;    0x17   ;; set volume

 ;;    0xF1   ;; pop A

 ;;    0xE6

 ;;    (Integer/parseInt "00000111" 2) ;; frequency-high mask

 ;;    0xE0   

 ;;    0x19   ;; set frequency-high

    

 ;;    0x2A   ;; load frequency low-bits

 ;;    0xE0

 ;;    0x18   ;; set frequency-low-bits

 

 ;;    0x2A   ;; load duration

 ;;    ]) 

 

 (defn music-step [sound-base-address wave-duty]

   ;; C == current-ticks

   ;; A == desired-ticks

   

   (flatten

    [;; restore variables from stack

     0xE1 ;; pop HL

     0xC1 ;; pop CB

     0xF1 ;; pop AF

 

 

     0xF5 ;; push A

     0xF0

     0x05 ;; load current ticks from 0xF005

     0xB8 ;; 

     0x30 ;; increment C only if last result caused carry

     0x01

     0x0C

 

     0x47 ;; update sub-ticks (A->B)

 

     0xF1 ;; pop AF, now A contains desired-ticks

 

     0xB9 ;; compare with current ticks

 

     ;; if desired-ticks = current ticks

     ;;   go to next note ; set current set ticks to 0.

 

     0x20

     (+ (count (do-message 0 0)) 2)

 

     (do-message sound-base-address wave-duty)

     

     0x0E

     0x00 ;; 0->C (current-ticks)

 

     ;; save variables to stack

     0xF5 ;; push AF

     0xC5 ;; push CB

     0xE5 ;; push HL

     

 

     ]))

     

 (def music-1 0x11)

 (def music-2 0x16)

 

 (defn music-kernel [wave-duty-1 wave-duty-2]

   (flatten

    [;; global initilization section

     (clear-music-registers)

     

     0x3E

     0x01

     0xE0

     0x06 ;; set TMA to 0

     

     0x3E

     (Integer/parseInt "00000110" 2)

     0xE0

     0x07 ;; set TAC to 65536 Hz and activate timer

 

     ;; initialize frame 1 

     0x21

     0x00

     0xA0 ;; set HL to 0xA000 == music-start 1

     0x0E

     0x00 ;; 0->C

     0x06

     0x00 ;; 0->B

 

     0xAF ;; 0->A

 

     0xF5 ;; push AF

     0xC5 ;; push CB

     0xE5 ;; push HL

 

     ;; initialize frame 2

     0x21

     0x00

     0xB0 ;; set HL to 0xB000 == music-start 2

 

     0xF5 ;; push AF

     0xC5 ;; push CB

     0xE5 ;; push HL

 

 

     ;; main music loop

 

     0xE8 ;; SP + 6; activate frame 1

     6

     (music-step music-1 wave-duty-1)

     ;;(repeat (count (music-step music-1)) 0x00)

     

     0xE8 ;; SP - 6; activate frame 2

     (->signed-8-bit -6)

     ;;(repeat (count (music-step music-2)) 0x00)

     (music-step music-2 wave-duty-2)

     

 

     0x18

     (->signed-8-bit (+

                      ;; two music-steps

                      (- (* 2 (count (music-step 0 0))))

                      -2 ;; this jump instruction

                      -2 ;; activate frame 1

                      -2 ;; activate frame 2

                      ))]))

 

 (defn frequency-code->frequency

   [code]

   (assert (<= 0 code 2047))

   (/ 131072 (- 2048 code)))

 

 (defn clamp [x low high]

   (cond  (> x high) high

          (< x low)  low

          true x))

 

 (defn frequency->frequency-code

   [frequency]

   (clamp

    (Math/round

     (float

      (/ (- (* 2048 frequency) 131072) frequency)))

    0x00 2048))

     

 (defn note-codes [frequency volume duration]

   (assert (<= 0 volume 0xF))

   (if (<= duration 0xFF)

     (let [frequency-code

           (frequency->frequency-code frequency)

           volume&high-frequency

           (+ (bit-shift-left volume 4)

              (bit-shift-right frequency-code 8))

           low-frequency

           (bit-and 0xFF frequency-code)]

       [note-code

        volume&high-frequency

        low-frequency

        duration])

     (vec

      (flatten 

       [(note-codes frequency volume 0xFF)

        (note-codes frequency volume (- duration 0xFF))]))))

   

 

 (defn midi-code->frequency

   [midi-code]

   (* 8.1757989156

      (Math/pow 2 (* (float (/ 12)) midi-code))))

 

 ;; division == clock-pulses / quarter-note

 ;; tempo    == microseconds / quarter-note

 

 ;; have: clock-pulses

 ;; want: seconds

 

 

 (defn silence [length]

   {:frequency 1

    :duration length

    :volume 0})

 

 (defn commands

   "return all events where #(= (:command %) command)"

   [command s]

   (filter #(= command (:command %)) s))

 

 (defn midi-track->mini-midi [#^File midi-file track-num]

   (let [midi-events (parse-midi midi-file)

 

         note-on-events  (commands :Note_on_c  midi-events)

         note-off-events (commands :Note_off_c midi-events)

 

         select-channel

         (fn [n s]

           (sort-by :time (filter #(= n (:channel (:args %))) s)))

 

         channel-on (select-channel track-num note-on-events)

         

         channel-off (select-channel track-num note-off-events)

         

         

         tempo (:args (first (commands :Tempo midi-events)))

         division

         (:division (:args (first (commands :Header midi-events))))

 

         notes

         (map

          (fn [note-on note-off]

            {:frequency (midi-code->frequency (:note (:args note-on)))

             :duration

             (/ (* (/ tempo division)

                   (- (:time note-off) (:time note-on)))

                1e6) ;; convert clock-pulses into seconds

             :volume (int (/ (:velocity (:args note-on)) 10))

             :time-stamp (/ (* (/ tempo division)

                               (:time note-on)) 1e6)})

          channel-on channel-off)

 

         silences

         (map (fn [note-1 note-2]

                (let [note-1-space (- (:time-stamp note-2)

                                      (:time-stamp note-1))

                      note-1-length (:duration note-1)]

                  (silence (- note-1-space note-1-length))))

              ;; to handle silence at the beginning.

              (concat [(assoc (silence 0)

                         :time-stamp 0)] notes)

              notes)

         

         notes-with-silence

         (concat

          (filter (comp not zero? :duration)

                  (interleave silences notes))

          [(silence 3)])]

 

      (map

       (fn [note-event]

         (note-codes (:frequency note-event)

                     (:volume note-event)

                     (int (* (:duration note-event) 0x100))))

       notes-with-silence)))

      

 

 (defn midi->mini-midi [#^File midi-file]

   {:track-1 (flatten (midi-track->mini-midi midi-file 0))

    :track-2 (flatten (midi-track->mini-midi midi-file 1))})

 

 (defn play-midi [#^File midi-file]

   (let [track-1-target 0xA000

         track-2-target 0xB000

         program-target 0xC000

         mini-midi (midi->mini-midi midi-file)

         long-silence (flatten (note-codes 20 0 9001))

         wave-duty-1 2

         wave-duty-2 2

         ]

     

     (-> (second (music-base))

         (set-memory-range track-1-target long-silence)

         (set-memory-range track-2-target long-silence)

         (set-memory-range track-1-target (:track-1 mini-midi))

         (set-memory-range track-2-target (:track-2 mini-midi))

         (set-memory-range

          program-target

          (music-kernel wave-duty-1 wave-duty-2))

         (PC! program-target))))

 

 (def C4 (partial note-codes 261.63))

 (def D4 (partial note-codes 293.66))

 (def E4 (partial note-codes 329.63))

 (def F4 (partial note-codes 349.23))

 (def G4 (partial note-codes 392))

 (def A4 (partial note-codes 440))

 (def B4 (partial note-codes 493.88))

 (def C5 (partial note-codes 523.3))

 

 (def scale

   (flatten

    [(C4 0xF 0x40)

     (D4 0xF 0x40)

     (E4 0xF 0x40)

     (F4 0xF 0x40)

     (G4 0xF 0x40)

     (A4 0xF 0x40)

     (B4 0xF 0x40)

     (C5 0xF 0x40)]))

                  

 (defn play-music [music-bytes]

   (let [program-target 0xC000

         music-target 0xA000]

     (-> (set-memory-range (second (music-base))

                           program-target (music-kernel))

         (set-memory-range music-target music-bytes)

         (PC! program-target))))

 

 

 

 ;; (defn test-note [music-bytes]

 ;;   (-> (set-memory-range (second (music-base))

 ;;                         0xC000 (concat (clear-music-registers)

 ;;                                        (play-note)

 ;;                                        (infinite-loop)))

 ;;       (set-memory-range 0xD000 music-bytes)

 ;;       (PC! 0xC000)

 ;;       (HL! 0xD000)

 ;;       ))

 

 

 (defn run-program

   ([program]

      (let [target 0xC000]

        (-> (set-memory-range (second (music-base))

                              target program)

            (PC! target)))))

 

 (defn test-timer []

   (flatten

    [0x3E

     0x01

     0xE0

     0x06 ;; set TMA to 0

     

     0x3E

     (Integer/parseInt "00000100" 2)

     0xE0

     0x07 ;; set TAC to 16384 Hz and activate timer

     

     (repeat

      500

      [0xF0

       0x05])]))