UNIX/src/audioin.c

/*---------------------------------------------------------------------------*
 *  audioin.c                                                                *
 *                                                                           *
 *  Copyright 2007, 2008 Nuance Communciations, Inc.                               *
 *                                                                           *
 *  Licensed under the Apache License, Version 2.0 (the 'License');          *
 *  you may not use this file except in compliance with the License.         *
 *                                                                           *
 *  You may obtain a copy of the License at                                  *
 *      http://www.apache.org/licenses/LICENSE-2.0                           *
 *                                                                           *
 *  Unless required by applicable law or agreed to in writing, software      *
 *  distributed under the License is distributed on an 'AS IS' BASIS,        *
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. *
 *  See the License for the specific language governing permissions and      *
 *  limitations under the License.                                           *
 *                                                                           *
 *---------------------------------------------------------------------------*/

/* -------------------------------------------------------------------------+
   |                               ScanSoft Inc.                              |
   + -------------------------------------------------------------------------*/


/* -------------------------------------------------------------------------+
   | Project       : ScanSoft AudioIn
   | Module        : audioin
   | File name     : audioin.c
   | Description   : This module contains the main implementation for the audioIn
   |                 component.
   | Reference(s)  : wavein, audioout, audioin.chm, audioin.doc, audioin.hlp,
   |                 SltGl00001_audioin_gl1.doc
   | Status        : Version 1.2
   + -------------------------------------------------------------------------*/
/*     Feb/25/2002: First QNX/SH4 "draft" version. Version 1.1              */
/*     Nov/25/2004: clean up and minor changes like choice of the codec     */
/*                  frame size which is now automatically selected          */
/*--------------------------------------------------------------------------*/

#if !defined(ANDROID) || defined(__ARM_ARCH_5__) || defined(__ARM_ARCH_4__)


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <pthread.h>
#include <sched.h>
#include <time.h>
#include <unistd.h>
#include <sys/select.h>
#include "plog.h"
#include "audioin.h"

#if defined(ANDROID)
#include "audioinwrapper.h"
#else
#include <alsa/asoundlib.h>
#endif

// #define SAVE_RAW_AUDIO              1

#ifdef SAVE_RAW_AUDIO
#include <sys/time.h>
#include <stdio.h>

static FILE *audio_data;
static struct timeval buffer_save_audio;
#endif

/*#define FILTER_ON*/

#ifdef FILTER_ON
#include "filter.h"
#endif

/* -------------------------------------------------------------------------+
   |   EXTERNAL DATA (+ meaning)                                              |
   + -------------------------------------------------------------------------*/

/* none */

/* -------------------------------------------------------------------------+
   |   MACROS                                                                 |
   + -------------------------------------------------------------------------*/

#define NR_OF_CHANNELS            1

#if defined(ANDROID)
/* size in samples */
/* We really no longer use this for ANDROID but more changes are needed to remove it. SteveR */
#define SAMPLES_BUFFER_SIZE             (8*1024)
#define SAMPLES_BUFFER_HIGH_WATERMARK   (6*1024)
#else
#define SAMPLES_BUFFER_SIZE            (50*4410)
#define SAMPLES_BUFFER_HIGH_WATERMARK  (40*4410)
#endif

/* IMPORTANT NOTE:
   Here a "frame" is an ALSA term.  A frame is comprised of 1 sample if mono,
   and 2 samples if stereo.  This should be distinguished from what the
   ASR engine and lhs_audioin*() API functions refer to as a frame which is
   a set of consecutive samples.
   (see http://www.alsa-project.org/alsa-doc/alsa-lib/pcm.html) */
#if defined(ANDROID)
#define CODEC_FRAGMENT_SIZE_IN_FRAMES                    1024
#else
//read the equivalent of 100 ms per buffer. Note: we are recording at 44 kHz
#define CODEC_FRAGMENT_SIZE_IN_FRAMES                    4410
#endif

/* -------------------------------------------------------------------------+
   |   TYPE DEFINITIONS                                                       |
   + -------------------------------------------------------------------------*/

/* -------------------------------------------------------------------------+
   |   GLOBAL CONSTANTS                                                       |
   + -------------------------------------------------------------------------*/


/* -------------------------------------------------------------------------+
   |   GLOBAL VARIABLES                                                       |
   + -------------------------------------------------------------------------*/

#if !defined(ANDROID)
static snd_pcm_t       *ghPCM;                   /* handle to the PCM recording device */
#endif

static int              gCodecFragmentSizeInFrames = CODEC_FRAGMENT_SIZE_IN_FRAMES;    /* fragment size used by the codec driver */
static audioinSample    gSamplesBufferCircularFifo[SAMPLES_BUFFER_SIZE]; /* circular buffer that buffers the incoming samples */

static int              gWriteIndexPointer = 0;  /* write pointer in the circular FIFO samples buffer */
static int              gReadIndexPointer  = 0;  /* read  pointer in the circular FIFO samples buffer */
static AUDIOIN_INFO     gAudioInInfo;            /* to store the info about the acquisition */
static pthread_mutex_t  gAudioMutex;             /* to prevent using the read/write pointers at the same time in both threads */

static pthread_cond_t   gThreadRunning;          /* synchronize when the AcquisitionThreadID is running*/
static int              gThreadRunningSignaled = 0;

static pthread_cond_t   gOpenExCalled;          /* synchronize when the lhs_audioinOpenEx is called*/
static int              gOpenExCalledSignaled = 0;

static pthread_cond_t   gCloseCalled;          /* synchronize when the lhs_audioinClose is called*/
static int              gCloseCalledSignaled = 0;

static pthread_t        AcquisitionThreadID;     /* acquisition thread id */

static int              gInitialized = 0; /* did we initialize some of the variables*/
static int              gTerminateThread = 0;
static struct timeval   timer;                   /* timer used by select to relinquish cpu times */

static int              gRecordingVolume = -1;   /* recording volume ; number between 0 and 15 */
static int              bRecord = 0;             /* recording state is off */
static int              bClose  = 1;             /* audio pipe is closed */

#ifdef FILTER_ON
static FIR_struct      *pFIR = NULL;             /* pointer to FIR structure */
#endif

#ifdef AUDIOIN_SUPPORT_CALLBACK
static pCallbackFunc    gpCallback         = NULL;
static void            *gpCallbackInstance = NULL;
static unsigned long    gnCallbackSamples  = 0;
#endif

/* -------------------------------------------------------------------------+
   |   LOCAL FUNCTION PROTOTYPES                                              |
   + -------------------------------------------------------------------------*/

