makernote_int.hpp

// SPDX-License-Identifier: GPL-2.0-or-later
 
#ifndef EXIV2_MAKERNOTE_INT_HPP
#define EXIV2_MAKERNOTE_INT_HPP
 
// *****************************************************************************
// included header files
#include "tags_int.hpp"
#include "types.hpp"
 
// namespace extensions
namespace Exiv2::Internal {
class IoWrapper;
class TiffComponent;
// *****************************************************************************
// function prototypes
std::string getExiv2ConfigPath();
 
std::string readExiv2Config(const std::string& section, const std::string& value, const std::string& def);
 
// *****************************************************************************
// class definitions
 
using NewMnFct = std::unique_ptr<TiffComponent> (*)(uint16_t, IfdId, IfdId, const byte*, size_t, ByteOrder);
 
using NewMnFct2 = std::unique_ptr<TiffComponent> (*)(uint16_t tag, IfdId group, IfdId mnGroup);
 
struct TiffMnRegistry {
  struct MakeKey;
  bool operator==(const std::string& key) const;
 
  bool operator==(IfdId key) const;
 
  // DATA
  const char* make_;     
  IfdId mnGroup_;        
  NewMnFct newMnFct_;    
  NewMnFct2 newMnFct2_;  
};
 
class TiffMnCreator {
 public:
  static std::unique_ptr<TiffComponent> create(uint16_t tag, IfdId group, const std::string& make, const byte* pData,
                                               size_t size, ByteOrder byteOrder);
  static std::unique_ptr<TiffComponent> create(uint16_t tag, IfdId group, IfdId mnGroup);
 
  ~TiffMnCreator() = default;
  TiffMnCreator(const TiffComponent&) = delete;
  TiffMnCreator& operator=(const TiffComponent&) = delete;
 
 private:
  static const TiffMnRegistry registry_[];  
};
 
class MnHeader {
 public:
 
 
  virtual ~MnHeader() = default;
 
 
  virtual bool read(const byte* pData, size_t size, ByteOrder byteOrder) = 0;
  virtual void setByteOrder(ByteOrder byteOrder);
 
 
  [[nodiscard]] virtual size_t size() const = 0;
  virtual size_t write(IoWrapper& ioWrapper, ByteOrder byteOrder) const = 0;
  [[nodiscard]] virtual size_t ifdOffset() const;
  [[nodiscard]] virtual ByteOrder byteOrder() const;
  [[nodiscard]] virtual size_t baseOffset(size_t mnOffset) const;
 
};  // class MnHeader
 
class OlympusMnHeader : public MnHeader {
 public:
 
 
  OlympusMnHeader();
 
  bool read(const byte* pData, size_t size, ByteOrder byteOrder) override;
 
  [[nodiscard]] size_t size() const override;
  size_t write(IoWrapper& ioWrapper, ByteOrder byteOrder) const override;
  [[nodiscard]] size_t ifdOffset() const override;
 
  static size_t sizeOfSignature();
 
 private:
  DataBuf header_;                 
  static const byte signature_[];  
 
};  // class OlympusMnHeader
 
class Olympus2MnHeader : public MnHeader {
 public:
 
 
  Olympus2MnHeader();
 
  bool read(const byte* pData, size_t size, ByteOrder byteOrder) override;
 
  [[nodiscard]] size_t size() const override;
  size_t write(IoWrapper& ioWrapper, ByteOrder byteOrder) const override;
  [[nodiscard]] size_t ifdOffset() const override;
  [[nodiscard]] size_t baseOffset(size_t mnOffset) const override;
 
  static size_t sizeOfSignature();
 
 private:
  DataBuf header_;                 
  static const byte signature_[];  
 
};  // class Olympus2MnHeader
 
class OMSystemMnHeader : public MnHeader {
 public:
 
 
  OMSystemMnHeader();
 
  bool read(const byte* pData, size_t size, ByteOrder byteOrder) override;
 
