Keeping track of note-ons and note-offs for a polyphonic synth can be a pain. Luckily, the [poly] object can be used to take care of that for you. However, the nuts and bolts of how to use it may not be immediately obvious, particularly given its sparse help patch. Hopefully this tutorial will clarify its usefulness. It will probably be easier to follow along with this explanation if you open the attached patch. I'll try to be thorough, which hopefully won't actually make it more confusing!

To start, [poly] accepts a MIDI-style message of note number and velocity in its left and right inlets, respectively...

[notein]
| \
[poly 4]

...or as a list in it left inlet.

[60 100(
|
[poly 4]

The first argument is the maximum number of voices (or note-ons) that [poly] will keep track of. When [poly] receives a new note-on, it will assign it a voice number and output the voice number, note number, and velocity out its outlets. When [poly] gets a note-off, it will automatically match it with its corresponding note-on and pass it out with the same voice number.

By [pack]ing the outputs, you can use [route] to send the note number and velocity to the specified voice. For those of you not familiar, [route] will take a list, match the first element of the list to one of its arguments, and send the rest of the list through the outlet that goes with that argument. So, if you have [route 1 2 3], and you send it a list where the first element is 2, then it will pass the rest of the list to the second outlet because 2 is the second argument here. It's basically a way of assigning "tags" to messages and making sure they go where they are assigned. If there is no match, it sends the whole list out the last outlet (which we won't be using here).

[poly 4]
| \ \
[pack f f f] <-- create list of voice number, note, and velocity
|
[route 1 2 3 4] <-- send note and velocity to the outlet corresponding to voice number

At each outlet of [route] (except the last) there should be a voice subpatch or abstraction that can be triggered on and off using note-on and note-off messages, respectively. In most cases, you'll want each voice to be exact copies of each other. (See the attached for this. It's not very ASCII art friendly.)

The last thing I'll mention is the second argument to [poly]. This argument is to activate voice-stealing: 1 turns voice-stealing on, 0 or no argument turns it off. This determines how [poly] behaves when the maximum number of voices has been exceeded. With voice-stealing activated, once [poly] goes over its voice limit, it will first send a note-off for the oldest voice it has stored, thus freeing up a voice, then it will pass the new note-on. If it is off, new note-ons are simply ignored and don't get passed through.

And that's it. It's really just a few objects, and it's all you need to get polyphony going.

[notein]
| \
| \
[poly 4 1]
| \ \
[pack f f f]
|
[route 1 2 3 4]
| | | |
( voices )

http://www.pdpatchrepo.info/hurleur/poly_tutorial.mmb.pd

@whale-av said:

Thanks David is this you back from Prague ? Hope your time was good! your code makes sense we've got difference instances of the same code using an arg no. and then using a message to address a particular abstraction......the issue with my code is i have the main body grid2.pd this contains an instance of an abstraction which is the following gridSamplerptest.pd

inside this one "gridsamplerptest" we use an array to unload an audio file. this is informed by the number given to the gridsamplertest X arg ....inside gridsamplerptest i have another four instances of the same abstraction which is voicePTest.pd it receives a note and velocity...however i believe that from there behaviour they don't differentiate from each other.... i.e velocity can be sent to one voicePtest but the signal will be coming from another voicePtest instance?

@Fauveboy This is because the voicePtest abstractions all send on the same channels. $1 in objects always resolve to the first creation argument of the abstraction. In your case, every voicePtest abstraction has $1 as creation argument which again resolves to the first creation argument of gridSamplerPtest, which is 1.

So for example [s~ $1-phase] becomes [s~ 1-phase] in each voicePtest abstraction.

General recommendation: Use $0 as a unique number inside each abstraction. Use creation arguments together with $1, $2 etc. to provide information from the parent to the child abstraction.

The creation arguments are shown in the title bar and you can do this to find out what is going on:

[o]    <- this is a bang
|
[f $1]
|
[print]

and

[o]    <- this is a bang
|
[f $0]
|
[print]

The results may be different or not for each abstraction or patch, so this is a way to examine your patch and find out what is going on. And yes, all those $-variables will be just numbers in the end (Although you can also use symbols as creation arguments.).

Okay does that mean $1 for the voicepTest args so they get the number from the gridsamplerptest but all the objecs inside are zero? Then they'll use different channels from each other. But in doing that im confused as to how to get has to get the values from the sub patch in gridsampler which include sample size into voicePtest becuase they have $1 for there argument which ould be a different channel to reach args inside voicetest now with $0?

the design only has one array. is it becuase for polyphony to work with a sample there needs to be multiple arrays? I was hoping just one array can be read multiple voices On the left is the load sample sub patch in the gridSamplePtest but these send and receive objects arnt going to reach separate voicePtest abstracts like this from one place are they?

@Fauveboy You can have more than one argument...... try $1 1.... $1 2 etc. and use the second argument ($2 inside the patch) to differentiate....
It looks like you are starting to get the hang of it........ let the fun commence!
David.

@Fauveboy Whatever works for you. The more advanced approach is to put $0 to every send, receive, array, text and struct object so every patch and abstraction is always separated and will never interfere when you for example open the same patch twice. So with this approach everything is separated, because you use the $0 of each abstraction inside the abstraction, which is great.

But than how can the abstraction communicate with the main patch? The solution is to give the $0 via creation argument down to the abstraction. Than inside the abstraction you know the $0 of the abstraction and the $0 of the main patch.

