idomimageresource.h

Go to the documentation of this file.

/*
 * idomimageresource.h
 *
 * Copyright (C) 2007-2026 Hybrid Software Helix Ltd. All rights reserved.
 */
 
#ifndef IDOMIMAGERESOURCE_H
#define IDOMIMAGERESOURCE_H
 
#include <memory>
#include <edl/edlfwd.h>
#include <edl/edltypes.h>
#include <edl/edlfwd.h>
#include <edl/edlstream.h>
#include <edl/idomnode.h>
#include <edl/idombrush.h>
#include <edl/idomcolor.h>
#include <edl/idomhashable.h>
#include <edl/iimagecodec.h>
#include <edl/icolormanager.h>
#include <edl/edlerrors.h>
#include <jawsmako/optionalcontent.h>
 
_BEGIN_EDL_DOM_NAMESPACE
 
class IDOMImageProperties;
DECL_SMART_PTR(IDOMImageProperties);

class IDOMImageProperties : public IEDLObject
{
#define IDOMImagePropertiesClassID 0x3E76E62E, 0x11414364, 0xA36BEF96, 0xE81EB47B
  public:

    static const CClassID &classID()
    {
        static CClassID id(IDOMImagePropertiesClassID);
        return id;
    };

    static EDL_API IDOMImagePropertiesPtr create();

    virtual void setProperty (const EDLString &name, const EDLString &value) = 0;

    virtual bool getProperty (const EDLString &name, EDLString &value) = 0;

    virtual void setBoolProperty (const EDLString &name, bool value) = 0;

    virtual bool getBoolProperty (const EDLString &name, bool &value) = 0;

    virtual void setIntProperty (const EDLString &name, int value) = 0;

    virtual bool getIntProperty (const EDLString &name, int &value) = 0;

    virtual void setObjectProperty (const EDLString &name, const IRCObjectPtr &object) = 0;

    virtual bool getObjectProperty (const EDLString &name, IRCObjectPtr &value) = 0;
 
 
};
#define edlobj2IDOMImageProperties(src) edl_cast((IDOMImageProperties *) nullptr, src)

enum eDOMImageType
{
    eDITUnknown = 0,   
    eDITJPEG,        
    eDITJBIG2,       
    eDITJPEG2000,    
    eDITPNG,         
    eDITCCITTFax,    
    eDITFlate,       
    eDITLZW,         
    eDITRunLength,   
    eDITRendered     
};
typedef enum eDOMImageType eDOMImageType;

class IDOMImage : public IDOMResource, public IDOMHashable
{
#define IDOMImageClassID 0xf1050c98, 0x1bee40e7, 0xaa604df2, 0x82e822c4
  public:
    class Data : public CClassParams
    {
      public:
        Data() : streamLength(0), imageType (eDITUnknown)
        { }
        EDLSysString    uri;
        IInputStreamPtr stream;
        uint64          streamLength;
        eDOMImageType   imageType;
    };

    virtual IImageDecoderPtr createImageDecoder (IEDLClassFactory *factory, const IDOMImagePropertiesPtr &imageProperties) = 0;

    virtual IImageFramePtr getImageFrame (IEDLClassFactory *factory);

    virtual IImageEncoderPtr createImageEncoder (const ISessionPtr &session, const IOutputStreamPtr &imageDest, const IDOMImagePropertiesPtr &imageProperties) = 0;

    virtual IDOMImagePropertiesPtr getImageProperties () = 0;

    virtual eDOMImageType getImageType () = 0;

    virtual bool getIsRendered() = 0;

    virtual IDOMImagePtr getImageWithSubstitutedColorSpace(IEDLClassFactory *factory, const IDOMColorSpacePtr &colorSpace);
};
 
DECL_SMART_PTR(IDOMImage);
#define edlobj2IDOMImage(src) edl_cast((IDOMImage *) nullptr, src)
 
 
class IDOMJPEGImage;
DECL_SMART_PTR(IDOMJPEGImage);

class IDOMJPEGImage : public virtual IDOMImage
{
#define IDOMJPEGImageClassID 0x07c50584, 0xf4d44316, 0xa3de2ddb, 0x83f3e7cf
  public:

    static EDL_API IDOMJPEGImagePtr create(IEDLClassFactory *pFactory, const IInputStreamPtr &stream);

    static EDL_API IDOMImagePtr createWriterAndImage(const ISessionPtr &session,
                                                     IImageFrameWriterPtr &frame,
                                                     const IDOMColorSpacePtr &colorSpace,
                                                     uint32 width, uint32 height,
                                                     uint8 bitsPerComponent = 8,
                                                     double xResolution = 96.0, double yResolution = 96.0,
                                                     uint8 quality = 3,
                                                     const IInputStreamPtr &inStream = IInputStreamPtr(),
                                                     const IOutputStreamPtr &outStream = IOutputStreamPtr());

    static EDL_API void encode(const ISessionPtr &pSession,
                               const IDOMImagePtr &image,
                               const IOutputStreamPtr &stream,
                               uint8 quality = 3,
                               bool allowCmyk = false,
                               bool invertCmyk = true);

    static EDL_API void encode(const ISessionPtr &pSession,
                               const IImageFramePtr &frame,
                               const IOutputStreamPtr &stream,
                               uint8 quality = 3,
                               bool allowCmyk = false,
                               bool invertCmyk = true);

    static const CClassID &classID()
    {
        static CClassID id(IDOMJPEGImageClassID);
        return id;
    };
 
};
#define edlobj2IDOMJPEGImage(src) edl_cast((IDOMJPEGImage *) nullptr, src)
 
 
class IDOMPNGImage;
DECL_SMART_PTR(IDOMPNGImage);

class IDOMPNGImage : public virtual IDOMImage
{
#define IDOMPNGImageClassID 0x7792c068, 0x67a94eaf, 0x9563973a, 0x910c6b61
  public:
    static EDL_API IDOMPNGImagePtr create(IEDLClassFactory *pFactory, const IInputStreamPtr &stream);

    static EDL_API IDOMImagePtr createWriterAndImage(const ISessionPtr &session,
                                                     IImageFrameWriterPtr &frame,
                                                     const IDOMColorSpacePtr &colorSpace,
                                                     uint32 width, uint32 height,
                                                     uint8 bitsPerComponent = 8,
                                                     double xResolution = 96.0, double yResolution = 96.0,
                                                     eImageExtraChannelType extraChannel = eIECNone,
                                                     const IInputStreamPtr &inStream = IInputStreamPtr(),
                                                     const IOutputStreamPtr &outStream = IOutputStreamPtr());
 

    static EDL_API void encode(const ISessionPtr &pSession, const IDOMImagePtr &image, const IOutputStreamPtr &stream);

    static EDL_API void encode(const ISessionPtr &pSession, const IImageFramePtr &frame, const IOutputStreamPtr &stream);
 
#ifdef SWIG
#if SWIGJAVA
    %apply char *BYTE { void *frameBuffer };
#endif
#if SWIGCSHARP
    %apply unsigned char INPUT[] { void *frameBuffer };
#endif
#if SWIGPYTHON
    %apply char INPUT[] { void *frameBuffer };
#endif
#endif
    static EDL_API void encode(const ISessionPtr &pSession, const IDOMColorSpacePtr &colorSpace, float dpi, uint8 bpc,
                               void *frameBuffer, uint32 width, uint32 height, int32 stride, bool hasAlpha,
                               const IOutputStreamPtr &stream);
#ifdef SWIG
    %clear void *frameBuffer;
#endif

