tiffcomposite_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 TIFFCOMPOSITE_INT_HPP_
#define TIFFCOMPOSITE_INT_HPP_

// *****************************************************************************
// included header files
#include "value.hpp"
#include "tifffwd_int.hpp"
#include "types.hpp"

// + standard includes
#include <iosfwd>
#include <vector>
#include <string>
#include <cassert>

// *****************************************************************************
// namespace extensions
namespace Exiv2 {

    class BasicIo;

    namespace Internal {

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

    typedef uint16_t TiffType;

    const TiffType ttUnsignedByte     = 1; 
    const TiffType ttAsciiString      = 2; 
    const TiffType ttUnsignedShort    = 3; 
    const TiffType ttUnsignedLong     = 4; 
    const TiffType ttUnsignedRational = 5; 
    const TiffType ttSignedByte       = 6; 
    const TiffType ttUndefined        = 7; 
    const TiffType ttSignedShort      = 8; 
    const TiffType ttSignedLong       = 9; 
    const TiffType ttSignedRational   =10; 
    const TiffType ttTiffFloat        =11; 
    const TiffType ttTiffDouble       =12; 
    const TiffType ttTiffIfd          =13; 

    TypeId toTypeId(TiffType tiffType, uint16_t tag, IfdId group);
    TiffType toTiffType(TypeId typeId);

    namespace Tag {
        const uint32_t none = 0x10000; 
        const uint32_t root = 0x20000; 
        const uint32_t next = 0x30000; 
        const uint32_t all  = 0x40000; 
        const uint32_t pana = 0x80000; 
    }

    class TiffPathItem {
    public:

        TiffPathItem(uint32_t extendedTag, IfdId group)
            : extendedTag_(extendedTag), group_(group) {}


        uint16_t tag()         const { return static_cast<uint16_t>(extendedTag_ & 0xffff); }
        uint32_t extendedTag() const { return extendedTag_; }
        IfdId    group()       const { return group_; }

    private:
        // DATA
        uint32_t extendedTag_;
        IfdId    group_;
    }; // class TiffPathItem

    class IoWrapper {
    public:


        IoWrapper(BasicIo& io, const byte* pHeader, long size, OffsetWriter* pow);



        long write(const byte* pData, long wcount);
        int putb(byte data);
        void setTarget(int id, uint32_t target);

    private:
        // DATA
        BasicIo& io_;              
        const byte* pHeader_;      
        long size_;                
        bool wroteHeader_;         
        OffsetWriter* pow_;        
    }; // class IoWrapper

    class TiffComponent {
    public:
        typedef std::auto_ptr<TiffComponent> AutoPtr;
        typedef std::vector<TiffComponent*> Components;


        TiffComponent(uint16_t tag, IfdId group);
        virtual ~TiffComponent();



        TiffComponent* addPath(uint16_t tag,
                               TiffPath& tiffPath,
                               TiffComponent* const pRoot,
                               AutoPtr object =AutoPtr(0));
        TiffComponent* addChild(AutoPtr tiffComponent);
        TiffComponent* addNext(AutoPtr tiffComponent);
        void accept(TiffVisitor& visitor);
        void setStart(const byte* pStart) { pStart_ = const_cast<byte*>(pStart); }
        uint32_t write(IoWrapper& ioWrapper,
                       ByteOrder byteOrder,
                       int32_t   offset,
                       uint32_t  valueIdx,
                       uint32_t  dataIdx,
                       uint32_t& imageIdx);


        uint16_t tag()                        const { return tag_; }
        IfdId    group()                      const { return group_; }
        byte*    start()                      const { return pStart_; }
        AutoPtr clone() const;
        uint32_t writeData(IoWrapper& ioWrapper,
                           ByteOrder byteOrder,
                           int32_t   offset,
                           uint32_t  dataIdx,
                           uint32_t& imageIdx) const;
        uint32_t writeImage(IoWrapper& ioWrapper,
                            ByteOrder byteOrder) const;
        uint32_t size() const;
        uint32_t count() const;
        uint32_t sizeData() const;
        uint32_t sizeImage() const;
        // Todo: This is only implemented in TiffEntryBase. It is needed here so that
        //       we can sort components by tag and idx. Something is not quite right.
        virtual int idx() const;

    protected:

