Hey hey everyone,
I want to implement a modulation matrix for a MIDI driven orchestra. Think of 
a typical hardware synth architecture:
instr SynthVoice ; produce audio for a single voice
...
endin

Run a fixed number of instances of SynthVoice.

instr ControlInput ; read controller input into a global array
...
endin

Keep that instrument running updating everything global, including a global 
modmatrix.

My current idea for the mod matrix:
a global two dimensional array with three rows and enough columns to hold all 
modmatrix slots. The rows are:
1. source parameter number
2. modulation amount
3. destination parameter number

The destination parameter number will correspond to the index of the global 
parameter array. These need to be modulated in every instance of SynthVoice 
with the current output of the modulation source, a locally running opcode. 
The output of local opcodes can be written directly to a local array, which is 
no problem.

But how to modify the destination? If I copied the global parameter array 
locally to each instrument, I'd waste memory. The array might have 200-400 
elements. Any ideas? I want to implement it in an efficient way, not wasting 
CPU power and if possibly not wasting memory, although that's not a big 
concern.

Thank you for considering this problem and any help you might give!

Ta-ta
----
Ffanci
* Homepage: https://freeshell.de/~silvain
* Twitter:  http://twitter.com/ffanci_silvain
* GitHub:   https://github.com/fsilvain

------------------------------------------------------------------------------
_______________________________________________
Csound-users mailing list
Csound-users@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/csound-users
Send bugs reports to
        https://github.com/csound/csound/issues
Discussions of bugs and features can be posted here

On Thu, 18 Jun 2015, F. Silvain wrote:
> But how to modify the destination? If I copied the global parameter array
> locally to each instrument, I'd waste memory. The array might have 200-400
> elements. Any ideas? I want to implement it in an efficient way, not wasting
> CPU power and if possibly not wasting memory, although that's not a big
> concern.

I'd go ahead and waste the memory.  There are not many systems capable of
running Csound at all but with memory so tight as to justify a more
complicated solution.

You might find the opcode modmatrix interesting,
it seems to be similar to what you want.
We also have a paper to describe some of the issues:
http://www.nime2011.org/proceedings/papers/G27-Brandtsegg.pdf
Oeyvind

2015-06-18 20:35 GMT+02:00 F. Silvain :
> Hey hey everyone,
> I want to implement a modulation matrix for a MIDI driven orchestra. Think of
> a typical hardware synth architecture:
> instr SynthVoice ; produce audio for a single voice
> ...
> endin
>
> Run a fixed number of instances of SynthVoice.
>
> instr ControlInput ; read controller input into a global array
> ...
> endin
>
> Keep that instrument running updating everything global, including a global
> modmatrix.
>
> My current idea for the mod matrix:
> a global two dimensional array with three rows and enough columns to hold all
> modmatrix slots. The rows are:
> 1. source parameter number
> 2. modulation amount
> 3. destination parameter number
>
> The destination parameter number will correspond to the index of the global
> parameter array. These need to be modulated in every instance of SynthVoice
> with the current output of the modulation source, a locally running opcode.
> The output of local opcodes can be written directly to a local array, which is
> no problem.
>
> But how to modify the destination? If I copied the global parameter array
> locally to each instrument, I'd waste memory. The array might have 200-400
> elements. Any ideas? I want to implement it in an efficient way, not wasting
> CPU power and if possibly not wasting memory, although that's not a big
> concern.
>
> Thank you for considering this problem and any help you might give!
>
> Ta-ta
> ----
> Ffanci
> * Homepage: https://freeshell.de/~silvain
> * Twitter:  http://twitter.com/ffanci_silvain
> * GitHub:   https://github.com/fsilvain
>
> ------------------------------------------------------------------------------
> _______________________________________________
> Csound-users mailing list
> Csound-users@lists.sourceforge.net
> https://lists.sourceforge.net/lists/listinfo/csound-users
> Send bugs reports to
>         https://github.com/csound/csound/issues
> Discussions of bugs and features can be posted here

