tiffvisitor_int.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 TIFFVISITOR_INT_HPP_
#define TIFFVISITOR_INT_HPP_
 
// *****************************************************************************
// included header files
#include "exif.hpp"
#include "tifffwd_int.hpp"
#include "types.hpp"
 
// + standard includes
#include <memory>
#include <iostream>
#include <iomanip>
#include <cassert>
#include <map>
#include <set>
#include <vector>
 
// *****************************************************************************
// namespace extensions
namespace Exiv2 {
 
    class IptcData;
    class XmpData;
 
    namespace Internal {
 
// *****************************************************************************
// class definitions
 
    class TiffVisitor {
    public:
        enum GoEvent {
            geTraverse       = 0,
            geKnownMakernote = 1
            // Note: If you add more events here, adjust the events_ constant too!
        };
 
    private:
        static const int events_ = 2;  
        bool go_[events_];             
 
    public:
 
 
        TiffVisitor();
        virtual ~TiffVisitor();
 
 
 
        void setGo(GoEvent event, bool go);
        virtual void visitEntry(TiffEntry* object) =0;
        virtual void visitDataEntry(TiffDataEntry* object) =0;
        virtual void visitImageEntry(TiffImageEntry* object) =0;
        virtual void visitSizeEntry(TiffSizeEntry* object) =0;
        virtual void visitDirectory(TiffDirectory* object) =0;
        virtual void visitDirectoryNext(TiffDirectory* object);
        virtual void visitDirectoryEnd(TiffDirectory* object);
        virtual void visitSubIfd(TiffSubIfd* object) =0;
        virtual void visitMnEntry(TiffMnEntry* object) =0;
        virtual void visitIfdMakernote(TiffIfdMakernote* object) =0;
        virtual void visitIfdMakernoteEnd(TiffIfdMakernote* object);
        virtual void visitBinaryArray(TiffBinaryArray* object) =0;
        virtual void visitBinaryArrayEnd(TiffBinaryArray* object);
        virtual void visitBinaryElement(TiffBinaryElement* object) =0;
 
 
 
        bool go(GoEvent event) const;
 
    }; // class TiffVisitor
 
    class TiffFinder : public TiffVisitor {
    public:
 
 
        TiffFinder(uint16_t tag, IfdId group)
            : tag_(tag), group_(group), tiffComponent_(0) {}
        virtual ~TiffFinder();
 
 
 
        virtual void visitEntry(TiffEntry* object);
        virtual void visitDataEntry(TiffDataEntry* object);
        virtual void visitImageEntry(TiffImageEntry* object);
        virtual void visitSizeEntry(TiffSizeEntry* object);
        virtual void visitDirectory(TiffDirectory* object);
        virtual void visitSubIfd(TiffSubIfd* object);
        virtual void visitMnEntry(TiffMnEntry* object);
        virtual void visitIfdMakernote(TiffIfdMakernote* object);
        virtual void visitBinaryArray(TiffBinaryArray* object);
        virtual void visitBinaryElement(TiffBinaryElement* object);
 
        void findObject(TiffComponent* object);
        void init(uint16_t tag, IfdId group);
 
 
 
        TiffComponent* result() const { return tiffComponent_; }
 
    private:
        uint16_t tag_;
        IfdId group_;
        TiffComponent* tiffComponent_;
    }; // class TiffFinder
 
    class TiffCopier : public TiffVisitor {
    public:
 
 
        TiffCopier(      TiffComponent*  pRoot,
                         uint32_t        root,
                   const TiffHeaderBase* pHeader,
                   const PrimaryGroups*  pPrimaryGroups);
        virtual ~TiffCopier();
 
 
 
        virtual void visitEntry(TiffEntry* object);
        virtual void visitDataEntry(TiffDataEntry* object);
        virtual void visitImageEntry(TiffImageEntry* object);
        virtual void visitSizeEntry(TiffSizeEntry* object);
        virtual void visitDirectory(TiffDirectory* object);
        virtual void visitSubIfd(TiffSubIfd* object);
        virtual void visitMnEntry(TiffMnEntry* object);
        virtual void visitIfdMakernote(TiffIfdMakernote* object);
        virtual void visitBinaryArray(TiffBinaryArray* object);
        virtual void visitBinaryElement(TiffBinaryElement* object);
 