        virtual TiffComponent* doAddPath(uint16_t  tag,
                                         TiffPath& tiffPath,
                                         TiffComponent* const pRoot,
                                         TiffComponent::AutoPtr object);
        virtual TiffComponent* doAddChild(AutoPtr tiffComponent);
        virtual TiffComponent* doAddNext(AutoPtr tiffComponent);
        virtual void doAccept(TiffVisitor& visitor) =0;
        virtual uint32_t doWrite(IoWrapper& ioWrapper,
                                 ByteOrder byteOrder,
                                 int32_t   offset,
                                 uint32_t  valueIdx,
                                 uint32_t  dataIdx,
                                 uint32_t& imageIdx) =0;


        virtual TiffComponent* doClone() const =0;
        virtual uint32_t doWriteData(IoWrapper& ioWrapper,
                                     ByteOrder byteOrder,
                                     int32_t   offset,
                                     uint32_t  dataIdx,
                                     uint32_t& imageIdx) const =0;
        virtual uint32_t doWriteImage(IoWrapper& ioWrapper,
                                      ByteOrder byteOrder) const =0;
        virtual uint32_t doSize() const =0;
        virtual uint32_t doCount() const =0;
        virtual uint32_t doSizeData() const =0;
        virtual uint32_t doSizeImage() const =0;

    private:
        // DATA
        uint16_t tag_;      
        IfdId    group_;    

        byte*    pStart_;

    }; // class TiffComponent

    struct TiffMappingInfo {
        struct Key;
        bool operator==(const Key& key) const;
        uint16_t tag() const { return static_cast<uint16_t>(extendedTag_ & 0xffff); }

        // DATA
        const char* make_;        
        uint32_t    extendedTag_; 
        IfdId       group_;       
        DecoderFct  decoderFct_;  
        EncoderFct  encoderFct_;  

    }; // struct TiffMappingInfo

    struct TiffMappingInfo::Key {
        Key(const std::string& m, uint32_t e, IfdId g) : m_(m), e_(e), g_(g) {}
        std::string m_;                    
        uint32_t    e_;                    
        IfdId       g_;                    
    };

    class TiffEntryBase : public TiffComponent {
        friend class TiffReader;
        friend class TiffEncoder;
        friend int selectNikonLd(TiffBinaryArray* const, TiffComponent* const);
    public:

        TiffEntryBase(uint16_t tag, IfdId group, TiffType tiffType =ttUndefined);
        virtual ~TiffEntryBase();



        void encode(TiffEncoder& encoder, const Exifdatum* datum);
        void setOffset(int32_t offset) { offset_ = offset; }
        void setData(byte* pData, int32_t size);
        void setData(DataBuf buf);
        void updateValue(Value::AutoPtr value, ByteOrder byteOrder);
        void setValue(Value::AutoPtr value);


        TiffType tiffType()      const { return tiffType_; }
        int32_t offset()         const { return offset_; }
        virtual int idx()        const;
        const byte* pData()      const { return pData_; }
        const Value* pValue()    const { return pValue_; }

    protected:

        TiffEntryBase(const TiffEntryBase& rhs);


        virtual void doEncode(TiffEncoder& encoder, const Exifdatum* datum) =0;
        void setCount(uint32_t count) { count_ = count; }
        void setIdx(int idx) { idx_ = idx; }
        virtual uint32_t doWrite(IoWrapper& ioWrapper,
                                 ByteOrder byteOrder,
                                 int32_t   offset,
                                 uint32_t  valueIdx,
                                 uint32_t  dataIdx,
                                 uint32_t& imageIdx);


        virtual uint32_t doCount() const;
        virtual uint32_t doWriteData(IoWrapper& ioWrapper,
                                     ByteOrder byteOrder,
                                     int32_t   offset,
                                     uint32_t  dataIdx,
                                     uint32_t& imageIdx) const;
        virtual uint32_t doWriteImage(IoWrapper& ioWrapper,
                                      ByteOrder byteOrder) const;
        virtual uint32_t doSize() const;
        virtual uint32_t doSizeData() const;
        virtual uint32_t doSizeImage() const;

        static uint32_t writeOffset(byte*     buf,
                                    int32_t   offset,
                                    TiffType  tiffType,
                                    ByteOrder byteOrder);

    private:

        TiffEntryBase& operator=(const TiffEntryBase& rhs);

        // DATA
        TiffType tiffType_;   
        uint32_t count_;      
        int32_t  offset_;     

