AudioTypes.h

#pragma once
 
#include "AudioConfig.h"
#ifdef USE_TYPETRAITS
#  include <type_traits>
#endif
#include "AudioTools/AudioLogger.h"
#include "AudioBasic/Collections/Vector.h"
 
// fix compile error for ESP32 C3
#undef HZ
 
// MIN
#undef MIN
#define MIN(A, B) ((A) < (B) ? (A) : (B))
 
 
namespace audio_tools {
 
using sample_rate_t = uint32_t;
 
enum RxTxMode  {UNDEFINED_MODE=0, TX_MODE=1, RX_MODE=2, RXTX_MODE=3 };
 
enum MemoryType {RAM, PS_RAM, FLASH_RAM};
 
static const char* RxTxModeNames[]={"UNDEFINED_MODE","TX_MODE","RX_MODE","RXTX_MODE" };
enum TimeUnit {MS, US, HZ};
static const char* TimeUnitStr[] {"MS","US","HZ"};
 
struct AudioInfo {
 
    sample_rate_t sample_rate = DEFAULT_SAMPLE_RATE;    
    uint16_t channels = DEFAULT_CHANNELS;  
    uint8_t bits_per_sample = DEFAULT_BITS_PER_SAMPLE; 
 
    AudioInfo() = default;
 
    AudioInfo(sample_rate_t sampleRate, uint16_t channelCount, uint8_t bitsPerSample) {
        sample_rate = sampleRate;
        channels = channelCount;
        bits_per_sample = bitsPerSample;
    };
 
    AudioInfo(const AudioInfo &) = default;
    
    bool operator==(AudioInfo alt){
        return sample_rate==alt.sample_rate && channels == alt.channels && bits_per_sample == alt.bits_per_sample;
    }
 
    bool operator!=(AudioInfo alt){
        return !(*this == alt);
    } 
 
    bool equals(AudioInfo alt){
        return *this == alt;
    }
 
    bool equalsExSampleRate(AudioInfo alt){
        return channels == alt.channels && bits_per_sample == alt.bits_per_sample;
    }
 
    void set(AudioInfo info)  {
      sample_rate = info.sample_rate;
      channels = info.channels;
      bits_per_sample = info.bits_per_sample;
    }
 
    void setAudioInfo(AudioInfo info)  {
        set(info);
    }
 
    void copyFrom(AudioInfo info){
      setAudioInfo(info);
    }
 
    AudioInfo& operator= (const AudioInfo& info){
      setAudioInfo(info);
      return *this;      
    }
 
    operator bool() {
      return sample_rate > 0 && channels > 0 && bits_per_sample > 0;
    }
 
    virtual void clear(){
      sample_rate = 0;
      channels = 0;
      bits_per_sample = 0;
    }
 
    virtual void logInfo(const char* source="") {
        LOGI("%s sample_rate: %d / channels: %d / bits_per_sample: %d",source, (int) sample_rate, (int)channels, (int)bits_per_sample);
    }  
 
};
 
class AudioInfoSupport {
    public:
      virtual void setAudioInfo(AudioInfo info) = 0;
      virtual AudioInfo audioInfo() = 0;
      virtual AudioInfo audioInfoOut() { return audioInfo();}
};
// Support legacy name
using AudioBaseInfo = AudioInfo;
using AudioBaseInfoDependent = AudioInfoSupport;
using AudioInfoDependent = AudioInfoSupport;
 
 
class AudioInfoSource {
    public:
      virtual void addNotifyAudioChange(AudioInfoSupport &bi) {
        if (!notify_vector.contains(&bi)) notify_vector.push_back(&bi);
      }
 
      virtual bool removeNotifyAudioChange(AudioInfoSupport &bi){
        int pos = notify_vector.indexOf(&bi);
        if (pos<0) return false;
        notify_vector.erase(pos);
        return true;
      }
 
      virtual void clearNotifyAudioChange() {
        notify_vector.clear();
      }
 
#if USE_OBSOLETE
      virtual void setNotifyAudioChange(AudioInfoSupport &bi) { 
        addNotifyAudioChange(bi);
      }
#endif
 