For example when you have an array in the main patch which has $0 in its name, you can not access it from within the abstraction because $0 of the main patch is unknown. But you can give the $0 of the main patch as creation argument to the abstraction, so now you can access the array via $1 (if its the first argument) and everything is perfect.

Here is an example: dollar-zero.zip

I dont think I understand just yet? is there a chance you can make sense of my code does what you're saying apply to it? Im sure I just need to mull over the logic you're explain but it just hasnt clicked yet.grid2.pd gridSamplerptest.pd voicePTest.pd

when you say via the creation argument…is $0 the creation argument?
I need gridamplerPtest $0 to be 1 because it is coordinated with the grid interface hardware with zero does it not remain as a four digit number?

@Fauveboy [someobject 15 13] <- 15 and 13 are the creation arguments of someobject. Yes, $0 is a four digit number.

@Fauveboy Here another demonstration: dollar-args.zip

Okay I think I've got this thank you very much. So...

In the main patch I havegrid2.pd

1st abstraction gridSamplerptest.pd takes the arg $0. (although if I want eight of these maybe I just give it a argument which is 1,2,3 etc?)…actually i would just copy and paste it 8 times
and they would have different $0 values inside them anyway….

Inside gridSamplerPtest I use the $1 to use the $0 from the main patch.

in the load.sample subpatch in gridSamplerPtest I load a sample. although for some reason when I go to properties on the array I’m not sure why but it ignores the “$” for the $0-table,so I’m getting errors at the moment.

There are also send and receive objects in load.sample that take the arg $0 because i want these to be unique to this particular gridSamplerPtest abstraction. the more important of these send and receive objects send data of the sample length and phase position.

in gridSamplerPtest i also have the abstraction voicePtest "$0" maybe this is irrelvant if im using $0 inside it?. making thesvoicePTest.pd particular abstractions unique to this gridSamplerPtest $0

inside voicePtest I use tabread4 table$1. $1 will ensure that it reads the table in gridSamplerPtest subpatch load.sample (when its not giving me errors) hopefully.

The pitch will vary between simultaneous button presses of voicePTest $0 . I need to make sure that the result of the value sent to adjust the pitch in an individual abstraction doesn’t send to another abstraction outside it…so with some objects where i don’t need to receive data from gridsamplerPtest I use $0 again so it only sends data with the abstraction its in.

This should work if I can work out whats happening with $0-table?

another note i have. Previously when i gave gridSamplerPtest an argument it was a number that correlated to an x y cordiniate on the monome grid based interface hardware.

so gridSamplePtest 1 would get received by an object such as x = $1. but I guess I got to use a different method to relate the number of gridSamplerPtest the rows located on the grid….

@Fauveboy Yes, $0 unique within the abstraction..... and within the parent.

If you have made an abstraction [abstr 1 2 3 $0] then actually the $0 value from the parent will be given to any $4 in the abstraction (its the 4th argument)
In the abstraction you would have ...... $1=1 $2=2 $3=3 $4=1001 $0=1002 (for example).
So in the parent $0=1001 = $4 in the abstraction.

Can you zip the whole patch again and post....... it is easier to unwrap then copy/paste/save/rename all the patches separately......
and I cannot find your $0-table........ in the 3 patches you have posted.

The reason for the error in the table is that the $0 in the message [read -resize.........] is not $0 as an argument because it is in a message.
You need to pump the value into the message....

I am sort of hoping this will be your Eureka! moment, now that you have learnt so much.......

David.

@Fauveboy Yes, you can use [abstraction 1], [abstraction 2] to distinguish different abstractions. And if you are very confident that you will never open up two instances of your patch at the same time, this would be enough. But if you open up two instances somewhere in the future, they will interfere with each other, if you have something like [send $1-something] inside the abstraction.

i use $0 all the time just to be sure and don't have to worry, but it is up to you. i would for example use [abstraction $0 1], [abstraction $0 2], if the abstractions would need to communicate with the main patch or each other. The important thing here is that every send, receive, text, array and struct get some $0, but this is only if you maybe open two instances at any time at once.

The other thing is that $-arguments in objects and messages work completely differently. As @whale-av just described while i am typing...

heres the patch in a zip file. im looking over it myself again after reading your messages just now. the $0-table is in the sub patch pd load.sample in the gridSampleptest abstraction grid 2.zip

grid200617.zip

just the lastest version of the patch here

it Works!

...is what to have a list of abstractions instead of copy and paste?....a bit like in c programming you can have an array and a for loop ?

@Fauveboy Usually just copy&paste. You can also create objects with dynamic patching, see https://forum.pdpatchrepo.info/topic/10813/collection-of-pd-internal-messages-dynamic-patching.

Also look at the [clone] object, which might be what you are looking for.

@Fauveboy Well that is good news...... having twisted my head right off my neck I thought this might work...... twisted.zip
but as you have it solved...... well done!

A Eureka moment in all that?

Yes....... abstraction = sub-routine (in 1970's speak).......

David.

@ingox I dont see see anything appearing as clone object?

@Fauveboy apparently [clone] is not present in pd extended...

@Maelstorm Hi there, I came across this post today as I've just started using PD recently and polyphony has become a bit of a struggle. For that reason your patch was great one sense but it does pose some new challenges.
How does one add ADSR functions to all the voices at once? Or even how does one select different waveshapes? I can build monophonic versions of both of these but once I get to polyphony, I hit a wall.