Slice//Jockey for Pure Data

(updated page available here)

Imagine a DJ set, and instead of turntables or cd players or iPods, it has two recorders. Real-time-beat-slicing recorders. Sound from your microphone is analysed, and sliced into coherent fragments which are engaged in playback rightaway. Slice//Jockey is a crossover of music game and live performance tool.

Slice//Jockey is one fruit of [slicerec~] and [sliceplay~], Pure Data externals designed for real-time beat slicing. The technique inside is discussed on earlier pages. In order to use Slice//Jockey, you must have Pd-extended installed on your computer (http://puredata.info) and add the Slice//Jockey package to it (download at page bottom). Start Pure Data, and open the file SliceJockey.pd.

Slice//Jockey has detailed help files built in, accessible via the question mark on the front. In addition to these technical help files, the global lay out and working of Slice//Jockey is discussed here on this page.

recorders

Two recorders are represented by blocks on the left and right side of the window. Sound from the computer's soundcard channels is mixed to mono and sent to both recorders. An input button on each recorder controls whether that recorder is listening to your input audio or not. If it is listening, sounds with clear attack will be recorded slice-wise automatically. Indicators above the scope trace will tell you when recording happens. Up to 8 slices are stored in a circular buffer for each recorder. When the 9th slice is recorded, the first one is discarded, and so on, following the FIFO (first in, first out) principle.

Technically speaking, your computer could easily record thousands of slices into memory. Restriction to eight slices per recorder is a conceptual choice, not an issue of memory efficiency. All eight slices are engaged in playback. No time for book keeping during live performance! If you want variation, just play again into the recorders. Do not be afraid of overwriting a beautiful sound with a dreadful squeak. That's life. The more you play, the better sounds you will find.

input sound

The input sound for the recorders is subject to basic processing only. You can activate a hi-pass filter, in case your microphone produces too much low frequency content due to proximity effect. Further, you can enable a compressor / noise suppressor to make the recorders more selective to your sounds in a noisy live situation. The mono input signal is plotted as a scope trace.

Filter, compander and in-to-out buttons are found on the bottom-left of the window, together with a time-signature (4/4 or 6/8) button. Notice those small characters. They indicate shortcut keys for the buttons. Shortcut keys only work when focus is on the Slice//Jockey window, and only for lower case characters (they are printed as capitals because that is how they show on keyboard keys)

It is beneficial to use a decent unidirectional microphone when feeding sound into Slice//Jockey. Omnidirectional microphones, like the ones built into computers, will pick up much of the speaker output and feed it back into the recorder. The recorder will happily continue slicing under such conditions, and results can be quite interesting. But it is better to have control over it. You can always point a unidirectional mic to the speaker deliberately if you want chaos.

x-y field and touch screen operation

The x-y field has twenty control objects in two dimensions. This means, some 40 parameters are controlled on the surface which is printed below with it's actual size. Resolution and precision is much better than for 40 knobs or faders with each 1/40 of the field surface. Not surprisingly, the x-y layout is inspired by Korg's famous Kaoss Pad, but also by recent music applications like Jeremy Wentworth's GrainMainFrame.

With all buttons and x-y objects given good measure, Slice//Jockey anticipates the hoped-for proliferation of serious tablet pc's. (I mean tablets with all-round operating system and ample connectivity.) In touch screen operation, manual control and visual control are unified. Because of this one-ness, you don't need to pay special attention it, and all brain activity can go into the musical process. I consider touch screen the optimal interface for my music applications.

Unfortunately, many a promising tablet pc announcement silently resolves into yet another virtual machine these days (2010, early 2011). While we are awaiting real-life products, we often remain dependant upon old friends keyboard and mouse for interaction with the computer's inner life. But I've also rediscovered the gamepad as a joyful means to play around with Slice//Jockey (MacOSX & Linux).

slice playback

Slice//Jockey records slices of audio into a circular buffer, while storing cuepoints for start and end of each slice. As stated, slices are engaged in playback immediately. But how is playback controlled? Obviously, you can not make a composition or midi sequence on beforehand for sounds still to be recorded. Instead, playback is triggered according to very basic principles, and manipulated with some controls.

Each recorder has three players associated: one for quarter notes, one for eighth notes and one for sixteenth notes. If you want, the players can be disconnected from BPM-synched triggering, to play with random time intervals. Each player follows a pattern to select slices for playback. These patterns are generated by a mathematical routine which guarantee optimal variation within a cycle of sixteen triggers. If you move playback controls, conditions for these routines change, and different patterns will result. For sixteenth notes, the pattern cycle is one bar. For eighth notes the pattern encompasses two bars, and for quarter notes four bars. If you want, the players can be disconnected from pattern-wise triggering, to play randomly selected slices.

These are playback controls on the x-y field, for quarter notes, eight notes and sixteenth notes. In horizontal direction, slice playback speed is set. Playback speed determines pitch, like a record or tape which is slowed down or sped up. Slice playback speed/pitch is independent from BPM tempo or trigger tempo. In vertical direction, the controls set variation in playback speed, as an addition to the basic playback speed which was set in horizontal direction. Variation of playback speed does not mean vibrato. From start till end of one slice, playback speed will remain constant. Playback speed will only vary from one slice to the next.

