Selector and multiplexers

[lalo]

Hi,
would be nice to have selectors and multiplexers...

to select multiple sources to 1 output
or multiple outputs from 1 source

[senso]

The module

select multiple sources to 1 output

already exists: It's the data/selector.

The

multiple outputs from 1 source

module will arrive soon, with a set of new objects.
If you are impatient, you can easilly create a subpatch witch do that (for few outputs).

[lalo]

yes...but does it work with audio signal inputs too?

[senso]

of course like most of data mudules.

[bsork]

In case anyone's interested, I fooled around with the new script module yesterday and created a (sort of) 8x8 matrix, where the source for the 8 outputs can be selected freely from the 8 inputs. No merging of input data though, so that e.g. inputs 1 and 2 can't be sent to output 3 at the same time. Any input can however be sent to as many (or no) output as one wishes.

This is my first attempt at writing a Usine script, so I'm sure I can make this little program a bit better. The CPU usage (according to the new and for me very welcome display in the upper rigth corner of the patch design window) was a bit high for my taste considering the simple code involved. However, I don't quite see any practical situation where I really would need to use as many as 8 inputs and 8 outputs. but it's much faster to delete than add some lines of code...

[senso]

hello,
it's interesting. You can post you scrip in the add-ons section. I'll take a look, if you want.
I know that the script language is very slow, and request a lot of CPU (too much...).
Actually, the script is not suitable for audio process, (only for data's or Midi calculation).

I'm working on.

[bsork]

As I mentioned, I have an idea or two to make the script a bit more efficient even if it's not a big nor a complicated program. I'll try those ideas out, and post the results in the add-ons; perhaps tomorrow.

I might even try to make a similar patch using 8 selectors just to make a comparison of the CPU usage.

Even if the scripts are slow and heavy on the CPU, I still find this to be a great addition to Usine, and some problems I've had creating patches with the "normal" modules should be gone now. (The problems may arise because I'm more used to writing lines of program code than connecting small boxes...)

[bsork]

I've uploaded the script to the Add-ons; it's called Matrix8x8.script. On my system the CPU load varied between 5% and 6.5% with the occasional dip to 4% or spike at around 7.5%. Deleting half the program and using only 4x4, resulted in a approximately halfed CPU load, as expected.

I also took a look at how much your MIDI delay etc patch used when idle (not sending any MIDI data through it), and it varied between 2% and 2.5%, even though that patch includes two scripts which both are more complicated than mine. Could it be that the big difference is there because mine contains so many in/out-parameters?

For the record, I also created a normal patch using 8 selectors that actually does exactly the same as the script, and it used between 0.5% and 0.7% with a spike or two at 1.2%...

Please don't spend time figuring out how my script can be improved as such, unless you think I've done something in a very impractical or inefficient way. I have no need for it - it used it just as an exercise - but maybe you can use it to check what can be improved in the script module. And please remove it from the Add-ons...

