Binning of Samples / BaseConverter

[uutzinger]

I took the Decimate class in BaseConverter.h and modified it to write a Binning class.
Binning sums a number of samples instead of discarding samples.
The code for binning is shown in the second code segment in this message.

My question is how shall I implement a main program that is using a class from the BaseConverter.h and applies it to a stream.

The following code is not quite right:

#include "AudioTools.h"

AudioInfo info(44100, 2, 16);
SineWaveGenerator<int16_t> sineWave(32000);                // subclass of SoundGenerator with max amplitude of 32000
GeneratedSoundStream<int16_t> sound(sineWave);             // stream generated from sine wave
Bin binner(4, 2, true, 16);                                // configure binning with binsize, channels, enable averaging, bits per channel
ConverterStream binning(sound, binner);                    // pipe sound to binner
CsvOutput<int16_t> out(Serial);                            // serial output
StreamCopy copier(out, binning);                           // copies binning stream to out

// Arduino Setup
void setup(void) {  
  // Open Serial 
  Serial.begin(115200);
  AudioLogger::instance().begin(Serial, AudioLogger::Warning);

  // Define CSV Output
  out.begin(audio_info);

  // Setup sine wave
  sineWave.begin(audio_info, N_B4);
  Serial.println("started...");
}

// Arduino loop - copy sound to out 
void loop() {
  copier.copy();
}

Proposed extension of the BaseConverter.h:

/**
 * @brief Provides reduced sampling rates through binning
 * @ingroup convert
*/

// Helper template to define the integer type for the summation based on input data type T
template<typename T>
struct AppropriateSumType;
template<> struct AppropriateSumType<int8_t>  { using type = int16_t; };
template<> struct AppropriateSumType<int16_t> { using type = int32_t; };
template<> struct AppropriateSumType<int24_t> { using type = int32_t; };
template<> struct AppropriateSumType<int32_t> { using type = int64_t; };

template<typename T>
class BinT : public BaseConverter {
    public:
        BinT(int binSize, int channels, bool average){
            setChannels(channels);
            setBinSize(binSize);
            setAverage(average);
        }
        /// Defines the number of channels
        void setChannels(int channels){
            this->channels = channels;
        }

        /// Sets the bins: e.g. with 4 we sum 4 sample
        void setBinSize(int binSize){
            this->binSize = binSize;
        }

        /// Enables averaging: e.g. when true it divides the sum by number of bins
        void setAverage(bool average){
            this->average = average;
        }

        size_t convert(uint8_t*src, size_t size) {
            return convert(src, src, size);
        }

        size_t convert(uint8_t* target, uint8_t* src, size_t size) {
            int frame_count = size / (sizeof(T) * channels);
            T* p_target = reinterpret_cast<T*>(target);
            T* p_source = reinterpret_cast<T*>(src);
            size_t result_size = 0;

            // Allocate stack memory for sums to avoid dynamic allocation overhead.
            // Ensure you have enough stack space or adjust accordingly for your environment.
            typename AppropriateSumType<T>::type sums[channels];

            for (int i = 0; i < frame_count; i += binSize) {
                // Initialize sums for each channel to the first element in the bin
                for (int ch = 0; ch < channels; ch++) {
                    sums[ch] = (i * channels + ch < frame_count * channels) ? p_source[i * channels + ch] : static_cast<T>(0);
                }

                // Sum up binSize number of samples for each channel, starting from the second sample in the bin
                for (int j = 1; j < binSize && (i + j) < frame_count; j++) {
                    for (int ch = 0; ch < channels; ch++) {
                        sums[ch] += p_source[(i + j) * channels + ch];
                    }
                }

                // Compute average or sum for each channel and write to target buffer
                for (int ch = 0; ch < channels; ch++) {
                    if (average) {
                        T avg = static_cast<T>(sums[ch] / binSize);
                        *p_target++ = avg;
                    } else {
                        *p_target++ = static_cast<T>(sums[ch]);
                    }
                }
                result_size += sizeof(T) * channels;
            }

            //LOGI("%d: %d -> %d avg:%s", binSize, (int)size, (int)result_size, average ? "on" : "off");
            return result_size;
        }

