Sound samplers are music devices which record and replay sound samples. Let's make a simple sampler which records and plays one short sound. Recording and playing are made in a loop. Additionally, the current sound is drawn as a graph and also as a stripe image, so you can use it for making input pictures for an image-to-sound transcoder example as described earlier.

This example is based on the emptyExample project in openFrameworks. As it receives and generates sound, add the next code to testApp.h in the class testApp declaration:

//Function for receiving audio
void audioReceived( float *input, int bufferSize, int nChannels );

//Function for generating audio
void audioOut( float *input, int bufferSize, int nChannels );

//Object for sound output and input setup
ofSoundStream soundStream;

At the beginning of testApp.cpp, after the #include "testApp.h" line, add constants and variables. The main thing here is the buffer array, which is used as storage for sound recording and also as a data source for sound playing. This buffer has a size which is generally not equal to the size of the input and output buffers passed in the audioReceived() and audioOut() functions. This means we need to use variables for holding the current recording and playing position, recPos and playPos respectively. Also, there are two modes of work selectable from the keyboard, sample recording and playing.To manage this, we define the flags recordingEnabled and playingEnabled:

//Constants
const int sampleRate = 44100;     //Sample rate of sound
const float duration = 0.25;      //Duration of the recorded 
                                  //sound in seconds
const int N = duration * sampleRate;    //Size of the PCM buffer

//Variables
vector<float> buffer;  //PCM buffer of sound sample
int recPos = 0;        //Current recording position in the buffer
int playPos = 0;       //Current playing position in the buffer

int recordingEnabled = 1;    //Is recording enabled
int playingEnabled = 0;      //Is playing enabled

The setup() function sets the buffer size and starts the sound output and input:

void testApp::setup(){
    //Set buffer size and fill it by zeros
    buffer.resize( N, 0.0 );

    //Start the sound output in stereo (2 channels)
    //and sound input in mono (1 channel)
    soundStream.setup( this, 2, 1, sampleRate, 256, 4 );
}

The update() function is empty. The draw() function draws a graph of the buffer and its stripe image. A stripe image is drawn by vertical lines of different colors. Note that the width of the screen w = 1024 is less than the sound buffer size N, so we are shrinking the buffer on the screen using the conversion formula:

i = float(x) * N / w

Also, while converting the buffer values into color values of the lines, we apply square root transformation. It makes small changes of audio samples more visually distinct. Image-to-sound transcoding works better with such a transformed image too. See the draw() function code in the example's text.

The most important functions of the example are audioReceived() and audioOut(). They record and play audio samples to and from the buffer array:

//Audio input
void testApp::audioReceived(
  float *input, int bufferSize, int nChannels ) {

  //If recording is enabled by the user,
  //then store received data
  if ( recordingEnabled ) {
      for (int i=0; i<bufferSize; i++) {
          buffer[ recPos ] = input[i];
          recPos++;
          //When the end of buffer is reached, recPos sets
          //to 0, so we record sound in a loop
          recPos %= N;
      }
  }
}

//Audio output
void testApp::audioOut(
       float *output, int bufferSize, int nChannels) {

  //If playing is enabled by the user, then do output sound
  if ( playingEnabled ) {
      for (int i=0; i<bufferSize; i++) {
          output[ 2*i ] = output[ 2*i+1 ]
                        = buffer[ playPos ];
          playPos++;
          //When the end of buffer is reached, playPos sets
          //to 0, so we hear looped sound
          playPos %= N;
      }
  }
}

Finally, add a reaction on the keyboard. Keys 1 and 2 will switch between the recording and playing modes. Key S will save the screen image to the grab.png file, so you can print it and use it as an input in the Image-to-sound transcoder example:

void testApp::keyPressed( int key ){

  //Enable recording mode
  if ( key == '1' ) {
      recordingEnabled = 1; playingEnabled = 0;
  }

  //Enable playing mode
  if ( key == '2' ) {
      recordingEnabled = 0; playingEnabled = 1;
  }

  //Save screen image to the file
  if ( key == 's' ) {
      ofImage grab;
      grab.grabScreen( 0, 0, ofGetWidth(), ofGetHeight() );
      grab.saveImage( "grab.png" );
  }
}

If you use a laptop, then it is highly possible that you may have an built-in microphone. If not, then before running the application, connect a microphone or web camera to your computer (most web cameras have microphones). Run the application and say something into the microphone. You will see a graph of the sound and also a stripe image as shown in the following screenshot:

Continue talking into the microphone and press 2. The recording will be stopped and the last recorded sound sample will play in a loop. As the recording is performed in a looped buffer with a length duration = 0.25 seconds, the resulting duration of the sample will be 0.25 seconds too.

Now press S and the image will be saved into the grab.png file in the bin/data folder of the application. Press 1 and the recording will start again.

soundStream.setup( this, 0, 1, sampleRate, 256, 4 );

//Write the sound sample to raw-file
if ( key == 'f' ) {
  //Create a file for writing
  //Here "wb" means that we open binary file for writing
  FILE *file = fopen( ofToDataPath("sound.raw").c_str(), "wb" );
  //Write the buffer into file
  fwrite( &buffer[0], N, sizeof( buffer[0] ), file );

  //Close the file
  fclose( file );
}