I also noticed a minor bug: The faders connected to the script (whose in- and output don't have any defined symbols) looked ok when created using ctrl-drag, but when reloaded after a restart of Usine, a '%' sign had been added after the value.

[senso]

great,
your script is very good. Of course I can give you some tips to improve the speed. I'll do that very soon.

Some of my MIDI scripts are complicated but if you look carefully, you can see that they don't do anything, most of time. The calculation is done only when MIDI events are received, and in fact it's very rare. Remember that the script calculation appears about 1000 times per seconds. Even if you play a Chopin sonata, less than 20 MIDI events arrive per seconds.

In you patch, 1000 time per second your script does:
- 16 assignations to variables or arrays
- 16 boolean evaluations.
- 8 out assignation
Hard job for the CPU...

I'm working on a CPU friend version of scripts. Not so easy but not impossible!

The % is the default value when no symbol is specified. Maybe it's not a good idea...I'll chek that point.
Actually, if you dont want any symbol, use the setSymbol procedure with an ' ' (space bar) in the initialization bloc.

[runagate]

bsork, I'm afraid that the link to your multiplexer doesn't work.

It is a great idea, though, the answer to exactly what I need right as I'm learning to use Usine.

And congrats - it appears that yours is the first add-on by anyone other than Uso.

I'd like to think I'll eventually be posting up add-ons, too, once I am experienced with this lovely program.

[senso]

You are right runagate.
Bug fixed, now available for download

[bsork]

Hello runagate and thanks for the gratulations, but I really don't think you should be using the version I uploaded since it's very CPU hungry. That's unless you'll use it as a starting point for your own creation(s) (or have a lot better PC than mine...).

As you can see earlier in the post, if a matrix is what're you looking for, it's quite easy to create a patch using as many data/selectors as you need outputs. A bit tiresome connecting all the wires from the 8 data sources to the 8 first inputs on the selectors (8*8=64 wires+wires to the destinations), but you'll be done in 10 minutes or so I guess.

Personally I haven't found much use for such a multiplexer thing, it's just an exercise in using the script module. I have gotten an idea to lower the CPU drain though, that I maybe try to code tonight.

[senso]

If I resume, the script is not suitable for massive data manipulation.
It can be use to create complex patches, Ie: counters, midi handlers, witch are hard to built with normal modules.

Especially, boolean evaluations like:
If (input1)
and (not input2)
or ((input1> 45) and (input2>input1)
then ...
is easy to calulate in a script.

I have just impemented the 'Dispatcher' module (1 in -> 8 out), witch is the inverse of the selector.
Contrary as I said to Lalo, the actual version of the selector doesn't work with audio. Now, it works.
Next release.

You'll find bellow, another version of the matrix script witch is 25% faster on my system (CPU 3% instead CPU 4%).

PS: In the next version of Usine, script engine will be 2 times faster.


The improvements are:

1) if you specify a min or a max value, you don't need to verify bounds, because in Usine, a value can't be out of range.
so

IF (src[5] > 0) AND (src[5] <= MAX_INPUTS) THEN

can be replaced by

IF (src[5] > 0) THEN

2) variables are faster than array.
src[N] is replaced by src1, src2, etc...

3) the Tparameter type is, in fact, Integer, witch is the order of declaration. So you can make additions to assign the input, like: GetValue(src0+7). I know it's tricky...

// parameters
VAR d1 : Tparameter;
VAR d2 : Tparameter;
VAR d3 : Tparameter;
VAR d4 : Tparameter;
VAR d5 : Tparameter;
VAR d6 : Tparameter;
VAR d7 : Tparameter;
VAR d8 : Tparameter;

VAR i1 : Tparameter;
VAR i2 : Tparameter;
VAR i3 : Tparameter;
VAR i4 : Tparameter;
VAR i5 : Tparameter;
VAR i6 : Tparameter;
VAR i7 : Tparameter;
VAR i8 : Tparameter;

VAR o1 : Tparameter;
VAR o2 : Tparameter;
VAR o3 : Tparameter;
VAR o4 : Tparameter;
VAR o5 : Tparameter;
VAR o6 : Tparameter;
VAR o7 : Tparameter;
VAR o8 : Tparameter;

var src0:integer;
var src1:integer;
var src2:integer;
var src3:integer;
var src4:integer;
var src5:integer;
var src6:integer;
var src7:integer;

CONST MAX_INPUTS = 8;

// initialisation
PROCEDURE init;
BEGIN
d1 := CreateParam('src1', ptDataField); SetIsOutput(d1, FALSE); SetMin(d1, 0); SetMax(d1, MAX_INPUTS); SetFormat(d1,'%.0f');
d2 := CreateParam('src2', ptDataField); SetIsOutput(d2, FALSE); SetMin(d2, 0); SetMax(d2, MAX_INPUTS); SetFormat(d2,'%.0f');
d3 := CreateParam('src3', ptDataField); SetIsOutput(d3, FALSE); SetMin(d3, 0); SetMax(d3, MAX_INPUTS); SetFormat(d3,'%.0f');
d4 := CreateParam('src4', ptDataField); SetIsOutput(d4, FALSE); SetMin(d4, 0); SetMax(d4, MAX_INPUTS); SetFormat(d4,'%.0f');
d5 := CreateParam('src5', ptDataField); SetIsOutput(d5, FALSE); SetMin(d5, 0); SetMax(d5, MAX_INPUTS); SetFormat(d5,'%.0f');
d6 := CreateParam('src6', ptDataField); SetIsOutput(d6, FALSE); SetMin(d6, 0); SetMax(d6, MAX_INPUTS); SetFormat(d6,'%.0f');
d7 := CreateParam('src7', ptDataField); SetIsOutput(d7, FALSE); SetMin(d7, 0); SetMax(d7, MAX_INPUTS); SetFormat(d7,'%.0f');
d8 := CreateParam('src8', ptDataField); SetIsOutput(d8, FALSE); SetMin(d8, 0); SetMax(d8, MAX_INPUTS); SetFormat(d8,'%.0f');

