crwimage_int.hpp

// ***************************************************************** -*- C++ -*-
/*
 * Copyright (C) 2004-2021 Exiv2 authors
 * This program is part of the Exiv2 distribution.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, 5th Floor, Boston, MA 02110-1301 USA.
 */
#ifndef CRWIMAGE_INT_HPP_
#define CRWIMAGE_INT_HPP_
 
// *****************************************************************************
// included header files
#include "tags_int.hpp"
#include "image.hpp"
 
// + standard includes
#include <iosfwd>
#include <string>
#include <vector>
#include <stack>
 
// *****************************************************************************
// namespace extensions
namespace Exiv2 {
 
// *****************************************************************************
// class declarations
    class ExifData;
 
    namespace Internal {
 
// *****************************************************************************
// class declarations
    class CiffHeader;
    class CiffComponent;
    struct CrwMapping;
    struct CrwSubDir;
 
// *****************************************************************************
// type definitions
 
    typedef void (*CrwDecodeFct)(const CiffComponent&,
                                 const CrwMapping*,
                                 Image&,
                                 ByteOrder);
 
    typedef void (*CrwEncodeFct)(const Image&,
                                 const CrwMapping*,
                                 CiffHeader*);
 
    typedef std::stack<CrwSubDir> CrwDirs;
 
    enum DataLocId {
        valueData,
        directoryData,
        lastDataLocId
    };
 
// *****************************************************************************
// class definitions
 
    class CiffComponent {
    public:
        typedef std::auto_ptr<CiffComponent> AutoPtr;
        typedef std::vector<CiffComponent*> Components;
 
 
 
        CiffComponent()
            : dir_(0), tag_(0), size_(0), offset_(0), pData_(0),
              isAllocated_(false) {}
        CiffComponent(uint16_t tag, uint16_t dir)
            : dir_(dir), tag_(tag), size_(0), offset_(0), pData_(0),
              isAllocated_(false) {}
        virtual ~CiffComponent();
 
 
        // Default assignment operator is fine
 
