USBAudioStreamBase.h

Go to the documentation of this file.

#pragma once
 
// See USBAudioDeviceBase.h: some cores #define abs(x), which breaks <chrono>
// (pulled in by <mutex>/<functional> on some toolchains).
#pragma push_macro("abs")
#undef abs
 
#include <cstddef>
#include <cstdint>
#include <functional>
#include <vector>
 
#pragma pop_macro("abs")
 
#include "AudioLogger.h"
#include "AudioTools/CoreAudio/AudioTypes.h"
#include "AudioTools/CoreAudio/BaseStream.h"
#include "AudioTools/CoreAudio/Buffers.h"
#include "AudioTools/Communication/USB/USBAudioConfig.h"
#include "AudioTools/Communication/USB/USBAudioConstants.h"
 
namespace audio_tools {
 
class USBAudioStreamBase : public AudioStream, public VolumeSupport {
 public:
  inline bool isEpInEnabled() const { return config_.enable_ep_in; }
 
  inline bool isEpOutEnabled() const { return config_.enable_ep_out; }
 
  const USBAudioConfig& config() const { return config_; }
 
  // ── Volume / Mute API ───────────────────────────────────────────────────
 
  float volume() override { return volume(0); }
 
  bool setVolume(float volume) override { return setVolume(volume, 0); }
 
  float volume(uint8_t channel) {
    return (channel < volume_.size()) ? volume_[channel] : 0.0f;
  }
 
  bool setVolume(float vol, uint8_t channel) {
    LOGW("setVolume %f channel: %d", vol, channel);
    if (channel >= volume_.size()) return false;
    volume_[channel] = vol;
    if (volume_cb_) volume_cb_(vol, channel);
    onVolumeChanged(channel);
    return true;
  }
 
  bool isMute(uint8_t channel = 0) const {
    return (channel < mute_.size()) ? mute_[channel] : false;
  }
 
  bool setMute(bool m, uint8_t channel = 0) {
    LOGW("setMute %s channel: %d", m ? "true" : "false", channel);
    if (channel >= mute_.size()) return false;
    mute_[channel] = m;
    if (mute_cb_) mute_cb_(m, channel);
    onMuteChanged(channel);
    return true;
  }
 
  void setVolumeCallback(std::function<void(float, uint8_t)> cb) {
    volume_cb_ = std::move(cb);
  }
 
  void setMuteCallback(std::function<void(bool, uint8_t)> cb) {
    mute_cb_ = std::move(cb);
  }
 
  void setSampleRateCallback(std::function<void(uint32_t)> cb) {
    sample_rate_cb_ = std::move(cb);
  }
 
  void setStreamingStateCallback(std::function<void(bool, bool)> cb) {
    streaming_state_cb_ = std::move(cb);
  }
 
  bool isStreamingActive() const {
    return isStreamingActiveTx() || isStreamingActiveRx();
  }
 
  virtual bool isStreamingActiveTx() const = 0;
 
  virtual bool isStreamingActiveRx() const = 0;
 
  virtual bool mounted() = 0;
 
  size_t write(const uint8_t* data, size_t len) {
    if (!is_started_) return 0;
    serviceUSB();
 
    // disregard data if the TX stream has not been opened (alt=0)
    if (!isStreamingActiveTx()) return len;
 
    // update the volume
    if (config_.volume_active) processVolume((uint8_t*)data, len);
 
    // Write all data, retrying if the buffer is full.  On single-core
    // platforms (RP2040), serviceUSB() drains the buffer by running
    // the USB stack task → xfer_cb.  On dual-core (ESP32), the USB task
    // drains independently and the RTOS buffer blocks internally.
    size_t written = 0;
    while (written < len) {
      int n = bufferTx().writeArray(data + written, len - written);
      written += n;
      if (written < len) {
        serviceUSB();                       // drain buffer to make space
        if (!isStreamingActiveTx()) break;  // stream stopped
      }
    }
    return written;
  }
 
  size_t readBytes(uint8_t* buffer, size_t bufsize) {
    if (!is_started_) return 0;
    serviceUSB();
 
    if (!rx_primed_) {
      uint8_t start_fill = config_.rx_start_fill_percent > 100
                               ? 100
                               : config_.rx_start_fill_percent;
      if (start_fill > 0 && bufferRx().levelPercent() < start_fill) return 0;
      rx_primed_ = true;
    }
 
    // get the data from the buffer
    size_t ret = bufferRx().readArray(buffer, bufsize);
    // upate the volume
    if (config_.volume_active) processVolume(buffer, ret);
 
    return ret;
  }
 