        void copyObject(TiffComponent* object);
 
    private:
              TiffComponent*  pRoot_;
              uint32_t        root_;
        const TiffHeaderBase* pHeader_;
        const PrimaryGroups*  pPrimaryGroups_;
    }; // class TiffCopier
 
    class TiffDecoder : public TiffVisitor {
    public:
 
 
        TiffDecoder(
            ExifData&            exifData,
            IptcData&            iptcData,
            XmpData&             xmpData,
            TiffComponent* const pRoot,
            FindDecoderFct       findDecoderFct
        );
        virtual ~TiffDecoder();
 
 
 
        virtual void visitEntry(TiffEntry* object);
        virtual void visitDataEntry(TiffDataEntry* object);
        virtual void visitImageEntry(TiffImageEntry* object);
        virtual void visitSizeEntry(TiffSizeEntry* object);
        virtual void visitDirectory(TiffDirectory* object);
        virtual void visitSubIfd(TiffSubIfd* object);
        virtual void visitMnEntry(TiffMnEntry* object);
        virtual void visitIfdMakernote(TiffIfdMakernote* object);
        virtual void visitBinaryArray(TiffBinaryArray* object);
        virtual void visitBinaryElement(TiffBinaryElement* object);
 
        void decodeTiffEntry(const TiffEntryBase* object);
        void decodeStdTiffEntry(const TiffEntryBase* object);
        void decodeIptc(const TiffEntryBase* object);
        void decodeXmp(const TiffEntryBase* object);
        void decodeCanonAFInfo(const TiffEntryBase* object);
 
    private:
 
 
        void getObjData(byte const*&         pData,
                        long&                size,
                        uint16_t             tag,
                        IfdId                group,
                        const TiffEntryBase* object);
 
    private:
        // DATA
        ExifData& exifData_;         
        IptcData& iptcData_;         
        XmpData&  xmpData_;          
        TiffComponent* const pRoot_; 
        const FindDecoderFct findDecoderFct_; 
        std::string make_;           
        bool decodedIptc_;           
 
    }; // class TiffDecoder
 
    class TiffEncoder : public TiffVisitor {
    public:
 
 
        TiffEncoder(
            const ExifData&      exifData,
            const IptcData&      iptcData,
            const XmpData&       xmpData,
                  TiffComponent* pRoot,
            const bool           isNewImage,
            const PrimaryGroups* pPrimaryGroups,
            const TiffHeaderBase* pHeader,
                  FindEncoderFct findEncoderFct
        );
        virtual ~TiffEncoder();
 
 
 
        virtual void visitEntry(TiffEntry* object);
        virtual void visitDataEntry(TiffDataEntry* object);
        virtual void visitImageEntry(TiffImageEntry* object);
        virtual void visitSizeEntry(TiffSizeEntry* object);
        virtual void visitDirectory(TiffDirectory* object);
        virtual void visitDirectoryNext(TiffDirectory* object);
        virtual void visitSubIfd(TiffSubIfd* object);
        virtual void visitMnEntry(TiffMnEntry* object);
        virtual void visitIfdMakernote(TiffIfdMakernote* object);
        virtual void visitIfdMakernoteEnd(TiffIfdMakernote* object);
        virtual void visitBinaryArray(TiffBinaryArray* object);
        virtual void visitBinaryArrayEnd(TiffBinaryArray* object);
        virtual void visitBinaryElement(TiffBinaryElement* object);
 
        void encodeTiffComponent(
                  TiffEntryBase* object,
            const Exifdatum*     datum =0
        );
 
        void encodeBinaryElement(TiffBinaryElement* object, const Exifdatum* datum);
        void encodeBinaryArray(TiffBinaryArray* object, const Exifdatum* datum);
        void encodeDataEntry(TiffDataEntry* object, const Exifdatum* datum);
        void encodeTiffEntry(TiffEntry* object, const Exifdatum* datum);
        void encodeImageEntry(TiffImageEntry* object, const Exifdatum* datum);
        void encodeMnEntry(TiffMnEntry* object, const Exifdatum* datum);
        void encodeSizeEntry(TiffSizeEntry* object, const Exifdatum* datum);
        void encodeSubIfd(TiffSubIfd* object, const Exifdatum* datum);
 