    static const CClassID &classID()
    {
        static CClassID id(IDOMPNGImageClassID);
        return id;
    };
};
#define edlobj2IDOMPNGImage(src) edl_cast((IDOMPNGImage *) nullptr, src)
 
 
class IDOMTIFFImage;
DECL_SMART_PTR(IDOMTIFFImage);

class IDOMTIFFImage : public IDOMImage
{
#define IDOMTIFFImageClassID 0x1469a59c, 0x78114e29, 0xb2fc0e45, 0x8aa62afe
  public:

    class Data : public IDOMImage::Data
    {
      public:
        Data() : imageIndex(0), allowMultiChannel(false)
        { }
        uint16 imageIndex;
        bool   allowMultiChannel;
    };

    typedef enum
    {
        eTCAuto, 
        eTCNone,
        eTCCCITT,
        eTCCCITT3,
        eTCCCITT4,
        eTCPackBits,
        eTCLZW,
    } eTIFFCompression;

    typedef enum
    {
        eTPNone, // Default
        eTPHorizontal,
    } eTIFFPrediction;
 

    static EDL_API IDOMTIFFImagePtr create(IEDLClassFactory *pFactory,
                                           const IInputStreamPtr &stream,
                                           uint16 imageIndex = 0,
                                           bool allowMultiChannel = false);
 

    static EDL_API IDOMImagePtr createWriterAndImage(const ISessionPtr &session,
                                                     IImageFrameWriterPtr &frame,
                                                     const IDOMColorSpacePtr &colorSpace,
                                                     uint32 width, uint32 height,
                                                     uint8 bitsPerComponent = 8,
                                                     double xResolution = 96.0, double yResolution = 96.0,
                                                     eTIFFCompression compressionType = eTCAuto,
                                                     eTIFFPrediction predictionType = eTPNone,
                                                     eImageExtraChannelType extraChannel = eIECNone,
                                                     bool bigTiff = false,
                                                     const IInputStreamPtr &inStream = IInputStreamPtr(),
                                                     const IOutputStreamPtr &outStream = IOutputStreamPtr());

    static EDL_API void encode(const ISessionPtr &pSession, const IDOMImagePtr &image, const IOutputStreamPtr &stream, eTIFFCompression scheme = eTCAuto, eTIFFPrediction predictionType = eTPNone, bool bigTiff = false);

    static EDL_API void encode(const ISessionPtr &pSession, const IImageFramePtr &frame, const IOutputStreamPtr &stream, eTIFFCompression scheme = eTCAuto, eTIFFPrediction predictionType = eTPNone, bool bigTiff = false);

    virtual uint16 getImageIndex() const = 0;

    static const CClassID &classID()
    {
        static CClassID id(IDOMTIFFImageClassID);
        return id;
    };
};
#define edlobj2IDOMTIFFImage(src) edl_cast((IDOMTIFFImage *) nullptr, src)
 
class IDOMPSDImage;
DECL_SMART_PTR(IDOMPSDImage);

class IDOMPSDImage : public IDOMImage
{
#define IDOMPSDImageClassID 0x0B2849E1, 0x93AF4798, 0xB5A66591, 0x19FED770
 
  public:

    class Data : public IDOMImage::Data
    {
      public:
        Data() : layerIndex (0)
        { }
        int16 layerIndex;
    };

    static EDL_API IDOMPSDImagePtr create(IEDLClassFactory *pFactory, const IInputStreamPtr &stream, int16 layerIndex = 0);

    virtual int16 getLayerIndex() const = 0;

    static const CClassID &classID()
    {
        static CClassID id(IDOMPSDImageClassID);
        return id;
    };
};
#define edlobj2IDOMPSDImage(src) edl_cast((IDOMPSDImage *) nullptr, src)
 

class IDOMWMPImage : public IDOMImage
{
#define IDOMWMPImageClassID 0x09bda5e5, 0x58cf4912, 0xbee4617d, 0x2c201426
  public:

    static const CClassID &classID()
    {
        static CClassID id(IDOMWMPImageClassID);
        return id;
    };
};
 
DECL_SMART_PTR(IDOMWMPImage);
#define edlobj2IDOMWMPImage(src) edl_cast((IDOMWMPImage *) nullptr, src)
 
class IDOMRawImage;
DECL_SMART_PTR(IDOMRawImage);

class IDOMRawImage : public IDOMImage
{
#define IDOMRawImageClassID 0x373a5278, 0x136411dc, 0x83140800, 0x200c9a66
  public:

    static EDL_API IDOMRawImagePtr create(IEDLClassFactory *pFactory,
                                          const IDOMColorSpacePtr &colorSpace,
                                          const IInputStreamPtr &stream,
                                          eDOMImageType type = eDITUnknown);

    class Data : public IDOMImage::Data
    {
      public:
        Data(): isSynthetic(false)
        {
            imageType = eDITUnknown;
        }
        bool                isSynthetic;
        IDOMColorSpacePtr   colorSpace;
        eDOMImageType       imageType;
    };

    static const CClassID &classID()
    {
        static CClassID id(IDOMRawImageClassID);
        return id;
    };

    static EDL_API IDOMImagePtr createWriterAndImage(const ISessionPtr &session,
                                                     IImageFrameWriterPtr &frame,
                                                     const IDOMColorSpacePtr &colorSpace,
                                                     uint32 width, uint32 height,
                                                     uint8 bitsPerComponent = 8,
                                                     double xResolution = 96.0, double yResolution = 96.0,
                                                     eImageExtraChannelType extraChannel = eIECNone,
                                                     const IInputStreamPtr &inStream = IInputStreamPtr(),
                                                     const IOutputStreamPtr &outStream = IOutputStreamPtr());

    virtual bool getSynthetic() const = 0;
};
 
#define edlobj2IDOMRawImage(src) edl_cast((IDOMRawImage *) nullptr, src)
 
class IDOMPWGImage;
DECL_SMART_PTR(IDOMPWGImage);

class IDOMPWGImage : public IDOMImage
{
#define IDOMPWGImageClassID     0x03DA8639, 0x20F74BB7, 0x8AEDC4F3, 0x5125A3EB
  public:

    class Data : public IDOMImage::Data
    {
      public:
        Data()
        {
          imageIndex        = 0;
          writeSignature    = false;
        }
        uint16              imageIndex;
        bool                writeSignature;
    };

    static const CClassID &classID()
    {
        static CClassID id(IDOMPWGImageClassID);
        return id;
    };

    static EDL_API IDOMPWGImagePtr create(IEDLClassFactory *pFactory,
                                          const IInputStreamPtr &stream,
                                          uint16 imageIndex = 0);

    static EDL_API IDOMImagePtr createWriterAndImage(const ISessionPtr &session,
                                                     IImageFrameWriterPtr &frame,
                                                     const IDOMColorSpacePtr &colorSpace,
                                                     uint32 width, uint32 height,
                                                     uint8 bitsPerComponent = 8,
                                                     double xResolution = 96.0, double yResolution = 96.0,
                                                     bool writeSignature = false,
                                                     const IInputStreamPtr &inStream = IInputStreamPtr(),
                                                     const IOutputStreamPtr &outStream = IOutputStreamPtr());

    static EDL_API void encode(const ISessionPtr &pSession, const IDOMImagePtr &image, const IOutputStreamPtr &stream, bool writeSignature = false);
 
    static EDL_API void encode(const ISessionPtr &pSession, const IImageFramePtr &frame, const IOutputStreamPtr &stream, bool writeSignature = false);

