FrequencyDetectorZeroCrossing.h

Go to the documentation of this file.

#pragma once
 
#include "AudioTools/CoreAudio/AudioBasic/Collections/Vector.h"
#include "AudioTools/CoreAudio/AudioStreams.h"
 
namespace audio_tools {
 
class FrequencyDetectorZeroCrossing : public AudioStream {
 public:
  FrequencyDetectorZeroCrossing() = default;
 
  FrequencyDetectorZeroCrossing(Print& out) { p_out = &out; };
 
  FrequencyDetectorZeroCrossing(Stream& in) {
    p_out = ∈
    p_in = ∈
  };
 
  bool begin(AudioInfo info) {
    setAudioInfo(info);
    return AudioStream::begin();
  }
 
  int available() override {
    if (p_in) return p_in->available();
    return 0;
  }
 
  int availableForWrite() override {
    if (p_out) return p_out->availableForWrite();
    return DEFAULT_BUFFER_SIZE;
  }
 
  size_t readBytes(uint8_t* data, size_t len) override {
    size_t result = p_in->readBytes(data, len);
    switch (info.bits_per_sample) {
      case 16:
        detect<int16_t>((int16_t*)data, len / sizeof(int16_t));
        break;
      case 24:
        detect<int24_t>((int24_t*)data, len / sizeof(int24_t));
        break;
      case 32:
        detect<int32_t>((int32_t*)data, len / sizeof(int32_t));
        break;
    }
    return result;
  }
 
  virtual size_t write(const uint8_t* data, size_t len) override {
    switch (info.bits_per_sample) {
      case 16:
        detect<int16_t>((int16_t*)data, len / sizeof(int16_t));
        break;
      case 24:
        detect<int24_t>((int24_t*)data, len / sizeof(int24_t));
        break;
      case 32:
        detect<int32_t>((int32_t*)data, len / sizeof(int32_t));
        break;
    }
 
    size_t result = len;
    if (p_out != nullptr) result = p_out->write(data, len);
    return result;
  }
 
  float frequency(int channel) {
    if (channel >= info.channels) {
      LOGE("Invalid channel: %d", channel);
      return 0;
    }
    return states[channel].freq;
  }
 
  void setFrequencyCallback(void (*callback)(int channel, float freq)) {
    freq_callback = callback;
  }
 
 protected:
  struct ChannelState {
    int count = 0;        
    bool active = false;  
    float freq = 0.0f;    
  };
  Vector<ChannelState> states;       
  Print* p_out = nullptr;            
  Stream* p_in = nullptr;            
  int count = 0;                     
  bool active = false;               
  void (*freq_callback)(int channel, float freq); 
 
  template <class T>
  void detect(T* samples, size_t len) {
    states.resize(info.channels);
    for (int ch = 0; ch < info.channels; ch++) {
      detectChannel(ch, samples, len);
    }
  }
 
  template <class T>
  void detectChannel(int channel, T* samples, size_t len) {
    ChannelState& state = states[channel];
    for (int i = channel; i < (int)(len - info.channels); i += info.channels) {
      if (state.active) state.count++;
      // Detect upward zero crossing (negative to positive)
      if (samples[i] <= 0 && samples[i + info.channels] > 0) {
        if (state.count > 0) {
          state.freq = (1.0f * info.sample_rate) / state.count;
          if (freq_callback) freq_callback(channel, state.freq);
        }
        state.count = 0;
        state.active = true;
      }
    }
  }
};
 
}  // namespace audio_tools