image.hpp

// ***************************************************************** -*- C++ -*-
/*
 * Copyright (C) 2004-2021 Exiv2 authors
 * This program is part of the Exiv2 distribution.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, 5th Floor, Boston, MA 02110-1301 USA.
 */
#ifndef IMAGE_HPP_
#define IMAGE_HPP_
 
// *****************************************************************************
#include "exiv2lib_export.h"
 
// included header files
#include "basicio.hpp"
#include "exif.hpp"
#include "iptc.hpp"
#include "xmp_exiv2.hpp"
 
// + standard includes
#include <string>
#include <vector>
 
// *****************************************************************************
// namespace extensions
namespace Exiv2 {
 
// *****************************************************************************
// class definitions

    namespace ImageType {
        const int none = 0;         
    }

    struct NativePreview {
        long position_;                         
        uint32_t size_;                         
        uint32_t width_;                        
        uint32_t height_;                       
        std::string filter_;                    
        std::string mimeType_;                  
    };

    typedef std::vector<NativePreview> NativePreviewList;

    typedef enum { kpsNone, kpsBasic, kpsXMP, kpsRecursive
                 , kpsIccProfile    , kpsIptcErase
                 } PrintStructureOption;

    class EXIV2API Image {
    public:
        typedef std::auto_ptr<Image> AutoPtr;



        Image(int              imageType,
              uint16_t         supportedMetadata,
              BasicIo::AutoPtr io);
        virtual ~Image();



        virtual void printStructure(std::ostream& out, PrintStructureOption option =kpsNone, int depth=0);
        virtual void readMetadata() =0;
        virtual void writeMetadata() =0;
        virtual void setExifData(const ExifData& exifData);
        virtual void clearExifData();
        virtual void setIptcData(const IptcData& iptcData);
        virtual void clearIptcData();
        virtual void setXmpPacket(const std::string& xmpPacket);
        virtual void clearXmpPacket();
        virtual void setXmpData(const XmpData& xmpData);
        virtual void clearXmpData();
        virtual void setComment(const std::string& comment);
        virtual void clearComment();
        virtual void setIccProfile(DataBuf& iccProfile,bool bTestValid=true);
        virtual void clearIccProfile();
        virtual bool iccProfileDefined() { return iccProfile_.size_?true:false;}

        virtual DataBuf* iccProfile() { return &iccProfile_; }
        virtual void setMetadata(const Image& image);
        virtual void clearMetadata();
        virtual ExifData& exifData();
        virtual IptcData& iptcData();
        virtual XmpData& xmpData();
        virtual std::string& xmpPacket();
        void writeXmpFromPacket(bool flag);
        void setByteOrder(ByteOrder byteOrder);

        void printTiffStructure(BasicIo& io,std::ostream& out, PrintStructureOption option,int depth,size_t offset=0);

        void printIFDStructure(BasicIo& io, std::ostream& out, Exiv2::PrintStructureOption option,uint32_t start,bool bSwap,char c,int depth);

        bool isBigEndianPlatform();

        bool isLittleEndianPlatform();
 
        bool isStringType(uint16_t type);
        bool isShortType(uint16_t type);
        bool isLongType(uint16_t type);
        bool isLongLongType(uint16_t type);
        bool isRationalType(uint16_t type);
        bool is2ByteType(uint16_t type);
        bool is4ByteType(uint16_t type);
        bool is8ByteType(uint16_t type);
        bool isPrintXMP(uint16_t type, Exiv2::PrintStructureOption option);
        bool isPrintICC(uint16_t type, Exiv2::PrintStructureOption option);
 
        uint64_t byteSwap(uint64_t value,bool bSwap) const;
        uint32_t byteSwap(uint32_t value,bool bSwap) const;
        uint16_t byteSwap(uint16_t value,bool bSwap) const;
        uint16_t byteSwap2(const DataBuf& buf,size_t offset,bool bSwap) const;
        uint32_t byteSwap4(const DataBuf& buf,size_t offset,bool bSwap) const;
        uint64_t byteSwap8(const DataBuf& buf,size_t offset,bool bSwap) const;




        ByteOrder byteOrder() const;
        bool good() const;
        virtual std::string mimeType() const =0;
        virtual int pixelWidth() const;
        virtual int pixelHeight() const;
        virtual const ExifData& exifData() const;
        virtual const IptcData& iptcData() const;
        virtual const XmpData& xmpData() const;
        virtual std::string comment() const;
        virtual const std::string& xmpPacket() const;
        virtual BasicIo& io() const;
        AccessMode checkMode(MetadataId metadataId) const;
        bool supportsMetadata(MetadataId metadataId) const;
        bool writeXmpFromPacket() const;
        const NativePreviewList& nativePreviews() const;

        void setTypeSupported(
            int              imageType,
            uint16_t         supportedMetadata
        ) {
            imageType_         = imageType;
            supportedMetadata_ = supportedMetadata;
        }

        int imageType() const { return imageType_; }
 
    protected:
        // DATA
        BasicIo::AutoPtr  io_;                
        ExifData          exifData_;          
        IptcData          iptcData_;          
        XmpData           xmpData_;           
        DataBuf           iccProfile_;        
        std::string       comment_;           
        std::string       xmpPacket_;         
        int               pixelWidth_;        
        int               pixelHeight_;       
        NativePreviewList nativePreviews_;    

        const std::string& tagName(uint16_t tag);

        const char* typeName(uint16_t tag) const;
 
    private:


        Image(const Image& rhs);
        Image& operator=(const Image& rhs);
 
        // DATA
        int               imageType_;         
        uint16_t          supportedMetadata_; 
        bool              writeXmpFromPacket_;
        ByteOrder         byteOrder_;         
 
        std::map<int,std::string> tags_;      
        bool                      init_;      
 
    }; // class Image

    typedef Image::AutoPtr (*NewInstanceFct)(BasicIo::AutoPtr io, bool create);
    typedef bool (*IsThisTypeFct)(BasicIo& iIo, bool advance);

    class EXIV2API ImageFactory {
        friend bool Image::good() const;
    public:
        static BasicIo::AutoPtr createIo(const std::string& path, bool useCurl = true);
#ifdef EXV_UNICODE_PATH
        static BasicIo::AutoPtr createIo(const std::wstring& wpath, bool useCurl = true);
#endif
        static Image::AutoPtr open(const std::string& path, bool useCurl = true);
#ifdef EXV_UNICODE_PATH
        static Image::AutoPtr open(const std::wstring& wpath, bool useCurl = true);
#endif
        static Image::AutoPtr open(const byte* data, long size);
        static Image::AutoPtr open(BasicIo::AutoPtr io);
        static Image::AutoPtr create(int type, const std::string& path);
#ifdef EXV_UNICODE_PATH
        static Image::AutoPtr create(int type, const std::wstring& wpath);
#endif
        static Image::AutoPtr create(int type);
        static Image::AutoPtr create(int type, BasicIo::AutoPtr io);
        static int getType(const std::string& path);
#ifdef EXV_UNICODE_PATH
        static int getType(const std::wstring& wpath);
#endif
        static int getType(const byte* data, long size);
        static int getType(BasicIo& io);
        static AccessMode checkMode(int type, MetadataId metadataId);
        static bool checkType(int type, BasicIo& io, bool advance);
 
    private:


        ImageFactory();
        ImageFactory(const ImageFactory& rhs);
 
    }; // class ImageFactory
 
// *****************************************************************************
// template, inline and free functions

    EXIV2API void append(Exiv2::Blob& blob, const byte* buf, uint32_t len);
 
}                                       // namespace Exiv2
 
#endif                                  // #ifndef IMAGE_HPP_