static void *AcquisitionThread(void *data);                /* Entry function for the acquisition thread */
static int OpenAndPrepareSound(unsigned long ulFrequency);

/**
 * returns 0 if success
 */
static int Initialize(AUDIOIN_H * phAudioIn)
{
  int doneWaiting = 0;

  if( gInitialized == 1 )
    return 0;

  /* creates the mutex that will be used to lock/unlock access to some variables/code */
  if (pthread_mutex_init(&gAudioMutex, NULL) != 0)
  {
    return 1;
  }

  if(pthread_cond_init(&gThreadRunning, 0) != 0 )
  {
    return 1;
  }

  if(pthread_cond_init(&gOpenExCalled, 0) != 0 )
  {
    return 1;
  }

  if(pthread_cond_init(&gCloseCalled, 0) != 0 )
  {
    return 1;
  }

  pthread_mutex_lock(&gAudioMutex);

  /* create a thread with very high priority that will do the acquisition */
  if (pthread_create(&AcquisitionThreadID, NULL, AcquisitionThread, phAudioIn) != 0)
  {
    return 1;
  }

  //wait for the thread to run
  while (!doneWaiting)
  {
    int rc = pthread_cond_wait(&gThreadRunning, &gAudioMutex);
    switch (rc)
    {
      case 0:
        if (!gThreadRunningSignaled)
        {
          // Avoid spurious wakeups
          continue;
        }
        else
        {
          gThreadRunningSignaled = 0;
          doneWaiting = 1;
          break;
        }
        break;
      default:
        pthread_mutex_unlock(&gAudioMutex);
        return 1;
    }
  }

  pthread_mutex_unlock(&gAudioMutex);


  //thread is now running.

  gInitialized = 1;

  return 0;
}

#if 0
/* disable this unused function for now until we decide what to do with this */

/**
 * returns 0 if success
 */
static int UnInitialize()
{
  //signal the thread that it has to stop running.
  pthread_mutex_lock ( &gAudioMutex );
  gTerminateThread = 1;

  //signal to tell that our thread is now running.
  if ( pthread_cond_signal ( &gOpenExCalled ) != 0 )
  {
    pthread_mutex_unlock ( &gAudioMutex );
    PLogError ( "Audio In Error pthread_cond_signal\n" );
    return 1;
  }
  gOpenExCalledSignaled = 1;
  pthread_mutex_unlock ( &gAudioMutex );

  /* wait until thread exits */
  if (pthread_join(AcquisitionThreadID, NULL) != 0)
  {
    return 1;
  }

  /* destroy the mutex */
  if (pthread_mutex_destroy(&gAudioMutex) !=0 )
  {
    return 1;
  }
  if( pthread_cond_destroy(&gThreadRunning) != 0 )
  {
    return 1;
  }
  if( pthread_cond_destroy(&gOpenExCalled) != 0 )
  {
    return 1;
  }
  if( pthread_cond_destroy(&gCloseCalled) != 0 )
  {
    return 1;
  }
  gInitialized = 0;
  return 0;
}
#endif

/* -------------------------------------------------------------------------+
   |   LOCAL FUNCTION (should be static)                                      |
   + -------------------------------------------------------------------------*/

static void setRecordOn(void)
{
  bRecord = 1;
}

static void setRecordOff(void)
{
  bRecord = 0;
}

static int getRecord(void)
{
  return bRecord;
}

static void setCloseOn(void)
{
  bClose = 1;
}

static void setCloseOff(void)
{
  bClose = 0;
}

static int getClose(void)
{
  return bClose;
}


/**************************************************************
 * AcquisitionThread                                           *
 *                                                             *
 * This function is the entry function of a thread created by  *
 * lhs_audioinOpen and which is responsible of getting the     *
 * samples from the codec and store them in a big circular     *
 * FIFO buffer.                                                *
 * The priority of this thread has been set to high in order   *
 * to prevent codec buffer overrun. Since the FIFO is limited  *
 * in size (5 sec default ; see SAMPLES_BUFFER_SIZE            *
 * parameter), the application must still be fast enough to    *
 * prevent FIFO overflow/overrun                               *
 **************************************************************/
#if defined(ANDROID)