Very interesting paper, Oeyvind. It reminds me of the time when I played 
with an EMS synthi-aks...

Richard

On 18/06/15 23:20, Oeyvind Brandtsegg wrote:
> You might find the opcode modmatrix interesting,
> it seems to be similar to what you want.
> We also have a paper to describe some of the issues:
> http://www.nime2011.org/proceedings/papers/G27-Brandtsegg.pdf
> Oeyvind
>
> 2015-06-18 20:35 GMT+02:00 F. Silvain :
>> Hey hey everyone,
>> I want to implement a modulation matrix for a MIDI driven orchestra. Think of
>> a typical hardware synth architecture:
>> instr SynthVoice ; produce audio for a single voice
>> ...
>> endin
>>
>> Run a fixed number of instances of SynthVoice.
>>
>> instr ControlInput ; read controller input into a global array
>> ...
>> endin
>>
>> Keep that instrument running updating everything global, including a global
>> modmatrix.
>>
>> My current idea for the mod matrix:
>> a global two dimensional array with three rows and enough columns to hold all
>> modmatrix slots. The rows are:
>> 1. source parameter number
>> 2. modulation amount
>> 3. destination parameter number
>>
>> The destination parameter number will correspond to the index of the global
>> parameter array. These need to be modulated in every instance of SynthVoice
>> with the current output of the modulation source, a locally running opcode.
>> The output of local opcodes can be written directly to a local array, which is
>> no problem.
>>
>> But how to modify the destination? If I copied the global parameter array
>> locally to each instrument, I'd waste memory. The array might have 200-400
>> elements. Any ideas? I want to implement it in an efficient way, not wasting
>> CPU power and if possibly not wasting memory, although that's not a big
>> concern.
>>
>> Thank you for considering this problem and any help you might give!
>>
>> Ta-ta
>> ----
>> Ffanci
>> * Homepage: https://freeshell.de/~silvain
>> * Twitter:  http://twitter.com/ffanci_silvain
>> * GitHub:   https://github.com/fsilvain
>>
>> ------------------------------------------------------------------------------
>> _______________________________________________
>> Csound-users mailing list
>> Csound-users@lists.sourceforge.net
>> https://lists.sourceforge.net/lists/listinfo/csound-users
>> Send bugs reports to
>>          https://github.com/csound/csound/issues
>> Discussions of bugs and features can be posted here
>
>


------------------------------------------------------------------------------
_______________________________________________
Csound-users mailing list
Csound-users@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/csound-users
Send bugs reports to
        https://github.com/csound/csound/issues
Discussions of bugs and features can be posted here

;-)

