audiometer.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_PROAV
#include <cmath>
#include <cstddef>
#include <promeki/atomic.h>
#include <promeki/namespace.h>
#include <promeki/sharedptr.h>
#include <promeki/uniqueptr.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class AudioMeter {
                PROMEKI_SHARED_BASE(AudioMeter)
        public:
                using Ptr = SharedPtr<AudioMeter, /*CopyOnWrite=*/false>;
 
                virtual ~AudioMeter() = default;
 
                virtual void process(const float *samples, size_t frames, size_t channels) = 0;
 
                virtual void reset() = 0;
};
 
class AudioPeakRmsMeter : public AudioMeter {
                PROMEKI_SHARED_DERIVED(AudioPeakRmsMeter)
        public:
                using Ptr = SharedPtr<AudioPeakRmsMeter, /*CopyOnWrite=*/false>;
 
                explicit AudioPeakRmsMeter(size_t channels) { setChannels(channels); }
 
                AudioPeakRmsMeter(const AudioPeakRmsMeter &) = delete;
                AudioPeakRmsMeter &operator=(const AudioPeakRmsMeter &) = delete;
 
                void setChannels(size_t channels) {
                        _channels = channels;
                        // Value-init form invokes each Atomic<float>'s
                        // explicit default constructor (T{} = 0.0f), so
                        // no follow-up zero-fill loop is needed.
                        _peak = MeterArray::createArrayValueInit(channels);
                        _rms  = MeterArray::createArrayValueInit(channels);
                }
 
                size_t channels() const { return _channels; }
 
                float peak(size_t ch) const {
                        if (ch >= _channels) return 0.0f;
                        return _peak[ch].load(MemoryOrder::Relaxed);
                }
 
                float rms(size_t ch) const {
                        if (ch >= _channels) return 0.0f;
                        return _rms[ch].load(MemoryOrder::Relaxed);
                }
 
                void setPeakDecay(float decay) { _peakDecay = decay; }
 
                void setRmsWindow(size_t windowFrames) {
                        if (windowFrames == 0) windowFrames = 1;
                        _rmsAlpha = 1.0f / static_cast<float>(windowFrames);
                }
 
                void process(const float *samples, size_t frames, size_t channels) override {
                        if (channels > _channels) channels = _channels;
                        if (frames == 0 || channels == 0) return;
 
                        const float decay = _peakDecay;
                        const float alpha = _rmsAlpha;
 
                        for (size_t c = 0; c < channels; ++c) {
                                float peak = _peak[c].load(MemoryOrder::Relaxed) * decay;
                                // Convert held RMS back to mean-square for accumulation.
                                float held = _rms[c].load(MemoryOrder::Relaxed);
                                float msq = held * held;
                                for (size_t f = 0; f < frames; ++f) {
                                        float s = samples[f * channels + c];
                                        float a = std::fabs(s);
                                        if (a > peak) peak = a;
                                        msq = msq + alpha * (s * s - msq);
                                }
                                _peak[c].store(peak, MemoryOrder::Relaxed);
                                _rms[c].store(std::sqrt(msq < 0.0f ? 0.0f : msq), MemoryOrder::Relaxed);
                        }
                }
 
                void reset() override {
                        for (size_t i = 0; i < _channels; ++i) {
                                _peak[i].store(0.0f, MemoryOrder::Relaxed);
                                _rms[i].store(0.0f, MemoryOrder::Relaxed);
                        }
                }
 
        private:
                // Atomic<float> is non-movable, so the per-channel
                // arrays are held by UniquePtr<T[]> — List<T> and
                // most other container wrappers require movable
                // elements and would not compile here.
                using MeterArray = promeki::UniquePtr<promeki::Atomic<float>[]>;
 
                size_t     _channels = 0;
                MeterArray _peak;
                MeterArray _rms;
                float      _peakDecay = 1.0f;
                float      _rmsAlpha = 1.0f / 4800.0f;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_PROAV