Gtaylor@rtqe.net at 16:14, 6 July 2012

2012-07-06T16:14:30Z

Gtaylor@rtqe.net at 22:17, 5 July 2012

2012-07-05T22:17:36Z

Gtaylor@rtqe.net at 15:34, 28 June 2012

2012-06-28T15:34:11Z

Admin: Created page with "Click here to open the tutorial patch: 02hUsingpoly~.maxpat ===A different approach to polyphony=== In an earlier MSP tutorial on using
2012-06-24T23:03:50Z

Created page with "Click here to open the tutorial patch: 02hUsingpoly~.maxpat ===A different approach to polyphony=== In an earlier MSP tutorial on using <link type="tutorial" module="msp..."

New page
Click here to open the tutorial patch: [[02hUsingpoly~.maxpat]]

===A different approach to polyphony===

In an earlier MSP tutorial on using
<link type="tutorial" module="msp" name="midichapter02">MIDI with MSP</link> ,
we demonstrated how to use the {{maxword|name=poly}} object to make polyphonic
voice assignments in a simple case. This chapter will describe a
more elegant and efficient way to handle polyphonic voice
allocation - the {{maxword|name=poly~}} object.

In the example in the previous chapter, we created multiple
copies of our synthesizer subpatch and used the poly object's
voice numbering to route messages to different copies of the
subpatch. Our example could just as easily have used any kind
of sound-producing subpatch.

* Take a look at the tutorial patcher. Open the {{maxword|name=patcher}} object
labeled 'thehardway'. The example inside uses the
subpatch <code>littlesynth~</code> to implement a simple four-voice
polyphonic synthesizer:
[[Image:Polychapter02a.png|border]]
While this method works, it has two disadvantages. First, there's
a lot of housekeeping necessary to duplicate and patch the multiple
copies of <code>littlesynth~</code> together. But there is also a
problem in terms of CPU usage. All four copies of
the <code>littlesynth~</code> subpatcher are always on, processing their
audio even when there is no sound being produced.

There is a way to solve this problem - the {{maxword|name=poly~}} object
allows you to create and manage multiple copies of the same MSP
subpatch all within one object. You can also control the signal
processing activity within each copy of the subpatch to conserve
CPU resources.

===The {{maxword|name=poly~}} object===

* Close the 'thehardway' subpatch and open the {{maxword|name=patcher}} object
labeled 'simple_poly'. Turn on the audio in the subpatch by
clicking the <code>startwindow</code> message to the {{maxword|name=dac~}}. Click
the {{maxword|name=toggle}} object at the top of the patcher and turn up
the volume on the {{maxword|name=gain~}} slider.
The {{maxword|name=poly~}} object takes as its argument the name of a patcher
file, followed by a number that specifies the number of copies
(or ''instances'') of the patch to be created. You'll want to
specify the same number of copies as you would have had to duplicate
manually when implementing polyphony the old-fashioned way.

* Double-click on the {{maxword|name=poly~}} object. This opens up the
subpatcher to show you the inside of the <code>littlebeep~</code> object.
Let's look at the <code>littlebeep~</code> patch for a minute. While you
haven't seen the {{maxword|name=in}}, {{maxword|name=out~}}, or {{maxword|name=thispoly~}} objects
before, the rest of the patcher is pretty straightforward; it takes
an incoming MIDI note number, converts it to a frequency value using
the {{maxword|name=mtof}} object, and outputs a sine wave at that frequency with
a duration of 140 milliseconds and an amplitude envelope supplied by
the {{maxword|name=line~}} object for <code>140</code> ms with an envelope on it.

But what about the {{maxword|name=in}} and {{maxword|name=out~}} objects? Subpatches
created for use in the {{maxword|name=poly~}} object use special objects for inlets
and outlets. The objects {{maxword|name=in}} and {{maxword|name=out}} create control inlets
and outlets, and the {{maxword|name=in~}} and {{maxword|name=out~}} objects create signal
inlets and outlets. You specify which inlet is assigned to which object
by adding a number argument to the object - the {{maxword|name=in}} <code>1</code> object
corresponds to the leftmost inlet on the {{maxword|name=poly~}} object, and so on.
The {{maxword|name=poly~}} object keeps track of the number of inlets and outlets it
needs to create when you tell it which subpatch to load.

