LibPSD.h

Go to the documentation of this file.

#ifndef __LIBPSD_H_       
#define __LIBPSD_H_
#include <stdlib.h>
#include <stdio.h>
#include <vector>


static const char *PSDErrorString[] = {
   "PSD_SUCCESS",
   "PSD_FAIL",
   "PSD_MEMORY_FAILURE",
   "PSD_ERROR_OPENING_FILE",
   "PSD_FOPEN_FAIL",
   "PSD_FILE_NOT_PSD",
   "PSD_READ_ERROR",
   "PSD_WRITE_ERROR",
   "PSD_WRONG_VERSION",
   "PSD_NO_INSTANCE",
   "PSD_INDEX_OUT_OF_RANGE",
   "PSD_FILE_HEADER_NOT_VALID",
   "PSD_PSDFILE_ERROR",
   "PSD_INVALID_LAYER",
   "PSD_CHANNEL_INDEX_OUT_OF_RANGE", 
   "PSD_LAYER_INDEX_OUT_OF_RANGE", 
   "PSD_DECOMPRESSION_ERROR",
   "PSD_BITDEPTH_ERROR"
};


namespace adsk { namespace libPSD { 
                                          
class PSDFile;

enum PSDBlendMode
{
    blendNORMAL = 0,
    blendMULTIPLY,
    blendDARKEN,
    blendDIFFERENCE,
    blendEXCLUSION,
    blendHARDLIGHT,
    blendCOLORDODGE,
    blendLIGHTEN,
    blendSCREEN,
    blendCOLORBURN,
    blendOVERLAY,
    blendHUE,
    blendSATURATION,
    blendLUMINOSITY,
    blendCOLOR,
    blendDISSOLVE,
    blendSOFTLIGHT,
    blendLINEARDODGE,
    blendVIVIDLIGHT,
    blendLINEARBURN,
    blendLINEARLIGHT,
    blendPINLIGHT,
    blendHARDMIX, 
    blendDARKERCOLOR,
    blendLIGHTERCOLOR,
    blendSUBTRACT,
    blendDIVIDE,          
    blendUNKNOW
};

enum PSDError {
    PSD_SUCCESS = 0,
    PSD_FAIL,
    PSD_MEMORY_FAILURE,
    PSD_ERROR_OPENING_FILE,
    PSD_FOPEN_FAIL,
    PSD_FILE_NOT_PSD,
    PSD_READ_ERROR,
    PSD_WRITE_ERROR,
    PSD_WRONG_VERSION,
    PSD_NO_INSTANCE,
    PSD_INDEX_OUT_OF_RANGE,
    PSD_FILE_HEADER_NOT_VALID,
    PSD_PSDFILE_ERROR,
    PSD_INVALID_LAYER,
    PSD_CHANNEL_INDEX_OUT_OF_RANGE, 
    PSD_LAYER_INDEX_OUT_OF_RANGE, 
    PSD_DECOMPRESSION_ERROR,
    PSD_BITDEPTH_ERROR
};



enum CompressionMethod 
{
    PSD_COMPRESSION_NONE = -1,
    PSD_COMPRESSION_RAW, 
    PSD_COMPRESSION_RLE,        
    PSD_COMPRESSION_ZIP, 
    PSD_COMPRESSION_ZIP_PREDICTION 
};

struct BlendChannelInfo
{
    unsigned int  source;
    unsigned int  destination;
    BlendChannelInfo() : source(0), destination(0) {}
};

enum layerType { LAYER_NORMAL = 0, 
                 LAYER_SET_OPEN, 
                 LAYER_SET_CLOSED, 
                 LAYER_DIVIDER 
};

struct SectionDividerSetting
{
    unsigned int    layerType;
    unsigned int    signature;
    unsigned int    blendKey;
    SectionDividerSetting() : layerType(0), signature(0), blendKey(0) {}
};

struct AdditionalLayerInfo
{
    unsigned int    signature;
    unsigned int    key;
    unsigned int    dataLength;
    unsigned char*  variableData;
    AdditionalLayerInfo() : signature(0), key(0), dataLength(0), variableData(0) {}
};

struct RESOLUTIONINFO {
   unsigned int     hRes;         // Fixed-point number: pixels per inch
   unsigned short   hResUnit;     // 1=pixels per inch, 2=pixels per centimeter
   unsigned short   WidthUnit;    // 1=in, 2=cm, 3=pt, 4=picas, 5=columns
   unsigned int     vRes;         // Fixed-point number: pixels per inch
   unsigned short   vResUnit;     // 1=pixels per inch, 2=pixels per centimeter
   unsigned short   HeightUnit;   // 1=in, 2=cm, 3=pt, 4=picas, 5=columns 
   RESOLUTIONINFO() : hRes(0), hResUnit(0), WidthUnit(0), vRes(0), vResUnit(0), HeightUnit(0) {}
};

struct LAYERSTATE {        
    unsigned short  state;        // 2 byte index of target layer (current layer) 0 = bottom.
    LAYERSTATE() : state(0) {}
};

struct IMAGERESOURCES {
    unsigned int    signature;
    unsigned short  key;
    char*           resName;
    unsigned int    resLength;
    char*           variableResData;
    IMAGERESOURCES() : signature('8BIM'), key(0), resName(0), resLength(0), variableResData(0) {}
};

struct PSD_FILE_HEADER {
    int             signature;  //-- "8BPS"
    unsigned short  version;    //-- Always 1
    char            fileRes[6];
    unsigned short  channels;   //-- 1 to 24
    unsigned int    height;     //-- Height 
    unsigned int    width;      //-- Width
    unsigned short  depthValue; //-- 1, 8, or 16, or 32.
    unsigned short  colorMode;  //-- PH_xxx Above
    PSD_FILE_HEADER() : signature('8BPS'), version(1), channels(4), height(0), width(0), depthValue(8), colorMode(3) {}
};

class MBDLL_DECL LRect
{
public  :
    LRect(int left=0, int top=0, int right=0, int bottom=0);
    LRect& operator= (const LRect& LR);

