audiodatadecoder.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_PROAV
#include <cstdint>
#include <cstddef>
#include <promeki/namespace.h>
#include <promeki/list.h>
#include <promeki/error.h>
#include <promeki/audiodesc.h>
#include <promeki/audiodataencoder.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class PcmAudioPayload;
 
class AudioDataDecoder {
        public:
                static constexpr uint32_t BitsPerPacket = AudioDataEncoder::BitsPerPacket;
                static constexpr uint32_t SyncBits = AudioDataEncoder::SyncBits;
                static constexpr uint32_t PayloadBits = AudioDataEncoder::PayloadBits;
                static constexpr uint32_t CrcBits = AudioDataEncoder::CrcBits;
                static constexpr uint8_t SyncNibble = AudioDataEncoder::SyncNibble;
 
                struct Band {
                                uint64_t firstSample = 0;
                                uint64_t sampleCount = 0;
                                uint32_t channel = 0;
                };
 
                struct DecodedItem {
                                Error error = Error::Ok;
                                uint8_t decodedSync = 0;
                                uint8_t decodedCrc = 0;
                                uint8_t expectedCrc = 0;
                                uint64_t payload = 0;
                                double samplesPerBit = 0.0;
                                uint64_t syncStartSample = 0;
                                int64_t streamSampleStart = -1;
                                int64_t packetSampleCount = 0;
                };
 
                using DecodedList = List<DecodedItem>;
 
                AudioDataDecoder() = default;
 
                explicit AudioDataDecoder(const AudioDesc &desc,
                                          uint32_t expectedSamplesPerBit = AudioDataEncoder::DefaultSamplesPerBit,
                                          float expectedAmplitude = AudioDataEncoder::DefaultAmplitude);
 
                bool isValid() const { return _valid; }
 
                uint32_t expectedSamplesPerBit() const { return _expectedSamplesPerBit; }
 
                float expectedAmplitude() const { return _expectedAmplitude; }
 
                const AudioDesc &desc() const { return _desc; }
 
                Error decode(const PcmAudioPayload &payload, const List<Band> &bands, DecodedList &out) const;
 
                DecodedItem decode(const PcmAudioPayload &payload, const Band &band) const;
 
                DecodedItem decode(const float *samples, size_t count) const;
 
                struct StreamState {
                                List<float> buffer;
                                int64_t sampleAnchor = 0;
                };
 
                static constexpr size_t kStreamBufferMaxSamples = 8192;
 
                void decodeAll(StreamState &state, const float *newSamples, size_t count, DecodedList &out) const;
 
        private:
                AudioDesc _desc;
                uint32_t  _expectedSamplesPerBit = 0;
                uint32_t  _samplesPerBitMin = 0;
                uint32_t  _samplesPerBitMax = 0;
                float     _expectedAmplitude = 0.0f;
                float     _positiveThreshold = 0.0f;
                bool      _valid = false;
 
                DecodedItem decodeOne(const PcmAudioPayload &payload, const Band &band) const;
                DecodedItem decodeSamples(const float *samples, size_t count) const;
                // Shared bandwidth-check + demod helper.  Given a
                // pre-measured sync (@p syncStart sub-sample-accurate
                // codeword leading edge, @p samplesPerBit measured
                // pitch, @p syncStartSampleInt integer first-positive
                // sample), runs the 76-bit integrate-and-compare
                // demod across @p samples and verifies the sync
                // nibble + CRC.  Used by both the per-band decode
                // path and the streaming decodeAll loop.
                DecodedItem demodulate(const float *samples, size_t count, double syncStart, double samplesPerBit,
                                       uint64_t syncStartSampleInt) const;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_PROAV