Jump to content


  • Posts

  • Joined

  • Last visited

Posts posted by AM

  1. here  a function... to barraqué's techniques


    (defun serie-proliferantes (row)
      (let* ((ri_row (pitch-invert (gen-retrograde row)))
             (row (loop for z in (loop for x in (pitch-to-midi ri_row)
                              collect (or (position x (pitch-to-midi row))
                                          (position (- x 12)
                                                    (pitch-to-midi row)) 
                                          (position (+ x 12) 
                                                    (pitch-to-midi row))))
                    collect (nth z ri_row))))
    (serie-proliferantes '(c5 ab4 g4 db5 e4 d4 bb4 eb4 b4  f4 fs4 a4))
    => (fs4 a4 g4 cs5 d5 c5 eb5 gs4 b4 f4 e5 bb4)



    seen here:



    page 19-20







  2. for my current project i have to CONVERT/MAP pitches/lengths/velocity or MIDI into a binary sequence. so i coded this simple FUNCTION... feel free to use/adapt....






    (defun fill-to-x-bit (listseq &key (bitlength 7))
      (loop for i in listseq
        when (< (length i) bitlength)
        collect (append (gen-repeat (- bitlength (length i)) 0) i)
        else collect i))
    (defun convert-to-binary (alist &key (parameter 'pitch) (length-resolution 127) (velocity-resolution 127) (pitch-resolution 127) (event nil)  (bitlength 7))
      (let ((pitch) (length) (velocity)
            (alist (progn 
                     (setf alist (cond ((stringp alist)
                                        (flatten (midi-to-omn alist :instrument 1)))
                                       (t alist)))
                     (if (omn-formp alist)
                       (cond ((equal parameter 'pitch)
                              (setf alist (omn :pitch alist)))
                             ((equal parameter 'length)
                              (setf alist (omn :length alist)))
                             ((equal parameter 'velocity)
                              (setf alist (omn :velocity alist)))
                             ((equal event 't)
                              (setf alist (single-events alist))))
        (if (null event)
          (cond ((pitchp (car alist))
                   (setf alist  (pitch-to-midi (pitch-melodize alist)))
                   (fill-to-x-bit (decimal-to-binary (vector-round 0 (if (null pitch-resolution)
                                                                      (- (find-max alist) (find-min alist))
                                                                      pitch-resolution) alist)) :bitlength bitlength)))
                ((lengthp (car alist))
                 (fill-to-x-bit (decimal-to-binary  (vector-round 1 length-resolution (mapcar 'float (omn :length alist)))) :bitlength bitlength))
                ((velocityp (car alist))
                 (fill-to-x-bit (decimal-to-binary  (vector-round 1 velocity-resolution (get-velocity  alist))) :bitlength bitlength)))
            (setf pitch (progn
                          (setf alist  (pitch-to-midi (pitch-melodize  (omn :pitch alist))))
                          (fill-to-x-bit (decimal-to-binary (vector-round 0 (if (null pitch-resolution)
                                                                             (- (find-max alist) (find-min alist))
                                                                             pitch-resolution) alist)) :bitlength bitlength)))
            (setf length (fill-to-x-bit (decimal-to-binary  (vector-round 1 length-resolution (mapcar 'float (omn :length alist)))) :bitlength bitlength))
            (setf velocity (fill-to-x-bit (decimal-to-binary  (vector-round 1 velocity-resolution (get-velocity  (omn :velocity alist))))  :bitlength bitlength))))))
    (convert-to-binary '(c4 cs5 fs3 c5 f5) :bitlength 15)
    (convert-to-binary '(-e e -q h e) :bitlength 15)
    (convert-to-binary '(p p ffff mp ) :bitlength 15)




  3. like that? should work...

    it "loops" x-times (depends on length of seeds-list) and collect the rhythms...


    (setf seeds (vector-round 1 100 (gen-white-noise 8 :seed 13)))
    (setf rhythm (loop for i in seeds 
                   collect (euclidean-rhythm 16 4 16 's :type 2 :seed i)))



    perhaps there is an OPMO-solution, this is LISP

  4. dear ole  


    i have no "preseted" soundsets for my work...

    in my current "sketch" i'm using/something something like this..


     '(e-bow "e-bow")
     '(harm-I "harm-1")
     '(harm-II "harm-II")
     '(harm-III "harm-III")
     '(harm-IV "harm-IV")
      '(harm-V "harm-V")
     '(harm-VI "harm-VI"))
    (def-sound-set gm-guitar
      (:group guitar 
              ord 0
              bartok-pizz 1
              tap 2
              ponte 3
              harm-I 4
              harm-II 5
              harm-III 6
              harm-IV 7
              harm-V 8
              harm-VI 9))
    (def-sound-set gm-vibraphone
      (:group vibraphone 
              ord 0
              tap 2))
    (def-sound-set gm-piano
      (:group piano 
              ord 0
              e-bow 1))


    for this CT-setup...


    git vibra pno.cePlayerOrc




  5. i have been working with conTimbre for a long time and it is exactly what i was looking for. playing techniques can easily be done by OPMO or SIBELIUS (vst3) via program changes. it has a great many different playing techniques. I always found IRCAM_LIB to be very inadequate, as there were not enough playing techniques etc. / you can also control CT via OSC (and as standalone or via MAXMSP). when I wrote for ensemble with additional e-player, CT-live always worked very well.


    (The only negative point I could say is that there are a few SAMPLES that weren't played / recorded very well. But with the size of the library, that's okay with me)

  6. Dear all


    Today I dealt briefly how to control PROCESSING (software and programming language) by Midi. There is a great interface for this: "rwmidi" by Giuseppe Torre. You can download and install it, it works fine!  


    A short Video (no Sound) with a very simple Processing Example



    I think this is a good combination if you want to visualize your midi output (or just use de midi-data in realtime)  or if you want to program a separate VISUAL track in OPMO. Here is a small example (I can't program usable in PROCESSING yet, sorry :-)) Downloads etc. are here ...





    here's a video, how to install etc...



    and as an attachm. my "sketch" in processing



    Greetings André


    P.S. I think there ist also a way to send data by OSC


  7. dear all


    here's an example (from my current work)...


    this little video shows how i generate/display SCORE (instrumental parts) on a screen + virtual conductor (piano part). the example is "nonsense", but shows how it looks/works... you see the bars (generating), the cue, beat... and the arrow (that shows you where to read/play) ...also you hear some bad (sry) sound-simulation of the setup.


    in this way i can generate a whole piece in realtime on STAGE (all musicians will read their part from their own screen). this one will be for 5 instruments, ePlayer and modular synthesizer. during the performance an algorithm (or some data-streams) will generate the piece in OPMO. with OSC i can send all datas (score, beat, tempo..)  from OPMO to POLYTEMPO-NETWORK  (https://polytempo.zhdk.ch) and work and coordinate different independent tempo layers, conducting etc...


    for more POLYTEMPO informations... have a look here: https://polytempo.zhdk.ch






  8. here is a sketch for an alternative "binary-(or element-)layer-FUNCTION


    (defun element-layer (lists &key (rnd nil))
      (let ((lists (if (null rnd)
                     (rnd-order lists :list t))))
          (loop for x in (rest lists)
            with list = (car lists)
            collect (setf list (loop for i in list
                                 with cnt = 0 
                                 when (equal i 0)
                                 collect (nth cnt x)
                                 and do (incf cnt)
                                 else collect i)))))))
    (element-layer  (list  '(1 0 0 1 1 0 0 1 0 0 0 0)
                           '(0 2 3 0 4 5 0 6 0 7 8 0)
                           '(11 12 13 14 15 16 17))
                    :rnd nil)
     => (1 11 2 1 1 3 12 1 4 5 13 6)
    ;;; hierarchic: every 0's will be replaced by the values from the next/sub-list...


  9. you want to map some integers (in your case pc..) to attributes? like that?


    (position-filter  '(0 1 2 3 4 5)  '(pizz arco ponte molto-ponte stacc stacc+pizz ten+arco ten+molto-ponte))
    => (pizz arco ponte molto-ponte stacc stacc+pizz)
    (position-filter  (pcs '6-Z10) '(pizz arco ponte molto-ponte stacc stacc+pizz ten+arco ten+molto-ponte))
    => (pizz arco molto-ponte stacc stacc+pizz ten+molto-ponte)
    or in pure CCL
      for i in '(0 1 2 3 4 5)
      with attr-list = '(pizz arco ponte molto-ponte stacc stacc+pizz ten+arco ten+molto-ponte)
      collect (nth i  attr-list))
    => (pizz arco ponte molto-ponte stacc stacc+pizz)


  10. like that..?... some code...




    (defun replace-velocities-in-a-seq (omn-list &key pitch velocity-list)
         with cnt = 0
         for i in (single-events omn-list)
         when (equal (cadr i) pitch)
         collect (omn-replace :velocity (nth cnt velocity-list) i)
         and do (incf cnt)
         else collect i
         when (> cnt (length velocity-list))
         do (setf cnt 0))))
    (replace-velocities-in-a-seq '(e c4 ppppp d4 d4 e4 f4 d4 d4 g4 b4 d4 d4 d4 d4)
                                 :pitch 'd4
                                 :velocity-list '(p mp mf f ff))
    ;=> (e c4 ppppp e d4 p e d4 mp e e4 ppppp e f4 ppppp e d4 mf e d4 f e g4 ppppp e b4 ppppp e d4 ff e d4 ppppp e d4 p e d4 mp)
    ;; if there are more 'd4's then velocity-values, -> it starts again with first velocity-value (= cycle)


  11. dear janusz


    at the moment i'm working with AUDULUS 3 and OPMO, work's fine.

    but there are some problems with the articulation. is it possible that in ord. there is a little "overlapping" between two notes? in this case AUDULUS don't "recognize" a change of velocity etc... with stacc it works fine (but with a gap).


    is there a "non-overlapping"-articulation with almost no gap between the notes?






  • Create New...

Important Information

Terms of Use Privacy Policy