i1 := CreateParam('in1', ptDataField); SetIsOutput(i1, FALSE);
i2 := CreateParam('in2', ptDataField); SetIsOutput(i2, FALSE);
i3 := CreateParam('in3', ptDataField); SetIsOutput(i3, FALSE);
i4 := CreateParam('in4', ptDataField); SetIsOutput(i4, FALSE);
i5 := CreateParam('in5', ptDataField); SetIsOutput(i5, FALSE);
i6 := CreateParam('in6', ptDataField); SetIsOutput(i6, FALSE);
i7 := CreateParam('in7', ptDataField); SetIsOutput(i7, FALSE);
i8 := CreateParam('in8', ptDataField); SetIsOutput(i8, FALSE);

o1 := CreateParam('out1', ptDataField); SetIsInput(o1, FALSE);
o2 := CreateParam('out2', ptDataField); SetIsInput(o2, FALSE);
o3 := CreateParam('out3', ptDataField); SetIsInput(o3, FALSE);
o4 := CreateParam('out4', ptDataField); SetIsInput(o4, FALSE);
o5 := CreateParam('out5', ptDataField); SetIsInput(o5, FALSE);
o6 := CreateParam('out6', ptDataField); SetIsInput(o6, FALSE);
o7 := CreateParam('out7', ptDataField); SetIsInput(o7, FALSE);
o8 := CreateParam('out8', ptDataField); SetIsInput(o8, FALSE);

END;



// Main
BEGIN
src0 := trunc(GetValue(d1));
src1 := trunc(GetValue(d2));
src2 := trunc(GetValue(d3));
src3 := trunc(GetValue(d4));
src4 := trunc(GetValue(d5));
src5 := trunc(GetValue(d6));
src6 := trunc(GetValue(d7));
src7 := trunc(GetValue(d8));

IF (src0 > 0) THEN
SetValue(o1, GetValue(src0+7));
IF (src1 > 0) THEN
SetValue(o2, GetValue(src1+7));
IF (src2 > 0) THEN
SetValue(o3, GetValue(src2+7));
IF (src3 > 0) THEN
SetValue(o4, GetValue(src3+7));
IF (src4 > 0) THEN
SetValue(o5, GetValue(src4+7));
IF (src5 > 0) THEN
SetValue(o6, GetValue(src5+7));
IF (src6 > 0) THEN
SetValue(o7, GetValue(src6+7));
IF (src7 > 0) THEN
SetValue(o8, GetValue(src7+7));
END.

[bsork]

Thanks alot senso! I'll check out you're code and bother you more (I'm afraid...) if I don't understand the GetValue(src0+7) bit.

I was also thinking that scripts in designed to handle control messages and not audio, it would be acceptable to "thin" out the execution, and eg run the code just for Nth calls to the script, something I'm going to try out on this one.

[runagate]

Warnings noted

I'd be much further into understanding (and using) Usine had my soundcard not chosen this time to have an apparently unsolvable problem.

What I can accomplish leaves me very, very impressed still.

Hopefully I'll become very active on the forums here as I imagine the more details discussed amongst users the easier it'll be for the next new people.

[senso]

hello, runagate and bsork

The script is designed for very specific use but I want to keep Usine as intuitive as possible. The most interesting is the way you produce music with it!

I was also thinking that scripts in designed to handle control messages and not audio, it would be acceptable to "thin" out the execution, and eg run the code just for Nth calls to the script

You are right bsork, in some situations it can be enough to run the script every 10,20, cycles respectively to 15, 30 ms.

about the tricky code getvalue(src0+7)....

when you use the writeln(inttostr(i1)) code, you obtain
i1=8
i2=9
because i1 and i2 are integer in order of the declaration bloc.

now the expanded code is

src0 := getValue(d1) ;
if src0=0 then nothing
if src0 = 1 then SetValue(o1, i1);
if src0 = 2 then SetValue(o1, i2);
...
but if you think that i1 = 8 and i2=9 you can replace above

if src0 = 1 then SetValue(o1, ;
if src0 = 2 then SetValue(o1, 9);
...


if src0 = 1 then SetValue(o1, src0+7);
if src0 = 2 then SetValue(o1, src0+7);

almost the same line...

finally,
if src0<>0 then then SetValue(o1, src0+7);

I know that it's a hard programming tip!

[bsork]

Hello again senso, I suspected that the GetValue(src0+7) method had something to do with the order of the parameters. To put it in another way to check if I have understood it correctly: If the output parameters were declared before the inputs, I would have had to write GetValue(src0+15) instead?

There are a couple of things with this method though:
1) Faders created by ctrl-drag from the srcX inputs, can be scrolled with the mouse wheel outside of the min/max-values, but only in the module parameters panel.
2) When the srcX inputs get values above max, the outX sends zero values or some other inX value. I can't quite figure out any pattern in the behaviour; you,ll have to try it.

