audiobuffer.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_PROAV
#include <promeki/namespace.h>
#include <promeki/audiodesc.h>
#include <promeki/audiometer.h>
#include <promeki/buffer.h>
#include <promeki/deque.h>
#include <promeki/error.h>
#include <promeki/result.h>
#include <promeki/enums.h>
#include <promeki/list.h>
#include <promeki/mediatimestamp.h>
#include <promeki/mutex.h>
#include <promeki/pcmaudiopayload.h>
#include <promeki/waitcondition.h>
#if PROMEKI_ENABLE_SRC
#include <promeki/audioresampler.h>
#endif
 
PROMEKI_NAMESPACE_BEGIN
 
class AudioBuffer {
        public:
                using PopResult = Result<size_t>;
 
                AudioBuffer() = default;
 
                explicit AudioBuffer(const AudioDesc &format);
 
                AudioBuffer(const AudioDesc &format, size_t capacity);
 
                AudioBuffer(const AudioBuffer &) = delete;
                AudioBuffer &operator=(const AudioBuffer &) = delete;
 
                AudioBuffer(AudioBuffer &&other) noexcept;
 
                AudioBuffer &operator=(AudioBuffer &&other) noexcept;
 
                ~AudioBuffer() = default;
 
                bool isValid() const { return _format.isValid(); }
 
                AudioDesc format() const {
                        Mutex::Locker lock(_mutex);
                        return _format;
                }
 
                void setFormat(const AudioDesc &format);
 
                const AudioDesc &inputFormat() const { return _inputFormat; }
 
                void setInputFormat(const AudioDesc &input);
 
                Error setResamplerQuality(const SrcQuality &quality);
 
                Error enableDriftCorrection(size_t targetSamples, double gain = 0.001);
 
                void disableDriftCorrection();
 
                bool driftCorrectionEnabled() const;
 
                double driftRatio() const;
 
                Error reserve(size_t samples);
 
                size_t capacity() const {
                        Mutex::Locker lock(_mutex);
                        return _capacity;
                }
 
                size_t available() const {
                        Mutex::Locker lock(_mutex);
                        return _count;
                }
 
                size_t free() const {
                        Mutex::Locker lock(_mutex);
                        return _capacity - _count;
                }
 
                bool isEmpty() const {
                        Mutex::Locker lock(_mutex);
                        return _count == 0;
                }
 
                bool isFull() const {
                        Mutex::Locker lock(_mutex);
                        return _count >= _capacity;
                }
 
                void clear();
 
                Error setChannelGains(const List<float> &gains);
 
                List<float> channelGains() const;
 
                Error setChannelRemap(const List<int> &remap);
 
                List<int> channelRemap() const;
 
                void setMeter(AudioMeter::Ptr meter);
 
                AudioMeter::Ptr meter() const;
 
                Error push(const void *data, size_t samples, const AudioDesc &srcFormat,
                           const MediaTimeStamp &pts = MediaTimeStamp());
 
                Error pushSilence(size_t samples, const MediaTimeStamp &pts = MediaTimeStamp());
 
                PopResult pop(void *dst, size_t samples, MediaTimeStamp *firstSamplePts = nullptr);
 
                PopResult popWait(void *dst, size_t samples, unsigned int timeoutMs = 0,
                                  MediaTimeStamp *firstSamplePts = nullptr);
 
                PopResult peek(void *dst, size_t samples,
                               MediaTimeStamp *firstSamplePts = nullptr) const;
 
                PopResult drop(size_t samples);
 
                Error push(const PcmAudioPayload &payload);
 
                Result<PcmAudioPayload::Ptr> popPayload(size_t minSamples, size_t maxSamples);
 
                Result<PcmAudioPayload::Ptr> popWaitPayload(size_t minSamples, size_t maxSamples,
                                                            unsigned int timeoutMs = 0);
 
                MediaTimeStamp nextSamplePts() const;
 
                int64_t resamplerSampleDelta() const;
 
        private:
                size_t bytesPerSample() const;
 
                void writeBytesAtTail(const uint8_t *data, size_t samples);
 
                void readBytesFromHead(uint8_t *dst, size_t samples, size_t skip) const;
 
                // Lock-free internals called with _mutex already held.
                Error  pushLocked(const void *data, size_t samples, const AudioDesc &srcFormat,
                                  const MediaTimeStamp &pts, size_t &outputSamples);
                Error  pushSilenceLocked(size_t samples);
                size_t popLocked(void *dst, size_t samples);
 
                struct Anchor {
                                uint64_t       outputIndex = 0;
                                MediaTimeStamp pts;
                };
 
                void layAnchorLocked(uint64_t outputIndex, const MediaTimeStamp &pts);
 
                MediaTimeStamp ptsAtOutputIndexLocked(uint64_t outputIndex) const;
 
                void pruneAnchorsLocked();
 
                mutable Mutex _mutex;
                WaitCondition _cv;
 
                AudioDesc       _format;
                AudioDesc       _inputFormat;
                Buffer          _storage;
                size_t          _capacity = 0;
                size_t          _head = 0;  
                size_t          _tail = 0;  
                size_t          _count = 0; 
                List<float>     _gains;     
                List<int>       _remap;     
                AudioMeter::Ptr _meter;     
 
                Deque<Anchor> _anchors;                  
                uint64_t      _outputProducedTotal = 0;  
                uint64_t      _outputConsumedTotal = 0;  
                int64_t       _resamplerSampleDelta = 0; 
 
                bool needsFloatProcessing() const { return !_remap.isEmpty() || !_gains.isEmpty() || _meter.isValid(); }
 
#if PROMEKI_ENABLE_SRC
                SrcQuality     _resamplerQuality;
                AudioResampler _resampler;
                bool           _driftEnabled = false;
                size_t         _driftTarget = 0;
                double         _driftGain = 0.001;
                double         _driftRatio = 1.0;    
                double         _driftIntegral = 0.0; 
 
                Error resampleAndPush(const float *nativeData, size_t samples,
                                      size_t &outputSamples, long &inputUsed);
 
                bool needsResampler(const AudioDesc &srcFormat) const;
 
                double computeRatio(const AudioDesc &srcFormat);
#endif
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_PROAV