soundgen.h

Go to the documentation of this file.

/*
  Created by Fabrizio Di Vittorio (fdivitto2013@gmail.com) - <http://www.fabgl.com>
  Copyright (c) 2019-2022 Fabrizio Di Vittorio.
  All rights reserved.
 
 
* Please contact fdivitto2013@gmail.com if you need a commercial license.
 
 
* This library and related software is available under GPL v3.
 
  FabGL is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
 
  FabGL is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
 
  You should have received a copy of the GNU General Public License
  along with FabGL.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 
#pragma once
 
 
#include <stdint.h>
#include <stddef.h>
 
#include "freertos/FreeRTOS.h"
 
#if __has_include("esp32/rom/lldesc.h")
  #include "esp32/rom/lldesc.h"
#else
  #include "rom/lldesc.h"
#endif
#include "soc/i2s_struct.h"
#include "soc/sens_struct.h"
 
#include "fabglconf.h"
#include "fabutils.h"
 
 
 
namespace fabgl {
 
 
#define FABGL_SOUNDGEN_DEFAULT_SAMPLE_RATE 16384
 
 
// DAC mode specific:
// setting 64 at 16KHz, generates 16000/64=250 interrupts per second
#define FABGL_SOUNDGEN_SAMPLE_BUFFER_SIZE 64
 
 
 
class WaveformGenerator {
public:
  WaveformGenerator() : next(nullptr), m_sampleRate(0), m_volume(100), m_enabled(false), m_duration(-1), m_autoDestroy(false), m_autoDetach(false) { }
 
  virtual ~WaveformGenerator() { }
 
  virtual void setFrequency(int value) = 0;
 
  void setDuration(uint32_t value) { m_duration = value; }
 
  uint32_t duration() { return m_duration; }
 
  void setAutoDetach(bool value) { m_autoDetach = value; }
 
  bool autoDetach() { return m_autoDetach; }
 
  void setAutoDestroy(bool value) { m_autoDestroy = value; m_autoDetach |= value; }
 
  bool autoDestroy() { return m_autoDestroy; }
 
  virtual int getSample() = 0;
 
  void setVolume(int value) { m_volume = value; }
 
  int volume() { return m_volume; }
 
  bool enabled() { return m_enabled; }
 
  void enable(bool value) { m_enabled = value; }
 
  void setSampleRate(int value) { m_sampleRate = value; }
 
  uint16_t sampleRate() { return m_sampleRate; }
 
  WaveformGenerator * next;
 
protected:
 
  void decDuration() { --m_duration; if (m_duration == 0) m_enabled = false; }
 
private:
  uint16_t m_sampleRate;
  int8_t   m_volume;
  int8_t   m_enabled;   // 0 = disabled, 1 = enabled
  uint32_t m_duration;  // number of samples to play (-1 = infinite)
  bool     m_autoDestroy; // if true: this object needs to be destroyed by the sound generator when there are no more samples to play
  bool     m_autoDetach;  // if true: this object needs to be autodetached from the sound generator when there are no more samples to play
};
 
 
class SineWaveformGenerator : public WaveformGenerator {
public:
  SineWaveformGenerator();
 
  void setFrequency(int value);
 
  int getSample();
 
private:
  uint32_t m_phaseInc;
  uint32_t m_phaseAcc;
  uint16_t m_frequency;
  int16_t  m_lastSample;
};
 
 
class SquareWaveformGenerator : public WaveformGenerator {
public:
  SquareWaveformGenerator();
 
  void setFrequency(int value);
 
  void setDutyCycle(int dutyCycle);
 
  int getSample();
 
private:
  uint32_t m_phaseInc;
  uint32_t m_phaseAcc;
  uint16_t m_frequency;
  int8_t   m_lastSample;
  uint8_t  m_dutyCycle;
};
 
 
class TriangleWaveformGenerator : public WaveformGenerator {
public:
  TriangleWaveformGenerator();
 
  void setFrequency(int value);
 
  int getSample();
 
private:
  uint32_t m_phaseInc;
  uint32_t m_phaseAcc;
  uint16_t m_frequency;
  int8_t   m_lastSample;
};
 
 
class SawtoothWaveformGenerator : public WaveformGenerator {
public:
  SawtoothWaveformGenerator();
 
  void setFrequency(int value);
 
  int getSample();
 
private:
  uint32_t m_phaseInc;
  uint32_t m_phaseAcc;
  uint16_t m_frequency;
  int8_t   m_lastSample;
};
 
 
class NoiseWaveformGenerator : public WaveformGenerator {
public:
  NoiseWaveformGenerator();
 
  void setFrequency(int value);
 
  int getSample();
 
private:
  uint16_t m_noise;
};
 
 
// "tries" to emulate VIC6561 noise generator
// derived from a reverse enginnered VHDL code: http://www.denial.shamani.dk/bb/viewtopic.php?t=8733&start=210
 
class VICNoiseGenerator : public WaveformGenerator {
public:
  VICNoiseGenerator();
 
  void setFrequency(int value);
  uint16_t frequency() { return m_frequency; }
 
  int getSample();
 
private:
  static const uint16_t LFSRINIT = 0x0202;
  static const int      CLK      = 4433618;
 
  uint16_t m_frequency;
  uint16_t m_counter;
  uint16_t m_LFSR;
  uint16_t m_outSR;
};
 
 
 
class SamplesGenerator : public WaveformGenerator {
public:
  SamplesGenerator(int8_t const * data, int length);
 
  void setFrequency(int value);
 
  int getSample();
 
private:
  int8_t const * m_data;
  int            m_length;
  int            m_index;
};
 
 
enum class SoundGenMethod {
  DAC,             
  SigmaDelta,      
  Auto,            
};
 
 
class SoundGenerator {
 
public:
 
  SoundGenerator(int sampleRate = FABGL_SOUNDGEN_DEFAULT_SAMPLE_RATE, gpio_num_t gpio = GPIO_AUTO, SoundGenMethod genMethod = SoundGenMethod::Auto);
 
  ~SoundGenerator();
 
  void clear();
 
  bool play(bool value);
 
  SamplesGenerator * playSamples(int8_t const * data, int length, int volume = 100, int durationMS = 0);
 
  template <typename T>
  void playSound(T const & waveform, int frequency, int durationMS, int volume = 100) {
    auto wf = new T(waveform);
    attach(wf);
    wf->setFrequency(frequency);
    wf->setVolume(volume);
    wf->setAutoDestroy(true);
    wf->setDuration(m_sampleRate / 1000 * durationMS);
    wf->enable(true);
    play(true);
  }
 
  bool playing() { return m_play; }
 
  WaveformGenerator * channels() { return m_channels; }
 
  void attach(WaveformGenerator * value);
 
  void detach(WaveformGenerator * value);
 
  void setVolume(int value) { m_volume = value; }
 
  int volume() { return m_volume; }
 
 
private:
 
  static void ISRHandler(void * arg);     // used in DAC mode
  static void timerHandler(void * args);  // used in sigma-delta mode
 
  void dac_init();
  void sigmadelta_init();
  void detachNoSuspend(WaveformGenerator * value);
  void setDMANode(int index, volatile uint16_t * buf, int len);
  void init();
  
  int getSample();
  
  #ifdef FABGL_EMULATED
  void sdl_init();
  static void SDLAudioCallback(void * data, Uint8 * buffer, int length);
  #endif
 
 
  WaveformGenerator * m_channels;
 
  uint16_t *          m_sampleBuffer[2];
 
  int8_t              m_volume;
 
  uint16_t            m_sampleRate;
 
  bool                m_play;
  
  gpio_num_t          m_gpio;
  
  intr_handle_t       m_isr_handle;
  
  lldesc_t volatile * m_DMAChain;
  
  SoundGenMethod      m_genMethod;
  
  bool                m_initDone;
  
  esp_timer_handle_t  m_timerHandle;
  
  #ifdef FABGL_EMULATED
  SDL_AudioDeviceID   m_device;
  #endif
 
};
 
 
 
 
} // end of namespace