      void setNotifyActive(bool flag){
        is_notify_active = flag;
      }
 
      bool isNotifyActive(){
        return is_notify_active;
      }
 
    protected:
      Vector<AudioInfoSupport*> notify_vector;
      bool is_notify_active = true;
 
      void notifyAudioChange(AudioInfo info){
        if (isNotifyActive()){
          for(auto n : notify_vector){
              n->setAudioInfo(info);
          }
        }
      }
 
};
 
class VolumeSupport {
  public:
    virtual float volume() { return volume_value; }
    virtual bool setVolume(float volume) { 
      volume_value = volume; 
      return true; 
    }
  protected:
    float volume_value = 1.0f;
};
 
class AudioWriter : public AudioInfoSupport {
    public: 
        virtual size_t write(const void *in_ptr, size_t in_size) = 0;
        virtual void setAudioInfo(AudioInfo from) = 0;
        virtual void setOutput(Print &out_stream) = 0;
        virtual operator bool() = 0;
        virtual bool begin() = 0;
        virtual bool begin(AudioInfo info) {
            setAudioInfo(info);
            return begin();
        }
        virtual void end() = 0;
    protected:
        void writeBlocking(Print *out, uint8_t* data, size_t len){
            TRACED();
            int open = len;
            int written = 0;
            while(open>0){
                int result = out->write(data+written, open);
                open -= result;
                written += result;
            }
        }
};
 
class AudioTime {
    public:
        static uint32_t toTimeUs(uint32_t samplingRate, uint8_t limit=10){
            uint32_t result = 1000000l / samplingRate;
            if (1000000l % samplingRate!=0){
                result++;
            }
            if (result <= limit){
                LOGW("Time for samplingRate %u -> %u is < %u μs - we rounded up", (unsigned int)samplingRate,  (unsigned int)result,  (unsigned int)limit);
                result = limit;
            }
            return result;
        }
 
        static uint32_t toBytes(uint32_t millis, AudioInfo info){
            size_t samples = info.sample_rate * millis / 1000;
            size_t bytes = samples * info.channels * info.bits_per_sample / 8;
            return bytes;
        }
 
        static uint32_t toTimeMs(uint32_t samplingRate, uint8_t limit=1){
            uint32_t result = 1000l / samplingRate;
            if (1000000l % samplingRate!=0){
                result++;
            }
            if (result <= limit){
                LOGW("Time for samplingRate %u -> %u is < %u μs - we rounded up", (unsigned int)samplingRate,  (unsigned int)result,  (unsigned int)limit);
                result = limit;
            }
            return result;
        }
 
        static float toRateUs(uint32_t time_us){
            return 1000000.0 / time_us;
        }
        
        static float toRateMs(uint32_t time_ms){
            return 1000.0 / time_ms;
        }
};
 
class NumberConverter {
    public:
        static int32_t convertFrom24To32(int24_t value)  {
            return value.scale32();
        }
 
        static int16_t convertFrom24To16(int24_t value)  {
            return value.scale16();
        }
 
        static float convertFrom24ToFloat(int24_t value)  {
            return value.scaleFloat();
        }
 
        static int16_t convertFrom32To16(int32_t value)  {
            return static_cast<float>(value) / INT32_MAX * INT16_MAX;
        }
 
        static int16_t convert16(int value, int value_bits_per_sample){
            return value * NumberConverter::maxValue(16) / NumberConverter::maxValue(value_bits_per_sample);
        }
 
        static int16_t convert8(int value, int value_bits_per_sample){
            return value * NumberConverter::maxValue(8) / NumberConverter::maxValue(value_bits_per_sample);
        }
 
        static int64_t maxValue(int value_bits_per_sample){
            switch(value_bits_per_sample){
                case 8:
                    return 127;
                case 16:
                    return 32767;
                case 24:
                    return 8388607;
                case 32:
                    return 2147483647;
            }
            return 32767;
        }
 
