tags.hpp

// SPDX-License-Identifier: GPL-2.0-or-later
 
#ifndef TAGS_HPP_
#define TAGS_HPP_
 
// *****************************************************************************
#include "exiv2lib_export.h"
 
// included header files
#include "metadatum.hpp"
 
// *****************************************************************************
// namespace extensions
namespace Exiv2 {
// *****************************************************************************
// class declarations
class ExifData;
class ExifKey;
class Value;
struct TagInfo;
 
// *****************************************************************************
// type definitions
 
using PrintFct = std::ostream& (*)(std::ostream&, const Value&, const ExifData* pExifData);
using TagListFct = const TagInfo* (*)();
 
// *****************************************************************************
// class definitions
 
enum class IfdId : uint32_t {
  ifdIdNotSet,
  ifd0Id,
  ifd1Id,
  ifd2Id,
  ifd3Id,
  exifId,
  gpsId,
  iopId,
  mpfId,
  subImage1Id,
  subImage2Id,
  subImage3Id,
  subImage4Id,
  subImage5Id,
  subImage6Id,
  subImage7Id,
  subImage8Id,
  subImage9Id,
  subThumb1Id,
  panaRawId,
  mnId,
  canonId,
  canonAfCId,
  canonAfMiAdjId,
  canonAmId,
  canonAsId,
  canonCbId,
  canonCiId,
  canonCsId,
  canonFilId,
  canonFlId,
  canonHdrId,
  canonLeId,
  canonMeId,
  canonMoID,
  canonMvId,
  canonRawBId,
  canonSiId,
  canonCfId,
  canonContrastId,
  canonFcd1Id,
  canonFcd2Id,
  canonFcd3Id,
  canonLiOpId,
  canonMyColorID,
  canonPiId,
  canonPaId,
  canonTiId,
  canonFiId,
  canonPrId,
  canonPreID,
  canonVigCorId,
  canonVigCor2Id,
  canonWbId,
  casioId,
  casio2Id,
  fujiId,
  minoltaId,
  minoltaCs5DId,
  minoltaCs7DId,
  minoltaCsOldId,
  minoltaCsNewId,
  nikon1Id,
  nikon2Id,
  nikon3Id,
  nikonPvId,
  nikonVrId,
  nikonPcId,
  nikonWtId,
  nikonIiId,
  nikonAfId,
  nikonAf21Id,
  nikonAf22Id,
  nikonAFTId,
  nikonFiId,
  nikonMeId,
  nikonFl1Id,
  nikonFl2Id,
  nikonFl3Id,
  nikonFl6Id,
  nikonFl7Id,
  nikonSi1Id,
  nikonSi2Id,
  nikonSi3Id,
  nikonSi4Id,
  nikonSi5Id,
  nikonSi6Id,
  nikonLd1Id,
  nikonLd2Id,
  nikonLd3Id,
  nikonLd4Id,
  nikonCb1Id,
  nikonCb2Id,
  nikonCb2aId,
  nikonCb2bId,
  nikonCb3Id,
  nikonCb4Id,
  olympusId,
  olympus2Id,
  olympusCsId,
  olympusEqId,
  olympusRdId,
  olympusRd2Id,
  olympusIpId,
  olympusFiId,
  olympusFe1Id,
  olympusFe2Id,
  olympusFe3Id,
  olympusFe4Id,
  olympusFe5Id,
  olympusFe6Id,
  olympusFe7Id,
  olympusFe8Id,
  olympusFe9Id,
  olympusRiId,
  panasonicId,
  pentaxId,
  pentaxDngId,
  samsung2Id,
  samsungPvId,
  samsungPwId,
  sigmaId,
  sony1Id,
  sony2Id,
  sonyMltId,
  sony1CsId,
  sony1Cs2Id,
  sony2CsId,
  sony2Cs2Id,
  sony2FpId,
  sonyMisc1Id,
  sonyMisc2bId,
  sonyMisc3cId,
  sonySInfo1Id,
  sony2010eId,
  sony1MltCs7DId,
  sony1MltCsOldId,
  sony1MltCsNewId,
  sony1MltCsA100Id,
  tagInfoMvId,
  lastId,
  ignoreId = lastId
};
 
inline std::ostream& operator<<(std::ostream& os, IfdId id) {
  return os << static_cast<int>(id);
}
 
struct EXIV2API GroupInfo {
  using GroupName = std::string;
  bool operator==(IfdId ifdId) const;                 
  bool operator==(const GroupName& groupName) const;  
  IfdId ifdId_;                                       
  const char* ifdName_;                               
  const char* groupName_;                             
  TagListFct tagList_;                                
};
 
enum class SectionId {
  sectionIdNotSet,
  imgStruct,     // 4.6.4 A
  recOffset,     // 4.6.4 B
  imgCharacter,  // 4.6.4 C
  otherTags,     // 4.6.4 D
  exifFormat,    // 4.6.3
  exifVersion,   // 4.6.5 A
  imgConfig,     // 4.6.5 C
  userInfo,      // 4.6.5 D
  relatedFile,   // 4.6.5 E
  dateTime,      // 4.6.5 F
  captureCond,   // 4.6.5 G
  gpsTags,       // 4.6.6
  iopTags,       // 4.6.7
  mpfTags,
  makerTags,  // MakerNote
  dngTags,    // DNG Spec
  panaRaw,
  tiffEp,  // TIFF-EP Spec
  tiffPm6,
  adobeOpi,
  lastSectionId
};
 
struct EXIV2API TagInfo {
  uint16_t tag_;         
  const char* name_;     
  const char* title_;    
  const char* desc_;     
  IfdId ifdId_;          
  SectionId sectionId_;  
  TypeId typeId_;        
  int16_t count_;        
  PrintFct printFct_;    
};
 
class EXIV2API ExifTags {
 public:
  static const GroupInfo* groupList();
  static const TagInfo* tagList(const std::string& groupName);
  static void taglist(std::ostream& os);
  static void taglist(std::ostream& os, const std::string& groupName);
 
