AsyncAudioValve.h

Go to the documentation of this file.

 
#ifndef ASYNC_AUDIO_VALVE_INCLUDED
#define ASYNC_AUDIO_VALVE_INCLUDED
 
 
/****************************************************************************
 *
 * System Includes
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Project Includes
 *
 ****************************************************************************/
 
#include <AsyncAudioSink.h>
#include <AsyncAudioSource.h>
 
 
 
/****************************************************************************
 *
 * Local Includes
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Forward declarations
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Namespace
 *
 ****************************************************************************/
 
namespace Async
{
 
 
/****************************************************************************
 *
 * Forward declarations of classes inside of the declared namespace
 *
 ****************************************************************************/
 
  
 
/****************************************************************************
 *
 * Defines & typedefs
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Exported Global Variables
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Class definitions
 *
 ****************************************************************************/
 
class AudioValve : public Async::AudioSink, public Async::AudioSource
{
  public:
    explicit AudioValve(void)
      : block_when_closed(false), is_open(true),
        is_idle(true), is_flushing(false), input_stopped(false)
    {
    }
  
    ~AudioValve(void) {}
    
    void setOpen(bool do_open)
    {
      if (is_open == do_open)
      {
        return;
      }
      
      is_open = do_open;
      
      if (do_open)
      {
        if (input_stopped)
        {
          input_stopped = false;
          sourceResumeOutput();
        }
      }
      else
      {
        if (!is_idle && !is_flushing)
        {
          sinkFlushSamples();
        }
        if (!block_when_closed && input_stopped)
        {
          input_stopped = false;
          sourceResumeOutput();
        }
        if (is_flushing)
        {
          is_idle = true;
          is_flushing = false;
          sourceAllSamplesFlushed();
        }
      }
    }
 
    void setBlockWhenClosed(bool block_when_closed)
    {
      if (block_when_closed == this->block_when_closed)
      {
        return;
      }
      
      this->block_when_closed = block_when_closed;
      
      if (!block_when_closed && input_stopped)
      {
        input_stopped = false;
        sourceResumeOutput();
      }
    }
    
    bool isOpen(void) const
    {
      return is_open;
    }
    
    bool isIdle(void) const
    {
      return is_idle;
    }
  
    int writeSamples(const float *samples, int count)
    {
      int ret = 0;
      is_idle = false;
      is_flushing = false;
      if (is_open)
      {
        ret = sinkWriteSamples(samples, count);
      }
      else
      {
        ret = (block_when_closed ? 0 : count);
      }
      
      if (ret == 0)
      {
        input_stopped = true;
      }
      
      return ret;
    }
    
    void flushSamples(void)
    {
      if (is_open)
      {
        is_flushing = true;
        sinkFlushSamples();
      }
      else
      {
        is_flushing = false;
        is_idle = true;
        sourceAllSamplesFlushed();
      }
    }
    
    void resumeOutput(void)
    {
      if (is_open)
      {
        if (input_stopped)
        {
          input_stopped = false;
          sourceResumeOutput();
        }
      }
    }
    
    virtual void allSamplesFlushed(void)
    {
      bool was_flushing = is_flushing;
      is_flushing = false;
      is_idle = true;
      if (is_open && was_flushing)
      {
        sourceAllSamplesFlushed();
      }
    }
    
    
  protected:
    
  private:
    AudioValve(const AudioValve&);
    AudioValve& operator=(const AudioValve&);
    
    bool block_when_closed;
    bool is_open;
    bool is_idle;
    bool is_flushing;
    bool input_stopped;
    
};  /* class AudioValve */
 
 
} /* namespace */
 
#endif /* ASYNC_AUDIO_VALVE_INCLUDED */
 
 
 
/*
 * This file has not been truncated
 */