musikinformatik-wise-24.org

Abspielen der Aufnahme

Die Aufnahme lässt sich mit einer einfachen temporalen Rekursion abspielen:

(defun play-recording (seq)
  (labels ((inner (time remain)
             (when remain
               (let* ((curr (first remain))
                      (next (+ time (getf curr :time)))
                      (x (getf curr :x))
                      (y (getf curr :y))
                      (bw (getf curr :bw)))
                 (set-val atsd.mousepos (list x y))
                 (set-val atsd.bw bw)
                 (at next #'inner next (rest remain))))))
    (inner (now) (get-dtime-seq seq))))

(play-recording *recording*)

Hier noch einmal der gesamte erforderliche Code für Aufnahme und Abspielen einer Live Interaktion zusammengefasst. Die Funktionen #'start-recording und #'stop-recording verwenden den Code dieses Kapitels in einer Form, die die Handhabung etwas vereinfacht, indem sie bei #'stop-recording auch die watch Verbindungen trennt, damit die *recording* bei Mausinteraktionen nicht immer weiter wächst. Zugleich setzt #'start-recording die globale *recording* Liste bei Beginn einer Aufnahme auf nil.

(defparameter *recording* nil
  "Liste mit der Aufnahme einer Live-Interaktion.")

(defparameter *unwatch* nil
  "Liste mit den Unwatch Funktionen für die Aufnahmeparameter.")

(defun stop-recording ()
  (dolist (fn *unwatch*) ;;; vorherige watch Bindungen aufheben
    (funcall fn))
  (setf *unwatch* nil))

(defun start-recording ()
  (stop-recording)
  (setf *recording* nil)
;;; Bindung aufstellen.
  (push (watch (lambda () (destructuring-bind (x y) (get-val atsd.mousepos)
                       (let ((bw (get-val atsd.bw)))
                         (push (list :time (now) :x x :y y :bw bw)
                               *recording*)))))
        *unwatch*))

(defun get-dtime-seq (recording)
  (let ((result nil))
    (loop
      for ((_time1 time1 . rest1) (_time2 time2 . rest2)) on recording 
      do (push (list* :time (if time2 (- time1 time2) 0) rest1) result))
    result))

(defun play-recording (seq)
  (labels ((inner (time remain)
             (when remain
               (let* ((curr (first remain))
                      (next (+ time (getf curr :time)))
                      (x (getf curr :x))
                      (y (getf curr :y))
                      (bw (getf curr :bw)))
                 (set-val atsd.mousepos (list x y))
                 (set-val atsd.bw bw)
                 (at next #'inner next (rest remain))))))
    (inner (now) (get-dtime-seq seq))))

;; Aufruf:
;; (play-recording *recording*)

Aufgaben

Veränder den obenstehenden Code dahingehend, dass man eine Aufnahme auch pausieren und anschließend neu starten kann, ohne, dass das bisher aufgenommene gelöscht wird.

Created: 2025-02-12 Mi 20:35

Validate