crwimage_int.hpp

// SPDX-License-Identifier: GPL-2.0-or-later

#ifndef EXIV2_CRWIMAGE_INT_HPP
#define EXIV2_CRWIMAGE_INT_HPP

// *****************************************************************************
// included header files
#include "image.hpp"
#include "tags_int.hpp"

// + standard includes
#include <stack>
#include <vector>

// *****************************************************************************
// namespace extensions
namespace Exiv2::Internal {
// *****************************************************************************
// class declarations
class CiffHeader;
class CiffComponent;
struct CrwMapping;
struct CrwSubDir {
  uint16_t dir;
  uint16_t parent;
};

// *****************************************************************************
// type definitions

using CrwDecodeFct = void (*)(const CiffComponent&, const CrwMapping*, Image&, ByteOrder);

using CrwEncodeFct = void (*)(const Image&, const CrwMapping*, CiffHeader*);

using CrwDirs = std::stack<CrwSubDir>;

enum class DataLocId { valueData, directoryData, lastDataLocId };

// *****************************************************************************
// class definitions

class CiffComponent {
 public:
  using UniquePtr = std::unique_ptr<CiffComponent>;
  using Components = std::vector<CiffComponent*>;


  CiffComponent() = default;
  CiffComponent(uint16_t tag, uint16_t dir);
  CiffComponent(const CiffComponent&) = delete;
  CiffComponent& operator=(const CiffComponent&) = delete;
  virtual ~CiffComponent() = default;


  // Default assignment operator is fine

  void add(UniquePtr component);
  CiffComponent* add(CrwDirs& crwDirs, uint16_t crwTagId);
  void remove(CrwDirs& crwDirs, uint16_t crwTagId);
  void read(const byte* pData, size_t size, uint32_t start, ByteOrder byteOrder);
  size_t write(Blob& blob, ByteOrder byteOrder, size_t offset);

  size_t writeValueData(Blob& blob, size_t offset);

  void setDir(uint16_t dir) {
    dir_ = dir;
  }
  void setValue(DataBuf&& buf);

  static TypeId typeId(uint16_t tag);
  static DataLocId dataLocation(uint16_t tag);



  void decode(Image& image, ByteOrder byteOrder) const;
  void print(std::ostream& os, ByteOrder byteOrder, const std::string& prefix = "") const;
  void writeDirEntry(Blob& blob, ByteOrder byteOrder) const;
  [[nodiscard]] uint16_t dir() const {
    return dir_;
  }

  [[nodiscard]] uint16_t tag() const {
    return tag_;
  }

  [[nodiscard]] bool empty() const;

  [[nodiscard]] size_t size() const {
    return size_;
  }

  [[nodiscard]] size_t offset() const {
    return offset_;
  }

  [[nodiscard]] const byte* pData() const {
    return pData_;
  }

  [[nodiscard]] uint16_t tagId() const {
    return tag_ & 0x3fff;
  }

  [[nodiscard]] TypeId typeId() const {
    return typeId(tag_);
  }

  [[nodiscard]] DataLocId dataLocation() const {
    return dataLocation(tag_);
  }

  [[nodiscard]] CiffComponent* findComponent(uint16_t crwTagId, uint16_t crwDir) const;

 protected:

  virtual void doAdd(UniquePtr component) = 0;
  virtual CiffComponent* doAdd(CrwDirs& crwDirs, uint16_t crwTagId);
  virtual void doRemove(CrwDirs& crwDirs, uint16_t crwTagId);
  virtual void doRead(const byte* pData, size_t size, uint32_t start, ByteOrder byteOrder);
  virtual size_t doWrite(Blob& blob, ByteOrder byteOrder, size_t offset) = 0;
  void setSize(size_t size) {
    size_ = size;
  }
  void setOffset(size_t offset) {
    offset_ = offset;
  }


  virtual void doDecode(Image& image, ByteOrder byteOrder) const = 0;
  virtual void doPrint(std::ostream& os, ByteOrder byteOrder, const std::string& prefix) const;
  [[nodiscard]] virtual bool doEmpty() const;
  [[nodiscard]] virtual CiffComponent* doFindComponent(uint16_t crwTagId, uint16_t crwDir) const;

 private:
  // DATA
  uint16_t dir_ = 0;   
  uint16_t tag_ = 0;   
  size_t size_ = 0;    
  size_t offset_ = 0;  

  // Notes on the ownership model of pData_: pData_ is a always a read-only
  // pointer to a buffer owned by somebody else. Usually it is a pointer
  // into a copy of the image that was memory-mapped in CrwImage::readMetadata().
  // However, if CiffComponent::setValue() is used, then it is a pointer into
  // the storage_ DataBuf below.
  const byte* pData_ = nullptr;  

  // This DataBuf is only used when CiffComponent::setValue is called.
  // Otherwise, it remains empty.
  DataBuf storage_;
};  // class CiffComponent

class CiffEntry : public CiffComponent {
  using CiffComponent::CiffComponent;

  using CiffComponent::doAdd;
  // See base class comment
  void doAdd(UniquePtr component) override;
  size_t doWrite(Blob& blob, ByteOrder byteOrder, size_t offset) override;


  // See base class comment
  void doDecode(Image& image, ByteOrder byteOrder) const override;

};  // class CiffEntry

class CiffDirectory : public CiffComponent {
  using CiffComponent::CiffComponent;

