Jump to content

AM

Members
  • Posts

    792
  • Joined

  • Last visited

Posts posted by AM

  1. dear all,

     

    i have a basic lisp-question to FORMAT and i did not find a solution...

     

    INPUT

     

    (setf alist '((/player "12" 1.0 1.0 1.0)
                  (/player "23" 1.0 1.0 1.0)
                  (/player "12" 1.0 1.0 1.0)	
                  (/player "23" 1.0 1.0 1.0)))
    
    ;; with FORMAT to
    => /player "12" 1.0 1.0 1.0, /player "23" 1.0 1.0 1.0, /player "12" 1.0 1.0 1.0, /player "23" 1.0 1.0 1.0

     

    by FORMAT 
    => i will save it in a TXT-file on desktop (that works (with-open-file...)), but i have a format-problems with the commatas and the ()

     

    thanx for such basic-lisp-help

    andré

  2. dear all

     

    i would like to send some specific data via OSC to MAX... 

    i can send "something" to max 

     

    (defparameter max '(127.0.0.1 7500)) ;; that works

     

    SEND data to MAX

    and i would like to send the following seq to MAX by OSC 

    /player "12" 1.0 1.0 1.0
     

    but how to do it / format it in OMPO?

     

    ;; data should be "113" 1 1. 25000  => but how to "format"? -> see the MAX form
    ;; ???
    (send-osc-data (create-osc-thread "player" max) data)

     

    /player is sended but not the rest of teh sequence 

     

     

    here is a screenshot from MAX, it worked with an external library (in CCL) but i would like to do it "directly" in OPMO.

     

    image.png.2deaaa5e3b4aa625c937276a06f1acff.png

     

    in MAX, that's what i'm sending - for example - as an internal test

    image.png.d9a5ac198ef987b42441476eed65129b.png

     

     

    thanx for some help...!!

    andré

  3. Quote

    Seriously? This is a one-man operation doing a major port of the software, not only to support a new hardware architecture, but also, as part of that, to completely swap out the underlying runtime backend. Give the guy a break, his job is hard enough without entitled people badgering him to get it done yesterday and criticizing his very efforts to communicate progress (before that, the criticism was that there wasn't any communication about it). What's "really going on"? Alien abduction? Coup attempt? Let the dev do his work.

    yes! agree with you, just let the developer(s) work instead of making a .... here. janusz is doing a great job!!

     

  4. I'm testing (for fun) the M2 with opusmodus (intel, a little wobbly on silicon) - of course I still have a copy on my intel-mac, just for fun!

     

    but the combination is really good. I calculate/play something in OPUSMODUS, sending by OSC to MAX/MSP and further to ABLETON LIVE; as a heavy test, the same thing in parallel to REAPER. everything with different plugins. no jerks, no glitches. That will be really great, this combination - when OPMO officially runs on silicon!

     

    then PROCESSING can also run in parallel 😄

     

    @opmo: thx a lot for all the special functions you have coded for me/us over the last few years, very specific/individual solutions for me, my work!!

     

     

     

     

  5. Didn't you read this (the compatibility) when you made the update, bought a new computer? I always check that - always. Also with MaxMsp, Avid Sibelius, Pro Tools ...

    Bildschirmfoto 2022-10-31 um 19.59.11.png

     

     

     

    SIBELIUS

    i think AVID SIBELIUS is not yet officially ready for VENTURA either, and M1 only under the Rosetta 2 translation layer.

     

     

    WWW.SCORINGNOTES.COM

    How Sibelius, Finale, Dorico, MuseScore, and Notion are faring on Apple's Ventura operating system and Apple Silicon-powered hardware.

     

  6. an example with 2 pitches = 2 intervals, with microtonal quantification

     

    (sort-asc
     (remove-duplicates
      (pitch-melodize
       (append
        (gen-summationsakkord '(3 5) :typ 'ks :gedachter-grundton 'db0 :quant nil)
        (gen-summationsakkord '(5 7) :typ 'ks :gedachter-grundton 'db0 :quant nil)))))
    
    (sort-asc
     (remove-duplicates
      (pitch-melodize
       (append
        (gen-summationsakkord '(3 5) :typ 'gs :gedachter-grundton 'db0 :quant nil)
        (gen-summationsakkord '(5 7) :typ 'gs :gedachter-grundton 'db0 :quant nil)))))

     

     

  7. here ist some code to generate "Summationsakkorde" (CLAUS KüHNL)... have a look to the PDF...

    (from the book "Claus Kühnl: Beiträge zu einer HArmonielehre 2000" Friedrich Hofmeister Musikverlag. p.42+)

     

    
    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    
    
    (defun gen-summationsakkord (primaerint &key (n 10)(typ 'ks) (gedachter-grundton 'c0) (quant 1/2) (chord t))
      (let ((partial-reihe (hertz-to-pitch (harmonics gedachter-grundton 100 :type :hertz) :quantize quant))
            (partial-liste
            (remove-duplicates
              (append primaerint 
                      (list (sum primaerint))
                      (loop repeat n
                        with k-int = (sum primaerint)
                        with g-int = (sum primaerint)
                        with a = (first primaerint)
                        with b = (second primaerint)
                        
                        collect 
                        (cond ((equal typ 'ks)
                               (setf k-int (+ (car primaerint) k-int)))
                              ((equal typ 'gs)
                               (setf g-int (+ (second primaerint) g-int)))
                              ((equal typ 'fibo)
                               (shiftf a b (+ a b)))))))))
        
        (if (null chord) 
          (position-filter (x-b partial-liste 1) partial-reihe)
          (chordize (position-filter (x-b partial-liste 1) partial-reihe)))))
    
    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    
    (gen-summationsakkord '(2 3) :typ 'ks :gedachter-grundton 'c2)
    (gen-summationsakkord '(2 3) :typ 'gs :gedachter-grundton 'c2)
    (gen-summationsakkord '(2 3) :typ 'fibo :gedachter-grundton 'c2)
    
    
    (gen-summationsakkord '(2 3) :typ 'ks :gedachter-grundton 'c2 :quant nil)
    
    (gen-summationsakkord '(3 4) :typ 'ks :gedachter-grundton 'f1)
    (gen-summationsakkord '(3 4) :typ 'gs :gedachter-grundton 'f1)
    (gen-summationsakkord '(3 4) :typ 'fibo :gedachter-grundton 'f1)

     

    Doc - 03.08.2022 - 20-41.pdf

     

  8. in general: you have to define exactly what you want (in a limited number of cases), if you change your idea along the way, you have to adapt the CODE again...

    look at the CODE, and the EVENT etc...

     

     

    ;; you have to define al longer length-value in EVENT: (* 4 1/8) = 1/2 => in EVENT '(h c4e4g4b4 mf ten)
    
    (setf event '(h c4e4g4b4 mf ten))
    (gen-arpeggio* event :rhy '(1/8) :offset nil)  

     

  9. here's a correction (bug) and a variant:

    okay... you want to "sum" the rests in a sequence 0, 2 ,3, 4 ...  by -1/24 rhy. (a special version)

    so i have to code this case as option. take the new version and use :offset 1

     

    (defun gen-arpeggio* (event &key (rhy'(1/28)) (legato nil) (offset nil))
      (let* ((pitches (melodize (omn :pitch event)))
             (length (car (omn :length event)))
             (velo (car (omn :velocity event)))
             (art (car (omn :articulation event)))
             (rhy (gen-repeat 10 rhy))
    
             (arpeggio-voices (loop repeat (length pitches)
                                for i from 0 to (1- (length pitches))
                                for j in pitches
                                for rhy in rhy
                                collect (if (= i 0)
                                          (length-adjust length (list rhy j velo art))
    										 (length-adjust length (append (gen-length (if (null offset)
                                                                                        (list i)
                                                                                        (list (+ i offset)))
                                                                                        (* -1 rhy)) (list rhy) (list j) 
                                                                          (list velo) (list art)))))))
        (assign-variable 'voice 
                         (if (null legato)
                           arpeggio-voices
                           (loop for x in arpeggio-voices
                             collect (length-legato x))))))
        
    
    (setf event '(q c4e4g4b4 mf ten))
    
    ;;; now it works correct
    (gen-arpeggio* event :rhy '(1/8 1/12 1/16 1/20))
    
    (list voice1)
    (list voice2)
    (list voice3)
    (list voice4)
    
    
    ;;; what makes intuitiv sense (old version/result)
    (gen-arpeggio* event :rhy '(1/24) :offset nil)
    ;; with OFFSET nil: the rests at the beginning are: 
    ;; * 0 rhy
    ;; * 1 rhy
    ;; * 2 rhy
    ;; * 3 rhy
    
    (list voice1)
    (list voice2)
    (list voice3)
    (list voice4)
    
    
    ;;; what are you looking for...
    (gen-arpeggio* event :rhy '(1/24) :offset 1)
    ;; with OFFSET 1: the rests at the beginning are: 
    ;; * 0 rhy
    ;; * 2 rhy
    ;; * 3 rhy
    ;; * 4 rhy
    
    (list voice1)
    (list voice2)
    (list voice3)
    (list voice4)

     

     

  10. here is a possible solution...

     

    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    ;;; THE FUNCTION ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    
    (defun gen-arpeggio (event &key (rhy'(1/28)) (legato nil))
      (let* ((pitches (melodize (omn :pitch event)))
             (length (car (omn :length event)))
             (velo (car (omn :velocity event)))
             (art (car (omn :articulation event)))
             (rhy (gen-repeat 10 rhy))
    
             (arpeggio-voices (loop repeat (length pitches)
                                for i from 0 to (1- (length pitches))
                                for j in pitches
                                for rhy in rhy
                                collect (if (= i 0)
                                          (length-rational-quantize (list rhy j velo art) :round length)
                                          (length-rational-quantize (append (gen-length (list i) (* -1 rhy)) (list rhy) (list j) 
                                                                            (list velo) (list art))
                                                                    :round length)))))
        (assign-variable 'voice 
                         (if (null legato)
                           arpeggio-voices
                           (loop for x in arpeggio-voices
                             collect (length-legato x))))))
        
    
    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    ;;; IT WORKS LIKE THAT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    
    ;;; type in ONE single-event (l p v a) with CHORD... for example:
    (setf event '(q c4e4g4b4 mf ten))
    
    ;;; evaluate the function (with a arpeggio-length, for example :ryh 1/28)
    (gen-arpeggio event :rhy 1/28)
    ; now the the result are "bounded" on 4 voices/variables = the number of the chord-pitches
    ; => (voice1 voice2 voice3 voice4)
    
    ;;; list every variable, so you will have the four "arpeggio-rhythm/times", so you can use that for 4 parts on your score 
    (list voice1)
    (list voice2)
    (list voice3)
    (list voice4)
    
    ;;; VARIANTS AND OPTIONS ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    
    ;;; if you choose ":legato t" => all the voices are like with PEDAL played
    (gen-arpeggio event :rhy 1/28 :legato t)
    
    
    ;;; if you want to put/merge all that into ONE VOICE just:
    (merge-voices voice1 voice2 voice3 voice4) 
    => (7q c4 ten e4 ten g4 ten b4 ten -7h.)
    
    
    ;;; if you want to have different rhy's just do it like that
    (gen-arpeggio event :rhy '(1/28 1/20 1/12 1/8))
    
    
    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    

     

     

  11. try this (it's an old function/setup, sorry)... works for me....

     

    1) evaluate all

    2) evaluate score

     

     

    ;; gen-hoquetus.4
    
    
    ;;; andré meier / 27-4-2016
    ;;; write a instrumentation-list (instrument + techniques + velocity), pitch-list 
    ;;; and length-list. the gen-hoquetus-function will split the melody 
    ;;; off... in any possibilities, techniques/articulations/velocities will be added
    ;;; this is only a function i coded for my actual work... perhaps you could use
    ;;; it or code it properly :-)
    ;;; HAVE FUN! regards, andré
    
    (setq instrumentation '(((pno ponte ppp))
                           ((vn pizz p)) 
                           ((vn pizz f) (va ponte f))
                           ((pno tasto ff))
                           ((pno pizz fff))
                           ((vn tasto mf) (pno ord ff) (vc tasto mf) (trp ord pp))
                           ((trp mute pp) (vn ponte mf))))
     
    ;; mainfuction:
     
    (defun gen-hoquetus.4 (filtered-instrument &key pitch length  instrument-list)
      (let ((events (generate-events.4 length pitch :optional_data instrument-list)))
        (filtering-color.4 filtered-instrument events)))
    
    (gen-hoquetus.4 'vn :pitch '(c4 d4 e5 f6) :length '(1/32 2/32 3/32 4/32) :instrument-list instrumentation)
    
    ;; subfunctions
     
    (defun generate-events.4 (durations pitches &key (velocity '(mf))
                                        (articulation '(-)) (optional_data 'nil))
      (loop repeat (length durations)
        with cnt-d = 0
        with cnt-rest = 0
        when (> (nth cnt-d durations) 0)
        collect (list (nth cnt-d durations) 
                      (nth cnt-rest pitches) 
                      (nth cnt-rest velocity)
                      (nth cnt-rest articulation) 
                      (nth cnt-rest optional_data))
        and do (incf cnt-rest)
        and do (incf cnt-d)
        else collect (list (nth cnt-d durations) 
                      'nil 
                      'nil
                      'nil 
                      'nil)
        and do (incf cnt-d)))
    
    
    
    (defun filtering-color.4 (selected-color event-stream)
      (loop for i in event-stream
        with match = 0
        append (loop for x in (fifth i)             
                 when (equal (first x) selected-color)
                 do (setq articulation (second x)
                          velocity (third x))
                 and do (setq match 1))
        when (and (= match 1)  (> (first i) 0))
        append (list (first i) (second i) velocity articulation)
        else collect (* -1 (abs (first i)))
        do (setq match 0)))
    
    
    ;; OMN_EXAMPLE:
    
    (setq pitches (midi-to-pitch '(60 61 62 63 64 65 66 67 68 69 70))) ; only an example
    (setq lengths (gen-length '(1 2 3 -4 5 6 5 -4 3 -2 1) 1/16)) ; only an example
    (setq instrumentation (loop repeat 10 collect
                            (rnd-pick '(((pno ponte ppp)) ; only an example
                                        ((vn pizz p)) 
                                        ((vn pizz f) (va ponte f))
                                        ((pno tasto ff))
                                        ((pno pizz fff))
                                        ((vn tasto mf) (pno ord ff) (vc tasto mf) (trp ord pp))
                                        ((trp mute pp) (vn ponte mf))))))
    
     
    (def-score hoquetus.4
               (:title "score title"
                       :key-signature '(c maj)
                       :time-signature '(4 4)
                       :tempo 120)
    
      
      (trumpet :omn (gen-hoquetus.4 'trp
                                    :pitch pitches
                                    :length lengths
                                    :instrument-list instrumentation)
               :channel 1)
      
      (piano :omn (gen-hoquetus.4 'pno
                                  :pitch pitches
                                  :length lengths
                                  :instrument-list instrumentation)
             :channel 2)
      
      (violin :omn (gen-hoquetus.4 'vn
                                   :pitch pitches
                                   :length lengths
                                   :instrument-list instrumentation)
              :channel 3)
      
      (viola :omn (gen-hoquetus.4 'va
                                  :pitch pitches
                                  :length lengths
                                  :instrument-list instrumentation)
             :channel 4)
      
      (violoncello :omn (gen-hoquetus.4 'vc
                                        :pitch pitches
                                        :length lengths
                                        :instrument-list instrumentation)
                   :channel 5))

     

  12. (defun permute-by-rule (n rule row)
      (append (list row)
              (loop repeat n
                collect (setf row (position-filter rule row)))))
    
    ;; row => a row (or a list)
    ;; n => number of generations
    ;; rule => new position/order in every generation - keep attention it's 0-based!!! => for 12 pitches use 0 to 11
    
    (permute-by-rule 20 '(2 0 1 5 11 3 8 6 4 9 10 7) (make-scale 'c4 12))

     

    Bildschirmfoto 2022-05-18 um 21.00.47.png

×
×
  • Create New...

Important Information

Terms of Use Privacy Policy