tiffimage_int.hpp

// SPDX-License-Identifier: GPL-2.0-or-later
 
#ifndef TIFFIMAGE_INT_HPP_
#define TIFFIMAGE_INT_HPP_
 
// *****************************************************************************
// included header files
#include <unordered_map>
#include "image.hpp"
#include "tiffcomposite_int.hpp"
#include "tifffwd_int.hpp"
 
// *****************************************************************************
// namespace extensions
namespace Exiv2::Internal {
// *****************************************************************************
// class definitions
 
class TiffHeaderBase {
 public:
 
 
  TiffHeaderBase(uint16_t tag, uint32_t size, ByteOrder byteOrder, uint32_t offset);
  virtual ~TiffHeaderBase() = default;
 
 
 
  virtual bool read(const byte* pData, size_t size);
  virtual void setByteOrder(ByteOrder byteOrder);
  virtual void setOffset(uint32_t offset);
 
 
 
  [[nodiscard]] virtual DataBuf write() const;
  virtual void print(std::ostream& os, const std::string& prefix = "") const;
  [[nodiscard]] virtual ByteOrder byteOrder() const;
  [[nodiscard]] virtual uint32_t offset() const;
  [[nodiscard]] virtual uint32_t size() const;
  [[nodiscard]] virtual uint16_t tag() const;
  virtual bool isImageTag(uint16_t tag, IfdId group, const PrimaryGroups* pPrimaryGroups) const;
 
 private:
  // DATA
  uint16_t tag_;         
  uint32_t size_;        
  ByteOrder byteOrder_;  
  uint32_t offset_;      
};
 
bool isTiffImageTag(uint16_t tag, IfdId group);
 
class TiffHeader : public TiffHeaderBase {
 public:
 
 
  explicit TiffHeader(ByteOrder byteOrder = littleEndian, uint32_t offset = 0x00000008, bool hasImageTags = true);
 
 
  bool isImageTag(uint16_t tag, IfdId group, const PrimaryGroups* pPrimaryGroups) const override;
 
 private:
  // DATA
  bool hasImageTags_;  
};
 
using TiffGroupKey = std::pair<uint32_t, IfdId>;
 
struct TiffGroupKey_hash {
  std::size_t operator()(const TiffGroupKey& pair) const noexcept {
    return std::hash<uint64_t>{}(static_cast<uint64_t>(pair.first) << 32 | static_cast<uint64_t>(pair.second));
  }
};
 
using TiffGroupTable = std::unordered_map<TiffGroupKey, NewTiffCompFct, TiffGroupKey_hash>;
 
using TiffTreeParent = std::pair<IfdId, uint32_t>;  // Parent group, parent tag
using TiffTreeTable = std::unordered_map<TiffGroupKey, TiffTreeParent, TiffGroupKey_hash>;
 
class TiffCreator {
 public:
  static std::unique_ptr<TiffComponent> create(uint32_t extendedTag, IfdId group);
  static TiffPath getPath(uint32_t extendedTag, IfdId group, uint32_t root);
 
 private:
  static const TiffTreeTable tiffTreeTable_;    
  static const TiffGroupTable tiffGroupTable_;  
};
 
class TiffParserWorker {
 public:
  static ByteOrder decode(ExifData& exifData, IptcData& iptcData, XmpData& xmpData, const byte* pData, size_t size,
                          uint32_t root, FindDecoderFct findDecoderFct, TiffHeaderBase* pHeader = nullptr);
  static WriteMethod encode(BasicIo& io, const byte* pData, size_t size, ExifData& exifData, IptcData& iptcData,
                            XmpData& xmpData, uint32_t root, FindEncoderFct findEncoderFct, TiffHeaderBase* pHeader,
                            OffsetWriter* pOffsetWriter);
 
 private:
  static std::unique_ptr<TiffComponent> parse(const byte* pData, size_t size, uint32_t root, TiffHeaderBase* pHeader);
  static PrimaryGroups findPrimaryGroups(TiffComponent* pSourceDir);
};
 
class TiffMapping {
 public:
  static DecoderFct findDecoder(const std::string& make, uint32_t extendedTag, IfdId group);
  static EncoderFct findEncoder(const std::string& make, uint32_t extendedTag, IfdId group);
 
 private:
  static const TiffMappingInfo tiffMappingInfo_[];  
};
 
class OffsetWriter {
 public:
  enum OffsetId {
    cr2RawIfdOffset  
  };
 
 
  void setOrigin(OffsetId id, uint32_t origin, ByteOrder byteOrder);
  void setTarget(OffsetId id, uint32_t target);
 
 
 
  void writeOffsets(BasicIo& io) const;
 private:
  struct OffsetData {
    uint32_t origin_{};                  
    uint32_t target_{};                  
    ByteOrder byteOrder_{littleEndian};  
  };
  using OffsetList = std::map<OffsetId, OffsetData>;
 
  // DATA
  OffsetList offsetList_;  
 
};  // class OffsetWriter
 
// Todo: Move this class to metadatum_int.hpp or tags_int.hpp
class FindExifdatum {
 public:
  explicit FindExifdatum(Exiv2::IfdId ifdId) : ifdId_(ifdId) {
  }
  bool operator()(const Exiv2::Exifdatum& md) const {
    return ifdId_ == md.ifdId();
  }
 
 private:
  Exiv2::IfdId ifdId_;
 
};  // class FindExifdatum
 
}  // namespace Exiv2::Internal
 
#endif  // #ifndef TIFFIMAGE_INT_HPP_