renderspec.h

Go to the documentation of this file.

/*
 * Copyright (C) 2024-2025 Global Graphics Software Ltd. All rights reserved.
 */
 
#ifndef JAWSMAKO_RENDERSPEC_H
#define JAWSMAKO_RENDERSPEC_H

#include <memory>
#include <jawsmako/jawsmako.h>
#include <jawsmako/types.h>
#include <edl/icolormanager.h>
 
namespace JawsMako
{
    using namespace EDL;
 
    typedef IJawsRenderer::CFrameBufferInfo CFrameBufferInfo;
    typedef IJawsRenderer::IHalftone IHalftone;
    typedef IJawsRenderer::CSpotHalftone CSpotHalftone;
    typedef IJawsRenderer::CColorSpotHalftone CColorSpotHalftone;
    typedef CEDLVector<CFrameBufferInfo> CFrameBufferInfoVect;
    class IPostProcessSpec;
    DECL_SMART_PTR(IPostProcessSpec);
    typedef CEDLVector<IPostProcessSpecPtr> CRenderPostProcessVect;
    class CSpotColorAlias
    {
      public:
        CSpotColorAlias() = default;
        CSpotColorAlias(const RawString &_spotName, const RawString &_remappedColorant)
        {
            spotName = _spotName;
            remappedColorant = _remappedColorant;
        }
        RawString spotName;         
        RawString remappedColorant; 
    };

    typedef CEDLVector<CSpotColorAlias> CSpotColorAliasVect;
    

    class CRenderSpec
    {
      public:
        CRenderSpec()
        {
            width                         = 0;
            height                        = 0;
            depth                         = 8;
            aaFactor                      = 1;
            alpha                         = false;
            optionalContentEvent          = eOCEView;
            rgbImageRenderingIntent       = eRenderingIntentUnset;
            cmykImageRenderingIntent      = eRenderingIntentUnset;
            ignoreInputIccProfiles        = false;
            use16BitInternalRendering     = false;
            preserveBlackForText          = eBPDefault;
            preserveBlackForOther         = eBPDefault;
        }
        virtual ~CRenderSpec() = default;
 
        // Assign base settings from another render spec
        void assignCommon(const CRenderSpec &other)
        {
            processSpace = other.processSpace;
            width = other.width;
            height = other.height;
            depth = other.depth;
            sourceRect = other.sourceRect;
            aaFactor = other.aaFactor;
            alpha = other.alpha;
            retainedSpotColors = other.retainedSpotColors;
            ignoredSpotColors = other.ignoredSpotColors;
            aliasedSpotColors = other.aliasedSpotColors;
            postProcesses = other.postProcesses;
            optionalContent = other.optionalContent;
            optionalContentEvent = other.optionalContentEvent;
            rgbImageRenderingIntent = other.rgbImageRenderingIntent;
            cmykImageRenderingIntent = other.cmykImageRenderingIntent;
            ignoreInputIccProfiles = other.ignoreInputIccProfiles;
            overrideCmmConfig = other.overrideCmmConfig;
            use16BitInternalRendering = other.use16BitInternalRendering;
            preserveBlackForText = other.preserveBlackForText;
            preserveBlackForOther = other.preserveBlackForOther;
        }
 
        IDOMColorSpacePtr      processSpace;                    
        uint32                 width;                           
        uint32                 height;                          
        uint8                  depth;                           
        FRect                  sourceRect;                      
        uint8                  aaFactor;                        
        bool                   alpha;                           
 
        CSpotColorNames        retainedSpotColors;              
        CSpotColorNames        ignoredSpotColors;               
        CSpotColorAliasVect    aliasedSpotColors;               
        
        CRenderPostProcessVect postProcesses;                   
 
        IOptionalContentPtr    optionalContent;                 
        eOptionalContentEvent  optionalContentEvent;            
 
        eRenderingIntent       rgbImageRenderingIntent;         
        eRenderingIntent       cmykImageRenderingIntent;        
 
        bool                   ignoreInputIccProfiles;          
        CColorManagerConfigPtr overrideCmmConfig;               
        bool                   use16BitInternalRendering;       

