tiffcomposite_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 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; 
        const uint32_t fuji      = 0x100000; 
        const uint32_t cmt2      = 0x110000; 
        const uint32_t cmt3      = 0x120000; 
        const uint32_t cmt4      = 0x130000; 
    }
 
    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;
        friend class TiffDecoder;
    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_