        uint32_t size_;
        byte*    pData_;      
        bool     isMalloced_; 
        int      idx_;        
        Value*   pValue_;     

    }; // class TiffEntryBase

    class TiffEntry : public TiffEntryBase {
    public:

        TiffEntry(uint16_t tag, IfdId group) : TiffEntryBase(tag, group) {}
        virtual ~TiffEntry();

    protected:

        virtual void doAccept(TiffVisitor& visitor);
        virtual void doEncode(TiffEncoder& encoder, const Exifdatum* datum);


        virtual TiffEntry* doClone() const;

    }; // class TiffEntry

    class TiffDataEntryBase : public TiffEntryBase {
    public:

        TiffDataEntryBase(uint16_t tag, IfdId group, uint16_t szTag, IfdId szGroup)
            : TiffEntryBase(tag, group),
              szTag_(szTag), szGroup_(szGroup) {}
        virtual ~TiffDataEntryBase();



        virtual void setStrips(const Value* pSize,
                               const byte*  pData,
                               uint32_t     sizeData,
                               uint32_t     baseOffset) =0;


        uint16_t szTag()   const { return szTag_; }
        IfdId    szGroup() const { return szGroup_; }

    private:
        // DATA
        const uint16_t szTag_;               
        const IfdId    szGroup_;             

    }; // class TiffDataEntryBase

    class TiffDataEntry : public TiffDataEntryBase {
        friend class TiffEncoder;
    public:

        TiffDataEntry(uint16_t tag, IfdId group, uint16_t szTag, IfdId szGroup)
            : TiffDataEntryBase(tag, group, szTag, szGroup),
              pDataArea_(0), sizeDataArea_(0) {}
        virtual ~TiffDataEntry();


        virtual void setStrips(const Value* pSize,
                               const byte*  pData,
                               uint32_t     sizeData,
                               uint32_t     baseOffset);

    protected:

        virtual void doAccept(TiffVisitor& visitor);
        virtual void doEncode(TiffEncoder& encoder, const Exifdatum* datum);
        virtual uint32_t doWrite(IoWrapper& ioWrapper,
                                 ByteOrder byteOrder,
                                 int32_t   offset,
                                 uint32_t  valueIdx,
                                 uint32_t  dataIdx,
                                 uint32_t& imageIdx);


        virtual TiffDataEntry* doClone() const;
        virtual uint32_t doWriteData(IoWrapper& ioWrapper,
                                     ByteOrder byteOrder,
                                     int32_t   offset,
                                     uint32_t  dataIdx,
                                     uint32_t& imageIdx) const;
        // Using doWriteImage from base class
        // Using doSize() from base class
        virtual uint32_t doSizeData() const;
        // Using doSizeImage from base class

    private:
        // DATA
        byte*          pDataArea_;           
        uint32_t       sizeDataArea_;        

    }; // class TiffDataEntry

    class TiffImageEntry : public TiffDataEntryBase {
        friend class TiffEncoder;
    public:

        TiffImageEntry(uint16_t tag, IfdId group, uint16_t szTag, IfdId szGroup)
            : TiffDataEntryBase(tag, group, szTag, szGroup) {}
        virtual ~TiffImageEntry();


        virtual void setStrips(const Value* pSize,
                               const byte*  pData,
                               uint32_t     sizeData,
                               uint32_t     baseOffset);

    protected:

        virtual void doAccept(TiffVisitor& visitor);
        virtual void doEncode(TiffEncoder& encoder, const Exifdatum* datum);
        virtual uint32_t doWrite(IoWrapper& ioWrapper,
                                 ByteOrder byteOrder,
                                 int32_t   offset,
                                 uint32_t  valueIdx,
                                 uint32_t  dataIdx,
                                 uint32_t& imageIdx);


        virtual TiffImageEntry* doClone() const;
        virtual uint32_t doWriteData(IoWrapper& ioWrapper,
                                     ByteOrder byteOrder,
                                     int32_t   offset,
                                     uint32_t  dataIdx,
                                     uint32_t& imageIdx) const;
        virtual uint32_t doWriteImage(IoWrapper& ioWrapper,
                                      ByteOrder byteOrder) const;
        virtual uint32_t doSize() const;
        virtual uint32_t doSizeData() const;
        virtual uint32_t doSizeImage() const;

    private:
        typedef std::vector<std::pair<const byte*, uint32_t> > Strips;