    virtual uint16 getImageIndex() const = 0;
};
#define edlobj2IDOMPWGImage(src) edl_cast((IDOMPWGImage *) nullptr, src)
 
class IDOMTrivialImage;
DECL_SMART_PTR(IDOMTrivialImage);

class IDOMTrivialImage : public IDOMImage
{
#define IDOMTrivialImageClassID 0x260a8c7a, 0xc9dd46e8, 0xa43c08ec, 0xf543b901
  public:
    static EDL_API IDOMTrivialImagePtr create(IEDLClassFactory *pFactory,
                                              const IDOMColorSpacePtr &colorSpace,
                                              uint16 width, uint16 height, uint32 stride,
                                              uint8 bitsPerComponent,
                                              const CEDLSimpleBuffer &imageData,
                                              eImageExtraChannelType extraChannel = eIECNone,
                                              eDOMImageType type = eDITUnknown);

    class Data : public CClassParams
    {
      public:
        Data()
        {
            imageType = eDITUnknown;
            width = 0;
            height = 0;
            stride = 0;
            bitsPerComponent = 0;
            extraChannelType = eIECNone;
            imageType = eDITUnknown;
        }
        IDOMColorSpacePtr      colorSpace;
        uint16                 width;
        uint16                 height;
        uint8                  bitsPerComponent;
        uint32                 stride;
        CEDLSimpleBuffer       imageData;
        eImageExtraChannelType extraChannelType;
        eDOMImageType          imageType;
        EDLSysString           uri;
    };

    static const CClassID &classID()
    {
        static CClassID id(IDOMTrivialImageClassID);
        return id;
    };

    virtual IInputStreamPtr getStream() const
    {
        return IInputStreamPtr ();
    }

    virtual void setStream(const IInputStreamPtr &stream)
    {
        UNREFERENCED_PARAMETER(stream);
        throwEDLError (JM_ERR_UNSUPPORTED);
    }
 
};
 
#define edlobj2IDOMTrivialImage(src) edl_cast((IDOMTrivialImage *) nullptr, src)
 
 
class IDOMPDFImage;
DECL_SMART_PTR(IDOMPDFImage);

class IDOMPDFAlternateImage : public IEDLObject, public IDOMHashable
{
#define IDOMPDFAlternateImageClassID 0x09cfB9ef, 0xdf084a30, 0x963979B6, 0x6f01eee2
  public:

    class Data : public CClassParams
    {
      public:
        Data() : defaultForPrinting(false), pFactory (nullptr)
        {}
 
        virtual ~Data() {}
        IEDLClassFactory                    *pFactory;
        IDOMImageBrushPtr                    alternateBrush;
        JawsMako::IOptionalContentDetailsPtr optionalContentDetails;
        bool                                 defaultForPrinting;
    };

    static EDL_API IDOMPDFAlternateImagePtr create(IEDLClassFactory *pFactory,
                                           const IDOMImageBrushPtr &alternateBrush,
                                           bool defaultForPrinting = false,
                                           const JawsMako::IOptionalContentDetailsPtr &optionalContentDetails = JawsMako::IOptionalContentDetailsPtr());

    static const CClassID &classID()
    {
        static CClassID id(IDOMPDFAlternateImageClassID);
        return id;
    };

    virtual IDOMImageBrushPtr getImageBrush() const = 0;

    virtual bool getDefaultForPrinting() const = 0;

    virtual JawsMako::IOptionalContentDetailsPtr getOptionalContentDetails() const = 0;
};
 

class IDOMPDFImage : public IDOMImage
{
#define IDOMPDFImageClassID 0x865d5367, 0x8fee4078, 0xadd975ad, 0x5106ee38
  public:

    class IDecodeParams : public IRCObject
    {
      public:
        virtual ~IDecodeParams() {}
    };
    DECL_SMART_PTR(IDecodeParams);
 

    class FlateLZWParams;
    DECL_SMART_PTR(FlateLZWParams);
    class FlateLZWParams : public IDecodeParams
    {
      public:
        static EDL_API FlateLZWParamsPtr create(uint32 predictor = 1, uint32 colors = 1,
                                                uint32 bpc = 8, uint32 columns = 1, uint32 earlyChange = 1);
        uint32 predictor;
        uint32 colors;
        uint32 bitsPerComponent;
        uint32 columns;
        uint32 earlyChange;
    };
    #define obj2FlateLZWParams(obj) IDOMPDFImage::FlateLZWParamsPtr(dynamic_cast<IDOMPDFImage::FlateLZWParams *>((IRCObject *) obj), true)

    class CCITTFaxParams;
    DECL_SMART_PTR(CCITTFaxParams);
    class CCITTFaxParams : public IDecodeParams
    {
      public:
        static EDL_API CCITTFaxParamsPtr create(int32 k = 0, bool endOfLine = false, bool encodedByteAlign = false,
                                                uint32 columns = 1728, uint32 rows = 0, bool endOfBlock = true,
                                                bool blackIs1 = false);
        int32  k;
        bool   endOfLine;
        bool   encodedByteAlign;
        uint32 columns;
        uint32 rows;
        bool   endOfBlock;
        bool   blackIs1;
    };
    #define obj2CCITTFaxParams(obj) IDOMPDFImage::CCITTFaxParamsPtr(dynamic_cast<IDOMPDFImage::CCITTFaxParams *>((IRCObject *) obj), true)

    class JBIG2Params;
    DECL_SMART_PTR(JBIG2Params);
    class JBIG2Params : public IDecodeParams
    {
      public:
        static EDL_API JBIG2ParamsPtr create(const IInputStreamPtr &globals = IInputStreamPtr());
        IInputStreamPtr globals;
    };
    #define obj2JBIG2Params(obj) IDOMPDFImage::JBIG2ParamsPtr(dynamic_cast<IDOMPDFImage::JBIG2Params *>((IRCObject *) obj), true)

    class DCTParams;
    DECL_SMART_PTR(DCTParams);
    class DCTParams : public IDecodeParams
    {
      public:
        static EDL_API DCTParamsPtr create(int32 colorTransform = 0);
        uint32 colorTransform;
    };
    #define obj2DCTParams(obj) IDOMPDFImage::DCTParamsPtr(dynamic_cast<IDOMPDFImage::DCTParams *>((IRCObject *) obj), true)
 
    typedef enum
    {
        eIANone,
        eIAAlpha,
        eIAPremultipliedAlpha
    } eImageAlpha;

    class Data : public IDOMImage::Data
    {
      public:
        Data() : imageId(INVALID_DOM_ID),
                 alpha (eIANone),
                 bitsPerComponent (0),
                 width (0),
                 height (0),
                 streamHash(0),
                 isRendered(false),
                 sourceId(INVALID_DOM_ID)
        {}
        virtual ~Data() {}
        CEDLVector<IDecodeParamsPtr>         decodeParams;
        CEDLVector<eDOMImageType>            imageTypes;
        IDOMColorSpacePtr                    colorSpace;
        uint32                               width;
        uint32                               height;
        uint8                                bitsPerComponent;
        eImageAlpha                          alpha;
        CEDLVector<float>                    decode;
        CEDLVector<uint16>                   colorKeyForMask;
        bool                                 isRendered;
        DOMid                                imageId; // Note: Excluded from hash()
        uint64                               streamHash; // For internal use only. Set to zero.
        DOMid                                sourceId;
    };
 
