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. |
 |
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.
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.
 |
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//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 |
|
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. |
 |
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.
 |
On MacOSX and Linux, an interface [gamepad2SliceJockeyOSX] resp.
[gamepad2SliceJockeyLinux] can be loaded to control Slice//Jockey with
a gamepad. There's a lot of
different gamepads out there, with different layout and mapping. I can
not guarantee that your gamepad will work with Slice//Jockey! Anyhow,
it should
have two analog joysticks and a layout equivalent to the ones shown
below. As you can see, their nr 1 - 4 buttons are arranged differently,
but that is only a minor nuisance.
 |
 |
Gamepad interfacing is done via Hans Christoph Steiner's [hid]
object. On Linux, some permission hocus pocus needs to be done before
gamepad data can be read by others than root. There is a
howto for that on puredata.info.
For Windows, I could not find a way to get it all working yet. Sorry.
The gamepad should be connected to the computer before starting up
Pure Data. Otherwise the pad will not be recognized. The gamepad
interface window looks like this on Linux:
 |
The 'Pd window' will show information on available devices, and the correct device nr. must be set manually, everytime at load. For OSX things are simpler: the first available joystick/gamepad is automatically selected. Move the analog sticks around and then click 'calibrate'. If the right stick's horizantal/vertical axes are swapped, enable 'swap z-axes'. Set the gamepad's mode switch to analog.
 |
When you press button number 1 on the gamepad, two controls on
the x-y field should turn orange, to indicate they are activated and
can be moved around with the joysticks. Mappings of gamepad buttons to Slice//Jockey controls are
depicted in |
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.
You'd want a usb port reserved for a usb microphone or other
audio-interface. 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. This year (2011) we may see the advent of
affordable atom-powered tablet pc's for Windows and Ubuntu. Their specs
would be comparable to the EeePC's, and they would provide an
ultra-portable hardware platform for real-time sound processing
implementations like Slice//Jockey.
 |
No need to say that Slice//Jockey runs smoothly on Apple MacBooks,
at 25-30% CPU load depending on model. Drop-outs never occur. I have
not tested Slice//Jockey on PPC Mac yet. However, the package for OSX
contains fat binaries which will run on PPC as well.
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.
|
|
The original version of SliceJockey is not compatible with Pd 0.43. It
is no longer maintained but still available for download here.
|
|
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.
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.
SliceJockey2test2.zip 528 KB, for Pd-E 0.42/0.43 on Linux, OSX and
Windows