The above two issues is not of any practical consequence for me since they're both connected to "illegal" values, so I continued with your version of the script to create an even CPU friendlier version, that only sends values at intervals. I ended up running the code every 8th time, and then only for one srcX at the time, and ended up with a CPU usage of (mostly) below 1%:

Code: Select all

// parameters
VAR d1 : Tparameter;
VAR d2 : Tparameter;
VAR d3 : Tparameter;
VAR d4 : Tparameter;
VAR d5 : Tparameter;
VAR d6 : Tparameter;
VAR d7 : Tparameter;
VAR d8 : Tparameter;

VAR i1 : Tparameter;
VAR i2 : Tparameter;
VAR i3 : Tparameter;
VAR i4 : Tparameter;
VAR i5 : Tparameter;
VAR i6 : Tparameter;
VAR i7 : Tparameter;
VAR i8 : Tparameter;

VAR o1 : Tparameter;
VAR o2 : Tparameter;
VAR o3 : Tparameter;
VAR o4 : Tparameter;
VAR o5 : Tparameter;
VAR o6 : Tparameter;
VAR o7 : Tparameter;
VAR o8 : Tparameter;

var src1 : integer;
var src2 : integer;
var src3 : integer;
var src4 : integer;
var src5 : integer;
var src6 : integer;
var src7 : integer;
var src8 : integer;

CONST MAX_INPUTS = 8;

// initialisation
PROCEDURE init;
BEGIN  
   d1 := CreateParam('src1', ptDataField); 
   SetIsOutput(d1, FALSE); SetMin(d1, 0); SetMax(d1, MAX_INPUTS); SetFormat(d1,'%.0f'); SetSymbol(d1, '');
   d2 := CreateParam('src2', ptDataField); 
   SetIsOutput(d2, FALSE); SetMin(d2, 0); SetMax(d2, MAX_INPUTS); SetFormat(d2,'%.0f'); SetSymbol(d2, '');
   d3 := CreateParam('src3', ptDataField); 
   SetIsOutput(d3, FALSE); SetMin(d3, 0); SetMax(d3, MAX_INPUTS); SetFormat(d3,'%.0f'); SetSymbol(d3, '');
   d4 := CreateParam('src4', ptDataField); 
   SetIsOutput(d4, FALSE); SetMin(d4, 0); SetMax(d4, MAX_INPUTS); SetFormat(d4,'%.0f'); SetSymbol(d4, '');
   d5 := CreateParam('src5', ptDataField); 
   SetIsOutput(d5, FALSE); SetMin(d5, 0); SetMax(d5, MAX_INPUTS); SetFormat(d5,'%.0f'); SetSymbol(d5, '');
   d6 := CreateParam('src6', ptDataField); 
   SetIsOutput(d6, FALSE); SetMin(d6, 0); SetMax(d6, MAX_INPUTS); SetFormat(d6,'%.0f'); SetSymbol(d6, '');
   d7 := CreateParam('src7', ptDataField); 
   SetIsOutput(d7, FALSE); SetMin(d7, 0); SetMax(d7, MAX_INPUTS); SetFormat(d7,'%.0f'); SetSymbol(d7, '');
   d8 := CreateParam('src8', ptDataField); 
   SetIsOutput(d8, FALSE); SetMin(d8, 0); SetMax(d8, MAX_INPUTS); SetFormat(d8,'%.0f'); SetSymbol(d8, '');

   i1 := CreateParam('in1', ptDataField); SetIsOutput(i1, FALSE);
   i2 := CreateParam('in2', ptDataField); SetIsOutput(i2, FALSE);
   i3 := CreateParam('in3', ptDataField); SetIsOutput(i3, FALSE);
   i4 := CreateParam('in4', ptDataField); SetIsOutput(i4, FALSE);
   i5 := CreateParam('in5', ptDataField); SetIsOutput(i5, FALSE);
   i6 := CreateParam('in6', ptDataField); SetIsOutput(i6, FALSE);
   i7 := CreateParam('in7', ptDataField); SetIsOutput(i7, FALSE);
   i8 := CreateParam('in8', ptDataField); SetIsOutput(i8, FALSE);

   o1 := CreateParam('out1', ptDataField); SetIsInput(o1, FALSE);
   o2 := CreateParam('out2', ptDataField); SetIsInput(o2, FALSE);
   o3 := CreateParam('out3', ptDataField); SetIsInput(o3, FALSE);
   o4 := CreateParam('out4', ptDataField); SetIsInput(o4, FALSE);
   o5 := CreateParam('out5', ptDataField); SetIsInput(o5, FALSE);
   o6 := CreateParam('out6', ptDataField); SetIsInput(o6, FALSE);
   o7 := CreateParam('out7', ptDataField); SetIsInput(o7, FALSE);
   o8 := CreateParam('out8', ptDataField); SetIsInput(o8, FALSE);