    static EDL_API IDOMPDFImagePtr create(IEDLClassFactory *pFactory,
                                          const IInputStreamPtr &stream,
                                          eDOMImageType imageType,
                                          const IDecodeParamsPtr &decodeParams,
                                          const IDOMColorSpacePtr &colorSpace,
                                          uint32 width, uint32 height,
                                          uint8 bitsPerComponent,
                                          const CEDLVector<float> &decode = CEDLVector<float>(),
                                          const CEDLVector<uint16> &colorKeyForMask = CEDLVector<uint16>(),
                                          eImageAlpha alpha = eIANone,
                                          bool rendered = false,
                                          const DOMid sourceId = INVALID_DOM_ID);
 
    static EDL_API IDOMPDFImagePtr create(IEDLClassFactory *pFactory,
                                          const IInputStreamPtr &stream,
                                          const CEDLVector<eDOMImageType> imageTypes,
                                          const CEDLVector<IDecodeParamsPtr> &decodeParams,
                                          const IDOMColorSpacePtr &colorSpace,
                                          uint32 width, uint32 height,
                                          uint8 bitsPerComponent,
                                          const CEDLVector<float> &decode = CEDLVector<float>(),
                                          const CEDLVector<uint16> &colorKeyForMask = CEDLVector<uint16>(),
                                          eImageAlpha alpha = eIANone,
                                          bool rendered = false,
                                          const DOMid sourceId = INVALID_DOM_ID);

    static const CClassID &classID()
    {
        static CClassID id(IDOMPDFImageClassID);
        return id;
    };

    virtual CEDLVector<IDecodeParamsPtr> getDecodeParameters() const = 0;

    virtual IDecodeParamsPtr getDecodeParametersAtIndex(uint32 index) const
    {
        CEDLVector<IDecodeParamsPtr> decodeParamsArr = getDecodeParameters ();
        IDecodeParamsPtr             decodeParams;
 
        if (index < decodeParamsArr.size ())
            decodeParams = decodeParamsArr [index];
 
        return decodeParams;
    }

    virtual CEDLVector<eDOMImageType> getImageTypes() const = 0;

    virtual CEDLVector<float> getDecode() const = 0;

    virtual uint8 getBitsPerComponent() const = 0;

    virtual CEDLVector<uint16> getColorKey() const = 0;

    virtual IDOMColorSpacePtr getColorSpace() const = 0;

    virtual eImageAlpha getAlphaDetails() const = 0;
};
#define edlobj2IDOMPDFImage(src) edl_cast((IDOMPDFImage *) nullptr, src)
 
class IDOMPCLImage;
DECL_SMART_PTR(IDOMPCLImage);

class IDOMPCLImage : public IDOMImage
{
#define IDOMPCLImageClassID 0x1444956E, 0xec014100, 0x9bec3968, 0xfe976935
  public:

    static const CClassID &classID()
    {
        static CClassID id(IDOMPCLImageClassID);
        return id;
    };

    typedef enum
    {
        eCMNoCompression = 0,
        eCMRleCompression = 1,
        eCMDeltaRowCompression = 3,
        eCMZeroFillCompression = 4
    } eCompressMode;

    class Data : public IDOMImage::Data
    {
      public:
        Data() : compressionMode(eCMNoCompression), bitsPerComponent(8), padding(0), width(0), height(0) {}
        eCompressMode     compressionMode;
        IDOMColorSpacePtr colorSpace;
        IInputStreamPtr   stream;
        uint8             bitsPerComponent;
        int32             width;
        int32             height;
        uint8             padding;
    };
 
    static EDL_API IDOMPCLImagePtr create(IEDLClassFactory *pFactory,
                                          const IInputStreamPtr &stream,
                                          const IDOMColorSpacePtr &colorSpace,
                                          uint8 bitsPerComponent,
                                          int32 width, int32 height,
                                          uint8 padding,
                                          eCompressMode compressionMode);
};
#define edlobj2IDOMPCLImage(src) edl_cast((IDOMPCLImage *) nullptr, src)
 
class IDOMRecombineImage;
DECL_SMART_PTR(IDOMRecombineImage);

class IDOMRecombineImage : public IDOMImage
{
#define IDOMRecombineImageClassID 0xe91e20cc, 0xbe2d469e, 0x8bad9d10, 0xca68Ad90
  public:

    class Data : public IDOMImage::Data
    {
      public:
        Data()
        {
            imageType = eDITUnknown;
            extraChannelIsMask = false;
        }
        IDOMColorSpacePtr        colorSpace;
        CEDLVector<IDOMImagePtr> componentImages;
        IDOMImagePtr             extraChannel;
        bool                     extraChannelIsMask; 
 
    };

    static EDL_API IDOMRecombineImagePtr create(IEDLClassFactory *pFactory,
                                        const IDOMColorSpacePtr &colorSpace,
                                        const CEDLVector<IDOMImagePtr> &componentImages,
                                        const IDOMImagePtr &extraChannel = IDOMImagePtr(),
                                        bool extraChannelIsMask = false);

    static const CClassID &classID()
    {
        static CClassID id(IDOMRecombineImageClassID);
        return id;
    };

    virtual bool getStream(IInputStreamPtr &stream) const
    {
        stream = IInputStreamPtr ();
        return false;
    }

    virtual void setStream(const IInputStreamPtr &stream)
    {
        UNREFERENCED_PARAMETER(stream);
        throwEDLError (EDL_ERR_UNDEFINED);
    }
};
#define edlobj2IDOMRecombineImage(src) edl_cast((IDOMRecombineImage *) nullptr, src)
 
class IDOMRecombineAlphaImage;
DECL_SMART_PTR(IDOMRecombineAlphaImage);

class IDOMRecombineAlphaImage : public IDOMImage
{
#define IDOMRecombineAlphaImageClassID 0x4270168b, 0xf1384655, 0x86cbb981, 0x2d47dbc0
  public:

    static EDL_API IDOMRecombineAlphaImagePtr create(IEDLClassFactory *pFactory,
                                                     const IDOMImagePtr &colorImage,
                                                     const IDOMImagePtr &extraChannel,
                                                     bool extraChannelIsMask = false);

    class Data : public IDOMImage::Data
    {
      public:
        Data()
        {
            imageType = eDITUnknown;
            extraChannelIsMask = false;
        }
        IDOMImagePtr             colorImage;
        IDOMImagePtr             extraChannel;
        bool                     extraChannelIsMask; 
 
    };

    static const CClassID &classID()
    {
        static CClassID id(IDOMRecombineAlphaImageClassID);
        return id;
    };

    virtual bool getStream(IInputStreamPtr &stream) const
    {
        stream = IInputStreamPtr ();
        return false;
    }

    virtual void setStream(const IInputStreamPtr &stream)
    {
        UNREFERENCED_PARAMETER(stream);
        throwEDLError (EDL_ERR_UNDEFINED);
    }
};
 
#define edlobj2IDOMRecombineAlphaImage(src) edl_cast((IDOMRecombineAlphaImage *) nullptr, src)
 
class IDOMCompositeImage;
DECL_SMART_PTR(IDOMCompositeImage);

class IDOMCompositeImage : public IDOMImage
{
#define IDOMCompositeImageClassID 0x95f3e000, 0xc9224e4a, 0x8c31b784, 0xe2e5b860
  public:

    class Data : public IDOMImage::Data
    {
      public:
        Data()
        {
            imageType = eDITUnknown;
        }
        CEDLVector<IDOMImagePtr> componentImages;
    };

    static EDL_API IDOMCompositeImagePtr create(IEDLClassFactory *pFactory, const CEDLVector<IDOMImagePtr> componentImages);