        typedef enum
        {
            eBPDefault = 0,   
            eBPOn = 1,        
            eBPOff = 2,       
        } eBlackPreservation;
 
        eBlackPreservation     preserveBlackForText;             
        eBlackPreservation     preserveBlackForOther;            
    };

    class CImageRenderSpec : public CRenderSpec
    {
      public:
        CImageRenderSpec() : CRenderSpec()
        {
            compress = true;
        }
 
        IDOMImagePtr result;   
        bool         compress; 
    };
    #define renderSpecToCImageRenderSpec(rs) (dynamic_cast<CImageRenderSpec *>(rs))

    class CImagesRenderSpec : public CRenderSpec
    {
      public:
        CImagesRenderSpec() : CRenderSpec()
        {
            compress = true;
        }
 
        CDOMImageVect result;   
        bool          compress; 
    };
    #define renderSpecToCImagesRenderSpec(rs) (dynamic_cast<CImagesRenderSpec *>(rs))

    class CFrameBufferRenderSpec: public CRenderSpec
    {
      public:
        CFrameBufferRenderSpec() : CRenderSpec()
        {
            buffer = nullptr;
            rowStride = 0;
            hostEndian = true;
        }
 
        void *buffer;    
        int32 rowStride; 
        bool hostEndian; 
    };
    #define renderSpecToCFrameBufferRenderSpec(rs) (dynamic_cast<CFrameBufferRenderSpec *>(rs))

    class CFrameBuffersRenderSpec: public CRenderSpec
    {
      public:
        CFrameBuffersRenderSpec() : CRenderSpec()
        {
            hostEndian = true;
        }
 
        CFrameBufferInfoVect bufferInfo; 
        bool hostEndian;                 
    };
    #define renderSpecToCFrameBuffersRenderSpec(rs) (dynamic_cast<CFrameBuffersRenderSpec *>(rs))
 
 

    class IPostProcessSpec : public IRCObject
    {
      public:
        typedef enum ePostProcessType
        {
            ePPTColorConversion,    
            ePPTToneCurves,         
            ePPTSpotMerge,          
            ePPTInkLimit,           
            ePPTHalftone,           
            ePPTCustomColor,        
            ePPTCustomSpot,         
            ePPTCustomSpotMerge     
        } ePostProcessType;

        virtual ePostProcessType getType() const = 0;
    };
 
    class CColorConversionPostProcessSpec;
    DECL_SMART_PTR(CColorConversionPostProcessSpec);

    class CColorConversionPostProcessSpec : public IPostProcessSpec
    {
      public:
        static JAWSMAKO_API CColorConversionPostProcessSpecPtr create(const IDOMColorSpacePtr &targetSpace,
                                                                      eRenderingIntent intent = eRelativeColorimetric,
                                                                      eBlackPointCompensation bpc = eBPCDefault);

        static JAWSMAKO_API CColorConversionPostProcessSpecPtr create(const IDOMICCProfilePtr &deviceLink,
                                                                      const IDOMColorSpacePtr &targetSpace,
                                                                      eRenderingIntent intent = eRelativeColorimetric,
                                                                      eBlackPointCompensation bpc = eBPCDefault);
 
        class CLogicalStep
        {
          public:
            CLogicalStep()
            {
                intent = eRelativeColorimetric;
                bpc = eBPCDefault;
            }
            IDOMColorSpacePtr       targetSpace;
            IDOMICCProfilePtr       deviceLink; 
            eRenderingIntent        intent;     
            eBlackPointCompensation bpc;        
 
            bool operator== (const CLogicalStep &other) const
            {
                return     (other.targetSpace == targetSpace)
                        && (other.deviceLink  == deviceLink)
                        && (other.intent      == intent)
                        && (other.bpc         == bpc);
            }
 
            bool operator!= (const CLogicalStep &other) const
            {
                return ! (*this == other);
            }
        };
        typedef CEDLVector<CLogicalStep> CLogicalSteps;

        static JAWSMAKO_API CColorConversionPostProcessSpecPtr create(const CLogicalSteps &steps);
 
