imagedataencoder.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/array.h>
#include <promeki/list.h>
#include <promeki/error.h>
#include <promeki/imagedesc.h>
#include <promeki/pixelformat.h>
#include <promeki/buffer.h>
#include <promeki/crc.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class Image;
class UncompressedVideoPayload;
 
class ImageDataEncoder {
        public:
                static constexpr size_t PrimerCount = 3;
 
                static constexpr uint32_t SyncBits = 4;
                static constexpr uint32_t PayloadBits = 64;
                static constexpr uint32_t CrcBits = 8;
                static constexpr uint32_t BitsPerRow = SyncBits + PayloadBits + CrcBits;
 
                static constexpr uint8_t SyncNibble = 0xAu;
 
                static constexpr size_t MaxPlanes = 4;
 
                struct Item {
                                uint32_t firstLine; 
                                uint32_t lineCount; 
                                uint64_t payload;   
                };
 
                ImageDataEncoder() = default;
 
                explicit ImageDataEncoder(const ImageDesc &desc);
 
                bool isValid() const { return _valid; }
 
                uint32_t bitWidth() const { return _bitWidth; }
 
                uint32_t patternWidth() const { return _bitWidth * BitsPerRow; }
 
                uint32_t padWidth() const { return _padWidth; }
 
                const ImageDesc &desc() const { return _desc; }
 
                Error encode(UncompressedVideoPayload &inout, const List<Item> &items) const;
 
                Error encode(UncompressedVideoPayload &inout, const Item &item) const;
 
        private:
                struct PlaneInfo {
                                size_t lineStride = 0; 
                                size_t hSubsampling = 1;
                                size_t vSubsampling = 1;
                                size_t cellBytes = 0; 
                                size_t padBytes = 0;  
                                Buffer oneCell;       
                                Buffer zeroCell;      
                                Buffer padBuf;        
                };
 
                ImageDesc                   _desc;
                uint32_t                    _bitWidth = 0;
                uint32_t                    _padWidth = 0;
                size_t                      _planeCount = 0;
                Array<PlaneInfo, MaxPlanes> _planes{};
                bool                        _valid = false;
 
                bool buildPrimers();
                void writeOneScanline(uint8_t *planeBase, size_t planeIndex, size_t lineInPlane, uint8_t syncBits,
                                      uint64_t payload, uint8_t crcBits) const;
 
        public:
                void writeScanlineBase(uint8_t *planeBase, size_t planeIndex, const Item &item, uint64_t lastEx,
                                       uint8_t syncBits, uint8_t crcVal) const;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_PROAV