    int  top;
    int  left;
    int  bottom;
    int  right;
} ;

inline LRect::LRect(int inLeft, int inTop, int inRight, int inBottom)
{
    left    = inLeft ;
    right   = inRight ;
    top     = inTop ;
    bottom  = inBottom ;
}

inline  LRect& LRect::operator= (const LRect& LR)
{
    if (this != &LR) {
        this->bottom = LR.bottom;
        this->left   = LR.left;
        this->right  = LR.right;
        this->top    = LR.top;
    }
    return *this;
}

// Layer information structures
class  MBDLL_DECL ChannelInfo
{
public :
        ChannelInfo();

        short               channelID;
        int                 channelDataLen;
        CompressionMethod   channelCompression;
        unsigned int        channelPos;
} ;

inline ChannelInfo::ChannelInfo()
    : channelID(0)
    ,channelDataLen(0)
    ,channelCompression(PSD_COMPRESSION_RAW)
    ,channelPos(0)
{ }

//------------------------------------------------------------------------------
class  MBDLL_DECL PSDLayerMeta
{
friend class PSDFile;

public :
    PSDLayerMeta();
    ~PSDLayerMeta();

    LRect                     m_layerRect;
    unsigned short            m_numChannels;
    std::vector<ChannelInfo>  m_channelInfo;

    unsigned int              m_blendModeSig;
    unsigned int              m_blendModeKey;
    unsigned char             m_baseClipping;
    unsigned char             m_filler;
    unsigned int              m_extraDataField;

    unsigned int              m_layerMaskSize;
    LRect                     m_vectorMaskRect;
    char                      m_vectorMaskColor;
    char                      m_vectorMaskFlags;

    LRect                     m_layerMaskRect;
    char                      m_layerMaskFlags;
    char                      m_userMaskBgColor;
    unsigned int              m_blendRangeSize;
    unsigned int              m_grayBlendSource;
    unsigned int              m_grayBlendDest;
    BlendChannelInfo*         m_BlendChannelRange; 

    unsigned int              m_width;
    unsigned int              m_height;
    unsigned int              m_nbPixels;

    unsigned int              m_numAdditionalLayers;
    AdditionalLayerInfo*      m_listAddLayerInfo;

    // for layerType, see "lsct" Section Divider Setting 
    //  on page 39 of File Format pdf 
    SectionDividerSetting     m_sectionDivider; // lsct data
    unsigned int              m_layerId;        // Layer ID which needs to be read and updated
                                                // to the resources section.

public:
    const QString&      getName() const { return m_layerName; }
    void                setName(const QString& layerName);

    // 0.0 is completely transparent, 1.0 is completely opaque
    float               getOpacity() const { return m_opacity/255.0f; }
    void                setOpacity(float opacity);

    // locked
    bool                getTransparencyProtected() const{return (bool)(m_optionFlags & 0x01);}
    void                setTransparencyProtected(bool trsProtected);

    bool                getLocked() const             { return m_bLocked;   }
    void                setLocked(bool locked = true) { m_bLocked = locked; }
    