  int available() override {
    if (!is_started_) return 0;
    return bufferRx().available();
  }
 
  int availableForWrite() override {
    if (!is_started_) return 0;
    return bufferTx().availableForWrite();
  }
 
  operator bool() override { return is_started_ && mounted(); }
 
  virtual BaseBuffer<uint8_t>& bufferTx() = 0;
 
  virtual BaseBuffer<uint8_t>& bufferRx() = 0;
 
  virtual void serviceUSB() = 0;
 
  virtual int getActualCore() const { return -1; }
 
 protected:
  bool is_started_ = false;
  // true while a dedicated FreeRTOS task is running the USB stack task
  bool usb_task_active_ = false;
  int core = -1;
  bool rx_primed_ = false;
  bool is_active_ = false;
 
  // ── Volume / mute state (sized to channels+1 in begin()) ─────────────────
  std::vector<float> volume_;
  std::vector<bool> mute_;
  std::function<void(float, uint8_t)> volume_cb_;
  std::function<void(bool, uint8_t)> mute_cb_;
  std::function<void(uint32_t)> sample_rate_cb_;
  std::function<void(bool, bool)> streaming_state_cb_;
  USBAudioConfig config_;
 
  virtual void onVolumeChanged(uint8_t /*channel*/) {}
 
  virtual void onMuteChanged(uint8_t /*channel*/) {}
 
  virtual bool beginUSB() = 0;
 
  virtual void resizeBuffers() = 0;
 
  void setConfig(const USBAudioConfig& cfg) { config_ = cfg; }
 
  bool configChanged(const USBAudioConfig& n) { return config_ != n; }
 
  void setupVolumeState() {
    const size_t vol_sz = (size_t)config_.channels + 1;
    volume_.assign(vol_sz, 1.0f);
    mute_.assign(vol_sz, false);
  }
 
  void processVolume(uint8_t* data, size_t len) {
    switch (config_.bits_per_sample) {
      case 8:
        processVolume<int8_t>((int8_t*)data, len);
        break;
      case 16:
        processVolume<int16_t>((int16_t*)data, len / 2);
        break;
      case 24:
        processVolume<int24_3bytes_t>((int24_3bytes_t*)data, len / 3);
        break;
      case 32:
        processVolume<int32_t>((int32_t*)data, len / 4);
        break;
      default:
        // Unsupported bit depth; do nothing.
        break;
    }
  }
 
  float getVolumeExt(uint8_t channel) const {
    if (volume_.empty()) return 1.0f;
    if (mute_[0]) return 0.0f;  // master mute
    float master = volume_[0];
    if (channel >= volume_.size()) return master;  // no per-channel entry
    if (mute_[channel]) return 0.0f;               // per-channel mute
    return master * volume_[channel];
  }
 
  template <typename T>
  void processVolume(T* data, size_t sample_count) {
    uint8_t ch_count = config_.channels;
    for (size_t i = 0; i < sample_count; i++) {
      uint8_t ch = (uint8_t)(i % ch_count) + 1;  // 1-based per-channel index
      float vol = getVolumeExt(ch);
      data[i] = (T)(data[i] * vol);
    }
  }
 
  static constexpr int16_t kVolumeMinDb256 = -25600;  // -100 dB in 1/256 dB
 
  static int16_t floatToUac2(float vol) {
    if (vol <= 0.0f) return (int16_t)0x8000;
    if (vol >= 1.0f) return 0;
    return (int16_t)((1.0f - vol) * kVolumeMinDb256);
  }
 
  static float uac2ToFloat(int16_t v) {
    if (v == (int16_t)0x8000) return 0.0f;
    if (v >= 0) return 1.0f;
    if (v <= kVolumeMinDb256) return 0.0f;
    return 1.0f - (float)v / (float)kVolumeMinDb256;
  }
 
  static bool isValidBitsPerSample(uint8_t bps) {
    return bps == 16 || bps == 24 || bps == 32;
  }
 
  void notifyStreamingState() {
    if (streaming_state_cb_)
      streaming_state_cb_(isStreamingActiveTx(), isStreamingActiveRx());
  }
};
 
}  // namespace audio_tools