void *AcquisitionThread ( void *data )
{
  int doneWaiting = 0;
  audioinSample   *CodecBuffer;
  long            x;
  long            y;
#ifdef AUDIOIN_SUPPORT_CALLBACK
  AUDIOIN_H       *phAudioIn = (AUDIOIN_H *)data;
  AUDIOIN_WAVEHDR *pwhdr;
#endif


  pthread_mutex_lock ( &gAudioMutex );

  //signal to tell that our thread is now running.
  if ( pthread_cond_signal ( &gThreadRunning ) != 0 )
  {
    pthread_mutex_unlock ( &gAudioMutex );
    PLogError ( "Audio In Error pthread_cond_signal\n" );
    exit ( 1 );
  }
  gThreadRunningSignaled = 1;

  while( 1 )
  {

    while (!doneWaiting)
    {
      int rc = pthread_cond_wait(&gOpenExCalled, &gAudioMutex);
      switch (rc)
      {
        case 0:
          if (!gOpenExCalledSignaled)
          {
            // Avoid spurious wakeups
            continue;
          }
          else
          {
            gOpenExCalledSignaled = 0;
            doneWaiting = 1;
            break;
          }
          break;
        default:
          PLogError ( "Audio In Error pthread_cond_signal\n" );
          pthread_mutex_unlock(&gAudioMutex);
          return ( (void *)NULL );
      }
    }
    doneWaiting = 0;
    pthread_mutex_unlock(&gAudioMutex);

    if( gTerminateThread == 1 )
      break;


    /* buffer of 16 bits samples */
    CodecBuffer = (audioinSample *)malloc ( gCodecFragmentSizeInFrames * sizeof ( audioinSample ) );

    if ( CodecBuffer == NULL )
    {
      PLogError ( "Audio In Error malloc\n" );
      exit ( 1 );
    }
    pwhdr = malloc ( sizeof ( AUDIOIN_WAVEHDR ) );

    if ( pwhdr == NULL )
    {
      PLogError ( "Audio In Error malloc\n" );
      exit ( 1 );
    }

    while ( !getClose ( ) )
    {

      int iReadFrames  = 0;  /* number of frames acquired by the codec */
      /* NOTE: here a frame is comprised of 1 sample if mono, 2 samples if stereo, etc */
      int iReadSamples = 0;  /* number of samples acquired by the codec */
      int frames_to_read;     /* Actual number to read */
      int frames_read;        /* Frames read on one read */

      iReadFrames = 0;

      do
      {
        frames_to_read = gCodecFragmentSizeInFrames - iReadFrames;
        /* AudioRead() - output: number of frames (mono: 1 sample, stereo: 2 samples)*/
        frames_read = AudioRead ( CodecBuffer + iReadFrames, frames_to_read );

        if ( frames_read > 0 )
          iReadFrames += frames_read;
      }
      while ( ( iReadFrames < gCodecFragmentSizeInFrames ) && ( frames_read > 0 ) );
      iReadSamples = iReadFrames;

      if ( getRecord ( ) )  /* else continue to read from driver but discard samples */
      {
        if ( iReadSamples < 0 )
        {
          iReadSamples = 0;
          gAudioInInfo.eStatusInfo = AUDIOIN_HWOVERRUN;
        }
        else
        {
#ifdef FILTER_ON
          /* x: index for start of input samples; y: index for output sample */
          for ( x = 0, y = 0; x < iReadSamples; x += pFIR->factor_down )
          {
            FIR_downsample ( pFIR->factor_down, &( CodecBuffer[x] ), &( CodecBuffer[y++] ), pFIR );
          }
          /* update the number samples */
          iReadSamples = y;
#endif
          pthread_mutex_lock ( &gAudioMutex );

          if ( gAudioInInfo.u32SamplesAvailable + iReadSamples > SAMPLES_BUFFER_SIZE )
          {
            gAudioInInfo.u32SamplesAvailable = SAMPLES_BUFFER_SIZE;
            gAudioInInfo.eStatusInfo = AUDIOIN_FIFOOVERRUN;
          }
          else
          {
            if ( gAudioInInfo.u32SamplesAvailable + iReadSamples > SAMPLES_BUFFER_HIGH_WATERMARK )
            {
              gAudioInInfo.eStatusInfo = AUDIOIN_HIGHWATERMARK;
            }
            else if ( gAudioInInfo.eStatusInfo != AUDIOIN_FIFOOVERRUN )
            {
              gAudioInInfo.eStatusInfo = AUDIOIN_NORMAL;
            }
            gAudioInInfo.u32SamplesAvailable += iReadSamples;
          }
          if ( gWriteIndexPointer + iReadSamples <= SAMPLES_BUFFER_SIZE )
          {
            memcpy ( &( gSamplesBufferCircularFifo[gWriteIndexPointer] ), CodecBuffer,
                iReadSamples * sizeof ( audioinSample ) );
            gWriteIndexPointer += iReadSamples;

            if ( gWriteIndexPointer >= SAMPLES_BUFFER_SIZE )
              gWriteIndexPointer = 0;
          }
          else
          {
            int NbToCopy;

            NbToCopy = SAMPLES_BUFFER_SIZE - gWriteIndexPointer;
            memcpy ( &( gSamplesBufferCircularFifo [gWriteIndexPointer] ), CodecBuffer,
                NbToCopy * sizeof ( audioinSample ) );
            gWriteIndexPointer = 0;
            memcpy ( gSamplesBufferCircularFifo, &( CodecBuffer [NbToCopy] ),
                ( iReadSamples-NbToCopy ) * sizeof ( audioinSample ) );
            gWriteIndexPointer = iReadSamples - NbToCopy;
          }

#ifdef AUDIOIN_SUPPORT_CALLBACK
          /* Callback notification.  Ideally this audio acquisition thread should be very lean.
             It should simply read from the low level driver, store the filtered samples in
             the FIFO, then go back to reading from the driver.  The additional data copy
             for the callback function is ok despite the overhead incurred, but only because
             there's some buffering done by the low level driver.  This design should be
             revisited to make it more general purpose.
             */
          if ( gpCallback != NULL )
          {
            pwhdr->nBufferLength  = iReadSamples * sizeof ( audioinSample );
            pwhdr->nBytesRecorded = pwhdr->nBufferLength;
            pwhdr->status = AUDIOIN_NORMAL;
            pwhdr->pData = CodecBuffer;
            /* pass samples to callback function who should deallocate the buffer and structure */
            gpCallback ( *phAudioIn, AUDIOIN_MSG_DATA, gpCallbackInstance, pwhdr, NULL );
          }
#endif
          /* samples are available to read */
          pthread_mutex_unlock ( &gAudioMutex );
          timer.tv_sec = 0;
          timer.tv_usec = 200;
          select ( 0, NULL, NULL, NULL, &timer );
        }
      } /* if (getRecord()) */

    } /* while (!getClose()) */
    if ( AudioClose ( ) !=0 )
    {
      PLogError ( "Audio In Error Closing Hardware\n" );
    }
    free ( CodecBuffer );

    pthread_mutex_lock ( &gAudioMutex );
    //signal to tell that our thread is now running.
    if ( pthread_cond_signal ( &gCloseCalled ) != 0 )
    {
      pthread_mutex_unlock ( &gAudioMutex );
      PLogError ( "Audio In Error pthread_cond_signal\n" );
      exit ( 1 );
    }
    gCloseCalledSignaled = 1;
  }

  pthread_exit ( (void *)NULL );
  return ( (void *)NULL );
}

#else
/* non-ANDROID version */