2015-06-19 10:25 GMT+02:00 Richard :
> Very interesting paper, Oeyvind. It reminds me of the time when I played
> with an EMS synthi-aks...
>
> Richard
>
> On 18/06/15 23:20, Oeyvind Brandtsegg wrote:
>> You might find the opcode modmatrix interesting,
>> it seems to be similar to what you want.
>> We also have a paper to describe some of the issues:
>> http://www.nime2011.org/proceedings/papers/G27-Brandtsegg.pdf
>> Oeyvind
>>
>> 2015-06-18 20:35 GMT+02:00 F. Silvain :
>>> Hey hey everyone,
>>> I want to implement a modulation matrix for a MIDI driven orchestra. Think of
>>> a typical hardware synth architecture:
>>> instr SynthVoice ; produce audio for a single voice
>>> ...
>>> endin
>>>
>>> Run a fixed number of instances of SynthVoice.
>>>
>>> instr ControlInput ; read controller input into a global array
>>> ...
>>> endin
>>>
>>> Keep that instrument running updating everything global, including a global
>>> modmatrix.
>>>
>>> My current idea for the mod matrix:
>>> a global two dimensional array with three rows and enough columns to hold all
>>> modmatrix slots. The rows are:
>>> 1. source parameter number
>>> 2. modulation amount
>>> 3. destination parameter number
>>>
>>> The destination parameter number will correspond to the index of the global
>>> parameter array. These need to be modulated in every instance of SynthVoice
>>> with the current output of the modulation source, a locally running opcode.
>>> The output of local opcodes can be written directly to a local array, which is
>>> no problem.
>>>
>>> But how to modify the destination? If I copied the global parameter array
>>> locally to each instrument, I'd waste memory. The array might have 200-400
>>> elements. Any ideas? I want to implement it in an efficient way, not wasting
>>> CPU power and if possibly not wasting memory, although that's not a big
>>> concern.
>>>
>>> Thank you for considering this problem and any help you might give!
>>>
>>> Ta-ta
>>> ----
>>> Ffanci
>>> * Homepage: https://freeshell.de/~silvain
>>> * Twitter:  http://twitter.com/ffanci_silvain
>>> * GitHub:   https://github.com/fsilvain
>>>
>>> ------------------------------------------------------------------------------
>>> _______________________________________________
>>> Csound-users mailing list
>>> Csound-users@lists.sourceforge.net
>>> https://lists.sourceforge.net/lists/listinfo/csound-users
>>> Send bugs reports to
>>>          https://github.com/csound/csound/issues
>>> Discussions of bugs and features can be posted here
>>
>>
>
>
> ------------------------------------------------------------------------------
> _______________________________________________
> Csound-users mailing list
> Csound-users@lists.sourceforge.net
> https://lists.sourceforge.net/lists/listinfo/csound-users
> Send bugs reports to
>         https://github.com/csound/csound/issues
> Discussions of bugs and features can be posted here

Hey Oeyvind,
thank you for your valuable help. The paper is great! It takes a different 
approach than I had in mind. It solved a lot of issues for me.

One question: how to deal with sidechaining, modifying the amount of one 
matrix slot by another matrix slot? Is it necessary to build two matrices, one 
calculating the modulation amounts for the other? Or is there a cleverer way?

Ta-ta
----
Ffanci
* Homepage: https://freeshell.de/~silvain
* Twitter:  http://twitter.com/ffanci_silvain
* GitHub:   https://github.com/fsilvain

------------------------------------------------------------------------------
_______________________________________________
Csound-users mailing list
Csound-users@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/csound-users
Send bugs reports to
        https://github.com/csound/csound/issues
Discussions of bugs and features can be posted here

Nice to hear ;-)
I'm unfamiliar with using the term sidechaining in the context of
modulator routing, but assuming you want one parameter to modulate
another, you can easily route the matrix parameter outputs back in as
modulator inputs, allowing anything to modulate anything including
modulator feedback. Feel free to ask if you run into any kind of
trouble or have questions on how to achieve a specific kind of
routing.
all best
Oeyvind

2015-06-19 13:40 GMT+02:00 F. Silvain :
> Hey Oeyvind,
> thank you for your valuable help. The paper is great! It takes a different
> approach than I had in mind. It solved a lot of issues for me.
>
> One question: how to deal with sidechaining, modifying the amount of one
> matrix slot by another matrix slot? Is it necessary to build two matrices, one
> calculating the modulation amounts for the other? Or is there a cleverer way?
>
> Ta-ta
> ----
> Ffanci
> * Homepage: https://freeshell.de/~silvain
> * Twitter:  http://twitter.com/ffanci_silvain
> * GitHub:   https://github.com/fsilvain
>
> ------------------------------------------------------------------------------
> _______________________________________________
> Csound-users mailing list
> Csound-users@lists.sourceforge.net
> https://lists.sourceforge.net/lists/listinfo/csound-users
> Send bugs reports to
>         https://github.com/csound/csound/issues
> Discussions of bugs and features can be posted here

Oeyvind Brandtsegg, Jun 19 2015:

