I’ve been spending a lot of time reworking my sound sets over the past year - and having acquired several new VIs (mainly VSL) during this time, I now need to find more consistent ways of mapping articulations to key switches so that results when working across different VIs are as expected.

My sound sets all use omn articulations linked to key switches and cc controller changes in the format:

leg (:key c0 :key c1 :key c2 cc20 65) - and so on.

This is typically how I have all the VSL instruments set up to trigger in Synchron Player. This approach works well even when there may be five or six levels (dimensions in Synchron Player) of key switches. I don’t have any problems with it and on the whole it works as I want it to. Combining key switches for more complex sets of switches I tend to manage by using articulations connected together such as con-sord+pizz+soft etc - and this also works well and ensures that flipping between different sets of switches, they behave as expected, and it makes writing the code in omn sequences clear. It also allows for some mapping of articulations to lengths to produce varied key switching, which has interesting results on many occasions.

However, I have recently started using some of VSL’s bigger Studio libraries where the sheer number of articulation options is just immense - and I am finding the usual approach is getting very complicated. For instance, in the Studio Orchestral Strings, there are so many articulations for ‘Repetitions’ (round robins) that cannot be managed in the same way, because the dimension-control for them is linked to speed of play only when playing repeating pitches and doesn’t work properly if using an articulation on its own and so it cannot simply be left on for all pitches in a given sequence because it doesn’t work unless a pitch is repeated directly in a sequence.

I have successfully built up a library of articulation mapping functions that use length-map to assign sets of articulations based on length values - so that short values link to short articulation key switches and longer ones to long articulation key switches and so on - which still works well when using randomisation of lengths. I think that the same sort of approach might be possible to link ‘Repetition’ key switches to speed of play so that when an omn pitch is repeated then the articulation for triggering the ‘Repetition’ key switch is mapped to those pitches so that the round-robin behaviour works based on the speed of play for those pitches.

What I think this would look like is that if an omn sequence contains repeats of a given pitch, then the articulation would be mapped to the relevant key-switch articulation for those pitches. I have looked at possible functions to do this. pattern-map might be candidate for doing this, but it’s not immediately obvious to me how this would work as that’s quite a generic mapping function. length-map is so easy to set up because it takes a specific length value and maps it directly to either a single articulation value or list of values but that obviously won’t work for pitches. The mapping of repeating pitches ONLY is a lot more tricky to conceive.

The other option I have considered is using dictum (in the :if :do form) - but again I cannot see an obvious way of the :if picking up repeated pitches only to :do a specific articulation for those pitches only because the usual input to the :if is a specific pitch value and not a sequence of the same pitch value.

I might be overlooking something really obvious but it might also be something that requires a bespoke function building several of the options above into a single operation: for instance, using dictum to pick up pitches and then map them separately to articulations.

Any ideas on how I might go about doing this - or other functions I should be having a look at?

bw

Andrew

Hi Andrew,

I don't know if that could help you but just in case, here's the function I'm using:

(defun articulation-map-omn (map omn &key (otherwise 'def))
  (do-verbose
      ("articulation-map-omn")
    (let ((plist (disassemble-omn omn)))
      (setf (getf plist :articulation)
            (pattern-map map (getf plist :length) :otherwise otherwise :swallow t))
      (apply 'make-omn plist))))

#| USAGE
(setf mat '((q c4 p d4 e e4 f4 s g4 f a4 g4 f4 q e4)
            (e d4 mp c4 s d4 e4 f4 e4 q d4 e c4 b3)
            (h a3 f -h)))

(setf prules '(
               ((s s s) (leg leg leg))
               ((s s)(leg leg))
               ((s e)(- -))
               ((s q)(- stacc))
               ((q) (stacc))
               ((e) (-))
               ))

(setf out (articulation-map-omn prules mat))
|#

Thanks for this - I’ll have a play around and see what I can do with this.

Andrew

Solution - length-map function.

length-map function works very well in most cases indeed except for leg who needs a more pattern matching approach in my opinion.

I have found the precise OM function that does what I need:

repeat-attribute

This function accurately replaces an articulation based on repetition of a pitch or length value. This works exactly as I was looking for — I knew it would be in the functions somewhere, I just couldn’t find it. length-map is a brilliant and very useful function as well - but for this particular task it wouldn’t be suitable as it was pitch values only that were to be processed.

I can just apply repeat-attribute to omn sequences when I want to use a round-robin articulation for repeated pitches rather than the articulation original assigned. No need for a workaround - this does the job.

Tests show this works as expected:

(setf sequence-reps '(d4 e4 f4 g4 g4 g4 g4 g4 d4 e4 d4 d4 d5 d4 d4 d5 d5 d5 a4 a4 g4 c4 c4))

(setf artics (rnd-sample 24 '(def nat ord stacc leg trem tr1 por gliss marc frull)))

(setf lens (rnd-sample 48 '(w h q e s)))

(setf vels (rnd-sample 24 '(ppp pp p mp mf f)))

(setf seq-t (make-omn :pitch sequence-reps :length lens :velocity vels :articulation artics)) ; original

>(e d4 ppp def h e4 f gliss e f4 mp stacc s g4 f ord w p stacc e pp por q p marc s ppp frull w d4 pp leg e4 f marc h d4 mp leg s mf gliss e d5 ppp stacc h d4 mp nat w p ord d5 ppp tr1 s p def h mf tr1 s a4 ppp def h pp leg e g4 f stacc q c4 mf gliss e ppp def h d4 mf stacc s e4 ppp def e f4 f gliss h g4 mp stacc e f ord w p stacc h pp por e p marc w d4 ppp frull s e4 pp leg h d4 f marc q mp leg e d5 mf gliss q d4 ppp stacc d4 mp nat h d5 p ord s ppp tr1 d5 p def a4 mf tr1 a4 ppp def e g4 pp leg c4 f stacc h mf gliss w d4 ppp def h e4 mf stacc)

(setf seq-reps (repeat-attribute 'rep seq-t)) ;replaced repeating pitch with 'rep articulation

>(e d4 ppp def h e4 f gliss e f4 mp stacc s g4 f rep w p rep e pp rep q p rep s ppp rep w d4 pp leg e4 f marc h d4 mp rep s mf rep e d5 ppp stacc h d4 mp rep w p rep d5 ppp rep s p rep h mf rep s a4 ppp rep h pp rep e g4 f stacc q c4 mf rep e ppp rep h d4 mf stacc s e4 ppp def e f4 f gliss h g4 mp rep e f rep w p rep h pp rep e p rep w d4 ppp frull s e4 pp leg h d4 f rep q mp rep e d5 mf gliss q d4 ppp rep d4 mp rep h d5 p rep s ppp rep d5 p rep a4 mf rep a4 ppp rep e g4 pp leg c4 f rep h mf rep w d4 ppp def h e4 mf stacc)

OM 64 >

Ah yes, good.

I'm using repeat-attribute sometimes to play staccs on repeated pitches in some otherwise legato passage.

Very useful indeed.