        void encodeTiffEntryBase(TiffEntryBase* object, const Exifdatum* datum);
        void encodeOffsetEntry(TiffEntryBase* object, const Exifdatum* datum);
 
        // Todo void encodeNikonSubIfd(TiffEntryBase* object, const Exifdatum* datum);
 
        void encodeIptc(TiffEntryBase* object, const Exifdatum* datum);
        void add(
            TiffComponent* pRootDir,
            TiffComponent* pSourceDir,
            uint32_t       root
        );
        void setDirty(bool flag =true);
 
 
 
        ByteOrder byteOrder() const { return byteOrder_; }
        bool dirty() const;
        WriteMethod writeMethod() const { return writeMethod_; }
 
    private:
 
 
        void encodeIptc();
        void encodeXmp();
 
 
 
        uint32_t updateDirEntry(byte* buf,
                                ByteOrder byteOrder,
                                TiffComponent* pTiffComponent) const;
        bool isImageTag(uint16_t tag, IfdId group) const;
 
    private:
        // DATA
        ExifData exifData_;          
        const IptcData& iptcData_;   
        const XmpData&  xmpData_;    
        bool del_;                   
        const TiffHeaderBase* pHeader_; 
        TiffComponent* pRoot_;       
        const bool isNewImage_;      
        const PrimaryGroups* pPrimaryGroups_; 
        TiffComponent* pSourceTree_; 
        ByteOrder byteOrder_;        
        ByteOrder origByteOrder_;    
        const FindEncoderFct findEncoderFct_; 
        std::string make_;           
        bool dirty_;                 
        WriteMethod writeMethod_;    
 
    }; // class TiffEncoder
 
    class TiffRwState {
    public:
 
 
        TiffRwState(ByteOrder byteOrder,
                    uint32_t  baseOffset)
            : byteOrder_(byteOrder),
              baseOffset_(baseOffset) {}
 
 
 
        ByteOrder          byteOrder()  const { return byteOrder_; }
        uint32_t           baseOffset() const { return baseOffset_; }
 
    private:
        ByteOrder byteOrder_;
        uint32_t  baseOffset_;
    }; // TiffRwState
 
    class TiffReader : public TiffVisitor {
    public:
 
 
        TiffReader(const byte*          pData,
                   uint32_t             size,
                   TiffComponent*       pRoot,
                   TiffRwState          state);
 
        virtual ~TiffReader();
 
 
 
        virtual void visitEntry(TiffEntry* object);
        virtual void visitDataEntry(TiffDataEntry* object);
        virtual void visitImageEntry(TiffImageEntry* object);
        virtual void visitSizeEntry(TiffSizeEntry* object);
        virtual void visitDirectory(TiffDirectory* object);
        virtual void visitSubIfd(TiffSubIfd* object);
        virtual void visitMnEntry(TiffMnEntry* object);
        virtual void visitIfdMakernote(TiffIfdMakernote* object);
        virtual void visitIfdMakernoteEnd(TiffIfdMakernote* object);
        virtual void visitBinaryArray(TiffBinaryArray* object);
        virtual void visitBinaryElement(TiffBinaryElement* object);
 
        void readTiffEntry(TiffEntryBase* object);
        void readDataEntryBase(TiffDataEntryBase* object);
        void setMnState(const TiffRwState* state =0);
        void setOrigState();
        bool circularReference(const byte* start, IfdId group);
        int nextIdx(IfdId group);
 
        void postProcess();
 
 
 
        ByteOrder byteOrder() const;
        uint32_t baseOffset() const;
 
    private:
        typedef std::map<const byte*, IfdId> DirList;
        typedef std::map<uint16_t, int> IdxSeq;
        typedef std::vector<TiffComponent*> PostList;
 
        // DATA
        const byte*          pData_;      
        const uint32_t       size_;       
        const byte*          pLast_;      
        TiffComponent* const pRoot_;      
        TiffRwState*         pState_;     
        TiffRwState          origState_;  
        TiffRwState          mnState_;    
        DirList              dirList_;    
        IdxSeq               idxSeq_;     
        PostList             postList_;   
        bool                 postProc_;   
    }; // class TiffReader
 
}}                                      // namespace Internal, Exiv2
 
#endif                                  // #ifndef TIFFVISITOR_INT_HPP_