tiffvisitor_int.hpp

// SPDX-License-Identifier: GPL-2.0-or-later
 
#ifndef TIFFVISITOR_INT_HPP_
#define TIFFVISITOR_INT_HPP_
 
// *****************************************************************************
// included header files
#include "exif.hpp"
#include "tifffwd_int.hpp"
#include "types.hpp"
 
#include <array>
 
// *****************************************************************************
// 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;               
  std::array<bool, events_> go_{true, true};  
 
 public:
 
 
  virtual ~TiffVisitor() = default;
 
 
 
  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;
 
 
 
  [[nodiscard]] bool go(GoEvent event) const;
 
};  // class TiffVisitor
 
class TiffFinder : public TiffVisitor {
 public:
 
 
  constexpr TiffFinder(uint16_t tag, IfdId group) : tag_(tag), group_(group) {
  }
  TiffFinder(const TiffFinder&) = delete;
  TiffFinder& operator=(const TiffFinder&) = delete;
  ~TiffFinder() override = default;
 
 
 
  void visitEntry(TiffEntry* object) override;
  void visitDataEntry(TiffDataEntry* object) override;
  void visitImageEntry(TiffImageEntry* object) override;
  void visitSizeEntry(TiffSizeEntry* object) override;
  void visitDirectory(TiffDirectory* object) override;
  void visitSubIfd(TiffSubIfd* object) override;
  void visitMnEntry(TiffMnEntry* object) override;
  void visitIfdMakernote(TiffIfdMakernote* object) override;
  void visitBinaryArray(TiffBinaryArray* object) override;
  void visitBinaryElement(TiffBinaryElement* object) override;
 
  void findObject(TiffComponent* object);
  void init(uint16_t tag, IfdId group);
 
 
 
  [[nodiscard]] 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);
  TiffCopier(const TiffCopier&) = delete;
  TiffCopier& operator=(const TiffCopier&) = delete;
  ~TiffCopier() override = default;
 
 
 
  void visitEntry(TiffEntry* object) override;
  void visitDataEntry(TiffDataEntry* object) override;
  void visitImageEntry(TiffImageEntry* object) override;
  void visitSizeEntry(TiffSizeEntry* object) override;
  void visitDirectory(TiffDirectory* object) override;
  void visitSubIfd(TiffSubIfd* object) override;
  void visitMnEntry(TiffMnEntry* object) override;
  void visitIfdMakernote(TiffIfdMakernote* object) override;
  void visitBinaryArray(TiffBinaryArray* object) override;
  void visitBinaryElement(TiffBinaryElement* object) override;
 
  void copyObject(const 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* pRoot,
              FindDecoderFct findDecoderFct);
  TiffDecoder(const TiffDecoder&) = delete;
  TiffDecoder& operator=(const TiffDecoder&) = delete;
  ~TiffDecoder() override = default;
 
 
 
  void visitEntry(TiffEntry* object) override;
  void visitDataEntry(TiffDataEntry* object) override;
  void visitImageEntry(TiffImageEntry* object) override;
  void visitSizeEntry(TiffSizeEntry* object) override;
  void visitDirectory(TiffDirectory* object) override;
  void visitSubIfd(TiffSubIfd* object) override;
  void visitMnEntry(TiffMnEntry* object) override;
  void visitIfdMakernote(TiffIfdMakernote* object) override;
  void visitBinaryArray(TiffBinaryArray* object) override;
  void visitBinaryElement(TiffBinaryElement* object) override;
 
  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(const byte*& pData, size_t& size, uint16_t tag, IfdId group, const TiffEntryBase* object);
 
  // DATA
  ExifData& exifData_;             
  IptcData& iptcData_;             
  XmpData& xmpData_;               
  TiffComponent* pRoot_;           
  FindDecoderFct findDecoderFct_;  
  std::string make_;               
  bool decodedIptc_{false};        
 
};  // class TiffDecoder
 
class TiffEncoder : public TiffVisitor {
 public:
 
 
  TiffEncoder(ExifData& exifData, IptcData& iptcData, XmpData& xmpData, TiffComponent* pRoot, bool isNewImage,
              const PrimaryGroups* pPrimaryGroups, const TiffHeaderBase* pHeader, FindEncoderFct findEncoderFct);
  TiffEncoder(const TiffEncoder&) = delete;
  TiffEncoder& operator=(const TiffEncoder&) = delete;
  ~TiffEncoder() override = default;
 
 
 