> Nice to hear ;-)
> I'm unfamiliar with using the term sidechaining in the context of
> modulator routing, but assuming you want one parameter to modulate
> another, you can easily route the matrix parameter outputs back in as
> modulator inputs, allowing anything to modulate anything including
> modulator feedback. Feel free to ask if you run into any kind of
> trouble or have questions on how to achieve a specific kind of
> routing.
...
Could you consider the following scenario and tell me, if my solution is the best I could do:
route lfo1 to pitch1 with modulation amout of 0
route controller1 to modulation amount 1 with a positive modulation amount
execute the second routing outside the matrix by multiplying the output of controller1 by modulation amount given and add this value to the corresponding index of the modulation amount ftable, i.e. (lfo1index+1) * pitch1index
This would mean, that the modmatrix will have to be calculated every control cycle, when controller1 changes. If controller1 is something like lfo2 it will change continuously, also changing the matrix itself, whenever a modulation amount of 0 is reached for the first routing. Correct?

I can't think of another method to do it, without modulating the overall amount of lfo1, which is not what I want to do.

Ta-ta
----
Ffanci
* Homepage: https://freeshell.de/~silvain
* Twitter:  http://twitter.com/ffanci_silvain
* GitHub:   https://github.com/fsilvain

------------------------------------------------------------------------------
_______________________________________________
Csound-users mailing list
Csound-users@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/csound-users
Send bugs reports to
        https://github.com/csound/csound/issues
Discussions of bugs and features can be posted here

Hi,
Unless I'm missing something (quite possible), what you want ot is use
controller 1 to set the amount of influence of LFO1 to the pitch
parameter (?).
So that when the controller is at zero you get no LFO-induced vibrato,
but as you increase the controller1 value you get more and more
vibrato.
If this is correct, I would use the following modulation matrix

Parameter sources: LFO amp, Pitch
Modulation sources: Controller, LFO signal

Mod matrix:
1.0   0.0
0.0   100.0

This means that Controller 1 affects the LFO amplitude (upper left of
the matrix),
and the LFO signal affects the pitch (+/- 100Hz)

The one thing to keep in mind is that the LFO amp is a parameter value
just like the pitch parameter, so, collecting all parameters that can
be modulated into the modmatrix you get full freedom of modulator
routing.
The modulation matrix itself is not recalculated every time a
modulator signal changes. If is recalculated only when the routing
coefficients changes (and that is only necessary when you want to make
a new routing).

Hope I did not miss the point alltogether,
now for coffee....


2015-06-20 13:00 GMT+02:00 F. Silvain :
> Oeyvind Brandtsegg, Jun 19 2015:
>
>> Nice to hear ;-)
>> I'm unfamiliar with using the term sidechaining in the context of
>> modulator routing, but assuming you want one parameter to modulate
>> another, you can easily route the matrix parameter outputs back in as
>> modulator inputs, allowing anything to modulate anything including
>> modulator feedback. Feel free to ask if you run into any kind of
>> trouble or have questions on how to achieve a specific kind of
>> routing.
> ...
> Could you consider the following scenario and tell me, if my solution is the best I could do:
> route lfo1 to pitch1 with modulation amout of 0
> route controller1 to modulation amount 1 with a positive modulation amount
> execute the second routing outside the matrix by multiplying the output of controller1 by modulation amount given and add this value to the corresponding index of the modulation amount ftable, i.e. (lfo1index+1) * pitch1index
> This would mean, that the modmatrix will have to be calculated every control cycle, when controller1 changes. If controller1 is something like lfo2 it will change continuously, also changing the matrix itself, whenever a modulation amount of 0 is reached for the first routing. Correct?
>
> I can't think of another method to do it, without modulating the overall amount of lfo1, which is not what I want to do.
>
> Ta-ta
> ----
> Ffanci
> * Homepage: https://freeshell.de/~silvain
> * Twitter:  http://twitter.com/ffanci_silvain
> * GitHub:   https://github.com/fsilvain
>
> ------------------------------------------------------------------------------
> _______________________________________________
> Csound-users mailing list
> Csound-users@lists.sourceforge.net
> https://lists.sourceforge.net/lists/listinfo/csound-users
> Send bugs reports to
>         https://github.com/csound/csound/issues
> Discussions of bugs and features can be posted here

