exif.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: GPL-2.0-or-later
 
#ifndef EXIF_HPP_
#define EXIF_HPP_
 
// *****************************************************************************
#include "exiv2lib_export.h"
 
// included header files
#include "metadatum.hpp"
#include "tags.hpp"
 
// + standard includes
#include <list>
 
// *****************************************************************************
// namespace extensions
namespace Exiv2 {
// *****************************************************************************
// class declarations
class ExifData;
 
// *****************************************************************************
// class definitions
 
class EXIV2API Exifdatum : public Metadatum {
  template <typename T>
  friend Exifdatum& setValue(Exifdatum&, const T&);
 
 public:
 
 
  explicit Exifdatum(const ExifKey& key, const Value* pValue = nullptr);
  Exifdatum(const Exifdatum& rhs);
  ~Exifdatum() override = default;
 
 
 
  Exifdatum& operator=(const Exifdatum& rhs);
  Exifdatum& operator=(const uint16_t& value);
  Exifdatum& operator=(const uint32_t& value);
  Exifdatum& operator=(const URational& value);
  Exifdatum& operator=(const int16_t& value);
  Exifdatum& operator=(const int32_t& value);
  Exifdatum& operator=(const Rational& value);
  Exifdatum& operator=(const std::string& value);
  Exifdatum& operator=(const Value& value);
  void setValue(const Value* pValue) override;
  int setValue(const std::string& value) override;
  int setDataArea(const byte* buf, size_t len) const;
 
 
 
  [[nodiscard]] std::string key() const override;
  [[nodiscard]] const char* familyName() const override;
  [[nodiscard]] std::string groupName() const override;
  [[nodiscard]] std::string tagName() const override;
  [[nodiscard]] std::string tagLabel() const override;
  [[nodiscard]] std::string tagDesc() const override;
  [[nodiscard]] uint16_t tag() const override;
  [[nodiscard]] IfdId ifdId() const;
  [[nodiscard]] const char* ifdName() const;
  [[nodiscard]] int idx() const;
  size_t copy(byte* buf, ByteOrder byteOrder) const override;
  std::ostream& write(std::ostream& os, const ExifData* pMetadata = nullptr) const override;
  [[nodiscard]] TypeId typeId() const override;
  [[nodiscard]] const char* typeName() const override;
  [[nodiscard]] size_t typeSize() const override;
  [[nodiscard]] size_t count() const override;
  [[nodiscard]] size_t size() const override;
  [[nodiscard]] std::string toString() const override;
  [[nodiscard]] std::string toString(size_t n) const override;
  [[nodiscard]] int64_t toInt64(size_t n = 0) const override;
  [[nodiscard]] float toFloat(size_t n = 0) const override;
  [[nodiscard]] Rational toRational(size_t n = 0) const override;
  [[nodiscard]] Value::UniquePtr getValue() const override;
  [[nodiscard]] const Value& value() const override;
  [[nodiscard]] size_t sizeDataArea() const;
  [[nodiscard]] DataBuf dataArea() const;
 
 private:
  // DATA
  ExifKey::UniquePtr key_;  
  Value::UniquePtr value_;  
 
};  // class Exifdatum
 
class EXIV2API ExifThumbC {
 public:
 
 
  explicit ExifThumbC(const ExifData& exifData);
 
 
 
  [[nodiscard]] DataBuf copy() const;
#ifdef EXV_ENABLE_FILESYSTEM
  [[nodiscard]] size_t writeFile(const std::string& path) const;
#endif
  [[nodiscard]] const char* mimeType() const;
  [[nodiscard]] const char* extension() const;
 
 private:
  // DATA
  const ExifData& exifData_;  
 
};  // class ExifThumb
 
class EXIV2API ExifThumb : public ExifThumbC {
 public:
 
 
  explicit ExifThumb(ExifData& exifData);
 
 
#ifdef EXV_ENABLE_FILESYSTEM
  void setJpegThumbnail(const std::string& path, URational xres, URational yres, uint16_t unit);
#endif
  void setJpegThumbnail(const byte* buf, size_t size, URational xres, URational yres, uint16_t unit);
#ifdef EXV_ENABLE_FILESYSTEM
  void setJpegThumbnail(const std::string& path);
#endif
  void setJpegThumbnail(const byte* buf, size_t size);
  void erase();
 
 private:
  // DATA
  ExifData& exifData_;  
 
};  // class ExifThumb
 
using ExifMetadata = std::list<Exifdatum>;
 
class EXIV2API ExifData {
 public:
  using iterator = ExifMetadata::iterator;
  using const_iterator = ExifMetadata::const_iterator;
 
 
 
  Exifdatum& operator[](const std::string& key);
  void add(const ExifKey& key, const Value* pValue);
  void add(const Exifdatum& exifdatum);
  iterator erase(iterator pos);
  iterator erase(iterator beg, iterator end);
  void clear();
  void sortByKey();
  void sortByTag();
  iterator begin() {
    return exifMetadata_.begin();
  }
  iterator end() {
    return exifMetadata_.end();
  }
  iterator findKey(const ExifKey& key);
 
 
 
  [[nodiscard]] const_iterator begin() const {
    return exifMetadata_.begin();
  }
  [[nodiscard]] const_iterator end() const {
    return exifMetadata_.end();
  }
  [[nodiscard]] const_iterator findKey(const ExifKey& key) const;
  [[nodiscard]] bool empty() const {
    return exifMetadata_.empty();
  }
  [[nodiscard]] size_t count() const {
    return exifMetadata_.size();
  }
 
 private:
  // DATA
  ExifMetadata exifMetadata_;
};  // class ExifData
 
class EXIV2API ExifParser {
 public:
  static ByteOrder decode(ExifData& exifData, const byte* pData, size_t size);
  static WriteMethod encode(Blob& blob, const byte* pData, size_t size, ByteOrder byteOrder, ExifData& exifData);
  static void encode(Blob& blob, ByteOrder byteOrder, ExifData& exifData) {
    encode(blob, nullptr, 0, byteOrder, exifData);
  }
 
};  // class ExifParser
 
}  // namespace Exiv2
 
#endif  // #ifndef EXIF_HPP_