void *AcquisitionThread ( void *data )
{
  int doneWaiting = 0;
  audioinSample   *CodecBuffer;
#ifdef FILTER_ON
  long            x;
  long            y;
#endif
#ifdef AUDIOIN_SUPPORT_CALLBACK
  AUDIOIN_H       *phAudioIn = (AUDIOIN_H *)data;
#endif

  pthread_mutex_lock ( &gAudioMutex );

  //signal to tell that our thread is now running.
  if ( pthread_cond_signal ( &gThreadRunning ) != 0 )
  {
    pthread_mutex_unlock ( &gAudioMutex );
    PLogError ( "Audio In Error pthread_cond_signal\n" );
    exit ( 1 );
  }
  gThreadRunningSignaled = 1;

  while( 1 )
  {
    while (!doneWaiting)
    {
      int rc = pthread_cond_wait(&gOpenExCalled, &gAudioMutex);
      switch (rc)
      {
        case 0:
          if (!gOpenExCalledSignaled)
          {
            // Avoid spurious wakeups
            continue;
          }
          else
          {
            gOpenExCalledSignaled = 0;
            doneWaiting = 1;
            break;
          }
          break;
        default:
          PLogError ( "Audio In Error pthread_cond_wait\n" );
          pthread_mutex_unlock(&gAudioMutex);
          return ( (void *)NULL );
      }
    }
    doneWaiting = 0;
    pthread_mutex_unlock(&gAudioMutex);

    if( gTerminateThread == 1 )
      break;

    /* buffer of 16 bits samples */
    CodecBuffer = (audioinSample *)malloc ( gCodecFragmentSizeInFrames * sizeof ( audioinSample ) );

    if ( CodecBuffer == NULL )
    {
      PLogError ( "Audio In Error pthread_cond_signal\n" );
      exit ( 1 );
    }

    while ( !getClose ( ) )
    {
      int iReadFrames  = 0;  /* number of frames acquired by the codec */
      /* NOTE: here a frame is comprised of 1 sample if mono, 2 samples if stereo, etc */
      int iReadSamples = 0;  /* number of samples acquired by the codec */
      if ( ( iReadFrames = snd_pcm_readi ( ghPCM, (void *)CodecBuffer, gCodecFragmentSizeInFrames ) ) < 0 )
      {
        if ( iReadFrames == -EBADFD )
        {
          PLogError ( "Audio In Error PCM Not In The Right State\n" );
        }
        else if ( iReadFrames == -EPIPE )
        {
          snd_pcm_prepare(ghPCM);
          PLogError ( "Audio In Error Overrun\n" );
        }
        else if ( iReadFrames == -ESTRPIPE )
        {
          PLogError ( "Audio In Error Stream Suspended\n" );
        }
      }
      iReadSamples = iReadFrames;

      if ( getRecord ( ) )  /* else continue to read from driver but discard samples */
      {
        if ( iReadSamples < 0 )
        {
          iReadSamples = 0;
          gAudioInInfo.eStatusInfo = AUDIOIN_HWOVERRUN;
        }
        else
        {
#ifdef FILTER_ON
          /* x: index for start of input samples; y: index for output sample */
          for ( x = 0, y = 0; x < iReadSamples; x += pFIR->factor_down )
          {
            FIR_downsample ( pFIR->factor_down, &( CodecBuffer[x] ), &( CodecBuffer[y++] ), pFIR );
          }
          /* update the number samples */
          iReadSamples = y;
#endif
#ifdef SAVE_RAW_AUDIO
          if ( iReadSamples > 0 )
            fwrite ( CodecBuffer, 2, iReadSamples, audio_data );
#endif

          pthread_mutex_lock ( &gAudioMutex );

          if ( gAudioInInfo.u32SamplesAvailable + iReadSamples > SAMPLES_BUFFER_SIZE )
          {
            gAudioInInfo.u32SamplesAvailable = SAMPLES_BUFFER_SIZE;
            gAudioInInfo.eStatusInfo = AUDIOIN_FIFOOVERRUN;
          }
          else
          {
            if ( gAudioInInfo.u32SamplesAvailable + iReadSamples > SAMPLES_BUFFER_HIGH_WATERMARK )
            {
              gAudioInInfo.eStatusInfo = AUDIOIN_HIGHWATERMARK;
            }
            else if ( gAudioInInfo.eStatusInfo != AUDIOIN_FIFOOVERRUN )
            {
              gAudioInInfo.eStatusInfo = AUDIOIN_NORMAL;
            }
            gAudioInInfo.u32SamplesAvailable += iReadSamples;
          }
          if ( gWriteIndexPointer + iReadSamples <= SAMPLES_BUFFER_SIZE )
          {
            memcpy ( &( gSamplesBufferCircularFifo[gWriteIndexPointer] ), CodecBuffer,
                iReadSamples * sizeof ( audioinSample ) );
            gWriteIndexPointer += iReadSamples;

            if ( gWriteIndexPointer >= SAMPLES_BUFFER_SIZE )
              gWriteIndexPointer = 0;
          }
          else
          {
            int NbToCopy;

            NbToCopy = SAMPLES_BUFFER_SIZE - gWriteIndexPointer;
            memcpy ( &( gSamplesBufferCircularFifo [gWriteIndexPointer] ), CodecBuffer,
                NbToCopy * sizeof ( audioinSample ) );
            gWriteIndexPointer = 0;
            memcpy ( gSamplesBufferCircularFifo, &( CodecBuffer [NbToCopy] ),
                ( iReadSamples-NbToCopy ) * sizeof ( audioinSample ) );
            gWriteIndexPointer = iReadSamples - NbToCopy;
          }
#ifdef AUDIOIN_SUPPORT_CALLBACK
          /* Callback notification.  Ideally this audio acquisition thread should be very lean.
             It should simply read from the low level driver, store the filtered samples in
             the FIFO, then go back to reading from the driver.  The additional data copy
             for the callback function is ok despite the overhead incurred, but only because
             there's some buffering done by the low level driver.  This design should be
             revisited to make it more general purpose.
             */
          while ( ( gpCallback != NULL ) && ( gAudioInInfo.u32SamplesAvailable >= gnCallbackSamples ) )
          {
            AUDIOIN_WAVEHDR *pwhdr;

            pwhdr = malloc ( sizeof ( AUDIOIN_WAVEHDR ) );

            if ( pwhdr != NULL )
            {
              pwhdr->nBufferLength  = gnCallbackSamples * sizeof ( audioinSample );
              pwhdr->nBytesRecorded = pwhdr->nBufferLength;
              pwhdr->status = gAudioInInfo.eStatusInfo;
              pwhdr->pData = malloc ( pwhdr->nBufferLength );

              if ( pwhdr->pData != NULL )
              {
                if ( gReadIndexPointer + gnCallbackSamples <= SAMPLES_BUFFER_SIZE )
                {
                  memcpy ( pwhdr->pData, &( gSamplesBufferCircularFifo [gReadIndexPointer] ),
                      pwhdr->nBufferLength );
                  gReadIndexPointer += gnCallbackSamples;

                  if ( gReadIndexPointer >= SAMPLES_BUFFER_SIZE )
                    gReadIndexPointer = 0;
                }
                else
                {
                  size_t nSamplesPart1 = SAMPLES_BUFFER_SIZE - gReadIndexPointer;
                  size_t nSamplesPart2 = gnCallbackSamples - nSamplesPart1;

                  memcpy ( pwhdr->pData, &( gSamplesBufferCircularFifo [gReadIndexPointer] ),
                      nSamplesPart1*sizeof ( audioinSample ) );
                  gReadIndexPointer = 0;
                  memcpy ( pwhdr->pData + nSamplesPart1 * sizeof (audioinSample ),
                      gSamplesBufferCircularFifo, nSamplesPart2 * sizeof ( audioinSample ) );
                  gReadIndexPointer = nSamplesPart2;
                }
                gAudioInInfo.u32SamplesAvailable -= gnCallbackSamples;
                /* pass samples to callback function who should deallocate the buffer and structure */
                gpCallback ( *phAudioIn, AUDIOIN_MSG_DATA, gpCallbackInstance, pwhdr, NULL );
              }
              else
              {
                // error
              }
            }
            else
            {
              // error
            }
          }
#endif
          /* samples are available to read */
          pthread_mutex_unlock ( &gAudioMutex );
          timer.tv_sec = 0;
          timer.tv_usec = 200;
          select ( 0, NULL, NULL, NULL, &timer );
        }
      } /* if (getRecord()) */

    } /* while (!getClose()) */

    if ( snd_pcm_close ( ghPCM ) !=0 )
    {
      PLogError ( "Audio In Error Closing Hardware\n" );
    }

    free ( CodecBuffer );

    pthread_mutex_lock ( &gAudioMutex );
    //signal to tell that our thread is now running.
    if ( pthread_cond_signal ( &gCloseCalled ) != 0 )
    {
      pthread_mutex_unlock ( &gAudioMutex );
      PLogError ( "Audio In Error pthread_cond_signal\n" );
      exit ( 1 );
    }
    gCloseCalledSignaled = 1;
  }
  pthread_exit ( (void *)NULL );
  return ( (void *)NULL );
}
#endif

