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_