audiodataencoder.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/buffer.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class PcmAudioPayload;
 
class AudioDataEncoder {
        public:
                static constexpr uint32_t SyncBits = 4;
                static constexpr uint32_t PayloadBits = 64;
                static constexpr uint32_t CrcBits = 8;
                static constexpr uint32_t BitsPerPacket = SyncBits + PayloadBits + CrcBits;
 
                static constexpr uint8_t SyncNibble = 0xAu;
 
                static constexpr uint32_t DefaultSamplesPerBit = 8;
 
                static constexpr uint32_t MinSamplesPerBit = 4;
 
                static constexpr uint32_t MaxSamplesPerBit = 64;
 
                static constexpr float DefaultAmplitude = 0.1f;
 
                static constexpr uint32_t DefaultLeadInBits = 0;
 
                static constexpr uint32_t MaxLeadInBits = 32;
 
                struct Item {
                                uint64_t firstSample = 0;
                                uint64_t sampleCount = 0;
                                uint32_t channel = 0;
                                uint64_t payload = 0;
                };
 
                AudioDataEncoder() = default;
 
                explicit AudioDataEncoder(const AudioDesc &desc, uint32_t samplesPerBit = DefaultSamplesPerBit,
                                          float amplitude = DefaultAmplitude,
                                          uint32_t leadInBits = DefaultLeadInBits);
 
                bool isValid() const { return _valid; }
 
                uint32_t samplesPerBit() const { return _samplesPerBit; }
 
                float amplitude() const { return _amplitude; }
 
                uint32_t leadInBits() const { return _leadInBits; }
 
                const AudioDesc &desc() const { return _desc; }
 
                uint64_t packetSamples() const {
                        return static_cast<uint64_t>(BitsPerPacket + _leadInBits) *
                               static_cast<uint64_t>(_samplesPerBit);
                }
 
                Error encode(PcmAudioPayload &inout, const List<Item> &items) const;
 
                Error encode(PcmAudioPayload &inout, const Item &item) const;
 
                static uint8_t computeCrc(uint64_t payload);
 
        private:
                AudioDesc _desc;
                uint32_t  _samplesPerBit = 0;
                float     _amplitude = 0.0f;
                uint32_t  _leadInBits = 0;
                bool      _valid = false;
 
                // Bytes per single sample of one channel, in the target format.
                size_t _bytesPerSample = 0;
                // Stride (bytes) between consecutive samples of the
                // same channel.  Equals _bytesPerSample for planar,
                // _bytesPerSample * channels for interleaved.
                size_t _channelStride = 0;
 
                // Pre-built half-bit primers and one-sample silence in
                // the target sample format.  Each primer holds
                // _samplesPerBit/2 single-channel samples; silence is
                // a single sample (zero amplitude, format-encoded).
                Buffer _posHalf;
                Buffer _negHalf;
                Buffer _silenceSample;
 
                Error stampOne(uint8_t *channelBase, const Item &item) const;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_PROAV