 public:

  ~CiffDirectory() override;

  CiffDirectory(const CiffDirectory&) = delete;
  CiffDirectory& operator=(const CiffDirectory&) = delete;


  // Default assignment operator is fine

  void readDirectory(const byte* pData, size_t size, ByteOrder byteOrder);

 private:

  // See base class comment
  void doAdd(UniquePtr component) override;
  // See base class comment
  CiffComponent* doAdd(CrwDirs& crwDirs, uint16_t crwTagId) override;
  // See base class comment
  void doRemove(CrwDirs& crwDirs, uint16_t crwTagId) override;
  size_t doWrite(Blob& blob, ByteOrder byteOrder, size_t offset) override;
  // See base class comment
  void doRead(const byte* pData, size_t size, uint32_t start, ByteOrder byteOrder) override;


  // See base class comment
  void doDecode(Image& image, ByteOrder byteOrder) const override;

  // See base class comment
  void doPrint(std::ostream& os, ByteOrder byteOrder, const std::string& prefix) const override;

  [[nodiscard]] bool doEmpty() const override;

  // See base class comment
  [[nodiscard]] CiffComponent* doFindComponent(uint16_t crwTagId, uint16_t crwDir) const override;

  // DATA
  Components components_;  
  UniquePtr m_;            // used by recursive doAdd

};  // class CiffDirectory

class CiffHeader {
 public:
  using UniquePtr = std::unique_ptr<CiffHeader>;


  CiffHeader() = default;
  virtual ~CiffHeader() = default;



  void read(const byte* pData, size_t size);
  void add(uint16_t crwTagId, uint16_t crwDir, DataBuf&& buf);
  void remove(uint16_t crwTagId, uint16_t crwDir) const;

  static const char* signature() {
    return signature_;
  }



  void write(Blob& blob) const;
  void decode(Image& image) const;

  [[nodiscard]] ByteOrder byteOrder() const {
    return byteOrder_;
  }
  [[nodiscard]] CiffComponent* findComponent(uint16_t crwTagId, uint16_t crwDir) const;

 private:
  // DATA
  static constexpr auto signature_ = "HEAPCCDR";  

  std::unique_ptr<CiffDirectory> pRootDir_;  
  ByteOrder byteOrder_ = littleEndian;       
  uint32_t offset_ = 0;                      
  std::vector<byte> pPadding_;               
  uint32_t padded_ = 0;                      

};  // class CiffHeader

struct CrwMapping {
  uint16_t crwTagId_;      
  uint16_t crwDir_;        
  uint32_t size_;          
  uint16_t tag_;           
  IfdId ifdId_;            
  CrwDecodeFct toExif_;    
  CrwEncodeFct fromExif_;  
};

class CrwMap {
 public:
  static void decode(const CiffComponent& ciffComponent, Image& image, ByteOrder byteOrder);
  static void encode(CiffHeader* pHead, const Image& image);

  static void loadStack(CrwDirs& crwDirs, uint16_t crwDir);

 private:
  static const CrwMapping* crwMapping(uint16_t crwDir, uint16_t crwTagId);

  static void decodeBasic(const CiffComponent& ciffComponent, const CrwMapping* pCrwMapping, Image& image,
                          ByteOrder byteOrder);

  static void decode0x0805(const CiffComponent& ciffComponent, const CrwMapping* pCrwMapping, Image& image,
                           ByteOrder byteOrder);

  static void decode0x080a(const CiffComponent& ciffComponent, const CrwMapping* pCrwMapping, Image& image,
                           ByteOrder byteOrder);

  static void decodeArray(const CiffComponent& ciffComponent, const CrwMapping* pCrwMapping, Image& image,
                          ByteOrder byteOrder);

  static void decode0x180e(const CiffComponent& ciffComponent, const CrwMapping* pCrwMapping, Image& image,
                           ByteOrder byteOrder);

  static void decode0x1810(const CiffComponent& ciffComponent, const CrwMapping* pCrwMapping, Image& image,
                           ByteOrder byteOrder);

  static void decode0x2008(const CiffComponent& ciffComponent, const CrwMapping* pCrwMapping, Image& image,
                           ByteOrder byteOrder);

  static void encodeBasic(const Image& image, const CrwMapping* pCrwMapping, CiffHeader* pHead);

  static void encode0x0805(const Image& image, const CrwMapping* pCrwMapping, CiffHeader* pHead);

  static void encode0x080a(const Image& image, const CrwMapping* pCrwMapping, CiffHeader* pHead);

  static void encodeArray(const Image& image, const CrwMapping* pCrwMapping, CiffHeader* pHead);

  static void encode0x180e(const Image& image, const CrwMapping* pCrwMapping, CiffHeader* pHead);

  static void encode0x1810(const Image& image, const CrwMapping* pCrwMapping, CiffHeader* pHead);

  static void encode0x2008(const Image& image, const CrwMapping* pCrwMapping, CiffHeader* pHead);

  // DATA
  static const CrwMapping crwMapping_[];  
  static const CrwSubDir crwSubDir_[];    

};  // class CrwMap

// *****************************************************************************
// template, inline and free functions

DataBuf packIfdId(const ExifData& exifData, IfdId ifdId, ByteOrder byteOrder);

}  // namespace Exiv2::Internal

#endif  // EXIV2_CRWIMAGE_INT_HPP