AsyncAudioGenerator.h

Go to the documentation of this file.

 
#ifndef ASYNC_AUDIO_GENERATOR_INCLUDED
#define ASYNC_AUDIO_GENERATOR_INCLUDED
 
 
/****************************************************************************
 *
 * System Includes
 *
 ****************************************************************************/
 
#include <cmath>
#include <cassert>
#include <iostream>
 
 
/****************************************************************************
 *
 * Project Includes
 *
 ****************************************************************************/
 
#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 AudioGenerator : public Async::AudioSource
{
  public:
    typedef enum {
      SIN,      
      SQUARE,   
      TRIANGLE  
    } Waveform;
 
    explicit AudioGenerator(Waveform wf=SIN)
      : m_arg(0.0f), m_arginc(0.0f), m_peak(0.0f),
        m_sample_rate(INTERNAL_SAMPLE_RATE), m_waveform(wf), m_power(0.0f),
        m_enabled(false)
    {
    }
 
    ~AudioGenerator(void)
    {
      enable(false);
    }
 
    void setWaveform(Waveform wf)
    {
      m_waveform = wf;
      calcLevel();
    }
 
    void setFq(float tone_fq)
    {
      m_arginc = 2.0f * M_PI * tone_fq / m_sample_rate;
      assert(m_arginc <= M_PI);
    }
 
    void setPower(float pwr_db)
    {
      m_power = powf(10.0f, pwr_db / 10.0f) / 2.0f;
      calcLevel();
    }
 
    void enable(bool enable)
    {
      m_enabled = enable;
      if (enable)
      {
        m_arg = 0.0f;
        writeSamples();
      }
      else
      {
        sinkFlushSamples();
      }
    }
 
    void resumeOutput(void)
    {
      if (m_enabled)
      {
        writeSamples();
      }
    }
 
    void allSamplesFlushed(void)
    {
    }
 
  private:
    static const int BLOCK_SIZE = 128;
 
    float     m_arg;
    float     m_arginc;
    float     m_peak;
    int       m_sample_rate;
    Waveform  m_waveform;
    float     m_power;
    bool      m_enabled;
 
    AudioGenerator(const AudioGenerator&);
    AudioGenerator& operator=(const AudioGenerator&);
 
    void calcLevel(void)
    {
      switch (m_waveform)
      {
        case SIN:
          m_peak = sqrt(2.0f * m_power);
          break;
        case SQUARE:
          m_peak = sqrt(m_power);
          break;
        case TRIANGLE:
          m_peak = sqrt(3.0f * m_power);
          break;
        default:
          m_peak = 0.0f;
          break;
      }
    }
 
    void writeSamples(void)
    {
      int written = 0;
      do
      {
        float buf[BLOCK_SIZE];
        float arg = m_arg;
        for (int i=0; i<BLOCK_SIZE; ++i)
        {
          switch (m_waveform)
          {
            case SIN:
              buf[i] = m_peak * sinf(arg);
              break;
            case SQUARE:
              buf[i] = (arg < M_PI) ? m_peak : -m_peak;
              break;
            case TRIANGLE:
              if (arg < M_PI / 2.0f)
              {
                buf[i] = m_peak * arg * 2.0f / M_PI;
              }
              else if (arg < M_PI)
              {
                buf[i] = m_peak * (2.0f - 2.0 * arg / M_PI);
              }
              else if (arg < 3.0f * M_PI / 2.0f)
              {
                buf[i] = -m_peak * (2.0f * arg / M_PI - 2.0f);
              }
              else
              {
                buf[i] = -m_peak * (4.0f - 2.0f * arg / M_PI);
              }
              break;
            default:
              buf[i] = 0;
              break;
          }
          arg += m_arginc;
          if (arg >= 2.0f * M_PI)
          {
            arg -= 2.0f * M_PI;
          }
        }
        written = sinkWriteSamples(buf, BLOCK_SIZE);
        if (written > 0)
        {
          m_arg += written * m_arginc;
          while (m_arg >= 2.0f * M_PI)
          {
            m_arg -= 2.0f * M_PI;
          }
        }
      } while (m_enabled && (written > 0));
    }
};  /* class AudioGenerator */
 
 
} /* namespace */
 
#endif /* ASYNC_AUDIO_GENERATOR_INCLUDED */
 
/*
 * This file has not been truncated
 */