        operator bool() {return binSize>1;};

    protected:
        int channels=2;
        int binSize=1;
        bool average=true;
        uint16_t count=0;
};

/**
 * @brief Provides reduced sampling rates through binning
 * @ingroup convert
*/

class Bin : public BaseConverter {
    public:
        Bin() = default;
        Bin(int binSize, int channels, bool average, int bits_per_sample){
            setBinSize(binSize);
            setChannels(channels);
            setAverage(average);
            setBits(bits_per_sample);
        }
        /// Defines the number of channels
        void setChannels(int channels){
            this->channels = channels;
        }
        void setBits(int bits){
            this->bits = bits;
        }
        /// Sets the binning size: e.g. with 4 we sum 4 samples
        void setBinSize(int binSize){
            this->binSize = binSize;
        }
        /// Enables averaging: e.g. when true it divides the sum by number of bins
        void setAverage(bool average){
            this->average = average;
        }

        size_t convert(uint8_t*src, size_t size) {
            return convert(src, src, size);
        }
        size_t convert(uint8_t*target, uint8_t*src, size_t size) {
            switch(bits){
                case 8:{
                    BinT<int8_t> bin8(binSize, channels, average);
                    return bin8.convert(target, src, size);
                }
                case 16:{
                    BinT<int16_t> bin16(binSize, channels, average);
                    return bin16.convert(target, src, size);
                }
                case 24:{
                    BinT<int24_t> bin24(binSize, channels, average);
                    return bin24.convert(target, src, size);
                }
                case 32:{
                    BinT<int32_t> bin32(binSize, channels, average);
                    return bin32.convert(target, src, size);
                }
                default:{
                    LOGE("Number of bits %d not supported.", bits);
                    return 0;
                }
            }
            return 0;
        }

        operator bool() {return binSize>1;};

    protected:
        int channels=2;
        int bits=16;
        int binSize=1;
        bool average=false;

};

[pschatzmann]

Using binning as copy target, it should be

GeneratedSoundStream<int16_t> source(sineWave);             // stream generated from sine wave
CsvOutput<int16_t> out(Serial);                           
ConverterStream binning(out,  binner);   // final output goes to CsvOutput                
StreamCopy copier(binning, source);                         

or using it as copy source it would be

GeneratedSoundStream<int16_t> source(sineWave);             // stream generated from sine wave
CsvOutput<int16_t> out(Serial);                           
ConverterStream binning(source,  binner);    // input is from GeneratedSoundStream                           
StreamCopy copier(out, binning);                         

Both should work, but I usually prefer the first option.
When your functionality is working I suggest you submit a pull request

[pschatzmann]

Another topic: did you ever use a TDM DAC ?

[uutzinger]

I don't have TDM DAC. Looks like a lot of components to solder if you make a custom board. But this makes sense for the latest multi channel sound immersion marketing efforts of some companies.
I have been working on simple board design with ES8388 for electronic stethoscope.
We have been using regular ESP32 continuous ADC for temperature measurements with Wheatstone bridge and although ADC is not very precise if you average a lot we got good enough temperature resolution (0.1 C). Also we were using regular continuous ADC for electrocardiogram with an analog front end for the electrodes. Works ok also. Your audio-tools library is universal and works for signal processing! I just noticed you have ESPNow examples. Audio will be a challenge but stethoscope has max frequencies of 1-2kHz.

[pschatzmann]

It seems that this can be ordered from china for 10 to 15 USD, so fortunately I don't need to do any soldering.

An electrocardiogram usually has around 10 electrodes: how did you manage to connect/process so many lines ?

For ESPNow it seems that I manage to send 1 channel with a sample rate of 8000 PCM data. By using a codec I can go up to 32000.

[uutzinger]

On ECG I only measure two channels: right arm versus left arm with ground on the leg.