AsyncAudioDevice.h

Go to the documentation of this file.

 
#ifndef ASYNC_AUDIO_DEVICE_INCLUDED
#define ASYNC_AUDIO_DEVICE_INCLUDED
 
 
/****************************************************************************
 *
 * System Includes
 *
 ****************************************************************************/
 
#include <sigc++/sigc++.h>
#include <stdint.h>
 
#include <string>
#include <map>
#include <list>
 
 
/****************************************************************************
 *
 * Project Includes
 *
 ****************************************************************************/
 
#include <AsyncTimer.h>
 
 
/****************************************************************************
 *
 * Local Includes
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Forward declarations
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Namespace
 *
 ****************************************************************************/
 
namespace Async
{
 
 
/****************************************************************************
 *
 * Forward declarations of classes inside of the declared namespace
 *
 ****************************************************************************/
 
class AudioIO;
class FdWatch;
 
 
/****************************************************************************
 *
 * Defines & typedefs
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Exported Global Variables
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Class definitions
 *
 ****************************************************************************/
 
class AudioDevice : public sigc::trackable
{
  public:
    typedef enum
    {
      MODE_NONE,  
      MODE_RD,    
      MODE_WR,    
      MODE_RDWR   
    } Mode;
  
    static AudioDevice *registerAudioIO(const std::string& dev_designator,
            AudioIO *audio_io);
    
    static void unregisterAudioIO(AudioIO *audio_io);
    
    static void setSampleRate(int rate) { sample_rate = rate; }
    
    static void setBlocksize(size_t size)
    {
      block_size_hint = size;
    }
    
    virtual size_t readBlocksize(void) = 0;
 
    virtual size_t writeBlocksize(void) = 0;
    
    static void setBlockCount(size_t count)
    {
      block_count_hint = (count <= 0) ? 0 : count;
    }
    
    static void setChannels(size_t channels)
    {
      AudioDevice::channels = channels;
    }
 
    static size_t getChannels(void) { return channels; }
 
    virtual bool isFullDuplexCapable(void) = 0;
    
    bool open(Mode mode);
    
    void close(void);
    
    Mode mode(void) const { return current_mode; }
    
    virtual void audioToWriteAvailable(void) = 0;
 
    /*
     * @brief   Tell the audio device to flush its buffers
     */
    virtual void flushSamples(void) = 0;
    
    virtual int samplesToWrite(void) const = 0;
    
    int sampleRate(void) const { return sample_rate; }
 
    const std::string& devName(void) const { return dev_name; }
    
    
  protected:
    static int          sample_rate;
    static size_t       block_size_hint;
    static size_t       block_count_hint;
    static size_t       channels;
 
    std::string         dev_name;
    
    explicit AudioDevice(const std::string& dev_name);
  
    virtual ~AudioDevice(void);
    
    virtual bool openDevice(Mode mode) = 0;
 
    virtual void closeDevice(void) = 0;
 
    void putBlocks(int16_t *buf, size_t frame_cnt);
 
    size_t getBlocks(int16_t *buf, size_t block_cnt);
 
    void setDeviceError(void);
 
  private:
    static const int    DEFAULT_SAMPLE_RATE = INTERNAL_SAMPLE_RATE;
    static const size_t DEFAULT_CHANNELS = 2;
    static const size_t DEFAULT_BLOCK_COUNT_HINT = 4;
    static const size_t DEFAULT_BLOCK_SIZE_HINT = 256; // Samples/channel/block
 
    static std::map<std::string, AudioDevice*>  devices;
 
    Mode                current_mode;
    size_t              use_count;
    std::list<AudioIO*> aios;
    Async::Timer        reopen_timer  {1000, Async::Timer::TYPE_PERIODIC};
 
    void reopenDevice(void);
 
};  /* class AudioDevice */
 
 
} /* namespace */
 
#endif /* ASYNC_AUDIO_DEVICE_INCLUDED */
 
 
 
/*
 * This file has not been truncated
 */