Messages sent to a {{maxword|name=poly~}} object are directed to different
instances of the subpatch dynamically using the <code>note</code>
and <code>midinote</code> messages, and manually using the <code>target</code> message.

When {{maxword|name=poly~}} receives a <code>note</code> message in its left inlet,
it scans through the copies of the subpatch it has in memory until it
finds one that is currently not busy, and then passes the message to it.
A subpatch instance can tell its parent {{maxword|name=poly~}} object that it is
busy using the {{maxword|name=thispoly~}} object. The {{maxword|name=thispoly~}} object accepts
either a signal or number in its inlet to set its busy state. A zero signal
or a value of <code>0</code> sent to its inlet tells the parent {{maxword|name=poly~}} that
this instance is available for <code>note</code> or <code>midinote</code> messages. A
non-zero signal or value sent to its inlet tells the parent {{maxword|name=poly~}} that
the instance is busy; no <code>note</code> or <code>midinote</code> messages will be sent
to the object until it is no longer busy. The busy state was intended to
correspond to the duration of a note being played by the subpatcher instance,
but it could be used to mean anything. In the example above, when the audio
level out of the {{maxword|name=~}} is nonzero -- that iteration of the subpatch is
currently busy. Once the amplitude envelope out of {{maxword|name=line~}} reaches zero
and the sound stops, that subpatch's copy of {{maxword|name=thispoly~}} tells {{maxword|name=poly~}} that
it is ready for more input.

===Muting voices===

Close the 'simple_poly' subpatch and open the {{maxword|name=patcher}} object
named 'poly_using_mute'. Start it running as you did the last
patcher, and double-click the {{maxword|name=poly~}} object.
The {{maxword|name=thispoly~}} object can also control the activity of
signal processing within each copy of the subpatch. When
the <code>mute</code> message is sent to {{maxword|name=thispoly~}} followed by
a <code>1</code>, all signal processing in that subpatch stops. When
a <code>mute 0 </code>message is received, signal processing starts again.

In this patcher, we've rewriten the <code>littlebeep~</code> subpatcher
to take advantage of this by turning off signal processing when a
note is finished and turning it on again when a new event is
received. While this doesn't change the function of the patch,
it would be more efficient, since the amount of CPU allocated is
always based on the number of notes currently sounding.

===Targeting individual voices===

* Close the 'poly_using_mute' subpatch and open the one
named 'poly_using_target'. Start the program and examine the
patcher logic both inside and outside the {{maxword|name=poly~}} object.
Another way to allocate events using {{maxword|name=poly~}} is through
the <code>target</code> message. Sending a <code>target</code> message followed
by an integer in the left inlet of a {{maxword|name=poly~}} subpatch
tells {{maxword|name=poly~}} to send all subsequent messages to that instance
of the subpatch. You can then use {{maxword|name=poly~}} in conjunction with
the {{maxword|name=poly}} object to create a MIDI synthesizer.

In this example {{maxword|name=patcher}}, pairs of incoming MIDI pitches
and velocities are used to synthesize a sine tone. When a list
is received, the subpatcher sends a <code>bang</code> to {{maxword|name=thispoly~}},
causing it to output the instance or voice number. In our tutorial
patcher, the voice number is sent out an outlet so you can watch it
from the parent patch.

In the parent patch the {{maxword|name=poly}} object assigns voice
numbers to MIDI pitch/velocity pairs output by {{maxword|name=makenote}}.
The voice number from the {{maxword|name=poly}} object is sent to {{maxword|name=poly~}}
with the <code>target</code> message prepended to it, telling {{maxword|name=poly~}}
to send subsequent data to the instance of the <code>targetbeep~</code>
subpatcher specified by {{maxword|name=poly~}}. When a new note is generated,
the target will change. Since {{maxword|name=poly}} keeps track of note-offs,
it should recycle voices properly. The second outlet of {{maxword|name=poly~}} reports
the voice that last received a message -- it should be the same as
the voice number output by {{maxword|name=poly}}, since we're using {{maxword|name=poly}} to
specify a specific target.

