;; MIDI-tools_2.html
;; neuromuse
;;Frederic Voisin, 2001 -2003
;; ce fichier a servi a l'execution temps-reel du programme LISP neuromuse#0.lisp utilise pour la creation de "L'Ecarlate"
;;(Gourfink, Toeplitz et Voisin), IRCAM, Festival Agora 2001


(defvar *midi-data* nil)
(defvar *moment-vectors* nil)
(defvar *temp-vector* nil)
(defvar *angle* nil)
(defvar *speed* nil)
(defvar *amplitude* nil)
(defvar *dur* nil)
(defvar *ecarts* nil)
(defvar *supports* nil)
(defvar *distances* nil)

;(defparameter *get-midi-process* nil)

(setf *MIDI-PROCESS-NAMES*
      (append *MIDI-PROCESS-NAMES* '("get-midi")))

(defun reset-data ()
  (setf *angle* nil
        *speed* nil
        *dur* nil
        *moment-vectors* nil
        *temp-vector* nil
        *ecarts* nil
        *supports* nil
        *midi-data* nil
        *distances* nil))

(defvar *gate* t)

;(reset-data)

(defun get-midi (refnum)
  (format t "~% Ready to get data...")
  (loop
    (do ((event (midishare::MidiGetEv refnum) (midishare::MidiGetEv refnum)))
        ((%null-ptr-p event))
      (let ((chan (midishare::chan event)))
        (when chan
          (let ((ctl (midishare::field event 0))
                (value (midishare::field event 1)))
            (cond ((< chan 10)
                   (setf *temp-vector* (append (list (list ctl value chan))
                                               *temp-vector*))
                   (when (and (= 18 ctl) (= 9 chan))
                     (format t "~% receiving vector..."))
                   (when (and (= 1 ctl) (= 0 chan))
                     (format t "~% Vector received.")
                     (get-moment))
                   )
                  ((= chan 10)
                   (when *gate*
                     (case ctl
                       (1
                        (setf *angle* (append *angle* (list value)))
                        (format t "receiving angle = ~S" value))
                       (2
                        (setf *speed* (append *speed* (list value)))
                        (format t "receiving speed = ~S" value))
                       (3
                        (setf *dur* (append *dur* (list value)))
                        (format t "receiving dur = ~S" value))
                       (4
                        (setf *amplitude* (append *amplitude* (list value)))
                        (format t "receiving amplitude = ~S" value))
                       (5
                        (setf *ecarts* (append *ecarts* (list value)))
                        (format t "receiving ecart = ~S" value))
                       (6
                        (setf *supports* (append *supports* (list value)))
                        (format t "receiving support = ~S" value))
                       )))
                  (t
                   (push (list ctl (midishare::field event 1) chan)
                         *midi-data*)
                   ))))
        ))
    (process-wait "waiting events" #'waiting-events-p refnum)))

(defun getmidi ()
  (setf *midi-monitor-process*
        (process-run-function
         '(:name "get-midi" :priority 0)
         #'get-midi
         *refnum*)))

;(reset-data)
;(getmidi)
;(PROCESS-KILL *midi-monitor-process*)

(defun distance (a b)
  (let ((r))
    (loop for i in a for j in b
          do
          (push (* (- j i) (- j i)) r))
    (sqrt (apply #'+ r))))

(defvar *distances* nil)

(defun get-moment ()
  (let ((r (make-list 180 :initial-element .0))
        activation
        )
    (when *temp-vector*
      (dolist (m *temp-vector*)
        (let* ((dim (elt m 2))
               (max (case dim (0 2.) (1 5.) (2 17.) (3 5.) (4 5.) (5 8.) (6 5.) (7 8.) (8 12.) (9 13.))))
          (setf (elt r (+ (* (1- (elt m 0)) 10) (elt m 2)))
                (scale (elt m 1) 0. max 0. 1.)))))
    (setf *temp-vector* nil
          *moment-vectors* (append *moment-vectors* (list (coerce r 'vector)))
          activation (coerce (run-aa (car (last *moment-vectors*)) ecarl180-1) 'list))
    (make-activation-window
     (coerce activation 'list)
     :scalex 14 :scaley 14 :col 10 :lin 18 :title (format nil "moment ~D" (length *moment-vectors*)))
    (setf *distances* (append *distances*
                              (list (distance activation (coerce (car (last *moment-vectors*)) 'list)))
                              ))
    (format t "~%> ecarl180 : distance = ~S." (car (last *distances* )))))

#|
(get-moment)
(length
*moment-vectors*
)

(defvar copy-of-*ecarts* (copy-tree *ecarts*))
(setf *ecarts* (echant (remove 0 *ecarts*) 100))

*moment-vectors*

(length
 *angle*
)
(length
*speed*
)
(length
*dur*
)

(length
*ecarts*
)
(length
*supports*
)

(length
(reverse *distances*)
)


(make-trace-window *speed* 10 2 "")

(loop for s from 0 to (1- (length  *moment-vectors*))
      do
      (make-activation-window (coerce (elt *moment-vectors* s) 'list)
                              :scalex 15 :scaley 15 :col 10 :lin 18 :title (format nil "M ~S" s)))


(make-trace-window (remove 0 *ecarts*) 2 5 "ecarts")

(make-trace-window
(scale *dur* (apply #'min *dur*) (apply #'max *dur*) 1 100)
10 5 "durees")
    
|#

;;fredv