    static const CClassID &classID()
    {
        static CClassID id(IDOMCompositeImageClassID);
        return id;
    };

    virtual bool getStream(IInputStreamPtr &stream) const
    {
        stream = IInputStreamPtr ();
        return false;
    }

    virtual void setStream(const IInputStreamPtr &stream)
    {
        UNREFERENCED_PARAMETER(stream);
        throwEDLError (EDL_ERR_UNDEFINED);
    }
};
 
#define edlobj2IDOMCompositeImage(src) edl_cast((IDOMCompositeImage *) nullptr, src)
 
class IDOMCachedImage;
DECL_SMART_PTR(IDOMCachedImage);

class IDOMCachedImage : public IDOMImage
{
#define IDOMCachedImageClassID 0x31438e03, 0xa0c54661, 0xac1e77d1, 0xd0f9ec87
  public:

    class Data : public IDOMImage::Data
    {
      public:
        Data()
        {
            imageType = eDITUnknown;
            width = 0;
            height = 0;
            bps = 0;
            extraChannelType = eIECNone;
            xResolution = 0.0;
            yResolution = 0.0;
            rawBytesPerRow = 0;
            cacheKey = 0;
            alwaysCache = false;
        }
        uint32                 width;
        uint32                 height;
        uint8                  bps;
        IDOMColorSpacePtr      colorSpace;
        eImageExtraChannelType extraChannelType;
        double                 xResolution;
        double                 yResolution;
        uint32                 rawBytesPerRow;
        IDOMImagePtr           sourceImage;
        uint64                 cacheKey;
        bool                   alwaysCache;
    };

    static EDL_API IDOMCachedImagePtr create(IEDLClassFactory *pFactory, const IDOMImagePtr &sourceImage, bool cacheSamples, bool alwaysCache = false);

    virtual IDOMImagePtr getSourceImage() const = 0;

    static const CClassID &classID()
    {
        static CClassID id(IDOMCachedImageClassID);
        return id;
    };

    virtual bool getStream(IInputStreamPtr &stream) const
    {
        stream = IInputStreamPtr ();
        return false;
    }

    virtual void setStream(const IInputStreamPtr &stream)
    {
        UNREFERENCED_PARAMETER(stream);
        throwEDLError (EDL_ERR_UNDEFINED);
    }
};
#define edlobj2IDOMCachedImage(src) edl_cast((IDOMCachedImage *) nullptr, src)
 

 
class IDOMImageFilter : public IEDLObject
{
  public:
    virtual IImageFramePtr createFilteredImageFrame(IEDLClassFactory *pFactory, const IImageFramePtr &sourceFrame) = 0;

    virtual uint64 hashParameters() = 0;
};
DECL_SMART_PTR(IDOMImageFilter);
#define edlobj2IDOMImageFilter(src) edl_cast((IDOMImageFilter *) nullptr, src)
typedef CEDLVector<IDOMImageFilterPtr> CDOMImageFilterVect;
 
class IDOMImageChannelSelectorFilter;
DECL_SMART_PTR(IDOMImageChannelSelectorFilter);

class IDOMImageChannelSelectorFilter : public IDOMImageFilter
{
#define IDOMImageChannelSelectorFilterClassID 0x014F52D9, 0x36284F76, 0xA2ED4585, 0xA0AC95CD
  public:
    typedef enum
    {
        eSelectExtraChannel,        // Device Gray with alpha/mask values as gray values.
        eSelectExtraChannelAsAlpha, // Presents a gray image with alpha retained as alpha.
        eSelectColorChannels,       // Presents a plain image with the alpha/mask stripped.
        eSelectChannel              // Channel as a Device Gray image with the alpha/mask stripped.
    } eSelection;

    static EDL_API IDOMImageChannelSelectorFilterPtr create(IEDLClassFactory *pFactory, eSelection selection, uint8 channel = 0);

    static const CClassID &classID()
    {
        static CClassID id(IDOMImageChannelSelectorFilterClassID);
        return id;
    };

    class Data : public CClassParams
    {
      public:
        eSelection selection;
        uint8 channel;
    };
 
};
#define edlobj2IDOMImageChannelSelectorFilter(src) edl_cast((IDOMImageChannelSelectorFilter *) nullptr, src)
 
 
class IDOMImageColorSpaceSubstitutionFilter;
DECL_SMART_PTR(IDOMImageColorSpaceSubstitutionFilter);

class IDOMImageColorSpaceSubstitutionFilter : public IDOMImageFilter
{
#define IDOMImageColorSpaceSubstitutionFilterClassID 0x70CF33A5, 0xF8D24BB2, 0x97B3A27A, 0xEB957EF3
  public:
    static EDL_API IDOMImageColorSpaceSubstitutionFilterPtr create(IEDLClassFactory *pFactory, const IDOMColorSpacePtr &colorSpace);

    static const CClassID &classID()
    {
        static CClassID id(IDOMImageColorSpaceSubstitutionFilterClassID);
        return id;
    };

    class Data : public CClassParams
    {
      public:
        IDOMColorSpacePtr substituteColorSpace;
    };
 
};
#define edlobj2IDOMImageColorSpaceSubstitutionFilter(src) edl_cast((IDOMImageColorSpaceSubstitutionFilter *) nullptr, src)
 
class IDOMImageColorConverterFilter;
DECL_SMART_PTR(IDOMImageColorConverterFilter);

class IDOMImageColorConverterFilter : public IDOMImageFilter
{
#define IDOMImageColorConverterFilterClassID 0xCF41C4A8, 0xB63A46A0, 0x8F1648BC, 0xB266EC94
  public:
    static EDL_API IDOMImageColorConverterFilterPtr create(IEDLClassFactory *pFactory,
                                                           const IDOMColorSpacePtr &space,
                                                           eRenderingIntent intent,
                                                           eBlackPointCompensation bpc,
                                                           const CColorManagerConfigPtr &overrideConfig = CColorManagerConfigPtr());

    static EDL_API IDOMImageColorConverterFilterPtr createNaive(IEDLClassFactory *pFactory,
                                                           const IDOMColorSpacePtr &space);
 

    static const CClassID &classID()
    {
        static CClassID id(IDOMImageColorConverterFilterClassID);
        return id;
    };

    class Data : public CClassParams
    {
      public:
        Data() : renderingIntent(ePerceptual), bpc(eBPCDefault), naiveConversion(false) {}
        IDOMColorSpacePtr       destinationColorSpace;
        eRenderingIntent        renderingIntent;
        eBlackPointCompensation bpc;
        bool                    naiveConversion;
        CColorManagerConfigPtr  overrideConfig;
    };
 
};
#define edlobj2IDOMImageColorConverterFilter(src) edl_cast((IDOMImageColorConverterFilter *) nullptr, src)
 
class IDOMImageBleederFilter;
DECL_SMART_PTR(IDOMImageBleederFilter);

class IDOMImageBleederFilter : public IDOMImageFilter
{
#define IDOMImageBleederFilterClassID 0xB31F7AA7, 0x38F043B8, 0xAC94C932, 0xCE38D04C
  public:
    static EDL_API IDOMImageBleederFilterPtr create(IEDLClassFactory *pFactory, uint16 bleedPixels = 1);

    static const CClassID &classID()
    {
        static CClassID id(IDOMImageBleederFilterClassID);
        return id;
    };