Oeyvind Brandtsegg, Jun 22 2015:
...
> Parameter sources: LFO amp, Pitch
> Modulation sources: Controller, LFO signal
>
> Mod matrix:
> 1.0   0.0
> 0.0   100.0
...
Hi there,
this is almost it. But with that routing everytime I will. route LFO1 elsewhere, it's signal will be modulated by controller1. I only wish to modulate the amount of LFO1 for that matrix slot or position. That is what some people called "sidechaining". In the Solaris hardware synth, it is presented to the user by having an additional entry for a modulation allowing for the sidechaining signal. In most synths I've seen, you simply get the modu7lation destination matrix slot x. It can be found in the DSI Prophet series and the Waldorf synths to name a few.

That does mean, that I will potentially enter a modulation value of 0 for LFO1 -> Pitch and let the amount be altered by controller1.

I've thought of a second method of achieving this, but still wondering, how fesable it is with a freely assignable matrix. Copy a modulator signal, when its amount is modulated and then just do what you did.
LFO1 -> Pitch
Ctrl1 -> slot1 (execute operation:
copy LFO1 output to LFO1_1
LFO1_1 -> Pitch
Ctrl1 -> LFO1_1

My concern is, that this synt should run in realtime on a dedicated system. thus I don't want to waste resources or run into unpredictable loads on the system.

Thank you for your dedicated help and patience!

Ta-ta
----
Ffanci
* Homepage: https://freeshell.de/~silvain
* Twitter:  http://twitter.com/ffanci_silvain
* GitHub:   https://github.com/fsilvain

------------------------------------------------------------------------------
Monitor 25 network devices or servers for free with OpManager!
OpManager is web-based network management software that monitors 
network devices and physical & virtual servers, alerts via email & sms 
for fault. Monitor 25 devices for free with no restriction. Download now
http://ad.doubleclick.net/ddm/clk/292181274;119417398;o
_______________________________________________
Csound-users mailing list
Csound-users@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/csound-users
Send bugs reports to
        https://github.com/csound/csound/issues
Discussions of bugs and features can be posted here

Ok, yes, what you want amounts to making two copies of the LFO signal
(as in your suggested method).
In Hadron, we also do something along these lines, as we have a
separate set of parameters dedicated to modulation mixing and shaping.
For example "multiplier" parameters in the modulation matrix, where we
have 2 inputs for a multiplier, all other modulators can be routed
into these inputs, and the output of the multiplication can be used as
yet another modulator. If I understand the sidechaining modulation
concept in Solaris correctly, this is similar.
In addition, we also have "dividers" working along the same lines (but
then it is always 1/iput), and "modulo" modulators (one modulator
makes another wrap around at specific values), shaping via ftables
(routing a modulator to a shaping table, and routing the output from
the table as any other modulator). All of these operations will create
extra parmeters and modulators in the modmatrix, but the matrix is
optimized and will only calculate the active routings, so the extra
matrix slots will not cost any CPU cycles. That is unless you actually
use all routing points simultaneously. Up until now, I've found the
matrix in practice will always be relatively sparsely populated. The
power of the flexibility is that everything is available and can be
activated dynamically, even if at any single point in time you might
use relatively few of the available options. "Relatively few" here
might mean that I will commonly use 30 or 40 of the available 10868
(209*52) matrix coefficients in the modmatrix for Hadron.
best
Oeyvind

2015-06-22 16:48 GMT+02:00 F. Silvain :
> Oeyvind Brandtsegg, Jun 22 2015:
> ...
>> Parameter sources: LFO amp, Pitch
>> Modulation sources: Controller, LFO signal
>>
>> Mod matrix:
>> 1.0   0.0
>> 0.0   100.0
> ...
> Hi there,
> this is almost it. But with that routing everytime I will. route LFO1 elsewhere, it's signal will be modulated by controller1. I only wish to modulate the amount of LFO1 for that matrix slot or position. That is what some people called "sidechaining". In the Solaris hardware synth, it is presented to the user by having an additional entry for a modulation allowing for the sidechaining signal. In most synths I've seen, you simply get the modu7lation destination matrix slot x. It can be found in the DSI Prophet series and the Waldorf synths to name a few.
>
> That does mean, that I will potentially enter a modulation value of 0 for LFO1 -> Pitch and let the amount be altered by controller1.
>
> I've thought of a second method of achieving this, but still wondering, how fesable it is with a freely assignable matrix. Copy a modulator signal, when its amount is modulated and then just do what you did.
> LFO1 -> Pitch
> Ctrl1 -> slot1 (execute operation:
> copy LFO1 output to LFO1_1
> LFO1_1 -> Pitch
> Ctrl1 -> LFO1_1
>
> My concern is, that this synt should run in realtime on a dedicated system. thus I don't want to waste resources or run into unpredictable loads on the system.
>
> Thank you for your dedicated help and patience!
>
> Ta-ta
> ----
> Ffanci
> * Homepage: https://freeshell.de/~silvain
> * Twitter:  http://twitter.com/ffanci_silvain
> * GitHub:   https://github.com/fsilvain
>
> ------------------------------------------------------------------------------
> Monitor 25 network devices or servers for free with OpManager!
> OpManager is web-based network management software that monitors
> network devices and physical & virtual servers, alerts via email & sms
> for fault. Monitor 25 devices for free with no restriction. Download now
> http://ad.doubleclick.net/ddm/clk/292181274;119417398;o
> _______________________________________________
> Csound-users mailing list
> Csound-users@lists.sourceforge.net
> https://lists.sourceforge.net/lists/listinfo/csound-users
> Send bugs reports to
>         https://github.com/csound/csound/issues
> Discussions of bugs and features can be posted here

Hey hey Oeyvind,
thank you very much! I have even solved the problem of flexibly routing controllers to other matrix amounts. Since I will limit my matrix to 16 modulations, I can create an array or ftable of 16 elements and copy control signals to it as needed. Now I only need to code it. :)

Thanks again! You were a great help!
Ta-ta
----
Ffanci
* Homepage: https://freeshell.de/~silvain
* Twitter:  http://twitter.com/ffanci_silvain
* GitHub:   https://github.com/fsilvain

------------------------------------------------------------------------------
Monitor 25 network devices or servers for free with OpManager!
OpManager is web-based network management software that monitors 
network devices and physical & virtual servers, alerts via email & sms 
for fault. Monitor 25 devices for free with no restriction. Download now
http://ad.doubleclick.net/ddm/clk/292181274;119417398;o
_______________________________________________
Csound-users mailing list
Csound-users@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/csound-users
Send bugs reports to
        https://github.com/csound/csound/issues
Discussions of bugs and features can be posted here

Thanks. Good luck with the project!

2015-06-23 14:55 GMT+02:00 F. Silvain :
> Hey hey Oeyvind,
> thank you very much! I have even solved the problem of flexibly routing controllers to other matrix amounts. Since I will limit my matrix to 16 modulations, I can create an array or ftable of 16 elements and copy control signals to it as needed. Now I only need to code it. :)
>
> Thanks again! You were a great help!
> Ta-ta
> ----
> Ffanci
> * Homepage: https://freeshell.de/~silvain
> * Twitter:  http://twitter.com/ffanci_silvain
> * GitHub:   https://github.com/fsilvain
>
> ------------------------------------------------------------------------------
> Monitor 25 network devices or servers for free with OpManager!
> OpManager is web-based network management software that monitors
> network devices and physical & virtual servers, alerts via email & sms
> for fault. Monitor 25 devices for free with no restriction. Download now
> http://ad.doubleclick.net/ddm/clk/292181274;119417398;o
> _______________________________________________
> Csound-users mailing list
> Csound-users@lists.sourceforge.net
> https://lists.sourceforge.net/lists/listinfo/csound-users
> Send bugs reports to
>         https://github.com/csound/csound/issues
> Discussions of bugs and features can be posted here