        // DATA
        Strips   strips_;       

    }; // class TiffImageEntry

    class TiffSizeEntry : public TiffEntryBase {
    public:

        TiffSizeEntry(uint16_t tag, IfdId group, uint16_t dtTag, IfdId dtGroup)
            : TiffEntryBase(tag, group), dtTag_(dtTag), dtGroup_(dtGroup) {}
        virtual ~TiffSizeEntry();


        uint16_t dtTag()   const { return dtTag_; }
        IfdId    dtGroup() const { return dtGroup_; }

    protected:

        virtual void doAccept(TiffVisitor& visitor);
        virtual void doEncode(TiffEncoder& encoder, const Exifdatum* datum);


        virtual TiffSizeEntry* doClone() const;

    private:
        // DATA
        const uint16_t dtTag_;        
        const IfdId    dtGroup_;      

    }; // class TiffSizeEntry

    class TiffDirectory : public TiffComponent {
        friend class TiffEncoder;
    public:

        TiffDirectory(uint16_t tag, IfdId group, bool hasNext =true)
            : TiffComponent(tag, group), hasNext_(hasNext), pNext_(0) {}
        virtual ~TiffDirectory();


        bool hasNext() const { return hasNext_; }

    protected:

        TiffDirectory(const TiffDirectory& rhs);


        virtual TiffComponent* doAddPath(uint16_t tag,
                                         TiffPath& tiffPath,
                                         TiffComponent* const pRoot,
                                         TiffComponent::AutoPtr object);
        virtual TiffComponent* doAddChild(TiffComponent::AutoPtr tiffComponent);
        virtual TiffComponent* doAddNext(TiffComponent::AutoPtr tiffComponent);
        virtual void doAccept(TiffVisitor& visitor);
        virtual uint32_t doWrite(IoWrapper& ioWrapper,
                                 ByteOrder byteOrder,
                                 int32_t   offset,
                                 uint32_t  valueIdx,
                                 uint32_t  dataIdx,
                                 uint32_t& imageIdx);


        virtual TiffDirectory* doClone() const;
        virtual uint32_t doWriteData(IoWrapper& ioWrapper,
                                     ByteOrder byteOrder,
                                     int32_t   offset,
                                     uint32_t  dataIdx,
                                     uint32_t& imageIdx) const;
        virtual uint32_t doWriteImage(IoWrapper& ioWrapper,
                                      ByteOrder byteOrder) const;
        virtual uint32_t doSize() const;
        virtual uint32_t doCount() const;
        virtual uint32_t doSizeData() const;
        virtual uint32_t doSizeImage() const;

    private:

        TiffDirectory& operator=(const TiffDirectory& rhs);


        uint32_t writeDirEntry(IoWrapper&     ioWrapper,
                               ByteOrder      byteOrder,
                               int32_t        offset,
                               TiffComponent* pTiffComponent,
                               uint32_t       valueIdx,
                               uint32_t       dataIdx,
                               uint32_t&      imageIdx) const;

    private:
        // DATA
        Components components_; 
        const bool hasNext_;    
        TiffComponent* pNext_;  

    }; // class TiffDirectory

    class TiffSubIfd : public TiffEntryBase {
        friend class TiffReader;
    public:

        TiffSubIfd(uint16_t tag, IfdId group, IfdId newGroup);
        virtual ~TiffSubIfd();

    protected:

        TiffSubIfd(const TiffSubIfd& rhs);


        virtual TiffComponent* doAddPath(uint16_t tag,
                                         TiffPath& tiffPath,
                                         TiffComponent* const pRoot,
                                         TiffComponent::AutoPtr object);
        virtual TiffComponent* doAddChild(TiffComponent::AutoPtr tiffComponent);
        virtual void doAccept(TiffVisitor& visitor);
        virtual void doEncode(TiffEncoder& encoder, const Exifdatum* datum);
        virtual uint32_t doWrite(IoWrapper& ioWrapper,
                                 ByteOrder byteOrder,
                                 int32_t   offset,
                                 uint32_t  valueIdx,
                                 uint32_t  dataIdx,
                                 uint32_t& imageIdx);


