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

is there a difference when using $0 or $1?...just realised that $0 is assigned a four digit value and $1 indicates sequencial arg.

Im getting warnings saying things are getting multply defined which suggestes the voiceptest's are deriving the same arg val?

@Fauveboy Yes there is a big difference. Everything that needs to be unique for the calculation of each voice needs a $0 (unique for each instance). If they get the $1 then every throw and catch in every voice will be having the same name.

inside gridSample is where the audio sample is loaded. there are objects which send that file size ect to the voice abstract that have arguments of $1 if they were $0 would they not be different from the voice abstract and therefore not receive the data ?

@Fauveboy Yes that's right. In the last patch I sent you and in the last picture you posted those do have $1 (the chunk size samples etc). Where are you getting errors?

Itts hard to say theres no specific error messgaes? Just warnings explaining about multiply defined

@Fauveboy if you go menu > find > find last error it will tell you which object(s) is causing the error.

ah yh i see its currently the throw~ $0-declick object

throw~ $1-declick doesn't cause an error...but the signal doesnt reach catch from throw using $1?
Are they not local variables to each other?

@Fauveboy Is there just one throw and one catch in each voice abstraction? In that case replacing them with s~ and r~ might solve it (keeping $0 of course).

okay thats fine actually thats worked thank you.. the issue now is that only the 1st voice abstraction happily plays the audio file back ? Is that some thing to do with the arguements the voice are or arn't deriving ?

@Fauveboy Whenever I work on something polyphonic, whenever I make a change to the voice abstraction and save it, it doesn't always update all the instances and therefore only the one you modified plays. You could try closing the whole patch and reopen it.

@Fauveboy Horribly tired and unable to follow....... so I might be wide of the mark. Playing audio in abstractions is complicated by needing to get $ variables into a message.
I made this a while ago and it might give some insight/understanding into/of what is not working.....
But it might not...... you might already be beyond this stage.........keyboard.zip
And it might not expose the problem at all.......
David.

@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.