Joanillo Media Art

jplay-sndfile is an application that I have been programming this week, and has a didactic purpose. Basically is an audio player that can also apply a frequency shift, and can also make a continuous sweep of frequencies. It is a JACK client (JACK, the Linux audio server), and is based, as a starting point, in sndfile-jackplay : you can find this piece of software within the utilities of the libsndfile library (http://www.mega-nerd.com/libsndfile/tools/# jackplay).

Everybody knows that if you play an audio file to twice the original frequency, it lasts half the time. Would be equivalent to taking a sample of two, and play at original sample rate.

Now let’s make the opposite case, we divide the frequency by two: the playback lasting time should be doubled. To do this, the easiest is to double each sample in two, and playback at the former sampling rate.

These two special cases, multiply by two and divide by two, are the easiest and most obvious cases. An analysis of these cases, studying the source code provided, can clarify many concepts related with Digital Signal Processing. However, is harder to process intermediate frequencies between 0.5 and 2, and harder still to make a continuous sweep of frequencies in a given range. This is what you can do and can be studied in this application that has a didactic character.

The output of the help option provides the following information:

$ jplay-sndfile -h

jplay-sndfile 1.00
Created by Joan Quintana Compte (joanillo)
joanqc arroba gmail.com – www.joanillo.org
Licensed under GPL v.3

jplay-sndfile is a JACK client intended for playing audio files (wav) and pitch shifting, written basically for learning, testing and educational purposes, and the first stage for future developments. A part of playing an audio file, you can change the pitch (between *0.5 and *2) of your audio file, you can play the audio file combing the pitch between two ranges. For testing is useful a sine wave, but remember that you can use any mono (one channel) audio files.
This Jack Audio client connects automatically to system:playback_1 and system:playback_2

usage: jplay-sndfile [-h] [[pitch-shift] | [pitch-shift-start pitch-shift-end]] wav-file

-h –help: this usage information
[pitch-shift] (0.5,2): shifting pitch
[pitch-shift-start] (0.5,2): shifting pitch start range
[pitch-shift-end] (0.5,2): shifting pitch end range
wav file: mono channel audio file

Examples:
./jplay_sndfile samples/hellosine.wav
./jplay_sndfile 0.65 samples/hellosine.wav
./jplay_sndfile 0.5 2 samples/hellosine.wav

The audio sample that follows is intended as a summary of what you can do with jplay-sndfile, and includes the following cases:

• ./jplay_sndfile samples/test_44100.wav
• ./jplay_sndfile .5 samples/test_44100.wav
• ./jplay_sndfile .8 samples/test_44100.wav
• ./jplay_sndfile 1.4 samples/test_44100.wav
• ./jplay_sndfile 2 samples/test_44100.wav
• ./jplay_sndfile .5 2 samples/test_44100x3.wav
• ./jplay_sndfile samples/sine_440_44100.wav
• ./jplay_sndfile .5 1 samples/square_440_44100.wav
• ./jplay_sndfile 1 2 samples/saw_440_44100.wav
• ./jplay_sndfile .5 samples/waves.wav
• ./jplay_sndfile 2 samples/waves.wav

jplay-sndfile-examples by joanillo

One of the interesting things is to study the callback function of the JACK API, which has resulted quite short. Here is the core ot this application. Basically the callback() function is called by the audio server each time the audio interface (sound card hardware) needs to fill its buffer with more data.

static int process (jack_nframes_t nframes, void * arg)
{
jack_default_audio_sample_t buf ;
unsigned int i;
outs = (jack_default_audio_sample_t *)jack_port_get_buffer (output_port, nframes) ;

info_t *info = (info_t *) arg;

memcpy (outs_original, buffer2 + frames_counter_original, sizeof (jack_default_audio_sample_t) * nframes * DOUBLE_SAMPLES * 2);

int k=0;
float k2;
k2 = nframes/info->shift_pitch;
float var, var2 = 0;
int part_entera = 0;
var = 1/info->shift_pitch – 1;

for (i = 0 ; i < nframes ; i++)
{
if (info->shift_pitch < 1) {
if (frames_counter + i >= info->numFrames / shift_pitch_equivalent) { // shift_pitch_equivalent = info.shift_pitch quan no faig un escombrat
info->play_done=1;
return 0;
}
} else { // >= 1
if (frames_counter_original + i >= info->numFrames * DOUBLE_SAMPLES) {
info->play_done=1;
return 0;
}
}

if (info->shift_pitch > 1) {
k=(int)(i*DOUBLE_SAMPLES*info->shift_pitch + .5);
outs[i] = outs_original[k];
} else if (info->shift_pitch <= 1) {
outs[k] = outs_original[i*DOUBLE_SAMPLES];
if ((int)var2 != part_entera) {
outs[k+1] = outs_original[i*DOUBLE_SAMPLES+1];
part_entera = int(var2);
k++;
}
var2 = var2 + var;
k++;
}

}
frames_counter += nframes;
frames_counter_original += nframes * DOUBLE_SAMPLES * info->shift_pitch ;

return 0 ;
} /* process */

And what is all this about? As we have said this is a didactic application, used primarily to learn:

• learning: Digital Signal Processing
• learning: libsndfile API
• learning JACK API, a typical example of a callback function

But a part of learning, we have an idea in mind in the next project: use a Wacom tablet, the ones that are used by graphic designers, to produce realistic sounds, sensitive to movement and pen pressure, but this is another project: Wacom gesture recognition and audio synthesis

• Download jplay-sndfile
• wiki project link