image.hpp

// SPDX-License-Identifier: GPL-2.0-or-later
 
#ifndef IMAGE_HPP_
#define IMAGE_HPP_
 
// *****************************************************************************
#include "exiv2lib_export.h"
 
// included header files
#include "basicio.hpp"
#include "exif.hpp"
#include "image_types.hpp"
#include "iptc.hpp"
#include "xmp_exiv2.hpp"
 
// *****************************************************************************
// namespace extensions
namespace Exiv2 {
// *****************************************************************************
// class definitions
 
struct NativePreview {
  size_t position_{};     
  size_t size_{};         
  size_t width_{};        
  size_t height_{};       
  std::string filter_;    
  std::string mimeType_;  
};
 
using NativePreviewList = std::vector<NativePreview>;
 
enum PrintStructureOption { kpsNone, kpsBasic, kpsXMP, kpsRecursive, kpsIccProfile, kpsIptcErase };
 
class EXIV2API Image {
 public:
  using UniquePtr = std::unique_ptr<Image>;
 
 
 
  Image(ImageType type, uint16_t supportedMetadata, BasicIo::UniquePtr io);
  virtual ~Image() = default;
 
 
 
  virtual void printStructure(std::ostream& out, PrintStructureOption option = kpsNone, size_t 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 appendIccProfile(const uint8_t* bytes, size_t size, bool bTestValid);
  virtual void checkIccProfile();
  virtual void clearIccProfile();
  virtual bool iccProfileDefined() {
    return !iccProfile_.empty();
  }
 
  [[nodiscard]] virtual const DataBuf& iccProfile() const {
    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, size_t depth, size_t offset = 0);
 
  void printIFDStructure(BasicIo& io, std::ostream& out, Exiv2::PrintStructureOption option, size_t start, bool bSwap,
                         char c, size_t depth);
 
  static bool isBigEndianPlatform();
 
  static bool isLittleEndianPlatform();
 
  static bool isStringType(uint16_t type);
  static bool isShortType(uint16_t type);
  static bool isLongType(uint16_t type);
  static bool isLongLongType(uint16_t type);
  static bool isRationalType(uint16_t type);
  static bool is2ByteType(uint16_t type);
  static bool is4ByteType(uint16_t type);
  static bool is8ByteType(uint16_t type);
  static bool isPrintXMP(uint16_t type, Exiv2::PrintStructureOption option);
  static bool isPrintICC(uint16_t type, Exiv2::PrintStructureOption option);
 
  static uint64_t byteSwap(uint64_t value, bool bSwap);
  static uint32_t byteSwap(uint32_t value, bool bSwap);
  static uint16_t byteSwap(uint16_t value, bool bSwap);
  static uint16_t byteSwap2(const DataBuf& buf, size_t offset, bool bSwap);
  static uint32_t byteSwap4(const DataBuf& buf, size_t offset, bool bSwap);
  static uint64_t byteSwap8(const DataBuf& buf, size_t offset, bool bSwap);
 
 
 
 
  [[nodiscard]] ByteOrder byteOrder() const;
 
  [[nodiscard]] bool good() const;
  [[nodiscard]] virtual std::string mimeType() const = 0;
  [[nodiscard]] virtual uint32_t pixelWidth() const;
  [[nodiscard]] virtual uint32_t pixelHeight() const;
  [[nodiscard]] virtual const ExifData& exifData() const;
  [[nodiscard]] virtual const IptcData& iptcData() const;
  [[nodiscard]] virtual const XmpData& xmpData() const;
  [[nodiscard]] virtual std::string comment() const;
  [[nodiscard]] virtual const std::string& xmpPacket() const;
  [[nodiscard]] virtual BasicIo& io() const;
  [[nodiscard]] AccessMode checkMode(MetadataId metadataId) const;
  [[nodiscard]] bool supportsMetadata(MetadataId metadataId) const;
  [[nodiscard]] bool writeXmpFromPacket() const;
  [[nodiscard]] const NativePreviewList& nativePreviews() const;
 
  void setTypeSupported(ImageType imageType, uint16_t supportedMetadata) {
    imageType_ = imageType;
    supportedMetadata_ = supportedMetadata;
  }
 
  [[nodiscard]] ImageType imageType() const {
    return imageType_;
  }
 
 
 
  Image(const Image&) = delete;
  Image& operator=(const Image&) = delete;
 
 protected:
  // DATA
  BasicIo::UniquePtr io_;             
  ExifData exifData_;                 
  IptcData iptcData_;                 
  XmpData xmpData_;                   
  DataBuf iccProfile_;                
  std::string comment_;               
  std::string xmpPacket_;             
  uint32_t pixelWidth_{0};            
  uint32_t pixelHeight_{0};           
  NativePreviewList nativePreviews_;  
 
  const std::string& tagName(uint16_t tag);
 
  static const char* typeName(uint16_t tag);
 
 private:
  // DATA
  ImageType imageType_;         
  uint16_t supportedMetadata_;  
#ifdef EXV_HAVE_XMP_TOOLKIT
  bool writeXmpFromPacket_{false};  
#else
  bool writeXmpFromPacket_{true};  
#endif
  ByteOrder byteOrder_{invalidByteOrder};  
 
  std::map<int, std::string> tags_;  
  bool init_{true};                  
 
};  // class Image
 
using NewInstanceFct = Image::UniquePtr (*)(BasicIo::UniquePtr io, bool create);
using IsThisTypeFct = bool (*)(BasicIo& iIo, bool advance);
 
class EXIV2API ImageFactory {
  friend bool Image::good() const;
 
 public:
  static BasicIo::UniquePtr createIo(const std::string& path, bool useCurl = true);
 
  static Image::UniquePtr open(const std::string& path, bool useCurl = true);
 
  static Image::UniquePtr open(const byte* data, size_t size);
  static Image::UniquePtr open(BasicIo::UniquePtr io);
  static Image::UniquePtr create(ImageType type, const std::string& path);
  static Image::UniquePtr create(ImageType type);
 
  static Image::UniquePtr create(ImageType type, BasicIo::UniquePtr io);
  static ImageType getType(const std::string& path);
  static ImageType getType(const byte* data, size_t size);
  static ImageType getType(BasicIo& io);
  static AccessMode checkMode(ImageType type, MetadataId metadataId);
  static bool checkType(ImageType type, BasicIo& io, bool advance);
};  // class ImageFactory
 
// *****************************************************************************
// template, inline and free functions
 
EXIV2API void append(Exiv2::Blob& blob, const byte* buf, size_t len);
 
}  // namespace Exiv2
 
#endif  // #ifndef IMAGE_HPP_