AsyncAudioStreamStateDetector.h

Go to the documentation of this file.

 
 
#ifndef ASYNC_AUDIO_STREAM_STATE_DETECTOR_INCLUDED
#define ASYNC_AUDIO_STREAM_STATE_DETECTOR_INCLUDED
 
 
/****************************************************************************
 *
 * System Includes
 *
 ****************************************************************************/
 
#include <sigc++/sigc++.h>
 
 
/****************************************************************************
 *
 * Project Includes
 *
 ****************************************************************************/
 
#include <AsyncAudioPassthrough.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 AudioStreamStateDetector
  : public AudioPassthrough, virtual public sigc::trackable
{
  public:
    enum class State
    {
      IDLE,     
      ACTIVE,   
      FLUSHING  
    };

    AudioStreamStateDetector(void) {}

    virtual ~AudioStreamStateDetector(void) override {}

    virtual int writeSamples(const float *samples, int count) override
    {
      setState(State::ACTIVE);
      return AudioPassthrough::writeSamples(samples, count);
    }

    virtual void flushSamples(void) override
    {
      setState(State::FLUSHING);
      AudioPassthrough::flushSamples();
    }

    virtual void allSamplesFlushed(void) override
    {
      setState(State::IDLE);
      AudioPassthrough::allSamplesFlushed();
    }

    bool isIdle(void) const { return (m_state == State::IDLE); }

    bool isActive(void) const { return (m_state == State::ACTIVE); }

    bool isFlushing(void) const { return (m_state == State::FLUSHING); }

    State state(void) const { return m_state; }

    sigc::signal<void(bool, bool)> sigStreamStateChanged;

    sigc::signal<void(bool)> sigStreamIsActive;

    sigc::signal<void(bool)> sigStreamIsIdle;
 
  private:
    AudioStreamStateDetector(const AudioStreamStateDetector&);
    AudioStreamStateDetector& operator=(const AudioStreamStateDetector&);
 
    struct StateMapValue
    {
      bool is_active;
      bool is_idle;
    };
    using StateMap = std::map<State, StateMapValue>;
 
    const StateMap STATE_MAP {
      {State::IDLE,     {false, true} },
      {State::ACTIVE,   {true, false} },
      {State::FLUSHING, {false, false}}
    };
    State m_state {State::IDLE};
 
    void setState(State new_state)
    {
      if (new_state == m_state)
      {
        return;
      }
 
      auto& old_mapping = STATE_MAP.at(m_state);
      auto& new_mapping = STATE_MAP.at(new_state);
      m_state = new_state;
 
      if (new_mapping.is_active != old_mapping.is_active)
      {
        sigStreamIsActive(new_mapping.is_active);
      }
 
      if (new_mapping.is_idle != old_mapping.is_idle)
      {
        sigStreamIsIdle(new_mapping.is_idle);
      }
 
      sigStreamStateChanged(new_mapping.is_active, new_mapping.is_idle);
    }
}; /* AudioStreamStateDetector */
 
 
} /* namespace */
 
#endif /* ASYNC_AUDIO_STREAM_STATE_DETECTOR_INCLUDED */
 
 
 
/*
 * This file has not been truncated
 */