Each of both recorder-playback sections has it's own effects controls on the x-y field. There is feedback delay, resonant filter, distortion and reverb. Left and right sections each have their own colour, which is reflected in controls on the x-y field. Here we see white-coloured controls, belonging to the left section.

Global controls on the x-y field are colored black. They control: - input signal level - output signal level and crossfader - reverb for input signal - BPM value and 16th note triplet feel - global pitch - trigger delay for left / right section playback

The right bottom of the window has buttons for help, settings, and session recorder. A simple soundfile player is included for quick evaluation. Below them is a beat indicator, counting beats according to the BPM value on the x-y field. Notice that the beat indicator will always sync with your live session, and not with soundfiles played back.

technical settings

Clicking the exclamation mark on the front window pops a window with technical settings. When preparing for a Slice//Jockey session, it may be necessary to tune some of these settings. This window has it's own help file to guide you through options.

Here I want to highlight Pure Data's audio settings, where you can select input and output devices for the program. Slice//Jockey listens to the input device which is set here. Do not forget to check the checkbox for input device, and set the appropriate number of channels. After selecting your devices, click 'apply' and 'ok'. Below is Pd's audio properties window for MacOSX. The window looks different for other operating systems.

Another setting to be highlighted is 'silence-threshold'. It's value determines at what sound level slice recording will end if there is nothing useful to hear anymore. But, imagine you have a very noisy microphone preamp, like is the case with some built-in mics: recording will not stop, even when you are 'silent', and the buffer is filled mainly with noise. You may even think that Slice//Jockey does not work at all. So, set the silence-threshold at least above the noise floor. You may need to tune mic level in your computer's system settings.

hardware and operating systems

I have run Slice//Jockey on different operating systems and various hardware. Pd extended is available for MacOSX, Linux and Windows, and so is Slice//Jockey. When running Pure Data with an external audio interface on Linux, you may need to route audio via Jack. Hints for running Pd as a realtime process on Linux are on puredata.info.

It could be stated that higher-end netbooks represent the minimum hardware requirements. The Atom N280 1.66GHz processor and 2 GB RAM in an Asus EeePC 1000HE made Slice//Jockey run at 40-50% CPU load on Windows and 70-80% on Linux. Drop-outs can easily happen with some configurations of audio interfaces and drivers. However, with patience, devotion and luck, decent output can be obtained from the netbook. Slice//Jockey's main window is tailored to the standardized netbook display resolution of 1024*600 pixels.

The EeePC shown below was modified, it has a touch screen built in. This is not my own computer, but I had the opportunity to test Slice//Jockey extensively.

Pico//Jockey for Raspberry Pi and other ARM computers

Pico//Jockey is a CPU-friendly version of Slice//Jockey, made to run on ARM processors. The package that can be downloaded from this page is compiled for Raspberry Pi, but it can be built for other ARM boards too. It works with vanilla Pd or Pd-extended.

Pico//Jockey's user interface is tailored to fit low resolution 7 inch screens. It was tested to work on a slightly modified PengPod 700 linux tablet (the built-in mic was replaced by a cable with mini jack connector). Be aware that usb devices, networking and graphical operations put a heavy strain on these small CPU's, therefore you'll experience audio dropouts under circumstances.

downloads

In order to use Slice//Jockey, you must have Pd-extended installed on your computer (http://puredata.info). The Slice//Jockey packages in the downloads below contain Pure Data patches plus source code and binaries for Linux 32 and 64 bit, OSX and Windows. Do read the readme for installation instructions.

Currently I'm working on Slice//Jockey2, an updated version which is compatible with Pd-exteded 0.42 and 0.43. The second beta test version is now available as SliceJockey2test2.

In order to use Pico//Jockey, you must have vanilla Pd or Pd-extended installed (http://puredata.info). The Pico//Jockey package in the downloads below contain Pure Data patches plus source code and binaries for Raspberry Pi (armv6). The build system allows building for armv7 ass well. Do read the readme for installation instructions.

The original version of SliceJockey is not compatible with Pd 0.43. It is no longer maintained but still available for download here.

license

Slice//Jockey is open source software. The source code for classes [slicerec~] and [sliceplay~] is published under BSD license, like the core code of Pd. The Pure Data patches in Slice//Jockey are GPL-licensed, to comply with several Pd extended classes employed.

support

Slice//Jockey is one of many possible realizations of realtime beatslicing, organised around  classes [slicerec~] and [sliceplay~] for Pure Data. Slice//Jockey is documented with included help files and this webpage. Individual support is not offered. For questions concerning installation and configuration of Pure Data, consult http://puredata.info/docs. Also consider searching the forum http://puredata.hurleur.com and the Pd mailing list archives. If you find a bug in [slicerec~], [sliceplay~] or the patch [SliceJockey], please send an email to the address in the readme file.