Two demo patchers for this post: waveformGroove.maxpat and waveformGlitch.maxpat. Look at the waveformGroove patcher first.

waveform~

The waveform~ object is a graphic editor for buffered audio. The easiest way to make use of waveform~ in a patcher is to copy and paste from the help file. This implementation is copied from the subpatcher for multi-channel audio.

Some things to note in this patcher. (unlock to see all the objects)

• the waveform~ objects have to be linked to a named buffer. The loadbang to the messages accomplishes this link. The messages are formatted as name buffername channel#.
• The four tools on the left are part of a pictslider object. The pictslider lets you load pictures that serve as the background for a selectable slider. The index of the tool selection is sent to the subpatcher wfkeys. The tools are: select, loop, move, and draw.
• The move tool lets you change the zoom of the display by clicking and dragging up or down.
• You can select loop sections by entering time messages in the number boxes above the waveform, or by using the select tool in the waveform.
• The set $1 messages update the number boxes above the waveform when you select in the waveform, without creating a feedback loop.
• Start and End points of the loop selection are sent to the groove~ object.

All other functions in the patcher have been covered before in previous posts and examples.

Now close waveformGroove and open waveformGlitch.

waveformGlitch replaces the MIDI keyboard control section with a glitch section (or grain making section, depending on your aesthetic preference). The key features include:

• A metro for triggering playback of waveform segments.
• A loopSize subpatcher that computes the loop size from the start and end points and then divides the loop segment into tenths.
• The metro bangs a random object, which randomly generates 0 – 9, multiplies it by the segment length (1/10th of loop size), then adds it to the start position of the loop.
• This position message is sent to groove~, which cause groove~ to jump to that part of the buffer for playback.

• The right side of the glitch section is an envelope generator.
• You can set a percentage of the timing interval for the sustain time, and att/rel ramps.
• Each metro bang sends the line~ generator to scaling objects that provide an envelope for the output of groove~.

• The metro also can be passed (by means of a gate) to a random object that is scaled to a playback range.
• The minimum and maximum of the scaling range can be set.

Important controls (output level, playback ratio, percentage of envelope duration, and metro speed) can be assigned to CC’s in the control section.

improvements

This is a basic glitch patch (with a slower metro) or grain generator (at faster speeds). There are a number of improvements that could be made, especially if you wanted to develop a granular synthesizer. For example, you could

• use a MIDI keyboard to set a playback ration and use the random generator to create random deviation within a range around the specified playback ratio.
• use the metro to move through the buffer in an ordered way, with a possible random deviation from that order.
• create multiple streams of grains using a poly~ object.

Demo patcher: RecordNGroove.maxpat

Today’s demo patcher is based on grooveplay, from the buffer~ and groove~ post.

Some minor changes, before diving into the new stuff. The buffer~ object (in the green section) is getting audio from the record~ object. I’ve deleted the read messages. You can put them back in, of course. In the groove section I changed sig~ to line~. The float feeding the right inlet sets a slew time (or portamento time) between ratio changes that come in the left inlet. This smooths out changes in playback ratio.

recording (ezadc~, record~)

The recording section has an ezdac~ (microphone) for input, feeding a record~ object (buffer name, length in ms, number of channels). Starting and stopping of recording is controlled by a toggle. The toggle can be controlled by a CC (sustain pedals/foot switches work really well). The timer section to the right keeps time between the toggle turning on (any non-zero number) and the toggle turning off (zero). Timing information sets the ending loop point for groove~, and triggers a bang to set the play position of groove~ back to the beginning of the sound buffer.

Since we’re recording into a buffer, we can’t resize the buffer to match our recorded input. There is a resize message for buffer~, but it erases the buffer~. The trick is to set the buffer~ size comfortably larger than you intend to use, and set the end loop point to the end of the recording.

groove

The groove section (red/pink) gets playback ratio from either a CC (like before) or a MIDI keyboard (discussed later). You have loop control being sent from the timer in the record section. This section is mostly the same as the last demo.

midi keyboard control

The blue section in the lower right contains a collection of objects designed to let you specify playback ratios by playing on a midi keyboard. The kslider lets you pick a root key, or key that sets unity ratio (1.) playback. The midi note number is converted to frequency, and that frequency is used as the denominator in our division operation. Incoming noteon messages provide a note number that is also converted to frequency and used as the numerator in the division operation. The result is a ratio that matches equal temperament** intervals and is sent via kbRatio.

Key velocity is being used to start and stop playback of groove~. On velocities coming from stripnote are sent via startBang to “rewind” the buffer, with a playback ratio following quickly afterwards. All velocities are sent to a select 0 object. Off velocities send out a bang, triggering the 0. message to be sent as the kbRatio. A playback ratio of zero stops playback.

**If you want to generate ratios for non-12-tone equal temperament you can generate any ratio you like as part of an expression object. Just intonation can be derived from integer ratios. Microtonal intervals can be generated with a formula of 2 to the x/y power, where y is the number of steps in the octave and x is the number of steps of your interval from the root key.

I included the example patcher (grooveplay.maxpat) in the zipped soundfilepatcher archive from Monday.

buffer~

Preliminary stuff first. buffer~ allows you to load a sound file into RAM. You can play it back with a number of objects, get information about it, etc., but it is in effect like sampler memory.

The object takes arguments for buffer name, length (in ms), and number of channels. You “read” files into a buffer (instead of sfplay~’s open), but it is more beneficial to use a replace message. The replace message resizes the buffer to match the length of the sound file loaded.

You can double-click the buffer to see a graphic waveform display of the loaded sound file. The left outlet of buffer will report mouse position (in ms) when you click on the graphic display. The right outlet sends a bang when a sound file is finished loading. This bang is useful for sending to objects that provide info about the sound, and for other uses.

groove~

I just love the name of this object! The groove~ object plays sound from a buffer. It needs an argument for the buffer name to read from, and for the number of channels. The number of outlets depends on the number of channels for playback — there will always be one more than the number of channels. (The last outlet sends out a sync signal, which we will seldom if ever use.)

groove~ takes a signal-rate input for playback speed, expressed as a decimal ratio. Unity playback is the ratio 1. Negative ratios play backwards. I’m scaling a CC and sending it to a sig~ object (converts a float to a signal). The output of the sig~ object is sent to groove~. The toggle can be used to start and stop playback, although it won’t change playback speeds. The extra 0. message is included as a simple stop button.

groove~ has one big gotcha to get it to start playing. You have to tell it where to start in the buffer (time in ms). I’m using the message with “0.” to do that (it’s marked with the rewind comment). If you aren’t looping playback, you’ll need to “rewind” the playback position to play the sound again.

Looping status is set with the loop message. Loop 1 (or true) turns looping on; loop 0 (false) turns looping off. The second inlet can be used to set the minimum loop position (loop start); the third inlet sets the maximum loop position (loop end). If neither min or max points have been set, groove~ will loop the entire sound file.