===Using {{maxword|name=poly~}} for audio processing.===

* Close the 'poly_using_target' patcher and open the one
named 'poly_using_signal_input'. Turn on the audio by clicking the {{maxword|name=ezdac~}} object, raise
the {{maxword|name=gain~}} slider, and start the {{maxword|name=metro}} by clicking
the {{maxword|name=toggle}} object. Change the value in the rightmost inlet
from <code>100.</code> to <code>50.</code> and listen to the result.
The floating-point {{maxword|name=number}} box can be used to specify
parameters to specific instances of a {{maxword|name=poly~}} subpatcher.
By connecting a {{maxword|name=loadbang}} object to {{maxword|name=thispoly~}}, we
can use the voice number to control the center frequency of a filter.

* Open the <code>littlefilter~</code> subpatch by double-clicking
the {{maxword|name=poly~}} object.
The <code>littlefilter~</code> abstraction uses the voice number
from {{maxword|name=thispoly~}} and multiplies it by the base frequency
received in the second inlet. The incoming signal is filtered
by all sixteen instances simultaneously, with the output amplitude
of each instance being controlled by an integer coming into the
first inlet.

The {{maxword|name=metro}} object in the main patcher is hooked up to both
a {{maxword|name=counter}} and a {{maxword|name=random}}. The {{maxword|name=counter}}, which
feeds the <code>target</code> message, cycles through the 16 voices
of <code>littlefilter~</code> loaded into the {{maxword|name=poly~}} object,
supplying each with a random number which is used to control the
amplitude of that voice.

A signal connected to an inlet of {{maxword|name=poly~}} will be sent
to the corresponding {{maxword|name=in~}} objects of all subpatcher
instances, so the {{maxword|name=noise~}} object in the example
above feeds noise to all the subpatchers inside the {{maxword|name=poly~}}.
The second inlet (which corresponds to the {{maxword|name=in}} <code>2</code> box
in the subpatcher) controls the base frequency of the filters.
Note that for the frequency to get sent to all {{maxword|name=poly~}}
iterations it is preceded by a <code>target 0</code> message. You
can open a specific instance of a {{maxword|name=poly~}} subpatch by
giving the object the <code>open</code> message, followed by the
voice you want to look at.

* Open voice <code>15</code> of the <code>littlefilter~</code> abstraction
by typing that number in to the {{maxword|name=number}} box attached
to the <code>open</code> message. The patcher assigned to voice
number 15 should look like this:
[[Image:Polychapter02b.png|border]]
As you can see, the base frequency of this particular iteration
of <code>littlefilter~</code> is 1500. Hz, which is the multiple of
the voice number (15) with the most recently entered base frequency
into the second inlet (100. Hz).

===Summary===

{{maxword|name=poly~}} is a powerful way to manage multiple copies of the same
subpatch for polyphonic voice allocation. The {{maxword|name=thispoly~}} object works
inside a subpatch to control its busy state and turn signal processing on
and off. The objects {{maxword|name=in}}, {{maxword|name=in~}}, {{maxword|name=out}}, and {{maxword|name=out~}} create
special control and signal inputs and outputs that work with the inlets and
outlets of the {{maxword|name=poly~}} object.

===See Also===

{{maxword|name=poly~}} - Polyphony/DSP manager for patchers

{{maxword|name=thispoly~}} - Control {{maxword|name=poly~}} voice allocation and muting

{{maxword|name=in}} - Message input for a patcher loaded by {{maxword|name=poly~}}

{{maxword|name=in~}} - Signal input for a patcher loaded by {{maxword|name=poly~}}

{{maxword|name=out}} - Message output for a patcher loaded by {{maxword|name=poly~}}

{{maxword|name=out~}} - Signal output for a patcher loaded by {{maxword|name=poly~}}

[[Category:Teaching Material]]

MSP Polyphony Tutorial 2: Using the poly~ Object - Revision history

Gtaylor@rtqe.net at 16:14, 6 July 2012

Gtaylor@rtqe.net at 22:17, 5 July 2012

Gtaylor@rtqe.net at 15:34, 28 June 2012