    // visibility flag
    bool                getVisibility() const {return (bool)!(m_optionFlags & 0x02);}
    void                setVisibility(bool visFlag);


    PSDBlendMode        getBlendingType() const;
    void                setBlendingType(PSDBlendMode blendMode);

    void                setNbChannel(unsigned short nbChannel) {m_numChannels=nbChannel;}
    void                setLayerRect(int top, int left, int bottom, int right);
    void                setChannelInfo(CompressionMethod method, 
                                       unsigned short nbChannel = 4);

private :
    void                readEachLayerRecord(PSDFile*       psdFile, 
                                            unsigned int & actualSize);

    PSDLayerMeta&       operator=   (const PSDLayerMeta *LM);

    QString             m_layerName;
    unsigned char       m_opacity;
    unsigned char       m_optionFlags;
    bool                m_bWroteToFile;
    bool                m_bLocked;
};

//------------------------------------------------------------------------------
class  MBDLL_DECL PSDFileMeta {

    friend class PSDFile;
    // PSD File header block gets filled here.
    struct VersionInfo {    
        unsigned int    version;
        bool            hasRealMergedData;
        int             writerNameL;
        char*           writerName;
        int             readerNameL;
        char*           readerName;
        unsigned int    fileVersion;
        VersionInfo() : version(0), hasRealMergedData(0), writerNameL(0), 
                        writerName(0), readerNameL(0), readerName(0), fileVersion(0) {}
    };


    class ThumbnailResource
    {
        unsigned int    format;                 // 1 = kJpegRGB . Also supports kRawRGB (0).
        unsigned int    width;                  // Width of thumbnail in pixels.
        unsigned int    height;                 // Height of thumbnail in pixels.
        unsigned int    width_bytes;            // Padded row bytes = (width * bits per pixel + 31) / 32 * 4.
        unsigned int    total_size;             // Total size = widthbytes * height * planes
        unsigned int    size_after_compression; // Used for consistency check.
        unsigned int    bits_per_pixel;         // 24
        unsigned int    number_of_planes;       // 1
        unsigned char*  jfif_data;             
        unsigned int*   thumbnail_data;  
        ThumbnailResource() : format(0), width(0), height(0),                
                              width_bytes(0), total_size(0), size_after_compression(0), 
                              bits_per_pixel(0), number_of_planes(0), jfif_data(0), thumbnail_data(0) {}       
    };

private:
    void DestroyVI();
    void DestroyThumbnail();

    RESOLUTIONINFO*     m_pResolutionInfo;
    unsigned int        m_imageResourcesSize;
    unsigned char*      m_colorData;
    unsigned int        m_colorDataSize;
    LAYERSTATE*         m_pLayerState;
    PSDFileMeta&        operator= (const PSDFileMeta &FM); 

public: 
    PSDFileMeta();
    ~PSDFileMeta();
    /*
    * Get/Set the X Resolution in Pixel per Inch.
    */
    float               GetXResolution() const;
    void                SetXResolution(float xres);
    /*
    * Get/Set the Y Resolution in Pixel per Inch.
    */
    float               GetYResolution() const;
    void                SetYResolution(float yres);
    /*
    * Get the resolution unit 
    * @Return value short 0=none, 1=pixels per inch, 2=pixels per centimeter
    */
    unsigned short      GetResUnit() const;
    void                SetResUnit(unsigned short resUnit);
    bool                SetFileHeaderStruct(unsigned int inWidth, unsigned int inHeight, 
                                            unsigned short inColorDepth, 
                                            unsigned short inChannels);
    /*
    * Get/Set the number of layer.
    *
    */
    unsigned int        GetNbLayers() const                { return m_numLayers; }
    void                SetNbLayers(unsigned int nbLayers) { m_numLayers = nbLayers; }

    // ColorModeData
    bool                SetColorModeData(unsigned char* colorModeData, 
                                         unsigned int   colorModeDataSize);

    // Get/Set the layer state.
    bool                LayerStateValid() const { return m_pLayerState != 0;   }
    unsigned short      GetLayerState()   const { return m_pLayerState->state; }
    void                SetLayerState(unsigned short layerState);
    
    // Synch File Resources
    void                Synch();