  [[nodiscard]] size_t size() const override;
  size_t write(IoWrapper& ioWrapper, ByteOrder byteOrder) const override;
  [[nodiscard]] size_t ifdOffset() const override;
  [[nodiscard]] size_t baseOffset(size_t mnOffset) const override;
 
  static size_t sizeOfSignature();
 
 private:
  DataBuf header_;                 
  static const byte signature_[];  
 
};  // class OMSystemMnHeader
 
class FujiMnHeader : public MnHeader {
 public:
 
 
  FujiMnHeader();
 
  bool read(const byte* pData, size_t size, ByteOrder byteOrder) override;
  // setByteOrder not implemented
 
  [[nodiscard]] size_t size() const override;
  size_t write(IoWrapper& ioWrapper, ByteOrder byteOrder) const override;
  [[nodiscard]] size_t ifdOffset() const override;
  [[nodiscard]] ByteOrder byteOrder() const override;
  [[nodiscard]] size_t baseOffset(size_t mnOffset) const override;
 
  static size_t sizeOfSignature();
 
 private:
  DataBuf header_;                    
  static const byte signature_[];     
  static const ByteOrder byteOrder_;  
  size_t start_{0};                   
 
};  // class FujiMnHeader
 
class Nikon2MnHeader : public MnHeader {
 public:
 
 
  Nikon2MnHeader();
 
  bool read(const byte* pData, size_t size, ByteOrder byteOrder) override;
 
  [[nodiscard]] size_t size() const override;
  size_t write(IoWrapper& ioWrapper, ByteOrder byteOrder) const override;
  [[nodiscard]] size_t ifdOffset() const override;
 
  static size_t sizeOfSignature();
 
 private:
  DataBuf buf_;                    
  size_t start_{0};                
  static const byte signature_[];  
 
};  // class Nikon2MnHeader
 
class Nikon3MnHeader : public MnHeader {
 public:
 
 
  Nikon3MnHeader();
 
  bool read(const byte* pData, size_t size, ByteOrder byteOrder) override;
  void setByteOrder(ByteOrder byteOrder) override;
 
  [[nodiscard]] size_t size() const override;
  size_t write(IoWrapper& ioWrapper, ByteOrder byteOrder) const override;
  [[nodiscard]] size_t ifdOffset() const override;
  [[nodiscard]] ByteOrder byteOrder() const override;
  [[nodiscard]] size_t baseOffset(size_t mnOffset) const override;
 
  static size_t sizeOfSignature();
 
 private:
  DataBuf buf_;                            
  ByteOrder byteOrder_{invalidByteOrder};  
  size_t start_;                           
  static const byte signature_[];          
 
};  // class Nikon3MnHeader
 
class PanasonicMnHeader : public MnHeader {
 public:
 
 
  PanasonicMnHeader();
 
  bool read(const byte* pData, size_t size, ByteOrder byteOrder) override;
 
  [[nodiscard]] size_t size() const override;
  size_t write(IoWrapper& ioWrapper, ByteOrder byteOrder) const override;
  [[nodiscard]] size_t ifdOffset() const override;
 
  static size_t sizeOfSignature();
 
 private:
  DataBuf buf_;                    
  size_t start_{0};                
  static const byte signature_[];  
 
};  // class PanasonicMnHeader
 
class PentaxDngMnHeader : public MnHeader {
 public:
 
 
  PentaxDngMnHeader();
 
  bool read(const byte* pData, size_t size, ByteOrder byteOrder) override;
 
  [[nodiscard]] size_t size() const override;
  size_t write(IoWrapper& ioWrapper, ByteOrder byteOrder) const override;
  [[nodiscard]] size_t ifdOffset() const override;
  [[nodiscard]] size_t baseOffset(size_t mnOffset) const override;
 
  static size_t sizeOfSignature();
 
 private:
  DataBuf header_;                 
  static const byte signature_[];  
 
};  // class PentaxDngMnHeader
 
class PentaxMnHeader : public MnHeader {
 public:
 
 
  PentaxMnHeader();
 