END;

VAR i, j: Integer;

// Main
BEGIN
   i := i + 1;
   IF ((i mod (MAX_INPUTS)) = 0) THEN
   BEGIN
     j := j + 1;
     CASE (j mod MAX_INPUTS) OF
       0 : BEGIN j := 0; src1 := trunc(GetValue(d1)); IF (src1 > 0) THEN SetValue(o1, GetValue(src1+MAX_INPUTS-1)); EXIT; END
       1 : BEGIN src2 := trunc(GetValue(d2)); IF (src2 > 0) THEN SetValue(o2, GetValue(src2+MAX_INPUTS-1)); EXIT; END;
       2 : BEGIN src3 := trunc(GetValue(d3)); IF (src3 > 0) THEN SetValue(o3, GetValue(src3+MAX_INPUTS-1)); EXIT; END;
       3 : BEGIN src4 := trunc(GetValue(d4)); IF (src4 > 0) THEN SetValue(o4, GetValue(src4+MAX_INPUTS-1)); EXIT; END;
       4 : BEGIN src5 := trunc(GetValue(d5)); IF (src5 > 0) THEN SetValue(o5, GetValue(src5+MAX_INPUTS-1)); EXIT; END;
       5 : BEGIN src6 := trunc(GetValue(d6)); IF (src6 > 0) THEN SetValue(o6, GetValue(src6+MAX_INPUTS-1)); EXIT; END;
       6 : BEGIN src7 := trunc(GetValue(d7)); IF (src7 > 0) THEN SetValue(o7, GetValue(src7+MAX_INPUTS-1)); EXIT; END;
       7 : BEGIN src8 := trunc(GetValue(d8)); IF (src8 > 0) THEN SetValue(o8, GetValue(src8+MAX_INPUTS-1)); EXIT; END;
      END;
      i := 0;
   END;
END.

[senso]

hello,

GetValue(src0+15)

You are right. Now I'm shure you understand the tricky script.

Faders created by ctrl-drag from the srcX inputs, can be scrolled with the mouse wheel outside of the min/max-values, but only in the module parameters panel.

yes, yes. you found the most absurd bug of the world...

When the srcX inputs get values above max, the outX sends zero values or some other inX value. I can't quite figure out any pattern in the behaviour; you,ll have to try it.

it's almost normal if you think about the order of the parameters.

Your script is perfect, and each value is evaluated any 8x8=64 cycles (about 100ms at 44100Hz) . In most situations it can be enough!

[bsork]

I work as a developer (doing large business/database stuff), and I can assure you, the scroll wheel bug is far from being the most absurd bug I've seen (and maybe created myself...)!

and to runagate; hope you'll get your problems sorted out quickly.