//
// Programmer:    Craig Stuart Sapp <craig@ccrma.stanford.edu>
// Creation Date: Thu Jul  5 12:36:25 PDT 2001
// Last Modified: Thu Jul  5 12:36:28 PDT 2001
// Filename:      ...sig/maint/code/audio/AudioInputStream/unix/AudioInputStream_unix.cpp
// Web Address:   http://sig.sapp.org/src/sig/AudioInputStream_unix.cpp
// Documentation: http://sig.sapp.org/doc/classes/AudioInputStream
// Syntax:        C++ 
//

#ifndef VISUAL

#include <pthread.h>
#include <linux/soundcard.h>

#include "AudioInputStream_unix.h"

#define DEFAULT_BUFFER_SIZE 512   /* 44100/100 = 441 ---> 512 */
#define SUBBUFFER_COUNT      16


// static variables
Array<ushort*>      AudioInputStream_unix::buffers;
int                 AudioInputStream_unix::currentwrite = 0;
CircularBuffer<int> AudioInputStream_unix::currentread;
int                 AudioInputStream_unix::classCount = 0;
int                 AudioInputStream_unix::initQ = 0;
pthread_t           AudioInputStream_unix::audioInThread = 0;
AudioInput          AudioInputStream_unix::audioin;



//////////////////////////////
//
// AudioInputStream_unix::AudioInputStream_unix --
//

AudioInputStream_unix::AudioInputStream_unix(void) {
   classCount++;
   if (classCount == 1) {
      init();
   }
}



//////////////////////////////
//
// AudioInputStream_unix::~AudioInputStream_unix --
//

AudioInputStream_unix::~AudioInputStream_unix() {
   classCount--;
   if (classCount == 0) {
      deinit();
   } else if (classCount < 0) {
      cout << "Error in destructor of AudioInputStream_unix" << endl;
      exit(1);
   }
}



//////////////////////////////
//
// getNextBuffer -- returns the next audio buffer that is filled
//    with audio data.  This function will block if there is
//    no audio data waiting to be read.
//

ushort* AudioInputStream_unix::getNextBuffer(void) {
   int buffernum = 0;
   while (currentread.getCount() < 1) { 
      // wait until data is ready
   };

   buffernum = currentread.extract();
   return buffers[buffernum];
}



//////////////////////////////
//
// AudioInputStream_unix::getBufferSize -- returns the size of the
//    audio buffers extracted with the getNextBuffer command.
//

int AudioInputStream_unix::getBufferSize(void) {
   // fixed size for now
   return DEFAULT_BUFFER_SIZE;
}



//////////////////////////////
//
// AudioInputStream_unix::open -- open the audio driver for reading
//

void AudioInputStream_unix::open(void) {
   audioin.open();
}



//////////////////////////////
//
// AudioInputStream_unix::open16LSB -- open the audio driver for reading
//    in 16 bit Least Significant Byte first.
//   Default values: channels = 1, srate = 44100
//

void AudioInputStream_unix::open16LSB(int channels, int srate) {
   audioin.open16LSB(channels, srate);
}



//////////////////////////////
//
// AudioInputStream_unix::close -- close the audio driver for reading
//

void AudioInputStream_unix::close(void) {
   audioin.close();
}



//////////////////////////////
//
// AudioInputStream_unix::deinit --
//

void AudioInputStream_unix::deinit(void) {
   if (!initQ) {
      return;
   } else {
      initQ = 0;
   }
   
   int i;
   for (i=0; i<SUBBUFFER_COUNT; i++) {
      if (buffers[i] != NULL) {
         delete [] buffers[i];
         buffers[i] = NULL;
      }
   }
   buffers.setSize(0);

   close();
}



//////////////////////////////
//
// AudioInputStream_unix::init --
//

void AudioInputStream_unix::init(void) {
   if (initQ) {
      return;
   } else {
      initQ = 1;
   }

   buffers.setSize(SUBBUFFER_COUNT);
   int i, j;
   for (i=0; i<SUBBUFFER_COUNT; i++) {
      buffers[i] = new ushort[DEFAULT_BUFFER_SIZE];
      for (j=0; j<DEFAULT_BUFFER_SIZE; j++) {
         buffers[i][j] = 0;
      }
   }
   currentread.setSize(SUBBUFFER_COUNT);
   currentread.reset();
   currentwrite = 0;

   open();

   // start the audio reading thread
   int flag = pthread_create(&audioInThread, NULL, 
      extractAudioInputStreamPrivate, NULL);
   if (flag == -1) {
      cout << "Unable to create MIDI input thread." << endl;
      exit(1);
   }
}


//////////////////////////////
//
// AudioInputStream_unix::getNextBufferToFill --
//

int AudioInputStream_unix::getNextBufferToFill(void) {
   int output = currentwrite;
   currentwrite++;
   if (currentwrite >= SUBBUFFER_COUNT) {
      currentwrite = 0;
   }

   return output;
}


///////////////////////////////////////////////////////////////////////////


///////////////////////////////
//
// extractAudioInputStreamPrivate -- thread function for handling
//   the audio input from the drivers.
//

void *extractAudioInputStreamPrivate(void *) {
   int buffer;

   while(1) {
      buffer = AudioInputStream_unix::getNextBufferToFill();
      AudioInputStream_unix::audioin.read((unsigned char*)
         (AudioInputStream_unix::buffers[buffer]), DEFAULT_BUFFER_SIZE*2);
      AudioInputStream_unix::currentread.insert(buffer);
   }
   return NULL;
}


#endif /* VISUAL */

// md5sum: 993849a638167d3f451229e109406de6 AudioInputStream_unix.cpp [20050403]