        ePostProcessType getType() const override
        {
            return ePPTColorConversion;
        }
 
      public:
        CLogicalSteps conversionSteps;
    };
    #define obj2CColorConversionPostProcessSpec(obj) CColorConversionPostProcessSpecPtr(dynamic_cast<CColorConversionPostProcessSpec *>((IRCObject *) (obj)), true)
 
    class CToneCurvesPostProcessSpec;
    DECL_SMART_PTR(CToneCurvesPostProcessSpec);

    class CToneCurvesPostProcessSpec : public IPostProcessSpec
    {
      public:
        static JAWSMAKO_API CToneCurvesPostProcessSpecPtr create(const CEDLVector<CFloatVect> &_toneCurves);
 
        ePostProcessType getType() const override
        {
            return ePPTToneCurves;
        }
 
      public:
        CEDLVector<CFloatVect> toneCurves;
    };
    #define obj2CToneCurvesPostProcessSpec(obj) CToneCurvesPostProcessSpecPtr(dynamic_cast<CToneCurvesPostProcessSpec *>((IRCObject *) (obj)), true)
 
    class CSpotMergePostProcessSpec;
    DECL_SMART_PTR(CSpotMergePostProcessSpec);

    class CSpotMergePostProcessSpec : public IPostProcessSpec
    {
      public:
        static JAWSMAKO_API CSpotMergePostProcessSpecPtr create(const IDOMColorSpaceDeviceN::CColorantInfoVect &_mergeSpotColors,
                                                                const CEDLVector<CFloatVect> &_toneCurves = CEDLVector<CFloatVect>());
 
        ePostProcessType getType() const override
        {
            return ePPTSpotMerge;
        }
 
      public:
        IDOMColorSpaceDeviceN::CColorantInfoVect mergeSpotColors;
        CEDLVector<CFloatVect>                   toneCurves;
    };
    #define obj2CSpotMergePostProcessSpec(obj) CSpotMergePostProcessSpecPtr(dynamic_cast<CSpotMergePostProcessSpec *>((IRCObject *) (obj)), true)
 
    class CInkLimitPostProcessSpec;
    DECL_SMART_PTR(CInkLimitPostProcessSpec);

    class CInkLimitPostProcessSpec : public IPostProcessSpec
    {
      public:
        static JAWSMAKO_API CInkLimitPostProcessSpecPtr create(float _maxTotalInk,
                                                               bool _keepBlack = true);
 
        ePostProcessType getType() const override
        {
            return ePPTInkLimit;
        }
 
      public:
        float maxTotalInk;
        bool  keepBlack;
    };
    #define obj2CInkLimitPostProcessSpec(obj) CInkLimitPostProcessSpecPtr(dynamic_cast<CInkLimitPostProcessSpec *>((IRCObject *) (obj)), true)
 
    class CHalftonePostProcessSpec;
    DECL_SMART_PTR(CHalftonePostProcessSpec);

    class CHalftonePostProcessSpec : public IPostProcessSpec
    {
      public:
        static JAWSMAKO_API CHalftonePostProcessSpecPtr create(const IHalftone *halftone, float dpi);

        class CSeparatedColorSpotHalftone : public CColorSpotHalftone
        {
          public:
            CSeparatedColorSpotHalftone(const float freq,
                                        const float cyanAngle = 15.0,
                                        const float magentaAngle = 75.0f,
                                        const float yellowAngle = 0.0f,
                                        const float blackAngle = 45.0f,
                                        const float defaultAngle = 45.0f) : CColorSpotHalftone(freq, false, cyanAngle, magentaAngle, yellowAngle, blackAngle)
            {
                angles.resize(5);
                angles[4] = defaultAngle;
            }
        };
 
        ePostProcessType getType() const override
        {
            return ePPTHalftone;
        }
 
      public:
        const IHalftone *halftone;
        float dpi;
    };
    #define obj2CHalftonePostProcessSpec(obj) CHalftonePostProcessSpecPtr(dynamic_cast<CHalftonePostProcessSpec *>((IRCObject *) (obj)), true)
 
}
 
#endif /* JAWSMAKO_RENDERSPEC_H */