        virtual TiffSubIfd* doClone() const;
        virtual uint32_t doWriteData(IoWrapper& ioWrapper,
                                     ByteOrder byteOrder,
                                     int32_t   offset,
                                     uint32_t  dataIdx,
                                     uint32_t& imageIdx) const;
        virtual uint32_t doWriteImage(IoWrapper& ioWrapper,
                                      ByteOrder byteOrder) const;
        uint32_t doSize() const;
        virtual uint32_t doSizeData() const;
        virtual uint32_t doSizeImage() const;

    private:

        TiffSubIfd& operator=(const TiffSubIfd& rhs);

        typedef std::vector<TiffDirectory*> Ifds;

        // DATA
        IfdId    newGroup_; 
        Ifds     ifds_;     

    }; // class TiffSubIfd

    class TiffMnEntry : public TiffEntryBase {
        friend class TiffReader;
        friend class TiffDecoder;
        friend class TiffEncoder;
    public:

        TiffMnEntry(uint16_t tag, IfdId group, IfdId mnGroup);
        virtual ~TiffMnEntry();

    protected:

        virtual TiffComponent* doAddPath(uint16_t tag,
                                         TiffPath& tiffPath,
                                         TiffComponent* const pRoot,
                                         TiffComponent::AutoPtr object);
        virtual TiffComponent* doAddChild(TiffComponent::AutoPtr tiffComponent);
        virtual TiffComponent* doAddNext(TiffComponent::AutoPtr tiffComponent);
        virtual void doAccept(TiffVisitor& visitor);
        virtual void doEncode(TiffEncoder& encoder, const Exifdatum* datum);
        virtual uint32_t doWrite(IoWrapper& ioWrapper,
                                 ByteOrder byteOrder,
                                 int32_t   offset,
                                 uint32_t  valueIdx,
                                 uint32_t  dataIdx,
                                 uint32_t& imageIdx);


        virtual TiffMnEntry* doClone() const;
        virtual uint32_t doCount() const;
        // Using doWriteData from base class
        // Using doWriteImage from base class
        virtual uint32_t doSize() const;
        // Using doSizeData from base class
        // Using doSizeImage from base class

    private:

        TiffMnEntry(const TiffMnEntry& rhs);
        TiffMnEntry& operator=(const TiffMnEntry& rhs);

        // DATA
        IfdId          mnGroup_;             
        TiffComponent* mn_;                  

    }; // class TiffMnEntry

    class TiffIfdMakernote : public TiffComponent {
        friend class TiffReader;
    public:

        TiffIfdMakernote(uint16_t  tag,
                         IfdId     group,
                         IfdId     mnGroup,
                         MnHeader* pHeader,
                         bool      hasNext =true);
        virtual ~TiffIfdMakernote();



        bool readHeader(const byte* pData, uint32_t size, ByteOrder byteOrder);
        void setByteOrder(ByteOrder byteOrder);
        void setImageByteOrder(ByteOrder byteOrder) { imageByteOrder_ = byteOrder; }


        uint32_t sizeHeader() const;
        uint32_t writeHeader(IoWrapper& ioWrapper, ByteOrder byteOrder) const;
        uint32_t mnOffset() const;
        uint32_t ifdOffset() const;
        ByteOrder byteOrder() const;
        ByteOrder imageByteOrder() const { return imageByteOrder_; }
        uint32_t baseOffset() const;

    protected:

        virtual TiffComponent* doAddPath(uint16_t tag,
                                         TiffPath& tiffPath,
                                         TiffComponent* const pRoot,
                                         TiffComponent::AutoPtr object);
        virtual TiffComponent* doAddChild(TiffComponent::AutoPtr tiffComponent);
        virtual TiffComponent* doAddNext(TiffComponent::AutoPtr tiffComponent);
        virtual void doAccept(TiffVisitor& visitor);
        virtual uint32_t doWrite(IoWrapper& ioWrapper,
                                 ByteOrder byteOrder,
                                 int32_t   offset,
                                 uint32_t  valueIdx,
                                 uint32_t  dataIdx,
                                 uint32_t& imageIdx);


        virtual TiffIfdMakernote* doClone() const;
        virtual uint32_t doWriteData(IoWrapper& ioWrapper,
                                     ByteOrder byteOrder,
                                     int32_t   offset,
                                     uint32_t  dataIdx,
                                     uint32_t& imageIdx) const;
        virtual uint32_t doWriteImage(IoWrapper& ioWrapper,
                                      ByteOrder byteOrder) const;
        virtual uint32_t doSize() const;
        virtual uint32_t doCount() const;
        virtual uint32_t doSizeData() const;
        virtual uint32_t doSizeImage() const;

