Lisp-Additive-Synthesis-Tool

;;********************************************

;;////////////////////////////////////////////

;;Lisp Additive Synthesis Tool - LAST

;;////////////////////////////////////////////

;;Mauricio Rodriguez - 2011

;;////////////////////////////////////////////

;;marod@ccrma.stanford.edu

;;////////////////////////////////////////////

;;********************************************

******************************

Use and copying of this software and preparation of derivative works

based upon this software are prohibited unless permission of the author.

Suggestions, comments and bug reports are welcome. Please address email to:

marod@ccrma.stanford.edu

******************************

(make-package :last)

(in-package :last)

;;Main:

;;spear-formatting [note-sequence(s)] / Note-event=[onset pitch duration channel velocity]

;;(spear-formatting (create-sequence '((0 58.5 20000 7 32) (0 60.5 10000 7 32))))

;;Code:

(defun harmonic-series (partials fundamental)

(do ((counter 0 (incf counter))

(output nil (cons (* counter fundamental) output)))

((= counter partials) (reverse output))))

(defun invert-harmonic-ratio (n)

(let* ((series (loop for x from 1 to n

collect x))

(grouping (reverse (make-pairs series))))

(cons 1.0 (loop for y in grouping

collect (/ (float (second y)) (float (first y)))))))

(defun invert-harmonic-series* (fundamental input)

(if (endp input)

'nil

(cons (* fundamental (first input))

(invert-harmonic-series* (* fundamental (first input)) (rest input)))))

(defun invert-harmonic-series (partials fundamental)

(invert-harmonic-series* fundamental (invert-harmonic-ratio partials)))

(defun distorted-harmonic-series (fundamental n percentage)

(let ((power (if (< percentage 0)

(+ 1 (/ percentage 100.0))

(+ 1 (abs (/ percentage 100.0))))))

(loop for x from 1 to n

collect (* fundamental (expt x power)))))

(defun distort-harmonic-series (fundamental percentage ratio-list)

(let ((power (if (< percentage 0)

(+ 1 (/ percentage 100.0))

(+ 1 (abs (/ percentage 100.0))))))

(loop for x in ratio-list

collect (* fundamental (expt x power)))))

(defun convert-midi-to-frequency (midi-value)

(* 440 (expt 2 (/ (- midi-value 69) 12.0))))

(defun convert-frequency-to-midi (frequency)

(+ 69 (* 12 (/ (log (/ frequency 440.0) 10) (log 2 10)))))

(defun midi-to-frequency (input-list)

(mapcar #'convert-midi-to-frequency input-list))

(defun frequency-to-midi (input-list)

(mapcar #'convert-frequency-to-midi input-list))

(defun partial-index (list index-list)

(cond ((eql index-list :all-partials) list)

((endp index-list) nil)

((endp list) nil)

((> (first index-list) (length list)) nil)

(t (cons (elt list (- (first index-list) 1))

(partial-index list (rest index-list))))))

(defun potentiation-list (n value)

(do* ((counter n (- counter 1))

(exponent -1 (+ exponent 1))

(output nil (cons (expt value exponent) output)))

((zerop counter) (reverse output))))

(defun amplitude-squared-inverse* (n)

(let ((squared-inverse (potentiation-list n 2)))

(loop for x in squared-inverse

collect (/ 1 x))))

(defun amplitude-inverse* (n)

(loop for x from 1 to n

collect (/ 1 x)))

(defun amplitude-squared-inverse (n)

(let ((squared-inverse (potentiation-list n 2)))

(loop for x in squared-inverse

collect (/ 1.0 x))))

(defun amplitude-inverse (n)

(loop for x from 1 to n

collect (/ 1.0 x)))

(defun sieve-duration (duration resolution)

(let ((output (loop for x from 0.0 to (* duration 1000) by 50

collect x)))

(loop for y in output

collect (/ y (* resolution 10000.0)))))

(defun sieve-duration (duration resolution)

(let ((output (loop for x from 0.0 to (* duration 1000) by (* resolution 1000.0)

collect x)))

(loop for y in output

collect (/ y 1000.0))))

(defun scale-milisec-duration (value)

(/ 1000.0 value))

(defun shift-duration (duration-list offset)

(mapcar #'(lambda (x) (+ offset x)) duration-list))

(defun move-onset* (offset input)

(let* ((offsetting (/ offset 1000.0))

(new-first (mapcar #'(lambda (x) (+ offsetting x)) (first input))))

(cons new-first (rest input))))

(defun move-onset (offset list)

(mapcar #'(lambda (x) (move-onset* offset x)) list))

(defun alea (low high)

(+ (min low high)

(if (= high low)

(random (+ (abs (- high low ))

(if (or (floatp low) (floatp high))

1))))))

(defun deviate (threshold percentage)

(let ((amount (* threshold percentage .01)))

(+ threshold (alea (- amount) amount))))

(defun deviate-percentage (threshold percentage)

(if (= threshold 0)

threshold

(let ((value (+ threshold (* threshold percentage .01))))

(if (> value 127)

127

value))))

(defun permute-list (list)

(let* ((current-list list)

(current-value (unless (endp current-list) (elt current-list (random (length current-list))))))

(if (endp current-list) nil

(cons current-value (permute-list (delete current-value current-list :count 1))))))

(defun normalize-duration (duration)

(read-from-string (format nil "~,1f" duration)))

(defun scale-envelope (duration input)

(let* ((target-duration (normalize-duration duration))

(maximum (first (first (last input))))

(x-values (mapcar #'(lambda (alpha) (normalize alpha 0.0 maximum 0.0 target-duration))

(loop for x in input

collect (first x))))

(y-values (loop for y in input

collect (second y))))

(mapcar #'list x-values y-values)))

(defun normalize-scaling (input)

(if (null input)

'nil

(cons (list (read-from-string (format nil "~,1f" (first (first input))))

(second (first input)))

(normalize-scaling (rest input)))))

(defun add-ratio (n ratio)

(do ((current-n (decf n) (decf current-n))

(times-value 1 (incf times-value))

(added-ratio ratio (* ratio times-value))

(output (list ratio) (cons added-ratio output)))

((= current-n 0) (rest (reverse output)))))

(defun partition-list (n segment-value)

(add-ratio n (/ (float segment-value) n)))

(defun segment-interpolation* (segment-1 segment-2 subdivisions)

(let ((segment-difference (abs (- segment-1 segment-2)))

(offset-value (min segment-1 segment-2)))

(mapcar #'(lambda (x) (+ x offset-value))

(partition-list subdivisions segment-difference))))

(defun segment-interpolation (segment-1 segment-2 subdivisions)

(let ((interpolation-list (segment-interpolation* segment-1 segment-2 subdivisions)))

(if (or (equal segment-1 segment-2) (< segment-1 segment-2))

interpolation-list

(reverse interpolation-list))))

(defun x-increment (start end)

(append (loop for x from start to end by 0.05

collect x)

(list end)))

(defun x-increment (start end resolution)

(append (loop for x from start to end by resolution

collect x)

(list end)))

(defun inter-break-points (a b)

(if (<= (- (- (first b) (first a)) 0.05) 0.00000001)

(list a b)

(let* ((n (round (/ (- (first b) (first a)) 0.05)))

(interpolation-list (append (list (second a)) (segment-interpolation (second a) (second b) n) (list (second b))))

(x-list (x-increment (first a) (first b))))

(mapcar #'list x-list interpolation-list))))

(defun inter-break-points (a b resolution)

(let* ((n (/ (- (first b) (first a)) resolution))

(interpolation-list (append (list (second a)) (segment-interpolation (second a) (second b) n) (list (second b))))

(x-list (x-increment (first a) (first b) resolution)))

(mapcar #'list x-list interpolation-list)))

(defun make-pairs* (list)

(if (endp list)

nil

(cons (list (first list) (second list))

(make-pairs* (rest list)))))

(defun make-pairs (list)

(let ((current-list (make-pairs* list)))

(loop for x in current-list

when (not (equal (second x) nil))

collect x)))

(defun sort-index (list)

(sort (loop for x in list

collect (first x)) #'<))

(defun order-index* (index-list list)

(do ((current-index

index-list

(rest current-index))

(current-list

list

(remove

(find-if #'(lambda (x) (= (first current-index) (first x)))

current-list)

current-list :test #'equal))

(output

nil

(cons

(find-if #'(lambda (x) (= (first current-index) (first x)))

current-list)

output)))

((endp current-index) (reverse output))))

(defun order-index (index-list)

(let ((sorting (sort-index index-list)))

(order-index* sorting index-list)))

(defun expand-envelope-coordinates (break-points)

(order-index (remove-duplicates

(loop for x in (make-pairs break-points)

append (inter-break-points (first x) (second x))) :test #'equal)))

(defun expand-envelope-coordinates (break-points resolution)

(order-index (remove-duplicates

(loop for x in (make-pairs break-points)

append (inter-break-points (first x) (second x) resolution)) :test #'equal)))

(defun envelope-values (break-points)

(let ((envelope (expand-envelope-coordinates break-points)))

(loop for x in envelope

collect (second x))))

(defun envelope-values (break-points resolution)

(let ((envelope (expand-envelope-coordinates break-points resolution)))

(loop for x in envelope

collect (second x))))

(defun normalize (x a b c d)

(+ c (* (- x a) (/ (float (- d c)) (- b a)))))

(defun map-freq (x a b c d)

(let ((value (+ c (* (- x a) (/ (float (- d c)) (- b a))))))

(format t "~&~10,6f" value)))

(defun map-amp (x)

(* x (/ 0.100000 1.0)))

(defun fibo-process (list)

(do ((sum (first list) (+ sum (first local-list)))

(local-list (rest list) (rest local-list))

(output-list nil (cons sum output-list)))

((not local-list) (reverse (cons (+ (first (last list)) (first output-list)) output-list)))))

(defun index-check (index input)

(if (>= (- index 1) (length input))

(reverse input)

input))

(defun index-check-p (index input)

(if (>= (- index 1) (length input))

'nil))

(defun gather-from-index (indexing-list input)

(if (null indexing-list)

'nil

(cons (nth (- (first indexing-list) 1) input)

(gather-from-index (rest indexing-list) input))))

(defun all-numbers (n)

(loop for x from 1 to n

collect x))

(defun delete-from-index (index list)

(gather-from-index (remove index (all-numbers (length list))) list))

(defun reverse-rotate (list)

(append (rest (reverse list)) (list (first (reverse list)))))

(defun collect-n (n input)

(do ((counter 0 (+ counter 1))

(current-input input (if (= (length current-input) 1)

input

(rest current-input)))

(output nil (cons (first current-input)

output)))

((= counter n) (reverse output))))

(defun additive-process (n input)

(let* ((additive-list* (loop for alpha in

(reverse (loop for x on (reverse input)

collect (reverse x)))

append alpha))

(additive-list** (append additive-list* (reverse additive-list*)))

(additive-list (collect-n (- n 1) additive-list**)))

(append additive-list (last input))))

(defun get-onset (input)

(first input))

(defun get-pitch (input)

(second input))

(defun get-duration (input)

(third input))

(defun get-channel (input)

(fourth input))

(defun get-velocity (input)

(fifth input))

(defun map-onset (input)

(mapcar #'(lambda (x) (get-onset x)) input))

(defun map-pitch (input)

(mapcar #'(lambda (x) (get-pitch x)) input))

(defun map-duration (input)

(mapcar #'(lambda (x) (get-duration x)) input))

(defun map-channel (input)

(mapcar #'(lambda (x) (get-channel x)) input))

(defun map-velocity (input)

(mapcar #'(lambda (x) (get-velocity x)) input))

(defun note-event** (onset pitch duration channel velocity)

(list onset pitch duration channel velocity))

(defun note-event-sequence** (onset-list pitch-list duration-list channel-list velocity-list)

(if (or (null onset-list) (null pitch-list) (null duration-list) (null channel-list) (null velocity-list))

'nil

(cons (note-event** (first onset-list)

(first pitch-list)

(first duration-list)

(first channel-list)

(first velocity-list))

(note-event-sequence** (rest onset-list)

(rest pitch-list)

(rest duration-list)

(rest channel-list)

(rest velocity-list)))))

;;(note-event-sequence** '(0 1000) '(60 64) '(1000 1000) '(1 1) '(64 127))

;;(note-event-sequence** '(0 1000) '(60 64) '(2000 1000) '(1 1) '(32 32))

(defun map-value (x a b c d)

(round (+ c (* (- x a) (/ (- d c) (- b a))))))

(defun map-value-list (list a b c d)

(if (null list)

'nil

(cons (map-value (first list) a b c d)

(map-value-list (rest list) a b c d))))

(defun delta-increment* (list &optional (current-value 0))

(if (null list)

'nil

(cons (+ (first list) current-value)

(delta-increment* (rest list) (setq current-value (+ current-value (first list)))))))

(defun delta-increment (list)

(cons 0 (butlast (delta-increment* list))))

(defun convert-duration-to-onset (list)

(delta-increment list))

;;(note-event-sequence** (delta-increment '(1000 1000)) '(60 64) '(2000 1000) '(1 1) '(32 32))

;;(additive-process 20 '(2000 800 1400))

(defun generate-additive-process* (n onset-list pitch-list duration-list channel-list velocity-list)

(note-event-sequence**

(delta-increment (additive-process n onset-list))

(additive-process n pitch-list)

(additive-process n duration-list)

(additive-process n channel-list)

(additive-process n velocity-list)))

;;(generate-additive-process* 20 '(1000 800 1400 50) '(58.5 78 60) '(2000 1000) '(1) '(32 16))

(defun choose-file-dialog (&key (prompt "Open file") (operation :open))

(let ((screen (capi:convert-to-screen)))

(capi:screen-width screen)

(capi:screen-height screen)

(capi:prompt-for-file prompt

:operation operation

:owner screen

:filters '("All Files" "*.*"))))

(defun choose-new-file-dialog (&key (prompt "Save File") (operation :save))

(choose-file-dialog :prompt prompt :operation operation))

(defun spear-formatting (input)

(with-open-file (output (choose-new-file-dialog)

:direction :output

:if-exists :supersede)

(do ((input-list input (rest input-list))

(partial-number 0 (+ partial-number 1))

(printing

(progn

(format output "~&~a" "par-text-partials-format")

(format output "~&~a ~a ~a ~a" "point-type" "time" "frequency" "amplitude")

(format output "~&~a ~a" "partials-count" (length input))

(format output "~&~a" "partials-data"))

(progn

(format output "~&~a ~a ~a ~a"

partial-number

(length (first (first input-list)))

(first (first (first input-list)))

(first (last (first (first input-list)))))

(loop for x in (mapcar #'list (first (first input-list)) (second (first input-list)) (third (first input-list)))

for string = "~&~,6f ~,6f ~,6f" then " ~,6f ~,6f ~,6f"

do (format output string

(float (first x))

(float (second x))

(float (third x)))))))

((endp input-list) 't))))

(defun note-event (n-partials

fundamental

duration

amplitude

&key

(envelope *constant-envelope*)

(distortion 0)

(invert-frequency 'nil)

(invert-amplitude 'nil)

(deviate-frequency 0)

(deviate-amplitude 0)

(partial-indexing :all-partials))

(let* ((total-duration (normalize-duration (/ duration 1000.0)))

(raw-envelope (envelope-values (normalize-scaling (scale-envelope total-duration envelope))))

(ratio-list (if invert-frequency

(invert-harmonic-ratio n-partials)

(loop for ratio from 1.0 to n-partials

collect ratio)))

(partials (partial-index (distort-harmonic-series (convert-midi-to-frequency fundamental) distortion ratio-list) partial-indexing))

(raw-amplitude (partial-index (if invert-amplitude

(let ((amplitude-values (reverse (mapcar #'map-amp (amplitude-squared-inverse n-partials)))))

(append (last amplitude-values) (butlast amplitude-values)))

(mapcar #'map-amp (amplitude-squared-inverse n-partials))) partial-indexing))

(onset (sieve-duration total-duration 0.05))

(expand-partials (loop for x in partials

collect (loop repeat (length onset)

collect (deviate x deviate-frequency))))

(expand-amplitude (loop for y in raw-amplitude

collect (mapcar #'* (loop repeat (length onset)

collect (* (normalize amplitude 0.0 127.0 0.0 1.0)

(deviate y deviate-amplitude))) raw-envelope))))

(loop for alpha in expand-partials

for beta in expand-amplitude

collect (list onset alpha beta))))

(spear-formatting

(note-event 10 60 1000 64

:distortion 10

:envelope *triangle-envelope*

:deviate-frequency 2

:deviate-amplitude 10

:invert-frequency 't))

(spear-formatting

(note-event 20 60 500 64

:distortion 20

:envelope *triangle-envelope*

:deviate-frequency 80

:deviate-amplitude 50

:invert-frequency 't

:invert-amplitude 't))

(spear-formatting

(note-event 10 60 20000 64

:distortion 10

:envelope *triangle-envelope*

:deviate-frequency 2

:deviate-amplitude 10

:invert-frequency 't))

(defmacro define-instrument (instrument-name

n-partials

&key

(envelope *trapezoid-envelope*)

(distortion 0)

(invert-frequency 'nil)

(invert-amplitude 'nil)

(deviate-frequency 0)

(deviate-amplitude 0)

(partial-indexing :all-partials))

`(eval (list 'defun ,instrument-name '(pitch duration velocity)

'(note-event ,n-partials pitch duration velocity

:envelope ,envelope

:distortion ,distortion

:invert-frequency ,invert-frequency

:invert-amplitude ,invert-amplitude

:deviate-frequency ,deviate-frequency

:deviate-amplitude ,deviate-amplitude

:partial-indexing ,partial-indexing))))

;;(define-instrument 'cicada 20 :distortion -10 :invert-amplitude 't)

;;(cicada 69 1000 32)

;;(apply #'cicada '(69 1000 32))

(defun spear-output (input &optional (counter 0))

(if (endp input)

(progn

(with-open-file

(output (make-pathname :directory '(:absolute "users" "home" "directory")

:name (format nil "~a-~a" "spear-format" counter)

:type "txt")

:direction :output

:if-exists :supersede)

(do ((input-list (first input) (rest input-list))

(partial-number 0 (+ partial-number 1))

(printing

(progn

(format output "~&~a" "par-text-partials-format")

(format output "~&~a ~a ~a ~a" "point-type" "time" "frequency" "amplitude")

(format output "~&~a ~a" "partials-count" (length (first input)))

(format output "~&~a" "partials-data"))

(progn

(format output "~&~a ~a ~a ~a"

partial-number

(length (first (first input-list)))

(first (first (first input-list)))

(first (last (first (first input-list)))))

(loop for x in (mapcar #'list (first (first input-list)) (second (first input-list)) (third (first input-list)))

for string = "~&~,6f ~,6f ~,6f" then " ~,6f ~,6f ~,6f"

do (format output string

(float (first x))

(float (second x))

(float (third x)))))))

((endp input-list) 't)))

(spear-output (rest input) (+ counter 1)))))

(defun create-note-event (input)

(move-onset (first input) (apply (eval (list 'function (instrument-table (fourth input))))

(list (second input) (third input) (fifth input)))))

(defun create-note-event* (input)

(move-onset (first input) (apply (eval (list 'function (instrument-table (fourth input))))

(list (second input) (third input) (fifth input)))))

(defun create-sequence* (&rest input)

input)

(defun create-sequence** (input)

(if (endp input)

'nil

(append (create-note-event (first input))

(create-sequence** (rest input)))))

(defun create-sequence (&rest input)

(create-sequence** (apply #'create-sequence* input)))

(defun create-sequence (input)

(if (endp input)

'nil

(append (create-note-event (first input))

(create-sequence (rest input)))))

;;(create-sequence '((500 69 2000 1 32) (500 69 2000 1 32)))

(defvar *constant-envelope* '((0.0 1.0) (1.0 1.0)))

(defvar *triangle-envelope* '((0.0 0.0) (0.5 1.0) (1.0 -0.5)))

(defvar *trapezoid-envelope* '((0.0 0.0) (0.1 1.0) (0.9 1.0) (1.0 -0.5)))

(defvar *line-down-envelope* '((0.0 0.0) (0.1 1.0) (1.0 -0.5)))

(defvar *line-up-envelope* '((0.0 0.0) (0.9 1.0) (1.0 -0.5)))

(defvar *bell-down-envelope* '((0.0 0.0) (0.1 1.0) (0.3 0.4) (1.0 -0.5)))

(defvar *bell-up-envelope* '((0.0 -0.5) (0.7 0.4) (0.9 1.0) (1.0 -1.0)))

(defvar *gaussian-envelope* '((0.0 0.0) (0.2 0.15) (0.4 0.8) (0.5 1.0) (0.6 0.8) (0.8 0.15) (1.0 -0.5)))

(define-instrument 'cicada

:distortion 10

:envelope *trapezoid-envelope*

:deviate-frequency 0.5

:deviate-amplitude 0.5

:invert-amplitude 't

:partial-indexing '(1 3 6 7 8 15 16 17 18 19 20))

(define-instrument 'magnet

:distortion 10

:envelope *triangle-envelope*

:deviate-frequency 2

:deviate-amplitude 10

:invert-frequency 't)

(defun bell (pitch duration velocity)

(append (note-event 25 pitch duration velocity

:distortion 10

:envelope *bell-down-envelope*

:deviate-amplitude 0.5

:partial-indexing '(2 3 7 9 11 13 17 19 21 23 25))

(note-event 25 pitch duration velocity

:distortion 12.5

:envelope *bell-down-envelope*

:deviate-amplitude 1

:invert-amplitude 't

:deviate-frequency 5

:partial-indexing '(2 3 7 9 11 13 17 19 21 23 25))

(note-event 25 (+ pitch 0.5) duration velocity

:distortion 10

:envelope *bell-down-envelope*

:deviate-amplitude 0.5

:partial-indexing '(2 3 7 9 11 13 17 19 21 23 25))

(note-event 25 (+ pitch 0.5) duration velocity

:distortion 12.5

:envelope *bell-down-envelope*

:deviate-amplitude 1

:invert-amplitude 't

:deviate-frequency 1

:partial-indexing '(2 3 7 9 11 13 17 19 21 23 25))))

(defun boreal (pitch duration velocity)

(append

(note-event 6 pitch duration velocity

:distortion 5

:envelope *line-up-envelope*

:deviate-frequency 1

:deviate-amplitude 50

:invert-frequency 't

:invert-amplitude 't)

(note-event 6 pitch duration velocity

:distortion 35

:envelope *line-up-envelope*

:deviate-frequency 1.5

:deviate-amplitude 50

:invert-frequency 't)))

(defun crystal (pitch duration velocity)

(append

(note-event 4 pitch duration velocity

:distortion 5

:envelope *gaussian-envelope*

:deviate-frequency 0.1

:deviate-amplitude 10

:invert-amplitude 't

:partial-indexing '(2 3 4))

(note-event 6 pitch duration (deviate-percentage velocity -20)

:envelope *gaussian-envelope*

:deviate-frequency 0.25

:deviate-amplitude 10

:partial-indexing '(2 3 4 5 6))))

(defun spark (pitch duration velocity)

(append

(note-event 20 pitch duration velocity

:distortion 5

:envelope *line-down-envelope*

:deviate-frequency 5

:deviate-amplitude 10

:partial-indexing '(2 3 4 5 6 7 8 9 10))

(move-onset 100

(note-event 20 pitch duration velocity

:distortion 10

:envelope *bell-down-envelope*

:deviate-frequency 10

:deviate-amplitude 50

:partial-indexing '(2 3 4 5 6 7 8 9 10)))

(move-onset 400

(note-event 20 pitch duration velocity

:distortion 20

:envelope *line-down-envelope*

:deviate-frequency 20

:deviate-amplitude 100

:partial-indexing '(2 3 4 5 6 7 8 9 10)))))

(defun soil (pitch duration velocity)

(append

(note-event 10 pitch duration velocity

:distortion 10

:envelope *line-down-envelope*

:deviate-amplitude 0.5

:invert-amplitude 't)

(note-event 10 pitch duration velocity

:distortion 12.5

:envelope *line-down-envelope*

:deviate-amplitude 0.5

:invert-amplitude 't)

(note-event 10 (+ pitch 0.5) duration velocity

:distortion 10

:envelope *bell-up-envelope*

:deviate-amplitude 0.5

:invert-amplitude 't)

(note-event 10 (+ pitch 0.5) duration velocity

:distortion 12.5

:envelope *bell-up-envelope*

:deviate-amplitude 0.5

:invert-amplitude 't)))

(defun instrument-table (instrument-number)

(case instrument-number

(1 'cicada)

(2 'magnet)

(3 'bell)

(4 'boreal)

(5 'crystal)

(6 'spark)

(7 'soil)))

(spear-formatting

(append (create-sequence '((0 58.5 20000 7 32)))

(move-onset 52000 (create-sequence '((0 60.5 10000 7 32))))

(move-onset 12400 (create-sequence (generate-additive-process* 50

'(1000 800 1400 100)

'(48 66.5 59 63.25)

'(2000 1000 3000 500)

'(1 2 3 4 5 6)

'(32 16 32 16 32))))

(move-onset 16000 (create-sequence (generate-additive-process* 50

(permute-list '(1000 800 1400 100))

(permute-list '(48 66.5 59 63.25))

(permute-list '(2000 1000 3000 500))

(permute-list '(1 2 3 4 5 6))

(permute-list '(32 16 32 16 32)))))))