pixelmemlayout.h

Go to the documentation of this file.

 
#pragma once
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_PROAV
#include <cstddef>
#include <promeki/namespace.h>
#include <promeki/string.h>
#include <promeki/list.h>
#include <promeki/error.h>
#include <promeki/result.h>
#include <promeki/datatype.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class DataStream;
 
class PixelMemLayout {
        public:
                PROMEKI_DATATYPE(PixelMemLayout, DataTypePixelMemLayout, 1)
 
                
                Error writeToStream(DataStream &s) const;
                template <uint32_t V> static Result<PixelMemLayout> readFromStream(DataStream &s);
 
                static constexpr size_t MaxComps = 8;  
                static constexpr size_t MaxPlanes = 4; 
 
                enum ID {
                        Invalid = 0, 
 
                        // -- Interleaved 4:4:4 (byte-aligned) --
                        I_4x8 = 1, 
                        I_3x8 = 2, 
 
                        // -- Interleaved 4:4:4 (DPX/Cineon packed) --
                        I_3x10_DPX = 3, 
 
                        // -- Interleaved 4:2:2 YUYV --
                        I_422_3x8 = 4,  
                        I_422_3x10 = 5, 
 
                        // -- Interleaved 4:2:2 UYVY --
                        I_422_UYVY_3x8 = 6,      
                        I_422_UYVY_3x10_LE = 7,  
                        I_422_UYVY_3x10_BE = 8,  
                        I_422_UYVY_3x12_LE = 9,  
                        I_422_UYVY_3x12_BE = 10, 
 
                        // -- Interleaved 4:2:2 v210 --
                        I_422_v210 = 11, 
 
                        // -- Planar 4:2:2 --
                        P_422_3x8 = 12,     
                        P_422_3x10_LE = 13, 
                        P_422_3x10_BE = 14, 
                        P_422_3x12_LE = 15, 
                        P_422_3x12_BE = 16, 
 
                        // -- Planar 4:2:0 --
                        P_420_3x8 = 17,     
                        P_420_3x10_LE = 18, 
                        P_420_3x10_BE = 19, 
                        P_420_3x12_LE = 20, 
                        P_420_3x12_BE = 21, 
 
                        // -- Semi-planar 4:2:0 (NV12) --
                        SP_420_8 = 22,     
                        SP_420_10_LE = 23, 
                        SP_420_10_BE = 24, 
                        SP_420_12_LE = 25, 
                        SP_420_12_BE = 26, 
 
                        // -- Interleaved 4:4:4 (10/12/16-bit in 16-bit words) --
                        I_4x10_LE = 27, 
                        I_4x10_BE = 28, 
                        I_3x10_LE = 29, 
                        I_3x10_BE = 30, 
                        I_4x12_LE = 31, 
                        I_4x12_BE = 32, 
                        I_3x12_LE = 33, 
                        I_3x12_BE = 34, 
                        I_4x16_LE = 35, 
                        I_4x16_BE = 36, 
                        I_3x16_LE = 37, 
                        I_3x16_BE = 38, 
 
                        // -- Monochrome (single component) --
                        I_1x8 = 39,     
                        I_1x10_LE = 40, 
                        I_1x10_BE = 41, 
                        I_1x12_LE = 42, 
                        I_1x12_BE = 43, 
                        I_1x16_LE = 44, 
                        I_1x16_BE = 45, 
 
                        // -- Float half-precision (16-bit IEEE 754) --
                        I_4xF16_LE = 46, 
                        I_4xF16_BE = 47, 
                        I_3xF16_LE = 48, 
                        I_3xF16_BE = 49, 
                        I_1xF16_LE = 50, 
                        I_1xF16_BE = 51, 
 
                        // -- Float single-precision (32-bit IEEE 754) --
                        I_4xF32_LE = 52, 
                        I_4xF32_BE = 53, 
                        I_3xF32_LE = 54, 
                        I_3xF32_BE = 55, 
                        I_1xF32_LE = 56, 
                        I_1xF32_BE = 57, 
 
                        // -- 10:10:10:2 packed (3x10-bit + 1x2-bit in 32 bits) --
                        I_10_10_10_2_LE = 58, 
                        I_10_10_10_2_BE = 59, 
 
                        // -- Semi-planar 4:2:0 NV21 (CrCb order) --
                        SP_420_NV21_8 = 60,     
                        SP_420_NV21_10_LE = 61, 
                        SP_420_NV21_10_BE = 62, 
                        SP_420_NV21_12_LE = 63, 
                        SP_420_NV21_12_BE = 64, 
 
                        // -- Semi-planar 4:2:2 (NV16) --
                        SP_422_8 = 65,     
                        SP_422_10_LE = 66, 
                        SP_422_10_BE = 67, 
                        SP_422_12_LE = 68, 
                        SP_422_12_BE = 69, 
 
                        // -- Planar 4:1:1 --
                        P_411_3x8 = 70, 
 
