Ensure single precision floating point arithmetic and rename utils (#13)

* rename files and introduce new namespace

* ensure all values are floating point

* use new file header and ensure floating point

* use floating point math operations

Author: Kevin Ahrendt

include/utils.h include/quantization_utils.hinclude/utils.h renamed to include/quantization_utils.h

@@ -4,6 +4,7 @@
 #include <stdint.h>
 
 namespace esp_audio_libs {
+namespace quantization_utils {
 
 /// @brief Converts an array of quantized samples with the specified number of bits into floating point samples.
 /// @param input_buffer Pointer to the input quantized samples aligned to the byte
@@ -23,4 +24,5 @@ void quantized_to_float(const uint8_t *input_buffer, float *output_buffer, uint3
 uint32_t float_to_quantized(const float *input_buffer, uint8_t *output_buffer, uint32_t num_samples,
                             uint8_t output_bits);
 
+}  // namespace quantization_utils
 }  // namespace esp_audio_libs

src/utils.cpp src/quantization_utils.cppsrc/utils.cpp renamed to src/quantization_utils.cpp

@@ -1,20 +1,21 @@
-#include "utils.h"
+#include "quantization_utils.h"
 
 namespace esp_audio_libs {
+namespace quantization_utils {
 
 void quantized_to_float(const uint8_t *input_buffer, float *output_buffer, uint32_t num_samples, uint8_t input_bits,
                         float gain_db) {
-  float gain = pow(10.0, gain_db / 20.0);
+  float gain = powf(10.0f, gain_db / 20.0f);
 
   if (input_bits <= 8) {
-    float gain_factor = gain / 128.0;
+    float gain_factor = gain / 128.0f;
 
     for (unsigned int i = 0; i < num_samples; ++i) {
       output_buffer[i] = ((int) input_buffer[i] - 128) * gain_factor;
     }
 
   } else if (input_bits <= 16) {
-    float gain_factor = gain / 32768.0;
+    float gain_factor = gain / 32768.0f;
     unsigned int i, j;
 
     for (i = j = 0; i < num_samples; ++i) {
@@ -23,7 +24,7 @@ void quantized_to_float(const uint8_t *input_buffer, float *output_buffer, uint3
       output_buffer[i] = value * gain_factor;
     }
   } else if (input_bits <= 24) {
-    float gain_factor = gain / 8388608.0;
+    float gain_factor = gain / 8388608.0f;
     unsigned int i, j;
 
     for (i = j = 0; i < num_samples; ++i) {
@@ -33,7 +34,7 @@ void quantized_to_float(const uint8_t *input_buffer, float *output_buffer, uint3
       output_buffer[i] = value * gain_factor;
     }
   } else if (input_bits <= 32) {
-    float gain_factor = gain / 2147483648.0;
+    float gain_factor = gain / 2147483648.0f;
     unsigned int i, j;
 
     for (i = j = 0; i < num_samples; ++i) {
@@ -48,7 +49,7 @@ void quantized_to_float(const uint8_t *input_buffer, float *output_buffer, uint3
 
 uint32_t float_to_quantized(const float *input_buffer, uint8_t *output_buffer, uint32_t num_samples,
                             uint8_t output_bits) {
-  float scalar = (static_cast<uint64_t>(1) << output_bits) / 2.0;
+  float scalar = (static_cast<uint64_t>(1) << output_bits) / 2.0f;
   int32_t offset = (output_bits <= 8) * 128;
   int32_t high_clip = (1 << (output_bits - 1)) - 1;
   int32_t low_clip = ~high_clip;
@@ -57,7 +58,7 @@ uint32_t float_to_quantized(const float *input_buffer, uint8_t *output_buffer, u
   uint32_t clipped_samples = 0;
 
   for (i = j = 0; i < num_samples; ++i) {
-    int32_t output = floor((input_buffer[i] * scalar) + 0.5);
+    int32_t output = floorf((input_buffer[i] * scalar) + 0.5f);
     if (output_bits < 32) {
       if (output > high_clip) {
         ++clipped_samples;
@@ -92,4 +93,5 @@ uint32_t float_to_quantized(const float *input_buffer, uint8_t *output_buffer, u
   return clipped_samples;
 }
 
-}
+}  // namespace quantization_utils
+}  // namespace esp_audio_libs

src/resample/art_resampler.cpp

@@ -80,11 +80,11 @@ Resample *resampleInit(int numChannels, int numTaps, int numFilters, float lowpa
   Resample *cxt = (Resample *) calloc(1, sizeof(Resample));
   int i;
 
-  if (lowpassRatio > 0.0 && lowpassRatio < 1.0)
+  if (lowpassRatio > 0.0f && lowpassRatio < 1.0f)
     flags |= INCLUDE_LOWPASS;
   else {
     flags &= ~INCLUDE_LOWPASS;
-    lowpassRatio = 1.0;
+    lowpassRatio = 1.0f;
   }
 
   if ((numTaps & 3) || numTaps <= 0 || numTaps > 1024) {
@@ -183,7 +183,7 @@ ResampleResult resampleProcess(Resample *cxt, const float *const *input, int num
       for (i = 0; i < cxt->numChannels; ++i)
         output[i][res.output_generated] = subsample(cxt, cxt->buffers[i], cxt->outputOffset);
 
-      cxt->outputOffset += (1.0 / ratio);
+      cxt->outputOffset += (1.0f / ratio);
       res.output_generated++;
       numOutputFrames--;
     }
@@ -224,7 +224,7 @@ ResampleResult resampleProcessInterleaved(Resample *cxt, const float *input, int
       for (i = 0; i < cxt->numChannels; ++i)
         *output++ = subsample(cxt, cxt->buffers[i], cxt->outputOffset);
 
-      cxt->outputOffset += (1.0 / ratio);
+      cxt->outputOffset += (1.0f / ratio);
       res.output_generated++;
       numOutputFrames--;
     }
@@ -261,7 +261,7 @@ unsigned int resampleGetRequiredSamples(Resample *cxt, int numOutputFrames, floa
       input_index++;
       res.input_used++;
     } else {
-      offset += (1.0 / ratio);
+      offset += (1.0f / ratio);
       numOutputFrames--;
     }
   }
@@ -288,7 +288,7 @@ unsigned int resampleGetExpectedOutput(Resample *cxt, int numInputFrames, float
       } else
         break;
     } else {
-      offset += (1.0 / ratio);
+      offset += (1.0f / ratio);
       res.output_generated++;
     }
   }
@@ -302,7 +302,7 @@ unsigned int resampleGetExpectedOutput(Resample *cxt, int numInputFrames, float
 // phase shift. The resampler cannot be reversed.
 
 void resampleAdvancePosition(Resample *cxt, float delta) {
-  if (delta < 0.0)
+  if (delta < 0.0f)
     fprintf(stderr, "resampleAdvancePosition() can only advance forward!\n");
   else
     cxt->outputOffset += delta;
@@ -336,7 +336,7 @@ void resampleAdvancePosition(Resample *cxt, float delta) {
 //         break;
 // }
 
-float resampleGetPosition(Resample *cxt) { return cxt->outputOffset + (cxt->numTaps / 2.0) - cxt->inputIndex; }
+float resampleGetPosition(Resample *cxt) { return cxt->outputOffset + (cxt->numTaps / 2.0f) - cxt->inputIndex; }
 
 // Free all resources associated with the resampler context, including the context pointer
 // itself. Do not use the context after this call.
@@ -368,11 +368,11 @@ static float apply_filter(float *A, float *B, int num_taps) {
 #endif
 
 static void init_filter(Resample *cxt, float *filter, float fraction, float lowpass_ratio) {
-  const float a0 = 0.35875;
-  const float a1 = 0.48829;
-  const float a2 = 0.14128;
-  const float a3 = 0.01168;
-  float filter_sum = 0.0;
+  const float a0 = 0.35875f;
+  const float a1 = 0.48829f;
+  const float a2 = 0.14128f;
+  const float a3 = 0.01168f;
+  float filter_sum = 0.0f;
   int i;
 
   // "dist" is the absolute distance from the sinc maximum to the filter tap to be calculated, in radians
@@ -386,22 +386,22 @@ static void init_filter(Resample *cxt, float *filter, float fraction, float lowp
     float ratio = dist / (cxt->numTaps / 2);
     float value;
 
-    if (dist != 0.0) {
+    if (dist != 0.0f) {
       value = sin(dist * lowpass_ratio) / (dist * lowpass_ratio);
 
       if (cxt->flags & BLACKMAN_HARRIS)
         value *= a0 + a1 * cos(ratio) + a2 * cos(2 * ratio) + a3 * cos(3 * ratio);
       else
-        value *= 0.5 * (1.0 + cos(ratio));  // Hann window
+        value *= 0.5f * (1.0f + cos(ratio));  // Hann window
     } else
-      value = 1.0;
+      value = 1.0f;
 
     filter_sum += cxt->tempFilter[i] = value;
   }
 
   // filter should have unity DC gain
 
-  float scaler = 1.0 / filter_sum, error = 0.0;
+  float scaler = 1.0f / filter_sum, error = 0.0f;
 
   for (i = cxt->numTaps / 2; i < cxt->numTaps; i = cxt->numTaps - i - (i >= cxt->numTaps / 2)) {
     filter[i] = (cxt->tempFilter[i] *= scaler) - error;
@@ -413,10 +413,10 @@ static float subsample_no_interpolate(Resample *cxt, float *source, float offset
   source += (int) floor(offset);
   offset -= floor(offset);
 
-  if (offset == 0.0 && !(cxt->flags & INCLUDE_LOWPASS))
+  if (offset == 0.0f && !(cxt->flags & INCLUDE_LOWPASS))
     return *source;
 
-  return apply_filter(cxt->filters[(int) floor(offset * cxt->numFilters + 0.5)], source - cxt->numTaps / 2 + 1,
+  return apply_filter(cxt->filters[(int) floor(offset * cxt->numFilters + 0.5f)], source - cxt->numTaps / 2 + 1,
                       cxt->numTaps);
 }
 
@@ -427,18 +427,18 @@ static float subsample_interpolate(Resample *cxt, float *source, float offset) {
   source += (int) floor(offset);
   offset -= floor(offset);
 
-  if (offset == 0.0 && !(cxt->flags & INCLUDE_LOWPASS))
+  if (offset == 0.0f && !(cxt->flags & INCLUDE_LOWPASS))
     return *source;
 
   i = (int) floor(offset *= cxt->numFilters);
   sum1 = apply_filter(cxt->filters[i], source - cxt->numTaps / 2 + 1, cxt->numTaps);
 
-  if ((offset -= i) == 0.0 && !(cxt->flags & INCLUDE_LOWPASS))
+  if ((offset -= i) == 0.0f && !(cxt->flags & INCLUDE_LOWPASS))
     return sum1;
 
   sum2 = apply_filter(cxt->filters[i + 1], source - cxt->numTaps / 2 + 1, cxt->numTaps);
 
-  return sum2 * offset + sum1 * (1.0 - offset);
+  return sum2 * offset + sum1 * (1.0f - offset);
 }
 
 static float subsample(Resample *cxt, float *source, float offset) {

src/resample/resampler.cpp

@@ -1,5 +1,5 @@
 #include "resampler.h"
-#include "utils.h"
+#include "quantization_utils.h"
 
 namespace esp_audio_libs {
 namespace resampler {
@@ -44,48 +44,48 @@ bool Resampler::initialize(ResamplerConfiguration &config) {
 
     this->sample_ratio_ = config.target_sample_rate / config.source_sample_rate;
 
-    if (this->sample_ratio_ < 1.0) {
-      this->lowpass_ratio_ -= (10.24 / this->number_of_taps_);
+    if (this->sample_ratio_ < 1.0f) {
+      this->lowpass_ratio_ -= (10.24f / this->number_of_taps_);
 
-      if (this->lowpass_ratio_ < 0.84) {
-        this->lowpass_ratio_ = 0.84;
+      if (this->lowpass_ratio_ < 0.84f) {
+        this->lowpass_ratio_ = 0.84f;
       }
 
       if (this->lowpass_ratio_ < this->sample_ratio_) {
         // avoid discontinuities near unity sample ratios
         this->lowpass_ratio_ = this->sample_ratio_;
       }
     }
-    if (this->lowpass_ratio_ * this->sample_ratio_ < 0.98 && config.use_pre_or_post_filter) {
-      float cutoff = this->lowpass_ratio_ * this->sample_ratio_ / 2.0;
+    if (this->lowpass_ratio_ * this->sample_ratio_ < 0.98f && config.use_pre_or_post_filter) {
+      float cutoff = this->lowpass_ratio_ * this->sample_ratio_ / 2.0f;
       art_resampler::biquad_lowpass(&this->lowpass_coeff_, cutoff);
       this->pre_filter_ = true;
     }
 
-    if (this->lowpass_ratio_ / this->sample_ratio_ < 0.98 && config.use_pre_or_post_filter && !this->pre_filter_) {
-      float cutoff = this->lowpass_ratio_ / this->sample_ratio_ / 2.0;
+    if (this->lowpass_ratio_ / this->sample_ratio_ < 0.98f && config.use_pre_or_post_filter && !this->pre_filter_) {
+      float cutoff = this->lowpass_ratio_ / this->sample_ratio_ / 2.0f;
       art_resampler::biquad_lowpass(&this->lowpass_coeff_, cutoff);
       this->post_filter_ = true;
     }
 
     if (this->pre_filter_ || this->post_filter_) {
       for (int i = 0; i < this->channels_; ++i) {
-        art_resampler::biquad_init(&this->lowpass_[i][0], &this->lowpass_coeff_, 1.0);
-        art_resampler::biquad_init(&this->lowpass_[i][1], &this->lowpass_coeff_, 1.0);
+        art_resampler::biquad_init(&this->lowpass_[i][0], &this->lowpass_coeff_, 1.0f);
+        art_resampler::biquad_init(&this->lowpass_[i][1], &this->lowpass_coeff_, 1.0f);
       }
     }
 
-    if (this->sample_ratio_ < 1.0) {
+    if (this->sample_ratio_ < 1.0f) {
       this->resampler_ = art_resampler::resampleInit(this->channels_, this->number_of_taps_, this->number_of_filters_,
                                       this->sample_ratio_ * this->lowpass_ratio_, flags | INCLUDE_LOWPASS);
-    } else if (this->lowpass_ratio_ < 1.0) {
+    } else if (this->lowpass_ratio_ < 1.0f) {
       this->resampler_ = art_resampler::resampleInit(this->channels_, this->number_of_taps_, this->number_of_filters_,
                                       this->lowpass_ratio_, flags | INCLUDE_LOWPASS);
     } else {
-      this->resampler_ = art_resampler::resampleInit(this->channels_, this->number_of_taps_, this->number_of_filters_, 1.0, flags);
+      this->resampler_ = art_resampler::resampleInit(this->channels_, this->number_of_taps_, this->number_of_filters_, 1.0f, flags);
     }
 
-    art_resampler::resampleAdvancePosition(this->resampler_, this->number_of_taps_ / 2.0);
+    art_resampler::resampleAdvancePosition(this->resampler_, this->number_of_taps_ / 2.0f);
   }
 
   return true;
@@ -104,11 +104,11 @@ ResamplerResults Resampler::resample(const uint8_t *input_buffer, uint8_t *outpu
   }
   uint32_t conversion_time = 0;
   if (this->requires_resampling_) {
-    quantized_to_float(input_buffer, this->float_input_buffer_, frames_to_process * this->channels_, this->input_bits_,
+    quantization_utils::quantized_to_float(input_buffer, this->float_input_buffer_, frames_to_process * this->channels_, this->input_bits_,
                        gain_db);
   } else {
     // Just converting the bits per sample
-    quantized_to_float(input_buffer, this->float_output_buffer_, frames_to_process * this->channels_, this->input_bits_,
+    quantization_utils::quantized_to_float(input_buffer, this->float_output_buffer_, frames_to_process * this->channels_, this->input_bits_,
                        gain_db);
   }
 
@@ -139,7 +139,7 @@ ResamplerResults Resampler::resample(const uint8_t *input_buffer, uint8_t *outpu
     }
   }
 
-  uint32_t clipped_samples = float_to_quantized(this->float_output_buffer_, output_buffer,
+  uint32_t clipped_samples = quantization_utils::float_to_quantized(this->float_output_buffer_, output_buffer,
                                                 frames_generated * this->channels_, this->output_bits_);
 
   ResamplerResults results = {.frames_used = frames_used,