    PSD_FILE_HEADER     m_hdr;
    VersionInfo         m_vi;
    ThumbnailResource*  m_pThumbnail;
    unsigned int        m_numLayers; // to obtain the layer count, we need to 
                                     // read the layer&mask section.
    std::vector<IMAGERESOURCES*> m_vImageRes;
};


//------------------------------------------------------------------------------
PSDFile   MBDLL_DECL    *PSDOpen(const QString& fileName, bool write = false);

//------------------------------------------------------------------------------
PSDError   MBDLL_DECL   PSDGetLastError(PSDFile *psdFile);

//------------------------------------------------------------------------------
const MBDLL_DECL  PSDFileMeta   *PSDGetFileMeta(const PSDFile *psdFile);

//------------------------------------------------------------------------------
bool  MBDLL_DECL        PSDSetFileMeta(PSDFile *psdFile, 
                                       const PSDFileMeta *psdFileMeta);

//------------------------------------------------------------------------------
const MBDLL_DECL  PSDLayerMeta     *PSDGetLayerMeta(const PSDFile *psdFile, 
                                        unsigned int   layerIndex);


//------------------------------------------------------------------------------
void  MBDLL_DECL        PSDSetLayerMeta(PSDFile *psdFile, unsigned int layerIndex, 
                                        PSDLayerMeta *psdLayerMeta);


//------------------------------------------------------------------------------
bool MBDLL_DECL PSDReadChannelImageData(PSDFile         *psdFile, 
                                        unsigned int     layerIndex, 
                                        unsigned int     channelIndex, 
                                        void            *buffer, 
                                        size_t           bufferSize);
                            
bool MBDLL_DECL PSDWriteChannelImageData(PSDFile        *psdFile, 
                                         unsigned int    layerIndex, 
                                         unsigned int    channelIndex, 
                                         void           *buffer, 
                                         size_t          bufferSize);
                             
bool MBDLL_DECL PSDReadChannelImageData(PSDFile         *psdFile, 
                                        void            *buffer, 
                                        size_t           bufferSize);

bool MBDLL_DECL PSDReadCompositeImageData(PSDFile       *psdFile, 
                                          unsigned int   imageWidth, 
                                          unsigned int   imageHeight, 
                                          void          *buffer, 
                                          size_t         bufferSize);     
                              
bool MBDLL_DECL PSDWriteCompositeImageData(PSDFile      *psdFile, 
                                           unsigned int  imageWidth, 
                                           unsigned int  imageHeight, 
                                           CompressionMethod compressMethod, 
                                           void         *buffer, 
                                           size_t        bufferSize);
     
bool MBDLL_DECL PSDWrite4ChanCompositeImageData(PSDFile     *psdFile, 
                                                unsigned int imageWidth, 
                                                unsigned int imageHeight, 
                                                CompressionMethod compressMethod, 
                                                void **ARGBPixels);
 
//------------------------------------------------------------------------------
void  MBDLL_DECL        PSDClose(PSDFile *psdFile);



// Helper/utility functions

//-----------------------------------------------------------------------------
bool  MBDLL_DECL PSDBlendLayers(unsigned char* rSrc, unsigned char* gSrc,
                    unsigned char* bSrc, unsigned char* aSrc, 
                    float glbOpacity,    LRect          inRectLayer1, 
                    int blendMode, unsigned int inWidth, unsigned int inHeight,
                    unsigned char* &rDst, unsigned char* &gDst,
                    unsigned char* &bDst, unsigned char* &aDst);

//-----------------------------------------------------------------------------
void  MBDLL_DECL PSDInterleaveImageData(int nPixels, const unsigned char *r, const unsigned char *g, 
                                         const unsigned char *b, const unsigned char *a, 
                                         unsigned int *target, bool multAlpha=true);

//-----------------------------------------------------------------------------
void  MBDLL_DECL PSDInterleaveImageData16_16(int nPixels, 
                                 const unsigned short *r, const unsigned short *g, 
                                 const unsigned short *b, const unsigned short *a, 
                                 unsigned short *target, bool multAlpha=true);


//-----------------------------------------------------------------------------
void  MBDLL_DECL PSDInterleaveImageData32_32(int nPixels, const float *r, const float *g, 
                                              const float *b, const float *a, 
                                              float *target,  bool multAlpha=true);


//-----------------------------------------------------------------------------
void  MBDLL_DECL PSDInterleaveImageData16(int nPixels, const unsigned short *r, const unsigned short *g, 
                                           const unsigned short *b, const unsigned short *a, 
                                           unsigned int *target, bool multAlpha=true);

//-----------------------------------------------------------------------------
void  MBDLL_DECL PSDInterleaveImageData32(int nPixels, const float *r, const float *g, 
                                           const float *b, const float *a, 
                                           unsigned int *target, bool multAlpha=true);


};}; //namespace Adsk;libPSD 
#endif