  bool read(const byte* pData, size_t size, ByteOrder byteOrder) override;
 
  [[nodiscard]] size_t size() const override;
  size_t write(IoWrapper& ioWrapper, ByteOrder byteOrder) const override;
  [[nodiscard]] size_t ifdOffset() const override;
 
  static size_t sizeOfSignature();
 
 private:
  DataBuf header_;                 
  static const byte signature_[];  
 
};  // class PentaxMnHeader
 
class SamsungMnHeader : public MnHeader {
 public:
 
 
  SamsungMnHeader();
 
  bool read(const byte* pData, size_t size, ByteOrder byteOrder) override;
 
  [[nodiscard]] size_t size() const override;
  size_t write(IoWrapper& ioWrapper, ByteOrder byteOrder) const override;
  [[nodiscard]] size_t baseOffset(size_t mnOffset) const override;
 
};  // class SamsungMnHeader
 
class SigmaMnHeader : public MnHeader {
 public:
 
 
  SigmaMnHeader();
 
  bool read(const byte* pData, size_t size, ByteOrder byteOrder) override;
 
  [[nodiscard]] size_t size() const override;
  size_t write(IoWrapper& ioWrapper, ByteOrder byteOrder) const override;
  [[nodiscard]] size_t ifdOffset() const override;
 
  static size_t sizeOfSignature();
 
 private:
  DataBuf buf_;                     
  size_t start_{0};                 
  static const byte signature1_[];  
  static const byte signature2_[];  
 
};  // class SigmaMnHeader
 
class SonyMnHeader : public MnHeader {
 public:
 
 
  SonyMnHeader();
 
  bool read(const byte* pData, size_t size, ByteOrder byteOrder) override;
 
  [[nodiscard]] size_t size() const override;
  size_t write(IoWrapper& ioWrapper, ByteOrder byteOrder) const override;
  [[nodiscard]] size_t ifdOffset() const override;
 
  static size_t sizeOfSignature();
 
 private:
  DataBuf buf_;                    
  size_t start_{0};                
  static const byte signature_[];  
 
};  // class SonyMnHeader
 
class Casio2MnHeader : public MnHeader {
 public:
 
 
  Casio2MnHeader();
 
  bool read(const byte* pData, size_t size, ByteOrder byteOrder) override;
 
  [[nodiscard]] size_t size() const override;
  size_t write(IoWrapper& ioWrapper, ByteOrder byteOrder) const override;
  [[nodiscard]] size_t ifdOffset() const override;
  [[nodiscard]] ByteOrder byteOrder() const override;
 
  static size_t sizeOfSignature();
 