        void add(AutoPtr component);
        CiffComponent* add(CrwDirs& crwDirs, uint16_t crwTagId);
        void remove(CrwDirs& crwDirs, uint16_t crwTagId);
        void read(const byte* pData,
                  uint32_t    size,
                  uint32_t    start,
                  ByteOrder   byteOrder);
        uint32_t write(Blob& blob, ByteOrder byteOrder, uint32_t offset);
        uint32_t writeValueData(Blob& blob, uint32_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;
        uint16_t dir()           const { return dir_; }
 
        uint16_t tag()           const { return tag_; }
 
        bool empty()             const;
 
        uint32_t size()          const { return size_; }
 
        uint32_t offset()        const { return offset_; }
 
        const byte* pData()      const { return pData_; }
 
        uint16_t tagId()         const { return tag_ & 0x3fff; }
 
        TypeId typeId()          const { return typeId(tag_); }
 
        DataLocId dataLocation() const { return dataLocation(tag_); }
 
        CiffComponent* findComponent(uint16_t crwTagId, uint16_t crwDir) const;
 
    protected:
 
 
        virtual void doAdd(AutoPtr component) =0;
        virtual CiffComponent* doAdd(CrwDirs& crwDirs, uint16_t crwTagId);
        virtual void doRemove(CrwDirs& crwDirs, uint16_t crwTagId);
        virtual void doRead(const byte* pData,
                            uint32_t    size,
                            uint32_t    start,
                            ByteOrder   byteOrder);
        virtual uint32_t doWrite(Blob&     blob,
                                 ByteOrder byteOrder,
                                 uint32_t  offset) =0;
        void setSize(uint32_t size)        { size_ = size; }
        void setOffset(uint32_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;
        virtual bool doEmpty() const;
        virtual CiffComponent* doFindComponent(uint16_t crwTagId,
                                               uint16_t crwDir) const;
 
    private:
        // DATA
        uint16_t    dir_;         
        uint16_t    tag_;         
        uint32_t    size_;        
        uint32_t    offset_;      
        const byte* pData_;       
        bool        isAllocated_; 
 
    }; // class CiffComponent
 
    class CiffEntry : public CiffComponent {
    public:
 
 
        CiffEntry() {}
        CiffEntry(uint16_t tag, uint16_t dir) : CiffComponent(tag, dir) {}
 
        virtual ~CiffEntry();
 
        // Default assignment operator is fine
 
    private:
 
        using CiffComponent::doAdd;
        // See base class comment
        virtual void doAdd(AutoPtr component);
        virtual uint32_t doWrite(Blob&     blob,
                                 ByteOrder byteOrder,
                                 uint32_t  offset);
 
 
        // See base class comment
        virtual void doDecode(Image& image, ByteOrder byteOrder) const;
 
    }; // class CiffEntry
 
    class CiffDirectory : public CiffComponent {
    public:
 
 
        CiffDirectory() : cc_(NULL) {}
        CiffDirectory(uint16_t tag, uint16_t dir) : CiffComponent(tag, dir), cc_(NULL) {}
 
        virtual ~CiffDirectory();
 
 
        // Default assignment operator is fine
 
        void readDirectory(const byte* pData,
                           uint32_t    size,
                           ByteOrder   byteOrder);
 
    private:
 
        // See base class comment
        virtual void doAdd(AutoPtr component);
        // See base class comment
        virtual CiffComponent* doAdd(CrwDirs& crwDirs, uint16_t crwTagId);
        // See base class comment
        virtual void doRemove(CrwDirs& crwDirs, uint16_t crwTagId);
        virtual uint32_t doWrite(Blob&     blob,
                                 ByteOrder byteOrder,
                                 uint32_t  offset);
        // See base class comment
        virtual void doRead(const byte* pData,
                            uint32_t    size,
                            uint32_t    start,
                            ByteOrder   byteOrder);
 
 
        // See base class comment
        virtual void doDecode(Image&    image,
                              ByteOrder byteOrder) const;
 
        // See base class comment
        virtual void doPrint(std::ostream&      os,
                             ByteOrder          byteOrder,
                             const std::string& prefix) const;
 
        virtual bool doEmpty() const;
 
        // See base class comment
        virtual CiffComponent* doFindComponent(uint16_t crwTagId,
                                               uint16_t crwDir) const;
 
    private:
        // DATA
        Components components_; 
        AutoPtr    m_; // used by recursive doAdd
        CiffComponent* cc_;
 
    }; // class CiffDirectory
 
    class CiffHeader {
    public:
        typedef std::auto_ptr<CiffHeader> AutoPtr;
 
 
 
        CiffHeader()
            : pRootDir_  (0),
              byteOrder_ (littleEndian),
              offset_    (0x0000001a),
              pPadding_  (0),
              padded_    (0)
            {}
        virtual ~CiffHeader();
 
 
 
        void read(const byte* pData, uint32_t size);
        void add(uint16_t crwTagId, uint16_t crwDir, DataBuf buf);
        void remove(uint16_t crwTagId, uint16_t crwDir);
 
        static const char* signature() { return signature_; }
 
 
 
        void write(Blob& blob) const;
        void decode(Image& image) const;
        void print(std::ostream& os, const std::string& prefix ="") const;
        ByteOrder byteOrder() const { return byteOrder_; }
        CiffComponent* findComponent(uint16_t crwTagId, uint16_t crwDir) const;
 
    private:
        // DATA
        static const char signature_[];   
 
        CiffDirectory*    pRootDir_;      
        ByteOrder         byteOrder_;     
        uint32_t          offset_;        
        byte*             pPadding_;      
        uint32_t          padded_;        
 
    }; // class CiffHeader
 
    struct CrwSubDir {
        uint16_t crwDir_;                 
        uint16_t parent_;                 
    }; // struct CrwSubDir
 
    struct CrwMapping {
 
 
        CrwMapping(
            uint16_t      crwTagId,
            uint16_t      crwDir,
            uint32_t      size,
            uint16_t      tag,
            Internal::IfdId ifdId,
            CrwDecodeFct  toExif,
            CrwEncodeFct  fromExif)
            : crwTagId_ (crwTagId),
              crwDir_   (crwDir),
              size_     (size),
              tag_      (tag),
              ifdId_    (ifdId),
              toExif_   (toExif),
              fromExif_ (fromExif)
            {}
 
        // DATA
        uint16_t      crwTagId_;  
        uint16_t      crwDir_;    
        uint32_t      size_;      
        uint16_t      tag_;       
        IfdId         ifdId_;     
        CrwDecodeFct  toExif_;    
        CrwEncodeFct  fromExif_;  
 
    }; // struct CrwMapping
 
    class CrwMap {
 
 
        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);
    private:
        // 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 Internal, Exiv2
 
#endif                                  // #ifndef CRWIMAGE_INT_HPP_