    class Data : public CClassParams
    {
      public:
        Data() : bleedPixels(1) {}
        uint16 bleedPixels;
    };
 
};
#define edlobj2IDOMImageBleederFilter(src) edl_cast((IDOMImageBleederFilter *) nullptr, src)
 
 
class IDOMImageDownsamplerFilter;
DECL_SMART_PTR(IDOMImageDownsamplerFilter);

class IDOMImageDownsamplerFilter : public IDOMImageFilter
{
#define IDOMImageDownsamplerFilterClassID 0x4DAECA20, 0x882B4B32, 0xA136C61B, 0xAA0F626A
public:
    typedef enum
    {
        eSubsample,
        eAverage,
        eBicubic,
    } eDownsamplingMethod;
 

    static EDL_API IDOMImageDownsamplerFilterPtr create(IEDLClassFactory *pFactory,
                                                        double xRes, double yRes = 0.0,
                                                        eDownsamplingMethod method = eSubsample,
                                                        bool useFloatingPointResolution = false);

    static const CClassID &classID()
    {
        static CClassID id(IDOMImageDownsamplerFilterClassID);
        return id;
    };
 

    class Data : public CClassParams
    {
      public:
        Data() : desiredXRes(0.0), desiredYRes(0.0), method(eSubsample), useFloatingPointResolutions(false) {}
        double              desiredXRes;
        double              desiredYRes;
        eDownsamplingMethod method;
        bool                useFloatingPointResolutions;
    };
 
};
#define edlobj2IDOMImageDownsamplerFilter(src) edl_cast((IDOMImageDownsamplerFilter *) nullptr, src)
 
class IDOMImageUpsamplerFilter;
DECL_SMART_PTR(IDOMImageUpsamplerFilter);

class IDOMImageUpsamplerFilter : public IDOMImageFilter
{
#define IDOMImageUpsamplerFilterClassID 0xecf523f5, 0xada84947, 0x89004d50, 0x70f5741d
public:
    typedef enum
    {
        eBilinear,
        eBicubic,
    } eUpsamplingMethod;
 

    static EDL_API IDOMImageUpsamplerFilterPtr create(IEDLClassFactory *pFactory,
                                                      double xRes, double yRes = 0.0,
                                                      eUpsamplingMethod method = eBilinear,
                                                      bool useFloatingPointResolution = false);

    static const CClassID &classID()
    {
        static CClassID id(IDOMImageUpsamplerFilterClassID);
        return id;
    };

    class Data : public CClassParams
    {
      public:
        Data() : desiredXRes(0.0), desiredYRes(0.0), method(eBilinear), useFloatingPointResolutions(false) {}
        double              desiredXRes;
        double              desiredYRes;
        eUpsamplingMethod   method;
        bool                useFloatingPointResolutions;
    };
 
};
#define edlobj2IDOMImageUpsamplerFilter(src) edl_cast((IDOMImageUpsamplerFilter *) nullptr, src)
 
 
class IDOMImageMaskExpanderFilter;
DECL_SMART_PTR(IDOMImageMaskExpanderFilter);

class IDOMImageMaskExpanderFilter : public IDOMImageFilter
{
#define IDOMImageMaskExpanderFilterClassID 0xC1262ED1, 0x5AB2451C, 0x9F921341, 0xA89262FF
  public:

    static EDL_API IDOMImageMaskExpanderFilterPtr create(IEDLClassFactory *pFactory, const IDOMColorPtr &color);

    static const CClassID &classID()
    {
        static CClassID id(IDOMImageMaskExpanderFilterClassID);
        return id;
    };

    class Data : public CClassParams
    {
      public:
        IDOMColorPtr color;
    };
 
};
#define edlobj2IDOMImageMaskExpanderFilter(src) edl_cast((IDOMImageMaskExpanderFilter *) nullptr, src)
 
class IDOMImageDeindexerFilter;
DECL_SMART_PTR(IDOMImageDeindexerFilter);

class IDOMImageDeindexerFilter : public IDOMImageFilter
{
#define IDOMImageDeindexerFilterClassID 0x5FD82F65, 0xAC16414C, 0xB98FDA8F, 0xB0A5A5BA
  public:

    static EDL_API IDOMImageDeindexerFilterPtr create(IEDLClassFactory *pFactory);

    static const CClassID &classID()
    {
        static CClassID id(IDOMImageDeindexerFilterClassID);
        return id;
    };

    class Data : public CClassParams
    {
      public:
    };
 
};
#define edlobj2IDOMImageDeindexerFilter(src) edl_cast((IDOMImageDeindexerFilter *) nullptr, src)
 
 
class IDOMImageDeviceNToBaseFilter;
DECL_SMART_PTR(IDOMImageDeviceNToBaseFilter);

class IDOMImageDeviceNToBaseFilter : public IDOMImageFilter
{
#define IDOMImageDeviceNToBaseFilterClassID 0xA8BFA7A4, 0x3896470E, 0xBFF879DB, 0xE83F507A
  public:
    static EDL_API IDOMImageDeviceNToBaseFilterPtr create(IEDLClassFactory *pFactory);

    static const CClassID &classID()
    {
        static CClassID id(IDOMImageDeviceNToBaseFilterClassID);
        return id;
    };

    class Data : public CClassParams
    {
      public:
        Data() : fastLut(false) {}
        bool fastLut;
    };
 
};
#define edlobj2IDOMImageDeviceNToBaseFilter(src) edl_cast((IDOMImageDeviceNToBaseFilter *) nullptr, src)
 
class IDOMImageSpotMergerFilter;
DECL_SMART_PTR(IDOMImageSpotMergerFilter);

class IDOMImageSpotMergerFilter : public IDOMImageFilter
{
#define IDOMImageSpotMergerFilterClassID 0xe5baa5f5, 0xcfba4d6d, 0x84a158B3, 0x83d8b169
  public:
    static EDL_API IDOMImageSpotMergerFilterPtr create(IEDLClassFactory *pFactory,
                                                       const IDOMColorSpacePtr &inProcessSpace = IDOMColorSpacePtr(),
                                                       const IDOMColorSpacePtr &outProcessSpace = IDOMColorSpacePtr(),
                                                       bool mergeSpots = true,
                                                       const IDOMColorSpaceDeviceN::CColorantInfoVect &spotsToMerge = IDOMColorSpaceDeviceN::CColorantInfoVect(),
                                                       const JawsMako::CSpotColorNames &spotsToRetain = JawsMako::CSpotColorNames(),
                                                       const JawsMako::CSpotColorNames &spotsToDrop = JawsMako::CSpotColorNames(),
                                                       eRenderingIntent intent = eRelativeColorimetric,
                                                       eBlackPointCompensation bpc = eBPCDefault,
                                                       const CColorManagerConfigPtr &overrideConfig = CColorManagerConfigPtr());
 
    class CProcessConversion
    {
      public:
        CProcessConversion(const IDOMColorSpacePtr &_outProcessSpace = IDOMColorSpacePtr(),
                           eRenderingIntent _intent = eRelativeColorimetric,
                           eBlackPointCompensation _bpc = eBPCDefault)
        {
            outProcessSpace = _outProcessSpace;
            intent = _intent;
            bpc = _bpc;
        }
 
        bool operator== (const CProcessConversion &other) const
        {
            return      (other.outProcessSpace  == outProcessSpace)
                    &&  (other.intent           == intent)
                    &&  (other.bpc              == bpc);
        }
 
        bool operator!= (const CProcessConversion &other) const
        {
            return ! (*this == other);
        }
 
        IDOMColorSpacePtr       outProcessSpace;
        eRenderingIntent        intent;
        eBlackPointCompensation bpc;
    };
    typedef CEDLVector<CProcessConversion> CProcessConversionVect;

