Just a last minute post, since crashing seems to be taking over your life.

To monitor your total cpu usage, you need to open the Activity Monitor (Mac only). Go to Applications | Utilities | Activity Monitor. You have various ways of looking at your usage. The key is looking at the overall percentage of cpu usage. When you get upwards of 80% (user + system) your system’s graphic interfaces will start to behave erratically. If you are using Jitter, this unpredictability could have implications, like Max crashing.

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.