/**************************************************************
 * OpenAndPrepareSound                                         *
 *************************************************************/


static int OpenAndPrepareSound(unsigned long ulFrequency)
{
#if defined(ANDROID)

  /* Only support certain frequencies.  Modify this to check frequency
     against a structure of valid frequencies */
#ifdef FILTER_ON
  if ( ulFrequency == 11025 )
  {
    if ( AudioSetInputFormat ( 44100, NR_OF_CHANNELS ) != 0 ) /* sample at 44100 then downsample */
    {
      PLogError ( "Audio In Error OpenAndPrepareSound - AudioSetInputFormat failed!\n");
      return LHS_E_AUDIOIN_COULDNOTOPENDEVICE;
    }
  }
  else
  {
    PLogError ( "Audio In Error OpenAndPrepareSound - invalid frequency!");
    return LHS_E_AUDIOIN_COULDNOTOPENDEVICE;
  }
#else
  if ( ( ulFrequency == 11025 ) || ( ulFrequency == 8000 ) )
  {
    if ( AudioSetInputFormat ( ulFrequency, NR_OF_CHANNELS ) != 0 )
    {
      PLogError ( "Audio In Error OpenAndPrepareSound - AudioSetInputFormat failed!");
      return LHS_E_AUDIOIN_COULDNOTOPENDEVICE;
    }
  }
  else
  {
    PLogError ( "Audio In Error OpenAndPrepareSound - invalid frequency!");
    return LHS_E_AUDIOIN_COULDNOTOPENDEVICE;
  }
#endif

  /* set some variables */
  gAudioInInfo.u32SamplesAvailable = 0;

  /* Open Audio driver */
  if (AudioOpen() < 0)
  {
    PLogError ( "Audio In Error OpenAndPrepareSound - AudioOpen failed!");
    return ~LHS_AUDIOIN_OK;
  }

#else

  snd_pcm_hw_params_t *hwparams;
  unsigned int         exact_rate;
  int                  dir;
  int                  rc;

  /* step 1 : open the sound device */
  /* ------------------------------ */
  if ((rc = snd_pcm_open(&ghPCM, "default", SND_PCM_STREAM_CAPTURE, 0)) < 0)
  {
    PLogError ( "Audio In Error snd_pcm_open() (rc = %d: %s)\n", rc, snd_strerror(rc));
    return LHS_E_AUDIOIN_COULDNOTOPENDEVICE;
  }

  if ((rc = snd_pcm_hw_params_malloc(&hwparams)) < 0)
  {
    PLogError ( "Audio In Error snd_pcm_hw_params_malloc() (rc = %d: %s)\n", rc, snd_strerror(rc));
    return LHS_E_AUDIOIN_COULDNOTOPENDEVICE;
  }

  /* step 2 : configuring the audio channel */
  /* -------------------------------------- */

  if ((rc = snd_pcm_hw_params_any(ghPCM, hwparams)) < 0)
  {
    PLogError ( "Audio In Error snd_pcm_hw_params_any() (rc = %d: %s)\n", rc, snd_strerror(rc));
    return LHS_E_AUDIOIN_COULDNOTOPENDEVICE;
  }

  if ((rc = snd_pcm_hw_params_set_access(ghPCM, hwparams, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0)
  {
    PLogError ( "Audio In Error snd_pcm_hw_params_set_access() (rc = %d: %s)\n", rc, snd_strerror(rc));
    return LHS_E_AUDIOIN_COULDNOTOPENDEVICE;
  }

  if ((rc = snd_pcm_hw_params_set_format(ghPCM, hwparams, SND_PCM_FORMAT_S16_LE)) < 0)
  {
    PLogError ( "Audio In Error snd_pcm_hw_params_set_format() (rc = %d: %s)\n", rc, snd_strerror(rc));
    return LHS_E_AUDIOIN_COULDNOTOPENDEVICE;
  }

#ifdef FILTER_ON
  if (ulFrequency == 11025)
  {
    exact_rate = 44100;
  }
  else
    return LHS_E_AUDIOIN_COULDNOTOPENDEVICE;
#else
  exact_rate = ulFrequency;
#endif

  dir = 0;

#if 0
  /* This version seems to have problems when the code is compiled into a shared library.
     The subsequent call to snd_pcm_hw_params() fails. */
  if ((rc = snd_pcm_hw_params_set_rate_near(ghPCM, hwparams, &exact_rate, &dir)) < 0)
  {
    PLogError ( "Audio In Error snd_pcm_hw_params_set_rate_near() (rc = %d: %s)\n", rc, snd_strerror(rc));
    return LHS_E_AUDIOIN_COULDNOTOPENDEVICE;
  }
#else
  /* This version works better and in fact makes more sense. */
  if ((rc = snd_pcm_hw_params_set_rate(ghPCM, hwparams, exact_rate, dir)) < 0)
  {
    PLogError ( "Audio In Error snd_pcm_hw_params_set_rate() (rc = %d: %s)\n", rc, snd_strerror(rc));
    return LHS_E_AUDIOIN_COULDNOTOPENDEVICE;
  }
#endif


  if ((rc = snd_pcm_hw_params_set_channels(ghPCM, hwparams, NR_OF_CHANNELS)) < 0)
  {
    PLogError ( "Audio In Error snd_pcm_hw_params_set_channels() (rc = %d: %s)\n", rc, snd_strerror(rc));
    return LHS_E_AUDIOIN_COULDNOTOPENDEVICE;
  }

  if ((rc = snd_pcm_hw_params(ghPCM, hwparams)) < 0)
  {
    PLogError ( "Audio In Error snd_pcm_hw_params() (rc = %d: %s)\n", rc, snd_strerror(rc));
    return LHS_E_AUDIOIN_COULDNOTOPENDEVICE;
  }

  /* step 3 : preparing for read */
  /* --------------------------- */

  /*prepare the channel */

  if ((rc = snd_pcm_prepare(ghPCM)) < 0)
  {
    PLogError ( "Audio In Error snd_pcm_prepare() (rc = %d: %s)\n", rc, snd_strerror(rc));
    return LHS_E_AUDIOIN_COULDNOTOPENDEVICE;
  }

  /* set some variables */
  gAudioInInfo.u32SamplesAvailable = 0;


#endif

  /* prepare to read samples */
  setCloseOff();

  return 0;
}


/* -------------------------------------------------------------------------+
   |   GLOBAL FUNCTIONS (prototypes in header file)                           |
   + -------------------------------------------------------------------------*/

/**************************************************************
 * lhs_audioinOpenEx                                             *
 *                                                             *
 * notes :                                                     *
 *  -the input parameters are in fact not used but present     *
 *    to ensure compatibility with Win32 implementations       *
 **************************************************************/
LHS_AUDIOIN_ERROR  lhs_audioinOpenEx (
    unsigned long u32AudioInID,         /*@parm [in]  Audio-in device ID (ranges from 0 to a number of available
                                          devices on the system). You can also use the following flag
                                          instead of a device identifier.
                                          <nl><nl><bold WAVE_MAPPER> = The function selects a
                                          waveform-audio input device capable of recording in the
                                          specified format. <bold Header:> Declared in Mmsystem.h from
                                          the Windows Multimedia: Platform SDK.*/
    unsigned long u32Frequency,         /*@parm [in]  Frequency of the recognition engine in Hz. */
    unsigned long u32NbrOfFrames,       /*@parm [in]  Number of frames buffered internally. */
    unsigned long u32SamplesPerFrame,   /*@parm [in]  Size, in samples, of each individual frame. */
    AUDIOIN_H * phAudioIn               /*@parm [out] Handle to the audio-in device */
    )
{
  //initialize some of the static variables.
  if( Initialize(phAudioIn) )
    return ~LHS_AUDIOIN_OK;


  /* prepare sound */
  if (OpenAndPrepareSound(u32Frequency) != 0)
  {
    return LHS_E_AUDIOIN_COULDNOTOPENDEVICE;
  }

  //signal the thread that it has to stop running.
  pthread_mutex_lock ( &gAudioMutex );
  //signal to tell that our thread is now running.
  if ( pthread_cond_signal ( &gOpenExCalled ) != 0 )
  {
    pthread_mutex_unlock ( &gAudioMutex );
    PLogError ( "Audio In Error pthread_cond_signal\n" );
    exit ( 1 );
  }
  gOpenExCalledSignaled = 1;
  pthread_mutex_unlock ( &gAudioMutex );

#ifdef FILTER_ON
  /* need to make this more generic to support different filters */
  pFIR = FIR_construct(filter_length, ps16FilterCoeff_up1_down4, u16ScaleFilterCoeff_up1_down4, FACTOR_UP, FACTOR_DOWN);
  if (pFIR == NULL)
  {
    // TO DO: HANDLE THIS (or modify for static allocation)
  }
#endif

  /* set the status to normal */
  gAudioInInfo.eStatusInfo = AUDIOIN_NORMAL;

  /* do not care, but some applications are checking a NULL handle */
  *phAudioIn = (void *)10;

#ifdef AUDIOIN_SUPPORT_CALLBACK
  gpCallback         = NULL;
  gpCallbackInstance = NULL;
  gnCallbackSamples  = 0;
#endif

  return LHS_AUDIOIN_OK;
}

/**************************************************************
 * lhs_audioinOpen                                             *
 *                                                             *
 * notes :                                                     *
 *  -the input parameters are in fact not used but present     *
 *    to ensure compatibility with Win32 implementation        *
 **************************************************************/
LHS_AUDIOIN_ERROR  lhs_audioinOpen (
    unsigned long u32AudioInID,         /*@parm [in]  Audio-in device ID (ranges from 0 to a number of available
                                          devices on the system). You can also use the following flag
                                          instead of a device identifier.
                                          <nl><nl><bold WAVE_MAPPER> = The function selects a
                                          waveform-audio input device capable of recording in the
                                          specified format. <bold Header:> Declared in Mmsystem.h from
                                          the Windows Multimedia: Platform SDK.*/
    unsigned long u32Frequency,         /*@parm [in]  Frequency of the recognition engine in Hz. */
    AUDIOIN_H * phAudioIn               /*@parm [out] Handle to the audio-in device */
    )
{
  return lhs_audioinOpenEx(u32AudioInID, u32Frequency, 0, 0, phAudioIn);
} /* lhs_audioinOpen */

#ifdef AUDIOIN_SUPPORT_CALLBACK
/**************************************************************
 * lhs_audioinOpenCallback                                     *
 *                                                             *
 * notes :                                                     *
 *  -the input parameters are in fact not used but present     *
 *    to ensure compatibility with Win32 implementation        *
 **************************************************************/
LHS_AUDIOIN_ERROR  lhs_audioinOpenCallback (
    unsigned long u32AudioInID,         /*@parm [in]  Audio-in device ID (ranges from 0 to a number of available
                                          devices on the system). You can also use the following flag
                                          instead of a device identifier.
                                          <nl><nl><bold WAVE_MAPPER> = The function selects a
                                          waveform-audio input device capable of recording in the
                                          specified format. <bold Header:> Declared in Mmsystem.h from
                                          the Windows Multimedia: Platform SDK.*/
    unsigned long u32Frequency,         /*@parm [in]  Frequency of the recognition engine in Hz. */
    unsigned long u32NbrOfSamples,      /*@parm [in] <nl><bold Input:> Number of samples requested per callback */
    pCallbackFunc pCallback,            /*@parm [in] callback function */
    void         *pCallbackInstance,    /*@parm [in] callback instance */
    AUDIOIN_H * phAudioIn               /*@parm [out] Handle to the audio-in device */
    )
{
  LHS_AUDIOIN_ERROR lhsErr;

#ifdef FILTER_ON
  gCodecFragmentSizeInFrames = u32NbrOfSamples * 4;
#else
  gCodecFragmentSizeInFrames = u32NbrOfSamples;
#endif

  if ((pCallback == NULL) || (u32NbrOfSamples == 0))
  {
    return LHS_E_AUDIOIN_INVALIDARG;
  }
  lhsErr = lhs_audioinOpenEx(u32AudioInID, u32Frequency, 0, 0, phAudioIn);
  if (lhsErr != LHS_AUDIOIN_OK)
  {
    return lhsErr;
  }

  /* install callback */
  gpCallback         = pCallback;
  gpCallbackInstance = pCallbackInstance;
  gnCallbackSamples  = u32NbrOfSamples;

  /* callback notification */
  gpCallback(*phAudioIn, AUDIOIN_MSG_OPEN, gpCallbackInstance, NULL, NULL);

  return LHS_AUDIOIN_OK;

} /* lhs_audioinOpenCallback */
#endif

/**************************************************************
 * lhs_audioinClose                                            *
 *                                                             *
 * notes :                                                     *
 *  -the input parameters are in fact not used but present     *
 *    to ensure compatibility with Win32 implementations       *
 **************************************************************/

LHS_AUDIOIN_ERROR lhs_audioinClose(AUDIOIN_H *phAudioIn)
{
  int doneWaiting = 0;

  /* Validate the handle */
  if ((phAudioIn == NULL) || (*phAudioIn == NULL))
  {
    return LHS_E_AUDIOIN_NULLPOINTER;
  }

  /* stop recording audio samples */
  setRecordOff();

  /* stop reading audio samples */
  setCloseOn();

  //wait for the thread to stop reading samples.
  pthread_mutex_lock ( &gAudioMutex );

  while (!doneWaiting)
  {
    int rc = pthread_cond_wait(&gCloseCalled, &gAudioMutex);
    switch (rc)
    {
      case 0:
        if (!gCloseCalledSignaled)
        {
          // Avoid spurious wakeups
          continue;
        }
        else
        {
          gCloseCalledSignaled = 0;
          doneWaiting = 1;
          break;
        }
        break;
      default:
        PLogError ( "Audio In Error pthread_cond_wait\n" );
        pthread_mutex_unlock(&gAudioMutex);
        return ~LHS_AUDIOIN_OK;
    }
  }
  pthread_mutex_unlock(&gAudioMutex);

#ifdef FILTER_ON
  FIR_deconstruct(pFIR);
#endif

#ifdef AUDIOIN_SUPPORT_CALLBACK
  /* callback notification */
  if (gpCallback != NULL) gpCallback(*phAudioIn, AUDIOIN_MSG_CLOSE, gpCallbackInstance, NULL, NULL);
#endif

  return LHS_AUDIOIN_OK;
}

/**************************************************************
 * lhs_audioinStart                                            *
 *                                                             *
 * notes :                                                     *
 *  -the input parameters are in fact not used but present     *
 *    to ensure compatibility with Win32 implementations       *
 *  -in fact the recording is never stopped or started, when   *
 *    non in 'start' status, the samples are just ignored      *
 **************************************************************/

LHS_AUDIOIN_ERROR lhs_audioinStart(AUDIOIN_H hAudioIn)
{
#ifdef SAVE_RAW_AUDIO
  char file_name [256];

  gettimeofday ( &buffer_save_audio, NULL );
  sprintf ( file_name, "data_%ld_%ld.raw", buffer_save_audio.tv_sec, buffer_save_audio.tv_usec );
  audio_data = fopen ( file_name, "w" );
#endif
  if (hAudioIn == NULL)
  {
    return LHS_E_AUDIOIN_NULLPOINTER;
  }

  pthread_mutex_lock ( &gAudioMutex );

#ifdef FILTER_ON
  FIR_reset(pFIR);
#endif

  gWriteIndexPointer = 0;
  gReadIndexPointer = 0;
  gAudioInInfo.u32SamplesAvailable = 0;

  /* start recording */
  setRecordOn();

#ifdef AUDIOIN_SUPPORT_CALLBACK
  /* callback notification */
  if (gpCallback != NULL) gpCallback(hAudioIn, AUDIOIN_MSG_START, gpCallbackInstance, NULL, NULL);
#endif
  pthread_mutex_unlock ( &gAudioMutex );

  return LHS_AUDIOIN_OK;
}

/**************************************************************
 * lhs_audioinStop                                             *
 *                                                             *
 * notes :                                                     *
 *  -the input parameters are in fact not used but present     *
 *    to ensure compatibility with Win32 implementations       *
 *  -in fact the recording is never stopped or started, when   *
 *    non in 'start' status, the samples are just ignored      *
 **************************************************************/

LHS_AUDIOIN_ERROR lhs_audioinStop(AUDIOIN_H hAudioIn)
{
#ifdef SAVE_RAW_AUDIO
  fclose ( audio_data );
#endif
  if (hAudioIn == NULL)
  {
    return LHS_E_AUDIOIN_NULLPOINTER;
  }
  pthread_mutex_lock ( &gAudioMutex );

  /* stop recording (discard samples) */
  setRecordOff();

#ifdef AUDIOIN_SUPPORT_CALLBACK
  /* callback notification */
  if (gpCallback != NULL) gpCallback(hAudioIn, AUDIOIN_MSG_STOP, gpCallbackInstance, NULL, NULL);
#endif
  pthread_mutex_unlock ( &gAudioMutex );

  return LHS_AUDIOIN_OK;
}

/**************************************************************
 * lhs_audioinGetSamples                                       *
 *                                                             *
 * notes :                                                     *
 **************************************************************/

LHS_AUDIOIN_ERROR lhs_audioinGetSamples(AUDIOIN_H hAudioIn, unsigned long * u32NbrOfSamples, void * pAudioBuffer, AUDIOIN_INFO * pgAudioInInfo)
{
  unsigned long cSamples;
  //unsigned long nToCopy;

  /* Check if the handle is valid */
  if (hAudioIn == NULL)
  {
    return LHS_E_AUDIOIN_NULLPOINTER;
  }

  cSamples = 0;

  while (1)
  {
    /* wait until we have enough samples */
    if (*u32NbrOfSamples <= gAudioInInfo.u32SamplesAvailable)
    {
      /* lock the code to prevent dual access to some variables */
      pthread_mutex_lock(&gAudioMutex);

      /* TO DO: consider copying in chunks (like in AquisitionThread)
         rather than 1 sample at a time. */

      /* copy all samples into the input buffer */
      while ((cSamples < *u32NbrOfSamples))
      {
        ((audioinSample *)pAudioBuffer)[cSamples++] = gSamplesBufferCircularFifo[gReadIndexPointer++];

        /* adapt the parameters */
        gAudioInInfo.u32SamplesAvailable -= 1;

        /* adapt circular buffer */
        if (gReadIndexPointer >= SAMPLES_BUFFER_SIZE)
        {
          gReadIndexPointer = 0;
        }

        /* enough samples */
        if (cSamples == *u32NbrOfSamples)
        {
          /* return the audioin info structure */
          memcpy(pgAudioInInfo, &gAudioInInfo, sizeof(AUDIOIN_INFO));
          pthread_mutex_unlock(&gAudioMutex);
          return LHS_AUDIOIN_OK;
        }
      }
    }
    else
    {
      /* relinquish CPU.  select() is more reliable than usleep(). */
      timer.tv_sec = 0;
      timer.tv_usec = 10000;
      select(0, NULL, NULL, NULL, &timer);
    }
  } /* while (1) */
}

/**************************************************************
 * lhs_audioinGetVersion                                       *
 *                                                             *
 * notes : not implemented                                     *
 **************************************************************/

LHS_AUDIOIN_ERROR lhs_audioinGetVersion(unsigned long *pu32Version)
{
  return LHS_E_AUDIOIN_NOTIMPLEMENTED;
}


/**************************************************************
 * lhs_audioinGetVolume/lhs_audioinSetVolume                   *
 *                                                             *
 * notes : not implemented                                     *
 **************************************************************/

LHS_AUDIOIN_ERROR lhs_audioinGetVolume(AUDIOIN_H hAudioIn, unsigned long *pu32Volume)
{
  *pu32Volume = gRecordingVolume;
  return LHS_AUDIOIN_OK;
}

LHS_AUDIOIN_ERROR lhs_audioinSetVolume(AUDIOIN_H hAudioIn, unsigned long u32Volume)
{
  gRecordingVolume = u32Volume;
  return LHS_E_AUDIOIN_NOTIMPLEMENTED;
}

/**************************************************************
 * lhs_audioinErrorGetString                                   *
 *                                                             *
 * notes : not implemented                                     *
 **************************************************************/

const char *lhs_audioinErrorGetString(const LHS_AUDIOIN_ERROR Error)
{
  return ("unknown error");
}


#else
/******************************************************************************/
/* STUB FUNCTIONS FOR SIMULATOR BUILD (DOES NOT SUPPORT THREADS)              */
/* This code is enabled if both ANDROID and __ARM_ARCH_5__ are defined.       */
/******************************************************************************/

#include "audioin.h"

LHS_AUDIOIN_ERROR  lhs_audioinOpenEx (
    unsigned long u32AudioInID,         /*@parm [in]  Audio-in device ID (ranges from 0 to a number of available
                                          devices on the system). You can also use the following flag
                                          instead of a device identifier.
                                          <nl><nl><bold WAVE_MAPPER> = The function selects a
                                          waveform-audio input device capable of recording in the
                                          specified format. <bold Header:> Declared in Mmsystem.h from
                                          the Windows Multimedia: Platform SDK.*/
    unsigned long u32Frequency,         /*@parm [in]  Frequency of the recognition engine in Hz. */
    unsigned long u32NbrOfFrames,       /*@parm [in]  Number of frames buffered internally. */
    unsigned long u32SamplesPerFrame,   /*@parm [in]  Size, in samples, of each individual frame. */
    AUDIOIN_H * phAudioIn               /*@parm [out] Handle to the audio-in device */
    )
{
  return LHS_E_AUDIOIN_NOTIMPLEMENTED;
}

LHS_AUDIOIN_ERROR  lhs_audioinOpen (
    unsigned long u32AudioInID,         /*@parm [in]  Audio-in device ID (ranges from 0 to a number of available
                                          devices on the system). You can also use the following flag
                                          instead of a device identifier.
                                          <nl><nl><bold WAVE_MAPPER> = The function selects a
                                          waveform-audio input device capable of recording in the
                                          specified format. <bold Header:> Declared in Mmsystem.h from
                                          the Windows Multimedia: Platform SDK.*/
    unsigned long u32Frequency,         /*@parm [in]  Frequency of the recognition engine in Hz. */
    AUDIOIN_H * phAudioIn               /*@parm [out] Handle to the audio-in device */
    )
{
  return LHS_E_AUDIOIN_NOTIMPLEMENTED;
}

#ifdef AUDIOIN_SUPPORT_CALLBACK
LHS_AUDIOIN_ERROR lhs_audioinOpenCallback(unsigned long u32AudioInID, unsigned long u32Frequency, unsigned long u32NbrOfSamples, pCallbackFunc pCallback, void* pCallbackInstance, AUDIOIN_H * phAudioIn)
{
  return LHS_E_AUDIOIN_NOTIMPLEMENTED;
}
#endif

LHS_AUDIOIN_ERROR lhs_audioinClose(AUDIOIN_H *phAudioIn)
{
  return LHS_E_AUDIOIN_NOTIMPLEMENTED;
}

LHS_AUDIOIN_ERROR lhs_audioinStart(AUDIOIN_H hAudioIn)
{
  return LHS_E_AUDIOIN_NOTIMPLEMENTED;
}

LHS_AUDIOIN_ERROR lhs_audioinStop(AUDIOIN_H hAudioIn)
{
  return LHS_E_AUDIOIN_NOTIMPLEMENTED;
}

LHS_AUDIOIN_ERROR lhs_audioinGetSamples(AUDIOIN_H hAudioIn, unsigned long * u32NbrOfSamples, void * pAudioBuffer, AUDIOIN_INFO * pgAudioInInfo)
{
  return LHS_E_AUDIOIN_NOTIMPLEMENTED;
}

LHS_AUDIOIN_ERROR lhs_audioinGetVersion(unsigned long *pu32Version)
{
  return LHS_E_AUDIOIN_NOTIMPLEMENTED;
}

LHS_AUDIOIN_ERROR lhs_audioinGetVolume(AUDIOIN_H hAudioIn, unsigned long *pu32Volume)
{
  return LHS_E_AUDIOIN_NOTIMPLEMENTED;
}

LHS_AUDIOIN_ERROR lhs_audioinSetVolume(AUDIOIN_H hAudioIn, unsigned long u32Volume)
{
  return LHS_E_AUDIOIN_NOTIMPLEMENTED;
}

const char *lhs_audioinErrorGetString(const LHS_AUDIOIN_ERROR Error)
{
  return "LHS_E_AUDIOIN_NOTIMPLEMENTED";
}

#endif