    private:
        TiffIfdMakernote(const TiffIfdMakernote& rhs);
        TiffIfdMakernote& operator=(const TiffIfdMakernote& rhs);

        // DATA
        MnHeader*     pHeader_;                 
        TiffDirectory ifd_;                     
        uint32_t      mnOffset_;                
        ByteOrder     imageByteOrder_;          

    }; // class TiffIfdMakernote

    typedef int (*CfgSelFct)(uint16_t, const byte*, uint32_t, TiffComponent* const);

    typedef DataBuf (*CryptFct)(uint16_t, const byte*, uint32_t, TiffComponent* const);

    struct ArrayDef {
        bool operator==(uint32_t idx) const { return idx_ == idx; }
        uint32_t size(uint16_t tag, IfdId group) const;
        // DATA
        uint32_t idx_;             
        TiffType tiffType_;        
        uint32_t count_;           
    };

    struct ArrayCfg {
        uint32_t tagStep() const { return elDefaultDef_.size(0, group_); }
        //DATA
        IfdId       group_;        
        ByteOrder   byteOrder_;    
        TiffType    elTiffType_;   
        CryptFct    cryptFct_;     
        bool        hasSize_;      
        bool        hasFillers_;   
        bool        concat_;       
        ArrayDef    elDefaultDef_; 
    };

    struct ArraySet {
        const ArrayCfg  cfg_;      
        const ArrayDef* def_;      
        const int       defSize_;  
    };

    class TiffBinaryArray : public TiffEntryBase {
    public:

        TiffBinaryArray(uint16_t tag,
                        IfdId group,
                        const ArrayCfg* arrayCfg,
                        const ArrayDef* arrayDef,
                        int defSize);
        TiffBinaryArray(uint16_t tag,
                        IfdId group,
                        const ArraySet* arraySet,
                        int setSize,
                        CfgSelFct cfgSelFct);
        virtual ~TiffBinaryArray();


        uint32_t addElement(uint32_t idx, const ArrayDef& def);
        bool initialize(IfdId group);
        bool initialize(TiffComponent* const pRoot);
        void iniOrigDataBuf();
        bool updOrigDataBuf(const byte* pData, uint32_t size);
        void setDecoded(bool decoded) { decoded_ = decoded; }


        const ArrayCfg* cfg() const { return arrayCfg_; }
        const ArrayDef* def() const { return arrayDef_; }
        int defSize() const { return defSize_; }
        bool decoded() const { return decoded_; }

    protected:

        TiffBinaryArray(const TiffBinaryArray& rhs);



        virtual TiffComponent* doAddPath(uint16_t tag,
                                         TiffPath& tiffPath,
                                         TiffComponent* const pRoot,
                                         TiffComponent::AutoPtr object);
        virtual TiffComponent* doAddChild(TiffComponent::AutoPtr tiffComponent);
        virtual void doAccept(TiffVisitor& visitor);
        virtual void doEncode(TiffEncoder& encoder, const Exifdatum* datum);
        virtual uint32_t doWrite(IoWrapper& ioWrapper,
                                 ByteOrder byteOrder,
                                 int32_t   offset,
                                 uint32_t  valueIdx,
                                 uint32_t  dataIdx,
                                 uint32_t& imageIdx);


        virtual TiffBinaryArray* doClone() const;
        virtual uint32_t doCount() const;
        // Using doWriteData from base class
        // Using doWriteImage from base class
        virtual uint32_t doSize() const;
        // Using doSizeData from base class
        // Using doSizeImage from base class

    private:

        TiffBinaryArray& operator=(const TiffBinaryArray& rhs);

        // DATA
        const CfgSelFct cfgSelFct_; 
        const ArraySet* arraySet_;  
        const ArrayCfg* arrayCfg_;  
        const ArrayDef* arrayDef_;  
        int defSize_;               
        int setSize_;               
        Components elements_;       
        byte* origData_;            
        uint32_t origSize_;         
        TiffComponent* pRoot_;      
        bool decoded_;              
    }; // class TiffBinaryArray

    class TiffBinaryElement : public TiffEntryBase {
    public:

        TiffBinaryElement(uint16_t tag, IfdId group);
        virtual ~TiffBinaryElement();



        void setElDef(const ArrayDef& def) { elDef_ = def; }
        void setElByteOrder(ByteOrder byteOrder) { elByteOrder_ = byteOrder; }



