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