  void visitEntry(TiffEntry* object) override;
  void visitDataEntry(TiffDataEntry* object) override;
  void visitImageEntry(TiffImageEntry* object) override;
  void visitSizeEntry(TiffSizeEntry* object) override;
  void visitDirectory(TiffDirectory* object) override;
  void visitDirectoryNext(TiffDirectory* object) override;
  void visitSubIfd(TiffSubIfd* object) override;
  void visitMnEntry(TiffMnEntry* object) override;
  void visitIfdMakernote(TiffIfdMakernote* object) override;
  void visitIfdMakernoteEnd(TiffIfdMakernote* object) override;
  void visitBinaryArray(TiffBinaryArray* object) override;
  void visitBinaryArrayEnd(TiffBinaryArray* object) override;
  void visitBinaryElement(TiffBinaryElement* object) override;
 
  void encodeTiffComponent(TiffEntryBase* object, const Exifdatum* datum = nullptr);
 
  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);
 
 
 
  [[nodiscard]] ByteOrder byteOrder() const {
    return byteOrder_;
  }
  [[nodiscard]] bool dirty() const;
  [[nodiscard]] WriteMethod writeMethod() const {
    return writeMethod_;
  }
 
 private:
 
 
  void encodeIptc();
  void encodeXmp();
 
 
 
  static uint32_t updateDirEntry(byte* buf, ByteOrder byteOrder, TiffComponent* pTiffComponent);
  [[nodiscard]] bool isImageTag(uint16_t tag, IfdId group) const;
 
  // DATA
  ExifData exifData_;                        
  const IptcData& iptcData_;                 
  const XmpData& xmpData_;                   
  bool del_{true};                           
  const TiffHeaderBase* pHeader_;            
  TiffComponent* pRoot_;                     
  bool isNewImage_;                          
  const PrimaryGroups* pPrimaryGroups_;      
  TiffComponent* pSourceTree_{nullptr};      
  ByteOrder byteOrder_;                      
  ByteOrder origByteOrder_;                  
  FindEncoderFct findEncoderFct_;            
  std::string make_;                         
  bool dirty_{false};                        
  WriteMethod writeMethod_{wmNonIntrusive};  
 
};  // class TiffEncoder
 
class TiffRwState {
 public:
 
 
  constexpr TiffRwState(ByteOrder byteOrder, size_t baseOffset) : byteOrder_(byteOrder), baseOffset_(baseOffset) {
  }
 
 
 
  [[nodiscard]] ByteOrder byteOrder() const {
    return byteOrder_;
  }
  [[nodiscard]] size_t baseOffset() const {
    return baseOffset_;
  }
 
 private:
  ByteOrder byteOrder_;
  size_t baseOffset_;
};  // TiffRwState
 
class TiffReader : public TiffVisitor {
 public:
 
 
  TiffReader(const byte* pData, size_t size, TiffComponent* pRoot, TiffRwState state);
  TiffReader(const TiffReader&) = delete;
  TiffReader& operator=(const TiffReader&) = delete;
 
  ~TiffReader() override = default;
 
 
 
  void visitEntry(TiffEntry* object) override;
  void visitDataEntry(TiffDataEntry* object) override;
  void visitImageEntry(TiffImageEntry* object) override;
  void visitSizeEntry(TiffSizeEntry* object) override;
  void visitDirectory(TiffDirectory* object) override;
  void visitSubIfd(TiffSubIfd* object) override;
  void visitMnEntry(TiffMnEntry* object) override;
  void visitIfdMakernote(TiffIfdMakernote* object) override;
  void visitIfdMakernoteEnd(TiffIfdMakernote* object) override;
  void visitBinaryArray(TiffBinaryArray* object) override;
  void visitBinaryElement(TiffBinaryElement* object) override;
 
  void readTiffEntry(TiffEntryBase* object);
  void readDataEntryBase(TiffDataEntryBase* object);
  void setMnState(const TiffRwState* state = nullptr);
  void setOrigState();
  bool circularReference(const byte* start, IfdId group);
  int nextIdx(IfdId group);
 
  void postProcess();
 
 
 
  [[nodiscard]] ByteOrder byteOrder() const;
  [[nodiscard]] size_t baseOffset() const;
 
 private:
  using DirList = std::map<const byte*, IfdId>;
  using IdxSeq = std::map<IfdId, int>;
  using PostList = std::vector<TiffComponent*>;
 
  // DATA
  const byte* pData_;      
  size_t size_;            
  const byte* pLast_;      
  TiffComponent* pRoot_;   
  TiffRwState* pState_;    
  TiffRwState origState_;  
  TiffRwState mnState_;    
  DirList dirList_;        
  IdxSeq idxSeq_;          
  PostList postList_;      
  bool postProc_{false};   
};
 
}  // namespace Internal
}  // namespace Exiv2
 
#endif  // #ifndef TIFFVISITOR_INT_HPP_