Hello,

I've a problem with my PD project, it's like a reactable.

Globally each Object (modules) like sound generator (synth,sample) , effects (flanger,etc..) connect itself (for the audio) dynamicaly with throw and catch.

For example (functional view) :
[Sound generator3]-- [throw3] [catch3]--[effect1]--[throw speaker]
[Sound generator6]-- [throw speaker]

[catch speaker]--[DSP]

My problem is when many audio source are send to the same [catch] (the speaker) then the sound is distorded, i think the catch add the "n" source and it "saturate"

Do you know how to "mix" the signal correclty using many throw to the same catch ?

Many thanks in advance

I believe that catch just adds the samplevalues together but doesn't try to saturate or something. Have you checked the pd meter? If it goes into the red (>=100) you're overloading your outputs.

Couldn't you monitor the count of objects that have been created and multiply your output accordingly to keep levels down?

You could always try to put a limitter in the signal chain (just before going to [dac~]). If you can use [vst~] (windows only?) there are a number of nice freeware brickwall limitters around (e.g. jeroen breebaert's).

Hope this helps,

D.

Hello,

Effectively i'm overloading the output, (the clip in in red) i got 105 to 107 ..

i don't know how to count the object connected (it's dynamic) .. i need a global variable ..

But did someone already get this kind of prob with throw and catch .. ??

Regards,

Nico

The [value] object is a pretty easy way to keep global variables.

This is a very common issue (at least i've had this problem quite a few times!). What you need to do is to make sure that your signal never goes over 100db (or 1 in audio terms in Pd) on his way to the output.
For instance, just before each of your [throw~] objects, you could put a [*~ 0.5]. That would reduce the "volume" considerably.
You have to keep in mind that whenever you add audio channels together (like for instance when all of your catch~'s end up into your dac~), the general volume increases. If it goes beyond 1, you will hear a distortion, no matter whether the volume of your speakers is high or not.

So what i would do is something like this:

|
|
[*~ 0.5]
|
[throw~]

[catch~]
|

everytime you have a throw/catch couple, and something like this before the output:

|
| [vsl]
| |
| [pack 0 10]
| |
| [line~]
| |
| /
[*~]
|
[dac~]

the vsl thing is a vertical slider, which to can set to range from 0 (volume turned all the way down) to, say, 5.

You can then adjust the value by which you multiply your audio signal before the throw~ (0.5 might be too high or too low depending on your signal).
In general, you shouldn't move your volume slider above 1. But if your signal is too weak in the end due too multiplying each channel by 0.5, you may want to raise it to a reasonable value (which implies moving the slider beyond 1).

Hope this helps.

@pamelapopo said:

So what i would do is something like this:

|
|
[*~ 0.5]
|
[throw~]

[catch~]
|

Much better solution! As long as your levels aren't exceeding 1.0 before hitting [throw~], this is exactly what you should do. You could even be slightly more cautious and do this:

|
[*~ 0.5]
|
[clip~ -1 1]
|
[throw~]

This way you at least won't clip at the dac.

Edit: actually, nevermind. This only works right if you have two [throw~]s.

You can also clip with [tanh~]. This will do soft clipping instead of hardclipping with [clip~].

|
[*~ 0.5]
|
[tanh~]
|
[throw~]

When i started with pd i also smoothed levels with a [line~] to avoid crackles. But this only seems necessary when mixing pure sine waves. Once you're using real-life samples or beats, complex synths,... it's not really necessary and by just multiplying you won't hear the difference (and you'll save a couple of cpu cycles).

One neat trick i've also learned is to put a [hip~ 5] before going to the [dac~], this will elliminate any dc-offset which might have creeped in (and reduces your possible headroom).