        const ArrayDef* elDef()       const { return &elDef_; }
        ByteOrder       elByteOrder() const { return elByteOrder_; }

    protected:

        virtual void doAccept(TiffVisitor& visitor);
        virtual void doEncode(TiffEncoder& encoder, const Exifdatum* datum);
        virtual uint32_t doWrite(IoWrapper& ioWrapper,
                                 ByteOrder byteOrder,
                                 int32_t   offset,
                                 uint32_t  valueIdx,
                                 uint32_t  dataIdx,
                                 uint32_t& imageIdx);


        virtual TiffBinaryElement* doClone() const;
        virtual uint32_t doCount() const;
        // Using doWriteData from base class
        // Using doWriteImage from base class
        virtual uint32_t doSize() const;
        // Using doSizeData from base class
        // Using doSizeImage from base class

    private:
        // DATA
        ArrayDef  elDef_;        
        ByteOrder elByteOrder_;  

    }; // class TiffBinaryElement

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

    bool cmpTagLt(TiffComponent const* lhs, TiffComponent const* rhs);

    bool cmpGroupLt(TiffComponent const* lhs, TiffComponent const* rhs);

    TiffComponent::AutoPtr newTiffEntry(uint16_t tag, IfdId group);

    TiffComponent::AutoPtr newTiffMnEntry(uint16_t tag, IfdId group);

    TiffComponent::AutoPtr newTiffBinaryElement(uint16_t tag, IfdId group);

    template<IfdId newGroup>
    TiffComponent::AutoPtr newTiffDirectory(uint16_t tag, IfdId /*group*/)
    {
        return TiffComponent::AutoPtr(new TiffDirectory(tag, newGroup));
    }

    template<IfdId newGroup>
    TiffComponent::AutoPtr newTiffSubIfd(uint16_t tag, IfdId group)
    {
        return TiffComponent::AutoPtr(new TiffSubIfd(tag, group, newGroup));
    }

    template<const ArrayCfg* arrayCfg, int N, const ArrayDef (&arrayDef)[N]>
    TiffComponent::AutoPtr newTiffBinaryArray0(uint16_t tag, IfdId group)
    {
        // *& acrobatics is a workaround for a MSVC 7.1 bug
        return TiffComponent::AutoPtr(
            new TiffBinaryArray(tag, group, arrayCfg, *(&arrayDef), N));
    }

    template<const ArrayCfg* arrayCfg>
    TiffComponent::AutoPtr newTiffBinaryArray1(uint16_t tag, IfdId group)
    {
        return TiffComponent::AutoPtr(
            new TiffBinaryArray(tag, group, arrayCfg, 0, 0));
    }

    template<const ArraySet* arraySet, int N, CfgSelFct cfgSelFct>
    TiffComponent::AutoPtr newTiffBinaryArray2(uint16_t tag, IfdId group)
    {
        return TiffComponent::AutoPtr(
            new TiffBinaryArray(tag, group, arraySet, N, cfgSelFct));
    }

    template<uint16_t szTag, IfdId szGroup>
    TiffComponent::AutoPtr newTiffThumbData(uint16_t tag, IfdId group)
    {
        return TiffComponent::AutoPtr(
            new TiffDataEntry(tag, group, szTag, szGroup));
    }

    template<uint16_t dtTag, IfdId dtGroup>
    TiffComponent::AutoPtr newTiffThumbSize(uint16_t tag, IfdId group)
    {
        return TiffComponent::AutoPtr(
            new TiffSizeEntry(tag, group, dtTag, dtGroup));
    }

    template<uint16_t szTag, IfdId szGroup>
    TiffComponent::AutoPtr newTiffImageData(uint16_t tag, IfdId group)
    {
        return TiffComponent::AutoPtr(
            new TiffImageEntry(tag, group, szTag, szGroup));
    }

    template<uint16_t dtTag, IfdId dtGroup>
    TiffComponent::AutoPtr newTiffImageSize(uint16_t tag, IfdId group)
    {
        // Todo: Same as newTiffThumbSize - consolidate (rename)?
        return TiffComponent::AutoPtr(
            new TiffSizeEntry(tag, group, dtTag, dtGroup));
    }

}}                                      // namespace Internal, Exiv2

#endif                                  // #ifndef TIFFCOMPOSITE_INT_HPP_