                        // -- 16-bit YCbCr additions --
                        P_422_3x16_LE = 71,      
                        P_422_3x16_BE = 72,      
                        P_420_3x16_LE = 73,      
                        P_420_3x16_BE = 74,      
                        SP_420_16_LE = 75,       
                        SP_420_16_BE = 76,       
                        I_422_UYVY_3x16_LE = 77, 
                        I_422_UYVY_3x16_BE = 78, 
 
                        // -- Planar 4:4:4 (RGB / YUV 4:4:4) --
                        P_444_3x8 = 79,     
                        P_444_3x10_LE = 81, 
 
                        // -- DPX Method B packed --
                        I_3x10_DPX_B = 80, 
 
                        // -- Semi-planar 4:2:2 16-bit (NV16, P216 wire) --
                        SP_422_16_LE = 82, 
                        SP_422_16_BE = 83, 
 
                        UserDefined = 1024 
                };
 
                enum Sampling {
                        SamplingUndefined = 0, 
                        Sampling444,           
                        Sampling422,           
                        Sampling411,           
                        Sampling420            
                };
 
                enum ChromaSitingH {
                        ChromaHUndefined = 0, 
                        ChromaHLeft,          
                        ChromaHCenter         
                };
 
                enum ChromaSitingV {
                        ChromaVUndefined = 0, 
                        ChromaVTop,           
                        ChromaVCenter         
                };
 
                using IDList = ::promeki::List<ID>;
 
                struct CompDesc {
                                int    plane;      
                                size_t bits;       
                                size_t byteOffset; 
                };
 
                struct PlaneDesc {
                                String name;               
                                size_t hSubsampling = 1;   
                                size_t vSubsampling = 1;   
                                size_t bytesPerSample = 0; 
                };
 
                struct Data {
                                ID            id = Invalid;                 
                                String        name;                         
                                String        desc;                         
                                Sampling      sampling = SamplingUndefined; 
                                size_t        pixelsPerBlock = 0;           
                                size_t        bytesPerBlock = 0;            
                                size_t        compCount = 0;                
                                CompDesc      comps[MaxComps] = {};         
                                size_t        planeCount = 0;               
                                PlaneDesc     planes[MaxPlanes] = {};       
                                ChromaSitingH chromaSitingH = ChromaHUndefined; 
                                ChromaSitingV chromaSitingV = ChromaVUndefined; 
 
                                size_t (*lineStrideFunc)(const Data *d, size_t planeIdx, size_t width, size_t linePad,
                                                         size_t lineAlign) = nullptr;
 
                                size_t (*planeSizeFunc)(const Data *d, size_t planeIdx, size_t width, size_t height,
                                                        size_t linePad, size_t lineAlign) = nullptr;
                };
 
                static ID registerType();
 
                static void registerData(Data &&data);
 
                static IDList registeredIDs();
 
                static PixelMemLayout lookup(const String &name);
 
                static PixelMemLayout lookup(const String &name, Error *err);
 
                static Result<PixelMemLayout> fromString(const String &name) {
                        Error err;
                        PixelMemLayout p = lookup(name, &err);
                        if (err.isError()) return makeError<PixelMemLayout>(err);
                        return makeResult(p);
                }
 
                inline PixelMemLayout(ID id = Invalid);
 
                bool isValid() const { return d != nullptr && d->id != Invalid; }
 
                ID id() const { return d->id; }
 
                const String &name() const { return d->name; }
 
                String toString() const { return d->name; }
 
                const String &desc() const { return d->desc; }
 
                Sampling sampling() const { return d->sampling; }
 
                ChromaSitingH chromaSitingH() const { return d->chromaSitingH; }
 
                ChromaSitingV chromaSitingV() const { return d->chromaSitingV; }
 
                size_t pixelsPerBlock() const { return d->pixelsPerBlock; }
 
                size_t bytesPerBlock() const { return d->bytesPerBlock; }
 
                size_t compCount() const { return d->compCount; }
 
                const CompDesc &compDesc(size_t index) const { return d->comps[index]; }
 
                size_t planeCount() const { return d->planeCount; }
 
                const PlaneDesc &planeDesc(size_t index) const { return d->planes[index]; }
 
                bool isValidPlane(size_t index) const { return index < d->planeCount; }
 
                size_t lineStride(size_t planeIndex, size_t width, size_t linePad = 0, size_t lineAlign = 1) const {
                        if (!isValidPlane(planeIndex) || d->lineStrideFunc == nullptr) return 0;
                        return d->lineStrideFunc(d, planeIndex, width, linePad, lineAlign);
                }
 
                size_t planeSize(size_t planeIndex, size_t width, size_t height, size_t linePad = 0,
                                 size_t lineAlign = 1) const {
                        if (!isValidPlane(planeIndex) || d->planeSizeFunc == nullptr) return 0;
                        return d->planeSizeFunc(d, planeIndex, width, height, linePad, lineAlign);
                }
 
                bool operator==(const PixelMemLayout &o) const { return d == o.d; }
 
                bool operator!=(const PixelMemLayout &o) const { return d != o.d; }
 
                const Data *data() const { return d; }
 
        private:
                const Data        *d = nullptr;
                static const Data *lookupData(ID id);
};
 
inline PixelMemLayout::PixelMemLayout(ID id) : d(lookupData(id)) {}
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_PROAV