crwimage_int.hpp

Go to the documentation of this file.

// ***************************************************************** -*- C++ -*-
/*
 * Copyright (C) 2004-2018 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_