cscpipeline.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CSC
#include <promeki/namespace.h>
#include <promeki/sharedptr.h>
#include <promeki/list.h>
#include <promeki/error.h>
#include <promeki/pixelformat.h>
#include <promeki/mediaconfig.h>
#include <promeki/csccontext.h>
#include <promeki/cscregistry.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class Image;
class UncompressedVideoPayload;
 
class CSCPipeline {
                PROMEKI_SHARED_FINAL(CSCPipeline)
        public:
                using Ptr = SharedPtr<CSCPipeline>;
 
                static constexpr size_t MaxLUTSize = 4096;
 
                enum StageType {
                        StageUnpack,           
                        StageChromaUpsample,   
                        StageRangeIn,          
                        StageMonoExpand,       
                        StageToneMap,          
                        StageEOTF,             
                        StageMatrix,           
                        StageOETF,             
                        StageRangeOut,         
                        StageChromaDownsample, 
                        StagePack,             
                        StageAlphaFill         
                };
 
                struct Stage {
                                StageType type;
 
                                void (*func)(const Stage *stage, const void *const *srcPlanes, const size_t *srcStrides,
                                             void *const *dstPlanes, const size_t *dstStrides, size_t width, size_t y,
                                             CSCContext &ctx) = nullptr;
 
                                float matrix[3][3] = {};
 
                                float matrixOffset[3] = {};
 
                                float matrixPreOffset[3] = {};
 
                                float rangeScale[4] = {};
 
                                float rangeBias[4] = {};
 
                                float *lut = nullptr;
 
                                size_t lutSize = 0;
 
                                int compCount = 3;
 
                                float alphaValue = 1.0f;
 
                                int chromaHRatio = 1;
 
                                int chromaVRatio = 1;
 
                                int semBufMap[8] = {0, 1, 2, 3, 4, 5, 6, 7};
 
                                int pixelCompCount = 0;
 
                                int bitsPerComp = 0;
 
                                int bytesPerBlock = 0;
 
                                int pixelsPerBlock = 1;
 
                                bool hasAlpha = false;
 
                                int alphaCompIndex = -1;
 
                                bool useSimd = true;
 
                                int planeCount = 1;
 
                                int planeBytesPerSample[4] = {};
 
                                int planeHSub[4] = {};
 
                                int planeVSub[4] = {};
 
                                int compPlane[8] = {};
 
                                int compByteOffset[8] = {};
 
                                int compBits[8] = {};
 
                                int hdrTransfer = 0;
 
                                enum HdrTransfer {
                                        HdrTransferNone   = 0,
                                        HdrTransferPqOETF = 1,
                                        HdrTransferPqEOTF = 2,
                                        HdrTransferHlgOETF = 3,
                                        HdrTransferHlgEOTF = 4,
                                };
 
                                enum ToneMapOperator {
                                        ToneMapNone     = -1, 
                                        ToneMapBt2390   = 0,
                                        ToneMapReinhard = 1,
                                        ToneMapHable    = 2,
                                        ToneMapAces     = 3,
                                        ToneMapBt2446a  = 4,
                                };
 
                                int toneMapOperator = ToneMapNone;
 
                                float toneMapSrcMaxPq = 0.0f;
 
                                float toneMapDstMaxPq = 0.0f;
 
                                ~Stage() { delete[] lut; }
                                Stage() = default;
                                Stage(const Stage &other);
                                Stage &operator=(const Stage &other);
                                Stage(Stage &&other) noexcept;
                                Stage &operator=(Stage &&other) noexcept;
                };
 
                CSCPipeline() = default;
 
                CSCPipeline(const PixelFormat &src, const PixelFormat &dst, const MediaConfig &config = MediaConfig());
 
                static Ptr cached(const PixelFormat &src, const PixelFormat &dst,
                                  const MediaConfig &config = MediaConfig());
 
                bool isValid() const { return _valid; }
 
                const PixelFormat &srcDesc() const { return _srcDesc; }
 
                const PixelFormat &dstDesc() const { return _dstDesc; }
 
                bool isIdentity() const { return _identity; }
 
                bool isFastPath() const { return _fastPathFunc != nullptr; }
 
                int stageCount() const { return _stages.size(); }
 
                const Stage &stage(int i) const { return _stages[i]; }
 
                Error execute(const UncompressedVideoPayload &src, UncompressedVideoPayload &dst) const;
 
                void processLine(const void *const *srcPlanes, const size_t *srcStrides, void *const *dstPlanes,
                                 const size_t *dstStrides, size_t width, size_t y, CSCContext &ctx) const;
 
        private:
                PixelFormat              _srcDesc;
                PixelFormat              _dstDesc;
                MediaConfig              _config;
                bool                     _valid = false;
                bool                     _identity = false;
                bool                     _useSimd = true;
                CSCRegistry::LineFuncPtr _fastPathFunc = nullptr;
                List<Stage>              _stages;
 
                void compile();
                void buildUnpackStage(const PixelFormat &pd, Stage &stage);
                void buildPackStage(const PixelFormat &pd, Stage &stage);
                void buildRangeStage(const PixelFormat &pd, Stage &stage, bool isInput);
                void buildTransferStage(const ColorModel &cm, Stage &stage, bool isEOTF, int bits);
                void buildMatrixStage(const ColorModel &src, const ColorModel &dst, Stage &stage);
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_CSC