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