        template <typename T> 
        static int64_t maxValueT(){
#ifdef USE_TYPETRAITS
            // int24_t uses 4 bytes instead of 3!
            return (std::is_same<T, int24_t>::value ) ? 8388607 : maxValue(sizeof(T)*8);
#else 
            return maxValue(sizeof(T)*8);
#endif
        }
 
        template <typename T> 
        static T clip(int64_t value){
            T mv = maxValue(sizeof(T)*8);
            if (value > mv){
                return mv;
            } else if (value < -mv){
                return -mv;
            } 
            return value;
        }
 
        template <typename FromT, typename ToT> 
        static ToT convert(FromT value){
            int64_t value1 = value;
            return clip<ToT>(value1 * maxValueT<ToT>() / maxValueT<FromT>());
        }
 
        template <typename FromT, typename ToT> 
        static void convertArray(FromT* from, ToT*to, int samples, float vol=1.0f){
            float  factor = static_cast<float>(maxValueT<ToT>()) / maxValueT<FromT>();
            float vol_factor = factor * vol;
            for (int j=0;j<samples;j++){
              to[j] = clip<ToT>(vol_factor * from[j]);
            }
        }
 
};
 
#if defined(USE_I2S) 
 
enum I2SFormat {
  I2S_STD_FORMAT,
  I2S_LSB_FORMAT,
  I2S_MSB_FORMAT,
  I2S_PHILIPS_FORMAT,
  I2S_RIGHT_JUSTIFIED_FORMAT,
  I2S_LEFT_JUSTIFIED_FORMAT,
  I2S_PCM,
};
 
static const char* i2s_formats[] = {"I2S_STD_FORMAT","I2S_LSB_FORMAT","I2S_MSB_FORMAT","I2S_PHILIPS_FORMAT","I2S_RIGHT_JUSTIFIED_FORMAT","I2S_LEFT_JUSTIFIED_FORMAT","I2S_PCM"};
 
enum I2SSignalType {
  Digital,
  Analog,
  PDM,
  TDM,
};
 
static const char* i2s_signal_types[] = {"Digital","Analog","PDM","TDM"};
 
#endif
 
template<typename T>
T readSample(Stream* p_stream){
  T result=0;
  uint8_t *p_result = (uint8_t*) &result;
  int open = sizeof(T);
  int total = 0;
  // copy missing data
  while (open>0){
    int read = p_stream->readBytes(p_result+total, open);
    open -= read;
    total += read;
  }
  return result;
}
 
template<typename T>
size_t readSamples(Stream* p_stream, T* data, int samples, int retryCount=-1){
  uint8_t *p_result = (uint8_t*) data;
  int open = samples*sizeof(T);
  int total = 0;
  int count0 = 0;
  // copy missing data - we abort after 5 x read returned 0 bytes
  while (open > 0){
    int read = p_stream->readBytes(p_result+total, open);
    open -= read;
    total += read;
    if (read == 0){
      count0++;
      delay(1);
    } else {
      count0 = 0;
    }
    // abort loop
    if (retryCount >= 0 && count0 > retryCount)
      break;
  }
  // convert bytes to samples
  return total / sizeof(T);
}
 
template<typename T>
size_t  writeSamples(Print* p_out, T* data, int samples, int maxSamples=512){
  uint8_t *p_result = (uint8_t*) data;
  int open = samples*sizeof(T);
  int total = 0;
  // copy missing data
  while (open>0){
    int to_write = min(open, static_cast<int>(maxSamples*sizeof(T)));
    int written = p_out->write(p_result+total, to_write );
    open -= written;
    total += written;
  }
  // convert bytes to samples
  return total / sizeof(T);
}
 
 
inline float mapFloat(float x, float in_min, float in_max, float out_min, float out_max) {
  return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}
 
static const char* mime_pcm = "audio/pcm";
 
 
#ifndef IS_DESKTOP
inline void waitFor(HardwareSerial &out){
    while(!out);
}
#endif
 
inline void waitFor(bool &flag){
    while(!flag);
}
 
using Pins = Vector<int>;
 
 
}