AsyncAudioIO.h

Go to the documentation of this file.

 
#ifndef ASYNC_AUDIO_IO_INCLUDED
#define ASYNC_AUDIO_IO_INCLUDED
 
 
/****************************************************************************
 *
 * System Includes
 *
 ****************************************************************************/
 
#include <cstdio>
#include <string>
 
 
/****************************************************************************
 *
 * Project Includes
 *
 ****************************************************************************/
 
#include <AsyncFdWatch.h>
#include <AsyncTimer.h>
#include <AsyncAudioSink.h>
#include <AsyncAudioSource.h>
 
 
/****************************************************************************
 *
 * Local Includes
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Forward declarations
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Namespace
 *
 ****************************************************************************/
 
namespace Async
{
 
/****************************************************************************
 *
 * Forward declarations of classes inside of the declared namespace
 *
 ****************************************************************************/
 
class AudioDevice;
class AudioValve;
class AudioFifo;
 
 
/****************************************************************************
 *
 * Defines & typedefs
 *
 ****************************************************************************/
 
 
  
/****************************************************************************
 *
 * Exported Global Variables
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Class definitions
 *
 ****************************************************************************/
 
class AudioIO : public Async::AudioSource, public Async::AudioSink
{
  public:
    typedef enum
    {
      MODE_NONE,  
      MODE_RD,    
      MODE_WR,    
      MODE_RDWR   
    } Mode;
  
    static void setSampleRate(int rate);
    
    static void setBlocksize(size_t size);
 
    size_t readBlocksize(void);
 
    size_t writeBlocksize(void);
    
    static void setBlockCount(size_t count);
    
    static void setChannels(size_t channels);
    
    AudioIO(const std::string& dev_name, size_t channel);
    
    ~AudioIO(void);
  
    bool isFullDuplexCapable(void);
  
    bool open(Mode mode);
  
    void close(void);
  
    //int samplesToWrite(void) const;
    
    /*
     * @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; }
    
    void setGain(float gain) { m_gain = gain; }
 
    float gain(void) const { return m_gain; }
    
    int sampleRate(void) const { return sample_rate; }
    
    size_t channel(void) const { return m_channel; }
    
    void resumeOutput(void) {}
    
    void allSamplesFlushed(void) {}
 
#if 0
    int writeSamples(const float *samples, int count);
    
    void flushSamples(void);
#endif
 
            
  protected:
    
  private:
    class InputFifo;
    class DelayedFlushAudioReader;
    
    Mode                    io_mode;
    AudioDevice             *audio_dev;
    float                   m_gain;
    int                     sample_rate;
    size_t                  m_channel;
    AudioValve              *input_valve;
    InputFifo               *input_fifo;
    DelayedFlushAudioReader *audio_reader;
 
      // Methods accessed by the Async::AudioDevice class
    friend class AudioDevice;
    AudioDevice *device(void) const { return audio_dev; }
    int readSamples(float *samples, int count);
    bool doFlush(void) const;
    bool isIdle(void) const;
    int audioRead(float *samples, int count);
    unsigned samplesAvailable(void);
 
};  /* class AudioIO */
 
 
} /* namespace */
 
#endif /* ASYNC_AUDIO_IO_INCLUDED */
 
 
/*
 * This file has not been truncated
 */