AsyncAudioIO.h

Go to the documentation of this file.

#ifndef ASYNC_AUDIO_IO_INCLUDED
#define ASYNC_AUDIO_IO_INCLUDED


/****************************************************************************
 *
 * System Includes
 *
 ****************************************************************************/

#include <sigc++/signal_system.h>

#include <cstdio>
#include <string>


/****************************************************************************
 *
 * Project Includes
 *
 ****************************************************************************/

#include <AsyncFdWatch.h>
#include <AsyncTimer.h>


/****************************************************************************
 *
 * Local Includes
 *
 ****************************************************************************/



/****************************************************************************
 *
 * Forward declarations
 *
 ****************************************************************************/



/****************************************************************************
 *
 * Namespace
 *
 ****************************************************************************/

namespace Async
{

/****************************************************************************
 *
 * Forward declarations of classes inside of the declared namespace
 *
 ****************************************************************************/

class AudioDevice;
class SampleFifo;


/****************************************************************************
 *
 * Defines & typedefs
 *
 ****************************************************************************/


  
/****************************************************************************
 *
 * Exported Global Variables
 *
 ****************************************************************************/



/****************************************************************************
 *
 * Class definitions
 *
 ****************************************************************************/

class AudioIO : public SigC::Object
{
  public:
    typedef enum
    {
      MODE_NONE,  
      MODE_RD,    
      MODE_WR,    
      MODE_RDWR   
    } Mode;
  
    AudioIO(const std::string& dev_name);
    
    ~AudioIO(void);
  
    bool isFullDuplexCapable(void);
  
    bool open(Mode mode);
  
    void close(void);
  
    int write(short *buf, int count);
    
    int samplesToWrite(void) const;
    
    /*
     * @brief   Call this method to flush all samples in the buffer
     *
     * This method is used to flush all the samples that are in the buffer.
     * That is, all samples in the buffer will be written to the audio device
     * and when finished, emit the allSamplesFlushed signal.
     */
    void flushSamples(void);
    
    /*
     * @brief   Call this method to clear all samples in the buffer
     *
     * This method is used to clear all the samples that are in the buffer.
     * That is, all samples in the buffer will be thrown away. Remaining
     * samples that have already been written to the sound card will be
     * flushed and when finished, the allSamplesFlushed signal is emitted.
     */
    void clearSamples(void);
    
    /*
     * @brief   Check if the audio device is busy flushing samples
     * @return  Returns \em true if flushing the buffer or else \em false
     */
    bool isFlushing(void) const { return is_flushing; }
    
    /*
     * @brief   Find out the current IO mode
     * @return  Returns the current IO mode
     */
    Mode mode(void) const { return io_mode; }    
    
    SigC::Signal2<int, short *, int> audioRead;

    SigC::Signal1<void, bool> writeBufferFull;
    
    SigC::Signal0<void> allSamplesFlushed;

            
  protected:
    
  private:
    static const int  RATE = 8000;
    static const int  CHANNELS = 1;
    //static const int  SIZE = 16;
    //static const int  FRAG_COUNT = 32;    // 32 frags ~ one second
    //static const int  FRAG_SIZE_LOG2 = 8; // 256 bytes/frag
    static const int  BUF_FRAG_COUNT = 4;
        
    //int                     fd;
    Mode              io_mode;
    //Async::FdWatch *  read_watch;
    //Async::FdWatch *  write_watch;
    //char *                  read_buf;
    
    //int             file;
    //Mode                    old_mode;
    
    AudioDevice       *audio_dev;
    SampleFifo        *write_fifo;
    SigC::Connection  read_con;
    bool              do_flush;
    Async::Timer      *flush_timer;
    bool              is_flushing;
    int               lead_in_pos;

    void audioReadHandler(Async::FdWatch *watch);
    void flushSamplesInDevice(int extra_samples=0);
    void flushDone(Timer *timer);
    
      // Methods accessed by the Async::AudioDevice class
    friend class AudioDevice;
    AudioDevice *device(void) const { return audio_dev; }
    SampleFifo &writeFifo(void) const { return *write_fifo; }
    int readSamples(short *samples, int count);
    bool doFlush(void) const { return do_flush; }
    
};  /* class AudioIO */


} /* namespace */

#endif /* ASYNC_AUDIO_IO_INCLUDED */



/*
 * This file has not been truncated
 */

---