    static EDL_API IDOMImageSpotMergerFilterPtr create(IEDLClassFactory *pFactory,
                                                       const IDOMColorSpacePtr &inProcessSpace,
                                                       bool mergeSpots,
                                                       const IDOMColorSpaceDeviceN::CColorantInfoVect &spotsToMerge,
                                                       const JawsMako::CSpotColorNames &spotsToRetain,
                                                       const JawsMako::CSpotColorNames &spotsToDrop,
                                                       const CProcessConversionVect &processConversions = CProcessConversionVect(),
                                                       const CColorManagerConfigPtr &overrideConfig = CColorManagerConfigPtr());

    static const CClassID &classID()
    {
        static CClassID id(IDOMImageSpotMergerFilterClassID);
        return id;
    };

    class Data : public CClassParams
    {
      public:
        Data() : mergeSpots(true) {}
        IDOMColorSpacePtr                        inProcessSpace;
        bool                                     mergeSpots;
        IDOMColorSpaceDeviceN::CColorantInfoVect spotsToMerge;
        JawsMako::CSpotColorNames                spotsToRetain;
        JawsMako::CSpotColorNames                spotsToDrop;
        CProcessConversionVect                   processConversions;
        CColorManagerConfigPtr                   overrideConfig;
    };
 
};
#define edlobj2IDOMImageSpotMergerFilter(src) edl_cast((IDOMImageSpotMergerFilter *) nullptr, src)
 
class IDOMImagePermuteFilter;
DECL_SMART_PTR(IDOMImagePermuteFilter);

class IDOMImagePermuteFilter : public IDOMImageFilter
{
#define IDOMImagePermuteFilterClassID 0xf729eef8, 0xd6bc721, 0x894c2cd8, 0xc89a7B4c
  public:

    static EDL_API IDOMImagePermuteFilterPtr create(IEDLClassFactory *pFactory,
                                                    const IDOMColorSpacePtr &colorSpace,
                                                    const CEDLVector<int8> &permute);

    static const CClassID &classID()
    {
        static CClassID id(IDOMImagePermuteFilterClassID);
        return id;
    };

    class Data : public CClassParams
    {
      public:
        IDOMColorSpacePtr colorSpace;
        CEDLVector<int8>  permute;
    };
 
};
 
 
class IDOMImageInverterFilter;
DECL_SMART_PTR(IDOMImageInverterFilter);

class IDOMImageInverterFilter : public IDOMImageFilter
{
#define IDOMImageInverterFilterClassID 0x46147105, 0x981F496D, 0xB1F4910F, 0xCBB59B52
  public:

    static EDL_API IDOMImageInverterFilterPtr create(IEDLClassFactory *pFactory);

    static const CClassID &classID()
    {
        static CClassID id(IDOMImageInverterFilterClassID);
        return id;
    };

    class Data : public CClassParams
    {
      public:
    };
 
};
#define edlobj2IDOMImageInverterFilter(src) edl_cast((IDOMImageInverterFilter *) nullptr, src)
 
class IDOMDePremultiplierFilter;
DECL_SMART_PTR(IDOMDePremultiplierFilter);

class IDOMDePremultiplierFilter : public IDOMImageFilter
{
#define IDOMDePremultiplierFilterClassID 0x0fc321ce, 0xf33e4fa3, 0xb79dbab3, 0xe93e388f
  public:
    static EDL_API IDOMDePremultiplierFilterPtr create(IEDLClassFactory *pFactory);

    static const CClassID &classID()
    {
        static CClassID id(IDOMDePremultiplierFilterClassID);
        return id;
    };

    class Data : public CClassParams
    {
      public:
    };
 
};
#define edlobj2IDOMDePremultiplierFilter(src) edl_cast((IDOMDePremultiplierFilter *) nullptr, src)
 
class IDOMImageMatteRemoverFilter;
DECL_SMART_PTR(IDOMImageMatteRemoverFilter);

class IDOMImageMatteRemoverFilter : public IDOMImageFilter
{
#define IDOMImageMatteRemoverFilterClassID 0x3d883344, 0x1c134c8e, 0xb40f88bd, 0xaa427fd6
  public:
    static EDL_API IDOMImageMatteRemoverFilterPtr create(IEDLClassFactory *pFactory,
                                                         const IDOMColorPtr &matteColor,
                                                         const IDOMImagePtr &maskImage);

    static const CClassID &classID()
    {
        static CClassID id(IDOMImageMatteRemoverFilterClassID);
        return id;
    };
    
    virtual IDOMColorPtr getMatteColor() const = 0;

    class Data : public CClassParams
    {
      public:
        IDOMColorPtr matteColor;
        IDOMImagePtr maskImage;
    };
 
};
#define edlobj2IDOMImageMatteRemoverFilter(src) edl_cast((IDOMImageMatteRemoverFilter *) nullptr, src)
 
 
class IDOMImageBitScalerFilter;
DECL_SMART_PTR(IDOMImageBitScalerFilter);

class IDOMImageBitScalerFilter : public IDOMImageFilter
{
#define IDOMImageBitScalerFilterClassID 0x4CCE45A6, 0xA1C54615, 0x9E477ADB, 0xED305706
  public:
    static EDL_API IDOMImageBitScalerFilterPtr create(IEDLClassFactory *pFactory, uint8 bps);

    static const CClassID &classID()
    {
        static CClassID id(IDOMImageBitScalerFilterClassID);
        return id;
    };

    class Data : public CClassParams
    {
      public:
        uint8 desiredBPS; 
    };
 
};
#define edlobj2IDOMImageBitScalerFilter(src) edl_cast((IDOMImageBitScalerFilter *) nullptr, src)
 
class IDOMImageColorKeyFilter;
DECL_SMART_PTR(IDOMImageColorKeyFilter);

class IDOMImageColorKeyFilter : public IDOMImageFilter
{
#define IDOMImageColorKeyFilterClassID 0x46129cf8, 0xff2c481c, 0xa7e0c9c7, 0x8865835b
  public:
    static EDL_API IDOMImageColorKeyFilterPtr create(IEDLClassFactory *pFactory, const CEDLVector<uint16> &key);

    static const CClassID &classID()
    {
        static CClassID id(IDOMImageColorKeyFilterClassID);
        return id;
    };

    class Data : public CClassParams
    {
      public:
        CEDLVector<uint16> key;
    };
 
};
#define edlobj2IDOMImageColorKeyFilter(src) edl_cast((IDOMImageColorKeyFilter *) nullptr, src)
 
class IDOMImageDecodeFilter;
DECL_SMART_PTR(IDOMImageDecodeFilter);

class IDOMImageDecodeFilter : public IDOMImageFilter
{
#define IDOMImageDecodeFilterClassID 0x29a2d3a8, 0xe92b4752, 0xa6f44fa2, 0x65aba989
  public:
    static EDL_API IDOMImageDecodeFilterPtr create(IEDLClassFactory *pFactory, const CEDLVector<float> &decode);

    static const CClassID &classID()
    {
        static CClassID id(IDOMImageDecodeFilterClassID);
        return id;
    };

    class Data : public CClassParams
    {
      public:
        CEDLVector<float> decode;
    };
 
};
#define edlobj2IDOMImageDecodeFilter(src) edl_cast((IDOMImageDecodeFilter *) nullptr, src)
 
class IDOMImageCropperFilter;
DECL_SMART_PTR(IDOMImageCropperFilter);

