renderspec.h

Go to the documentation of this file.

/*
 * Copyright (C) 2024-2026 Hybrid Software Helix Ltd. All rights reserved.
 */
 
#ifndef JAWSMAKO_RENDERSPEC_H
#define JAWSMAKO_RENDERSPEC_H

#include <memory>
#include <jawsmako/types.h>
#include <edl/icolormanager.h>
 
namespace JawsMako
{
    using namespace EDL;
 
    //====================================================================================================

    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 IHalftone
    {
      public:
        virtual ~IHalftone() = default;
    };

    class CSpotHalftone : public IHalftone
    {
     public:
 
        // The frequency must be greater than 0.
        CSpotHalftone(float freq, bool useFullResForFlattening = false)
        {
            frequency = freq;
            useFullResolutionForFlattening = useFullResForFlattening;
        }
        float frequency;                        
        bool useFullResolutionForFlattening;    
    };
       
    class CColorSpotHalftone : public IHalftone
    {
      public:
        // Default is CMYK. Resize and set angles to suit
        CColorSpotHalftone(float freq, bool useFullResForFlattening = false,
                          float cyanAngle = 15.0, float magentaAngle = 75.0f, float yellowAngle = 0.0f, float blackAngle = 45.0f)
        {
            frequency = freq;
            useFullResolutionForFlattening = useFullResForFlattening;
            angles.resize(4);
            angles[0] = cyanAngle;
            angles[1] = magentaAngle;
            angles[2] = yellowAngle;
            angles[3] = blackAngle;
        }
        float frequency;                        
        bool  useFullResolutionForFlattening;   
        CEDLVector<float> angles;               
    };

    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;
        }
    };
 
    class CThresholdArrayHalftone : public IHalftone
    {
      public:
        CThresholdArrayHalftone()
        {
            width = 0;
            height = 0;
        }
 
        uint32 width;                       
        uint32 height;                      
        CEDLVector<uint8> thresholdArray;   
    };

    class CColorThresholdArrayHalftone : public IHalftone
    {
      public:
        CColorThresholdArrayHalftone()
        {
            width = 0;
            height = 0;
        }
 
        uint32 width;                                       
        uint32 height;                                      
        CEDLVector< CEDLVector<uint8> > thresholdArrays;    
    };

    class CThresholdHalftone : public IHalftone
    {
      public:
        CThresholdHalftone(uint8 thresh = 127)
        {
            threshold = thresh;
        }
 
        uint8 threshold; 
    };
 

    class CEDSHalftone : public IHalftone
    {
      public:
        CEDSHalftone()
        {
            // Default is a simple Atkinson monochrome error diffusion screen
            dropSizes = 1;
            rows = 3;
            columns = 4;
            pixelColumn = 1;
            denominator = 6;
            weights[0] = 0;
            weights[1] = 0;
            weights[2] = 1;
            weights[3] = 1;
            weights[4] = 0;
            weights[5] = 1;
            weights[6] = 1;
            weights[7] = 1;
            weights[8] = 0;
            weights[9] = 0;
            weights[10] = 0;
            weights[11] = 1;
            weights[12] = 0;
            weights[13] = 0;
            weights[14] = 0;
            weights[15] = 0;
            weights[16] = 0;
            weights[17] = 0;
            weights[18] = 0;
            weights[19] = 0;
            useSerpentine = false;
            perturbation = 0.0f;
        }
 
        uint8  dropSizes;     
        uint8  rows;          
        uint8  columns;       
        uint8  pixelColumn;   
        uint32 denominator;   
        uint8  weights[20];   
        bool   useSerpentine; 
        float  perturbation;  
    };
 
    //====================================================================================================

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

        virtual ePostProcessType getType() const = 0;
    };
    DECL_SMART_PTR(IPostProcessSpec);
    typedef CEDLVector<IPostProcessSpecPtr> CRenderPostProcessVect;
 
    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:
 
        typedef JawsMako::CSeparatedColorSpotHalftone   CSeparatedColorSpotHalftone;

        static JAWSMAKO_API CHalftonePostProcessSpecPtr create(const IHalftone *halftone, float dpi);
 
        ePostProcessType getType() const override
        {
            return ePPTHalftone;
        }
 
      public:
        const IHalftone *halftone;
        float dpi;
    };
    #define obj2CHalftonePostProcessSpec(obj) CHalftonePostProcessSpecPtr(dynamic_cast<CHalftonePostProcessSpec *>((IRCObject *) (obj)), true)
 
    //====================================================================================================

    class CRenderSpec
    {
      public:
        CRenderSpec()
        {
            width                         = 0;
            height                        = 0;
            depth                         = 8;
            aaFactor                      = 1;
            alpha                         = false;
            decomposeDeviceN              = false;
            optionalContentEvent          = eOCEView;
            rgbImageRenderingIntent       = eRenderingIntentUnset;
            cmykImageRenderingIntent      = eRenderingIntentUnset;
            ignoreInputIccProfiles        = false;
            use16BitInternalRendering     = false;
            preserveBlackForText          = eBPDefault;
            preserveBlackForOther         = eBPDefault;
            ditherShadingPatterns         = false;
        }
        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;
            decomposeDeviceN = other.decomposeDeviceN;
            replacementSpotColors = other.replacementSpotColors;
            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;
            ditherShadingPatterns = other.ditherShadingPatterns;
        }
 
        IDOMColorSpacePtr      processSpace;                    
        uint32                 width;                           
        uint32                 height;                          
        uint8                  depth;                           
        FRect                  sourceRect;                      
        uint8                  aaFactor;                        
        bool                   alpha;                           
 
        CSpotColorNames        retainedSpotColors;              
        CSpotColorNames        ignoredSpotColors;               
        CSpotColorAliasVect    aliasedSpotColors;               
        
        bool                   decomposeDeviceN;                
        IDOMColorSpaceDeviceN::CColorantInfoVect
                               replacementSpotColors;           
        
        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;            
 
        bool                   ditherShadingPatterns;            
    };

    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 CFrameBufferInfo
    {
        public:
            void    *buffer;            
            uint32  bufferOfs;          
            uint8   bufferOfsBits;      
            int32   rowStride;          
            int32   pixelStride;        
            int8    pixelStrideBits;    
 
            CFrameBufferInfo()
            {
                buffer          = nullptr;
                bufferOfs       = 0;
                bufferOfsBits   = 0;
                rowStride       = 0;
                pixelStride     = 0;
                pixelStrideBits = 0;
            }
 
            bool operator== (const CFrameBufferInfo &other) const
            {
                return      (other.buffer         == buffer)
                    &&  (other.bufferOfs      == bufferOfs)
                    &&  (other.bufferOfsBits  == bufferOfsBits)
                    &&  (other.rowStride      == rowStride)
                    &&  (other.pixelStride    == pixelStride)
                    && (other.pixelStrideBits == pixelStrideBits)
                    ;
            }
 
            bool operator!= (const CFrameBufferInfo &other) const
            {
                return ! (*this == other);
            }
    };
    typedef CEDLVector<CFrameBufferInfo> CFrameBufferInfoVect;

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

    class IRenderer : public IRCObject
    {
      public:
 
        virtual ~IRenderer() = default;

        virtual void render(const IDOMNodePtr &node,
                            CRenderSpec *renderSpec) = 0;
    };
}
 
#endif /* JAWSMAKO_RENDERSPEC_H */