  static const char* sectionName(const ExifKey& key);
  static uint16_t defaultCount(const ExifKey& key);
  static const char* ifdName(const std::string& groupName);
 
  static bool isMakerGroup(const std::string& groupName);
  static bool isExifGroup(const std::string& groupName);
 
};  // class ExifTags
 
class EXIV2API ExifKey : public Key {
 public:
  using UniquePtr = std::unique_ptr<ExifKey>;
 
 
 
  explicit ExifKey(const std::string& key);
  ExifKey(uint16_t tag, const std::string& groupName);
  explicit ExifKey(const TagInfo& ti);
 
  ExifKey(const ExifKey& rhs);
  ~ExifKey() override;
 
 
 
  ExifKey& operator=(const ExifKey& rhs);
  void setIdx(int idx) const;
 
 
  [[nodiscard]] std::string key() const override;
  [[nodiscard]] const char* familyName() const override;
  [[nodiscard]] std::string groupName() const override;
  [[nodiscard]] IfdId ifdId() const;
  [[nodiscard]] std::string tagName() const override;
  [[nodiscard]] uint16_t tag() const override;
  [[nodiscard]] std::string tagLabel() const override;
  [[nodiscard]] std::string tagDesc() const override;
  [[nodiscard]] TypeId defaultTypeId() const;  // Todo: should be in the base class
 
  [[nodiscard]] UniquePtr clone() const;
  [[nodiscard]] int idx() const;
 
 private:
  [[nodiscard]] ExifKey* clone_() const override;
 
  // Pimpl idiom
  struct Impl;
  std::unique_ptr<Impl> p_;
 
};  // class ExifKey
 
// *****************************************************************************
// free functions
 
EXIV2API std::ostream& operator<<(std::ostream& os, const TagInfo& ti);
 
}  // namespace Exiv2
 
#endif  // #ifndef TAGS_HPP_