class IDOMImageCropperFilter : public IDOMImageFilter
{
#define IDOMImageCropperFilterClassID 0xaa346d98, 0xa1B546cb, 0xae4a16ac, 0xd7f60017
  public:
    static EDL_API IDOMImageCropperFilterPtr create(IEDLClassFactory *pFactory, const IntRect &selectPixels);

    static const CClassID &classID()
    {
        static CClassID id(IDOMImageCropperFilterClassID);
        return id;
    };

    class Data : public CClassParams
    {
      public:
        IntRect selectPixels;
    };
 
};
#define edlobj2IDOMImageCropperFilter(src) edl_cast((IDOMImageCropperFilter *) nullptr, src)
 
class IDOMImagePortionFilter;
DECL_SMART_PTR(IDOMImagePortionFilter);

class IDOMImagePortionFilter : public IDOMImageFilter
{
#define IDOMImagePortionFilterClassID 0x754D1F39, 0xC6F345CB, 0xABD6F636, 0xAC4B6B66
  public:
    static EDL_API IDOMImagePortionFilterPtr create(IEDLClassFactory *pFactory, const IntRect &viewBox);

    static const CClassID &classID()
    {
        static CClassID id(IDOMImagePortionFilterClassID);
        return id;
    };

    class Data : public CClassParams
    {
      public:
        IntRect selectPixels;
    };
 
};
#define edlobj2IDOMImagePortionFilter(src) edl_cast((IDOMImagePortionFilter *) nullptr, src)
 
class IDOMImageFlipFilter;
DECL_SMART_PTR(IDOMImageFlipFilter);

class IDOMImageFlipFilter : public IDOMImageFilter
{
#define IDOMImageFlipFilterClassID  0x94CBBDB5, 0xC0EA4628, 0x90B33375, 0x32D316AB
 
  public:

    static EDL_API IDOMImageFlipFilterPtr create(IEDLClassFactory *pFactory, bool flipX, bool flipY);

    static const CClassID &classID()
    {
        static CClassID id(IDOMImageFlipFilterClassID);
        return id;
    };

    class Data : public CClassParams
    {
      public:
        bool    flipX = false;
        bool    flipY = false;
    };
 
};
#define edlobj2IDOMImageFlipFilter(src) edl_cast((IDOMImageFlipFilter *) nullptr, src)
 
class IDOMImageMaskDilatorFilter;
DECL_SMART_PTR(IDOMImageMaskDilatorFilter);

class IDOMImageMaskDilatorFilter : public IDOMImageFilter
{
#define IDOMImageMaskDilatorFilterClassID 0x62a2a3fb, 0x1fd84a8f, 0xa1bff7Bd, 0x335c6B60
  public:

    static EDL_API IDOMImageMaskDilatorFilterPtr create(IEDLClassFactory *pFactory);

    static const CClassID &classID()
    {
        static CClassID id(IDOMImageMaskDilatorFilterClassID);
        return id;
    };
 
};
#define edlobj2IDOMImageMaskDilatorFilter(src) edl_cast((IDOMImageMaskDilatorFilter *) nullptr, src)
 
class IDOMFilteredImage;
DECL_SMART_PTR(IDOMFilteredImage);

class IDOMFilteredImage : public IDOMImage
{
#define IDOMFilteredImageClassID 0xC4ACE9A2, 0xC45F4060, 0x98F9788A, 0x5D84C9F0
  public:
    static EDL_API IDOMFilteredImagePtr create(IEDLClassFactory *pFactory, const IDOMImagePtr &sourceImage, const IDOMImageFilterPtr &filter);

    static EDL_API IDOMFilteredImagePtr create(IEDLClassFactory *pFactory, const IDOMImagePtr &sourceImage, const CDOMImageFilterVect &filters);

    class Data : public IDOMImage::Data
    {
      public:
        CDOMImageFilterVect filters;
        IDOMImagePtr sourceImage;
    };

    static const CClassID &classID()
    {
        static CClassID id(IDOMFilteredImageClassID);
        return id;
    };

    virtual void pushFilter(const IDOMImageFilterPtr &filter) = 0;

    virtual uint32 getNumFilters() const = 0;

    virtual IDOMImageFilterPtr getFilterAtIndex(uint32 index) const = 0;

    virtual IDOMImagePtr getSourceImage() const = 0;
 

    virtual bool getStream(IInputStreamPtr &stream) const
    {
        stream = IInputStreamPtr ();
        return false;
    }

    virtual void setStream(const IInputStreamPtr &stream)
    {
        UNREFERENCED_PARAMETER(stream);
        throwEDLError (EDL_ERR_UNDEFINED);
    }
};
#define edlobj2IDOMFilteredImage(src) edl_cast((IDOMFilteredImage *) nullptr, src)
 
 
class IDOMCustomImage;
DECL_SMART_PTR(IDOMCustomImage);

class IDOMCustomImage : public IDOMImage
{
#define IDOMCustomImageClassID 0xc5984a51, 0x94894b93, 0xa5a1e0fa, 0x21da5267
  public:
    
    class ICustomImageFrame
    {
      public:
        virtual ~ICustomImageFrame() = default;
        
#ifdef SWIG
#if SWIGCSHARP
        %apply char *ARRAY_OUTPUT_SIZEINDEX_1 { void *pScanLine };
#endif
#if SWIGJAVA
        %apply signed char *INOUT {void *pScanLine};
#endif
#if SWIGPYTHON
        %apply char INOUT[] {void *pScanLine};
#endif
#endif
        virtual void readScanLine (void *pScanLine, size_t bufferSize) = 0;
#ifdef SWIG
        %clear void *pScanLine;
#endif
        
        virtual void skipScanLines (uint32 skipCount) = 0;
    };
    typedef std::shared_ptr<ICustomImageFrame> ICustomImageFramePtr;

    class ICustomImageData
    {
      public:
        virtual ~ICustomImageData() = default;
        
        virtual IDOMColorSpacePtr getColorSpace() = 0;
        
        virtual uint32 getWidth() = 0;
        
        virtual uint32 getHeight() = 0;
        
        virtual uint8 getDepth() = 0;

        virtual double getXResolution() = 0;

        virtual double getYResolution() = 0;

        virtual eImageExtraChannelType getExtraChannelType() = 0;
        
        virtual uint32 getRawBytesPerRow () = 0;

        virtual bool getEfficientlySkippable() = 0;

        virtual uint64 getKey() = 0;
        
        virtual bool shouldCache() = 0;
        
        virtual ICustomImageFramePtr getFrame() = 0;
    };
    typedef std::shared_ptr<ICustomImageData> ICustomImageDataPtr;
 
    
    static EDL_API IDOMCustomImagePtr create(IEDLClassFactory *pFactory,
                                             const ICustomImageDataPtr &imageData,
                                             eDOMImageType imageType = eDITUnknown);

    class Data : public IDOMImage::Data
    {
      public:
        ICustomImageDataPtr imageData;
    };

    static const CClassID &classID()
    {
        static CClassID id(IDOMCustomImageClassID);
        return id;
    };
    
    virtual ICustomImageDataPtr getImageData() const = 0;

    IInputStreamPtr getStream() const override
    {
        return IInputStreamPtr ();
    }

    void setStream(const IInputStreamPtr &) override
    {
        throwEDLError (EDL_ERR_UNDEFINED);
    }
};
#define edlobj2IDOMCustomImage(src) edl_cast((IDOMCustomImage *) nullptr, src)
 
 
_END_EDL_DOM_NAMESPACE
 
#endif /* IDOMIMAGERESOURCE_H */