MDFEchoCancellationStream.h

Go to the documentation of this file.

#pragma once
 
#include "AudioTools/CoreAudio/AudioStreams.h"
#include "AudioTools/CoreAudio/Buffers.h"
#include "MDFEchoCancellation.h"
 
namespace audio_tools {
 
template <typename T = int16_t, typename SampleType = MDFFloat>
class MDFEchoCancellationStream : public AudioStream {
 public:
  MDFEchoCancellationStream(Stream& in, int filterLength,
                            AudioFFTBase& fftDriver,
                            Allocator& alloc = DefaultAllocator)
      : p_io(&in),
        p_fft(&fftDriver),
        canceller(filterLength, fftDriver, alloc) {}
 
  MDFEchoCancellationStream(Stream& in, int filterLength, int nbMic,
                            int nbSpeakers, AudioFFTBase& fftDriver,
                            Allocator& alloc = DefaultAllocator)
      : p_io(&in),
        p_fft(&fftDriver),
        canceller(filterLength, nbMic, nbSpeakers, fftDriver, alloc) {}
 
  size_t write(const uint8_t* buf, size_t len) override {
    int frame_size = getFrameSize();
    size_t samples = len / sizeof(T);
    size_t frames = samples / (size_t)frame_size;
    const T* data = (const T*)buf;
    for (size_t f = 0; f < frames; f++) {
      canceller.playback(data + f * frame_size);
    }
    return frames * (size_t)frame_size * sizeof(T);
  }
 
  size_t readBytes(uint8_t* buf, size_t len) override {
    size_t read = p_io->readBytes(buf, len);
    size_t samples = read / sizeof(T);
    int frame_size = getFrameSize();
    size_t frames = samples / (size_t)frame_size;
    T* data = (T*)buf;
    for (size_t f = 0; f < frames; f++) {
      canceller.capture(data + f * frame_size, data + f * frame_size);
    }
    return frames * (size_t)frame_size * sizeof(T);
  }
 
  void setAudioInfo(AudioInfo info) override {
    AudioStream::setAudioInfo(info);
    canceller.setSamplingRate(info.sample_rate);
    canceller.setMicChannels(info.channels);
    canceller.setSpeakerChannels(info.channels);
  }
 
  void setFilterLen(int len) { canceller.setFilterLength(len); }
 
  int getFilterLen() { return canceller.getFilterLength(); }
 
  void reset() { canceller.reset(); }
 
  MDFEchoCancellation<T, SampleType>& getEchoCanceller() { return canceller; }
 
 protected:
  Stream* p_io = nullptr;
  AudioFFTBase* p_fft = nullptr;
  MDFEchoCancellation<T, SampleType> canceller;
 
  int getFrameSize() {
    if (p_fft) {
      return p_fft->config().length;
    }
    return 512;  // default fallback
  }
};
 
}  // namespace audio_tools