 private:
  DataBuf buf_;                       
  size_t start_{0};                   
  static const byte signature_[];     
  static const ByteOrder byteOrder_;  
 
};  // class Casio2MnHeader
 
// *****************************************************************************
// template, inline and free functions
 
std::unique_ptr<TiffComponent> newIfdMn(uint16_t tag, IfdId group, IfdId mnGroup, const byte* pData, size_t size,
                                        ByteOrder byteOrder);
 
std::unique_ptr<TiffComponent> newIfdMn2(uint16_t tag, IfdId group, IfdId mnGroup);
 
std::unique_ptr<TiffComponent> newOlympusMn(uint16_t tag, IfdId group, IfdId mnGroup, const byte* pData, size_t size,
                                            ByteOrder byteOrder);
 
std::unique_ptr<TiffComponent> newOlympusMn2(uint16_t tag, IfdId group, IfdId mnGroup);
 
std::unique_ptr<TiffComponent> newOlympus2Mn2(uint16_t tag, IfdId group, IfdId mnGroup);
 
std::unique_ptr<TiffComponent> newOMSystemMn(uint16_t tag, IfdId group, IfdId mnGroup, const byte* pData, size_t size,
                                             ByteOrder byteOrder);
 
std::unique_ptr<TiffComponent> newOMSystemMn2(uint16_t tag, IfdId group, IfdId mnGroup);
 
std::unique_ptr<TiffComponent> newFujiMn(uint16_t tag, IfdId group, IfdId mnGroup, const byte* pData, size_t size,
                                         ByteOrder byteOrder);
 
std::unique_ptr<TiffComponent> newFujiMn2(uint16_t tag, IfdId group, IfdId mnGroup);
 
std::unique_ptr<TiffComponent> newNikonMn(uint16_t tag, IfdId group, IfdId mnGroup, const byte* pData, size_t size,
                                          ByteOrder byteOrder);
 
std::unique_ptr<TiffComponent> newNikon2Mn2(uint16_t tag, IfdId group, IfdId mnGroup);
 
std::unique_ptr<TiffComponent> newNikon3Mn2(uint16_t tag, IfdId group, IfdId mnGroup);
 
std::unique_ptr<TiffComponent> newPanasonicMn(uint16_t tag, IfdId group, IfdId mnGroup, const byte* pData, size_t size,
                                              ByteOrder byteOrder);
 
std::unique_ptr<TiffComponent> newPanasonicMn2(uint16_t tag, IfdId group, IfdId mnGroup);
 
std::unique_ptr<TiffComponent> newPentaxMn(uint16_t tag, IfdId group, IfdId mnGroup, const byte* pData, size_t size,
                                           ByteOrder byteOrder);
 
std::unique_ptr<TiffComponent> newPentaxMn2(uint16_t tag, IfdId group, IfdId mnGroup);
 
std::unique_ptr<TiffComponent> newPentaxDngMn2(uint16_t tag, IfdId group, IfdId mnGroup);
 
std::unique_ptr<TiffComponent> newSamsungMn(uint16_t tag, IfdId group, IfdId mnGroup, const byte* pData, size_t size,
                                            ByteOrder byteOrder);
 
std::unique_ptr<TiffComponent> newSamsungMn2(uint16_t tag, IfdId group, IfdId mnGroup);
 
std::unique_ptr<TiffComponent> newSigmaMn(uint16_t tag, IfdId group, IfdId mnGroup, const byte* pData, size_t size,
                                          ByteOrder byteOrder);
 
std::unique_ptr<TiffComponent> newSigmaMn2(uint16_t tag, IfdId group, IfdId mnGroup);
 
std::unique_ptr<TiffComponent> newSonyMn(uint16_t tag, IfdId group, IfdId mnGroup, const byte* pData, size_t size,
                                         ByteOrder byteOrder);
 
std::unique_ptr<TiffComponent> newSony1Mn2(uint16_t tag, IfdId group, IfdId mnGroup);
 
std::unique_ptr<TiffComponent> newSony2Mn2(uint16_t tag, IfdId group, IfdId mnGroup);
 
std::unique_ptr<TiffComponent> newCasioMn(uint16_t tag, IfdId group, IfdId mnGroup, const byte* pData, size_t size,
                                          ByteOrder byteOrder);
 
std::unique_ptr<TiffComponent> newCasio2Mn2(uint16_t tag, IfdId group, IfdId mnGroup);
 
int sonyCsSelector(uint16_t tag, const byte* pData, size_t size, TiffComponent* pRoot);
 
int sony2010eSelector(uint16_t tag, const byte* pData, size_t size, TiffComponent* pRoot);
 
int sony2FpSelector(uint16_t tag, const byte* pData, size_t size, TiffComponent* pRoot);
 
int sonyMisc2bSelector(uint16_t tag, const byte* pData, size_t size, TiffComponent* pRoot);
 
int sonyMisc3cSelector(uint16_t tag, const byte* pData, size_t size, TiffComponent* pRoot);
 
int nikonSelector(uint16_t tag, const byte* pData, size_t size, TiffComponent* pRoot);
 
DataBuf nikonCrypt(uint16_t tag, const byte* pData, size_t size, TiffComponent* pRoot);
 
}  // namespace Exiv2::Internal
 
#endif  // EXIV2_MAKERNOTE_INT_HPP