AnalogAudioStream.h

Go to the documentation of this file.

#pragma once
#include <algorithm>
#include "AudioToolsConfig.h"
 
// Support AnalogAudioStream
#if defined(USE_ANALOG) 
#  include "AnalogDriverBase.h"
#  include "AnalogDriverESP32.h"
#  include "AnalogDriverESP32V1.h"
#  include "AnalogDriverMBED.h"
#  include "AnalogDriverZephyr.h"
#  include "AnalogDriverArduino.h"
 
namespace audio_tools {
 
class AnalogAudioStream  : public AudioStream {
  public:
    AnalogAudioStream()=default;
    AnalogAudioStream(AnalogDriverBase &driver) { p_driver = &driver;};
 
    virtual ~AnalogAudioStream() {
      end();
    }
 
    AnalogConfig defaultConfig(RxTxMode mode=TX_MODE) {
        TRACED();
        AnalogConfig config(mode);
        return config;
    }
 
    virtual void setAudioInfo(AudioInfo info) {
        TRACEI();
        if (adc_config.sample_rate != info.sample_rate
            || adc_config.channels != info.channels
            || adc_config.bits_per_sample != info.bits_per_sample) {
            adc_config.sample_rate = info.sample_rate;
            adc_config.bits_per_sample = info.bits_per_sample;
            adc_config.channels = info.channels;
            adc_config.logInfo();
            end();
            begin(adc_config);        
        }
    }
 
    bool begin() override {
      return begin(adc_config);
    }
 
    bool begin(AnalogConfig cfg) {
      TRACEI();
      return p_driver->begin(cfg);
    }
 
    void end() override {
      TRACEI();
      p_driver->end();
    }
 
    AnalogConfig &config() {
      return adc_config;
    }
 
    size_t write(const uint8_t *data, size_t len) override {
      TRACED();
      const size_t max_write_size = 1024;
      size_t open = len;
      size_t written = 0;
      while (open > 0) {
        size_t to_write = std::min(open, max_write_size);
        size_t result = p_driver->write(data + written, to_write);
        written += result;
        open -= result;
        if (result < to_write) break;
      }
      return written;
    }
 
    size_t readBytes(uint8_t *data, size_t len) override {
        return p_driver->readBytes(data, len);
    }
 
    int available() override {
        return p_driver->available();
    }
 
    int availableForWrite() override {
        return p_driver->availableForWrite();
    }
 
    AnalogDriverBase* driver() {
        return p_driver;
    }
 
protected:
    AnalogDriver analog_driver;
    AnalogDriverBase *p_driver = &analog_driver;
    AnalogConfig adc_config;
};
 
}
 
#endif
 
// Support AnalogAudioArduino
#if defined(USE_TIMER) && defined(ARDUINO)
#  include "AnalogAudioArduino.h"
#endif