// ***************************************************************** -*- 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.

 */

/*

  File:      tiffcomposite.cpp

  Author(s): Andreas Huggel (ahu) <ahuggel@gmx.net>

  History:   11-Apr-06, ahu: created

 */

// *****************************************************************************

// included header files

#include "config.h"

#include "tiffimage_int.hpp"

#include "tiffcomposite_int.hpp"

#include "tiffvisitor_int.hpp"

#include "makernote_int.hpp"

#include "value.hpp"

#include "error.hpp"

#include "enforce.hpp"

// + standard includes

#include <string>

#include <cstring>

#include <iostream>

#include <iomanip>

#include <algorithm>

// *****************************************************************************

namespace {

    //! Add \em tobe - \em curr 0x00 filler bytes if necessary

    uint32_t fillGap(Exiv2::Internal::IoWrapper& ioWrapper, uint32_t curr, uint32_t tobe);

}

// *****************************************************************************

// class member definitions

namespace Exiv2 {

    namespace Internal {

    bool TiffMappingInfo::operator==(const TiffMappingInfo::Key& key) const

    {

        return    (   0 == strcmp("*", make_)

                   || 0 == strncmp(make_, key.m_.c_str(), strlen(make_)))

               && (Tag::all == extendedTag_ || key.e_ == extendedTag_)

               && key.g_ == group_;

    }

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

        : io_(io), pHeader_(pHeader), size_(size), wroteHeader_(false), pow_(pow)

    {

        if (pHeader_ == 0 || size_ == 0) wroteHeader_ = true;

    }

    long IoWrapper::write(const byte* pData, long wcount)

    {

        if (!wroteHeader_ && wcount > 0) {

            io_.write(pHeader_, size_);

            wroteHeader_ = true;

        }

        return io_.write(pData, wcount);

    }

    int IoWrapper::putb(byte data)

    {

        if (!wroteHeader_) {

            io_.write(pHeader_, size_);

            wroteHeader_ = true;

        }

        return io_.putb(data);

    }

    void IoWrapper::setTarget(int id, uint32_t target)

    {

        if (pow_) pow_->setTarget(OffsetWriter::OffsetId(id), target);

    }

    TiffComponent::TiffComponent(uint16_t tag, IfdId group)

        : tag_(tag), group_(group), pStart_(0)

    {

    }

    TiffEntryBase::TiffEntryBase(uint16_t tag, IfdId group, TiffType tiffType)

        : TiffComponent(tag, group),

          tiffType_(tiffType), count_(0), offset_(0),

          size_(0), pData_(0), isMalloced_(false), idx_(0),

          pValue_(0)

    {

    }

    TiffSubIfd::TiffSubIfd(uint16_t tag, IfdId group, IfdId newGroup)

        : TiffEntryBase(tag, group, ttUnsignedLong), newGroup_(newGroup)

    {

    }

    TiffMnEntry::TiffMnEntry(uint16_t tag, IfdId group, IfdId mnGroup)

        : TiffEntryBase(tag, group, ttUndefined), mnGroup_(mnGroup), mn_(0)

    {

    }

    TiffIfdMakernote::TiffIfdMakernote(uint16_t  tag,

                                       IfdId     group,

                                       IfdId     mnGroup,

                                       MnHeader* pHeader,

                                       bool      hasNext)

        : TiffComponent(tag, group),

          pHeader_(pHeader),

          ifd_(tag, mnGroup, hasNext),

          mnOffset_(0),

          imageByteOrder_(invalidByteOrder)

    {

    }

    TiffBinaryArray::TiffBinaryArray(uint16_t tag,

                                     IfdId group,

                                     const ArrayCfg* arrayCfg,

                                     const ArrayDef* arrayDef,

                                     int defSize)

        : TiffEntryBase(tag, group, arrayCfg->elTiffType_),

          cfgSelFct_(0),

          arraySet_(0),

          arrayCfg_(arrayCfg),

          arrayDef_(arrayDef),

          defSize_(defSize),

          setSize_(0),

          origData_(0),

          origSize_(0),

          pRoot_(0),

          decoded_(false)

    {

        assert(arrayCfg != 0);

    }

    TiffBinaryArray::TiffBinaryArray(uint16_t tag,

                                     IfdId group,

                                     const ArraySet* arraySet,

                                     int setSize,

                                     CfgSelFct cfgSelFct)

        : TiffEntryBase(tag, group), // Todo: Does it make a difference that there is no type?

          cfgSelFct_(cfgSelFct),

          arraySet_(arraySet),

          arrayCfg_(0),

          arrayDef_(0),

          defSize_(0),

          setSize_(setSize),

          origData_(0),

          origSize_(0),

          pRoot_(0),

          decoded_(false)

    {

        // We'll figure out the correct cfg later

        assert(cfgSelFct != 0);

        assert(arraySet_ != 0);

    }

    TiffBinaryElement::TiffBinaryElement(uint16_t tag, IfdId group)

        : TiffEntryBase(tag, group),

        elByteOrder_(invalidByteOrder)

    {

        elDef_.idx_ = 0;

        elDef_.tiffType_ = ttUndefined;

        elDef_.count_ = 0;

    }

    TiffComponent::~TiffComponent()

    {

    }

    TiffDirectory::~TiffDirectory()

    {

        for (Components::iterator i = components_.begin(); i != components_.end(); ++i) {

            delete *i;

        }

        delete pNext_;

    }

    TiffSubIfd::~TiffSubIfd()

    {

        for (Ifds::iterator i = ifds_.begin(); i != ifds_.end(); ++i) {

            delete *i;

        }

    }

    TiffEntryBase::~TiffEntryBase()

    {

        if (isMalloced_) {

            delete[] pData_;

        }

        delete pValue_;

    }

    TiffEntry::~TiffEntry()

    {

    }

    TiffDataEntryBase::~TiffDataEntryBase()

    {

    }

    TiffDataEntry::~TiffDataEntry()

    {

    }

    TiffImageEntry::~TiffImageEntry()

    {

    }

    TiffSizeEntry::~TiffSizeEntry()

    {

    }

    TiffMnEntry::~TiffMnEntry()

    {

        delete mn_;

    }

    TiffIfdMakernote::~TiffIfdMakernote()

    {

        delete pHeader_;

    }

    TiffBinaryArray::~TiffBinaryArray()

    {

        for (Components::iterator i = elements_.begin(); i != elements_.end(); ++i) {

            delete *i;

        }

    }

    TiffBinaryElement::~TiffBinaryElement()

    {

    }

    TiffEntryBase::TiffEntryBase(const TiffEntryBase& rhs)

        : TiffComponent(rhs),

          tiffType_(rhs.tiffType_),

          count_(rhs.count_),

          offset_(rhs.offset_),

          size_(rhs.size_),

          pData_(rhs.pData_),

          isMalloced_(rhs.isMalloced_),

          idx_(rhs.idx_),

          pValue_(rhs.pValue_ ? rhs.pValue_->clone().release() : 0)

    {

        if (rhs.isMalloced_) {

            pData_ = new byte[rhs.size_];

            memcpy(pData_, rhs.pData_, rhs.size_);

        }

    }

    TiffDirectory::TiffDirectory(const TiffDirectory& rhs)

        : TiffComponent(rhs),

          hasNext_(rhs.hasNext_),

          pNext_(0)

    {

    }

    TiffSubIfd::TiffSubIfd(const TiffSubIfd& rhs)

        : TiffEntryBase(rhs),

          newGroup_(rhs.newGroup_)

    {

    }

    TiffBinaryArray::TiffBinaryArray(const TiffBinaryArray& rhs)

        : TiffEntryBase(rhs),

          cfgSelFct_(rhs.cfgSelFct_),

          arraySet_(rhs.arraySet_),

          arrayCfg_(rhs.arrayCfg_),

          arrayDef_(rhs.arrayDef_),

          defSize_(rhs.defSize_),

          setSize_(rhs.setSize_),

          origData_(rhs.origData_),

          origSize_(rhs.origSize_),

          pRoot_(rhs.pRoot_),

          decoded_(false)

    {

    }

    TiffComponent::AutoPtr TiffComponent::clone() const

    {

        return AutoPtr(doClone());

    }

    TiffEntry* TiffEntry::doClone() const

    {

        return new TiffEntry(*this);

    }

    TiffDataEntry* TiffDataEntry::doClone() const

    {

        return new TiffDataEntry(*this);

    }

    TiffImageEntry* TiffImageEntry::doClone() const

    {

        return new TiffImageEntry(*this);

    }

    TiffSizeEntry* TiffSizeEntry::doClone() const

    {

        return new TiffSizeEntry(*this);

    }

    TiffDirectory* TiffDirectory::doClone() const

    {

        return new TiffDirectory(*this);

    }

    TiffSubIfd* TiffSubIfd::doClone() const

    {

        return new TiffSubIfd(*this);

    }

    TiffMnEntry* TiffMnEntry::doClone() const

    {

        assert(false); // Not implemented

        return 0;

    }

    TiffIfdMakernote* TiffIfdMakernote::doClone() const

    {

        assert(false); // Not implemented

        return 0;

    }

    TiffBinaryArray* TiffBinaryArray::doClone() const

    {

        return new TiffBinaryArray(*this);

    }

    TiffBinaryElement* TiffBinaryElement::doClone() const

    {

        return new TiffBinaryElement(*this);

    }

    int TiffComponent::idx() const

    {

        return 0;

    }

    int TiffEntryBase::idx() const

    {

        return idx_;

    }

    void TiffEntryBase::setData(DataBuf buf)

    {

        std::pair<byte*, long> p = buf.release();

        setData(p.first, p.second);

        isMalloced_ = true;

    }

    void TiffEntryBase::setData(byte* pData, int32_t size)

    {

        if (isMalloced_) {

            delete[] pData_;

        }

        pData_ = pData;

        size_  = size;

        if (pData_ == 0) size_ = 0;

    }

    void TiffEntryBase::updateValue(Value::AutoPtr value, ByteOrder byteOrder)

    {

        if (value.get() == 0) return;

        uint32_t newSize = value->size();

        if (newSize > size_) {

            setData(DataBuf(newSize));

        }

        if (pData_ != NULL) {

            memset(pData_, 0x0, size_);

        }

        size_ = value->copy(pData_, byteOrder);

        assert(size_ == newSize);

        setValue(value);

    } // TiffEntryBase::updateValue

    void TiffEntryBase::setValue(Value::AutoPtr value)

    {

        if (value.get() == 0) return;

        tiffType_ = toTiffType(value->typeId());

        count_ = value->count();

        delete pValue_;

        pValue_ = value.release();

    } // TiffEntryBase::setValue

    void TiffDataEntry::setStrips(const Value* pSize,

                                  const byte*  pData,

                                  uint32_t     sizeData,

                                  uint32_t     baseOffset)

    {

        if (!pValue() || !pSize) {

#ifndef SUPPRESS_WARNINGS

            EXV_WARNING << "Directory " << groupName(group())

                        << ", entry 0x" << std::setw(4)

                        << std::setfill('0') << std::hex << tag()

                        << ": Size or data offset value not set, ignoring them.\n";

#endif

            return;

        }

        if (pValue()->count() == 0) {

#ifndef SUPPRESS_WARNINGS

            EXV_WARNING << "Directory " << groupName(group())

                        << ", entry 0x" << std::setw(4)

                        << std::setfill('0') << std::hex << tag()

                        << ": Data offset entry value is empty, ignoring it.\n";

#endif

            return;

        }

        if (pValue()->count() != pSize->count()) {

#ifndef SUPPRESS_WARNINGS

            EXV_WARNING << "Directory " << groupName(group())

                        << ", entry 0x" << std::setw(4)

                        << std::setfill('0') << std::hex << tag()

                        << ": Size and data offset entries have different"

                        << " number of components, ignoring them.\n";

#endif

            return;

        }

        uint32_t size = 0;

        for (int i = 0; i < pSize->count(); ++i) {

            size += static_cast<uint32_t>(pSize->toLong(i));

        }

        uint32_t offset = static_cast<uint32_t>(pValue()->toLong(0));

        // Todo: Remove limitation of JPEG writer: strips must be contiguous

        // Until then we check: last offset + last size - first offset == size?

        if (  static_cast<uint32_t>(pValue()->toLong(pValue()->count()-1))

            + static_cast<uint32_t>(pSize->toLong(pSize->count()-1))

            - offset != size) {

#ifndef SUPPRESS_WARNINGS

            EXV_WARNING << "Directory " << groupName(group())

                        << ", entry 0x" << std::setw(4)

                        << std::setfill('0') << std::hex << tag()

                        << ": Data area is not contiguous, ignoring it.\n";

#endif

            return;

        }

        if (   offset > sizeData

            || size > sizeData

            || baseOffset + offset > sizeData - size) {

#ifndef SUPPRESS_WARNINGS

            EXV_WARNING << "Directory " << groupName(group())

                        << ", entry 0x" << std::setw(4)

                        << std::setfill('0') << std::hex << tag()

                        << ": Data area exceeds data buffer, ignoring it.\n";

#endif

            return;

        }

        pDataArea_ = const_cast<byte*>(pData) + baseOffset + offset;

        sizeDataArea_ = size;

        const_cast<Value*>(pValue())->setDataArea(pDataArea_, sizeDataArea_);

    } // TiffDataEntry::setStrips

    void TiffImageEntry::setStrips(const Value* pSize,

                                   const byte*  pData,

                                   uint32_t     sizeData,

                                   uint32_t     baseOffset)

    {

        if (!pValue() || !pSize) {

#ifndef SUPPRESS_WARNINGS

            EXV_WARNING << "Directory " << groupName(group())

                        << ", entry 0x" << std::setw(4)

                        << std::setfill('0') << std::hex << tag()

                        << ": Size or data offset value not set, ignoring them.\n";

#endif

            return;

        }

        if (pValue()->count() != pSize->count()) {

#ifndef SUPPRESS_WARNINGS

            EXV_WARNING << "Directory " << groupName(group())

                        << ", entry 0x" << std::setw(4)

                        << std::setfill('0') << std::hex << tag()

                        << ": Size and data offset entries have different"

                        << " number of components, ignoring them.\n";

#endif

            return;

        }

        for (int i = 0; i < pValue()->count(); ++i) {

            const uint32_t offset = static_cast<uint32_t>(pValue()->toLong(i));

            const byte* pStrip = pData + baseOffset + offset;

            const uint32_t size = static_cast<uint32_t>(pSize->toLong(i));

            if (   offset > sizeData

                || size > sizeData

                || baseOffset + offset > sizeData - size) {

#ifndef SUPPRESS_WARNINGS

                EXV_WARNING << "Directory " << groupName(group())

                            << ", entry 0x" << std::setw(4)

                            << std::setfill('0') << std::hex << tag()

                            << ": Strip " << std::dec << i

                            << " is outside of the data area; ignored.\n";

#endif

            }

            else if (size != 0) {

                strips_.push_back(std::make_pair(pStrip, size));

            }

        }

    } // TiffImageEntry::setStrips

    uint32_t TiffIfdMakernote::ifdOffset() const

    {

        if (!pHeader_) return 0;

        return pHeader_->ifdOffset();

    }

    ByteOrder TiffIfdMakernote::byteOrder() const

    {

        assert(imageByteOrder_ != invalidByteOrder);

        if (!pHeader_ || pHeader_->byteOrder() == invalidByteOrder) {

            return imageByteOrder_;

        }

        return pHeader_->byteOrder();

    }

    uint32_t TiffIfdMakernote::mnOffset() const

    {

        return mnOffset_;

    }

    uint32_t TiffIfdMakernote::baseOffset() const

    {

        if (!pHeader_) return 0;

        return pHeader_->baseOffset(mnOffset_);

    }

    bool TiffIfdMakernote::readHeader(const byte* pData,

                                      uint32_t    size,

                                      ByteOrder   byteOrder)

    {

        if (!pHeader_) return true;

        return pHeader_->read(pData, size, byteOrder);

    }

    void TiffIfdMakernote::setByteOrder(ByteOrder byteOrder)

    {

        if (pHeader_) pHeader_->setByteOrder(byteOrder);

    }

    uint32_t TiffIfdMakernote::sizeHeader() const

    {

        if (!pHeader_) return 0;

        return pHeader_->size();

    }

    uint32_t TiffIfdMakernote::writeHeader(IoWrapper& ioWrapper, ByteOrder byteOrder) const

    {

        if (!pHeader_) return 0;

        return pHeader_->write(ioWrapper, byteOrder);

    }

    uint32_t ArrayDef::size(uint16_t tag, IfdId group) const

    {

        TypeId typeId = toTypeId(tiffType_, tag, group);

        return count_ * TypeInfo::typeSize(typeId);

    }

    bool TiffBinaryArray::initialize(IfdId group)

    {

        if (arrayCfg_ != 0) return true; // Not a complex array or already initialized

        for (int idx = 0; idx < setSize_; ++idx) {

            if (arraySet_[idx].cfg_.group_ == group) {

                arrayCfg_ = &arraySet_[idx].cfg_;

                arrayDef_ = arraySet_[idx].def_;

                defSize_  = arraySet_[idx].defSize_;

                return true;

            }

        }

        return false;

    }

    bool TiffBinaryArray::initialize(TiffComponent* const pRoot)

    {

        if (cfgSelFct_ == 0) return true; // Not a complex array

        int idx = cfgSelFct_(tag(), pData(), TiffEntryBase::doSize(), pRoot);

        if (idx > -1) {

            arrayCfg_ = &arraySet_[idx].cfg_;

            arrayDef_ = arraySet_[idx].def_;

            defSize_  = arraySet_[idx].defSize_;

        }

        return idx > -1;

    }

    void TiffBinaryArray::iniOrigDataBuf()

    {

        origData_ = const_cast<byte*>(pData());

        origSize_ = TiffEntryBase::doSize();

    }

    bool TiffBinaryArray::updOrigDataBuf(const byte* pData, uint32_t size)

    {

        assert(pData != 0);

        if (origSize_ != size) return false;

        if (origData_ == pData) return true;

        memcpy(origData_, pData, origSize_);

        return true;

    }

    uint32_t TiffBinaryArray::addElement(uint32_t idx, const ArrayDef& def)

    {

        uint16_t tag = static_cast<uint16_t>(idx / cfg()->tagStep());

        int32_t sz = EXV_MIN(def.size(tag, cfg()->group_), TiffEntryBase::doSize() - idx);

        TiffComponent::AutoPtr tc = TiffCreator::create(tag, cfg()->group_);

        TiffBinaryElement* tp = dynamic_cast<TiffBinaryElement*>(tc.get());

        // The assertion typically fails if a component is not configured in

        // the TIFF structure table (TiffCreator::tiffTreeStruct_)

        assert(tp);

        tp->setStart(pData() + idx);

        tp->setData(const_cast<byte*>(pData() + idx), sz);

        tp->setElDef(def);

        tp->setElByteOrder(cfg()->byteOrder_);

        addChild(tc);

        return sz;

    } // TiffBinaryArray::addElement

    TiffComponent* TiffComponent::addPath(uint16_t tag,

                                          TiffPath& tiffPath,

                                          TiffComponent* const pRoot,

                                          TiffComponent::AutoPtr object)

    {

        return doAddPath(tag, tiffPath, pRoot, object);

    } // TiffComponent::addPath

    TiffComponent* TiffComponent::doAddPath(uint16_t  /*tag*/,

                                            TiffPath& /*tiffPath*/,

                                            TiffComponent* const /*pRoot*/,

                                            TiffComponent::AutoPtr /*object*/)

    {

        return this;

    } // TiffComponent::doAddPath

    TiffComponent* TiffDirectory::doAddPath(uint16_t tag,

                                            TiffPath& tiffPath,

                                            TiffComponent* const pRoot,

                                            TiffComponent::AutoPtr object)

    {

        assert(tiffPath.size() > 1);

        tiffPath.pop();

        const TiffPathItem tpi = tiffPath.top();

        TiffComponent* tc = 0;

        // Try to use an existing component if there is still at least one

        // composite tag on the stack or the tag to add is the MakerNote tag.

        // This is used to prevent duplicate entries. Sub-IFDs also, but the > 1

        // condition takes care of them, see below.

        if (   tiffPath.size() > 1

            || (tpi.extendedTag() == 0x927c && tpi.group() == exifId)) {

            if (tpi.extendedTag() == Tag::next) {

                tc = pNext_;

            }

            else {

                for (Components::iterator i = components_.begin(); i != components_.end(); ++i) {

                    if ((*i)->tag() == tpi.tag() && (*i)->group() == tpi.group()) {

                        tc = *i;

                        break;

                    }

                }

            }

        }

        if (tc == 0) {

            TiffComponent::AutoPtr atc;

            if (tiffPath.size() == 1 && object.get() != 0) {

                atc = object;

            }

            else {

                atc = TiffCreator::create(tpi.extendedTag(), tpi.group());

            }

            assert(atc.get() != 0);

            // Prevent dangling sub-IFD tags: Do not add a sub-IFD component without children.

            // Todo: How to check before creating the component?

            if (tiffPath.size() == 1 && dynamic_cast<TiffSubIfd*>(atc.get()) != 0) return 0;

            if (tpi.extendedTag() == Tag::next) {

                tc = this->addNext(atc);

            }

            else {

                tc = this->addChild(atc);

            }

        }

        return tc->addPath(tag, tiffPath, pRoot, object);

    } // TiffDirectory::doAddPath

    TiffComponent* TiffSubIfd::doAddPath(uint16_t tag,

                                         TiffPath& tiffPath,

                                         TiffComponent* const pRoot,

                                         TiffComponent::AutoPtr object)

    {

        assert(!tiffPath.empty());

        const TiffPathItem tpi1 = tiffPath.top();

        tiffPath.pop();

        if (tiffPath.empty()) {

            // If the last element in the path is the sub-IFD tag itself we're done.

            // But that shouldn't happen - see TiffDirectory::doAddPath

            return this;

        }

        const TiffPathItem tpi2 = tiffPath.top();

        tiffPath.push(tpi1);

        TiffComponent* tc = 0;

        for (Ifds::iterator i = ifds_.begin(); i != ifds_.end(); ++i) {

            if ((*i)->group() == tpi2.group()) {

                tc = *i;

                break;

            }

        }

        if (tc == 0) {

            if (tiffPath.size() == 1 && object.get() != 0) {

                tc = addChild(object);

            }

            else {

                TiffComponent::AutoPtr atc(new TiffDirectory(tpi1.tag(), tpi2.group()));

                tc = addChild(atc);

            }

            setCount(static_cast<uint32_t>(ifds_.size()));

        }

        return tc->addPath(tag, tiffPath, pRoot, object);

    } // TiffSubIfd::doAddPath

    TiffComponent* TiffMnEntry::doAddPath(uint16_t tag,

                                          TiffPath& tiffPath,

                                          TiffComponent* const pRoot,

                                          TiffComponent::AutoPtr object)

    {

        assert(!tiffPath.empty());

        const TiffPathItem tpi1 = tiffPath.top();

        tiffPath.pop();

        if (tiffPath.empty()) {

            // If the last element in the path is the makernote tag itself we're done

            return this;

        }

        const TiffPathItem tpi2 = tiffPath.top();

        tiffPath.push(tpi1);

        if (mn_ == 0) {

            mnGroup_ = tpi2.group();

            mn_ = TiffMnCreator::create(tpi1.tag(), tpi1.group(), mnGroup_);

            assert(mn_);

        }

        return mn_->addPath(tag, tiffPath, pRoot, object);

    } // TiffMnEntry::doAddPath

    TiffComponent* TiffIfdMakernote::doAddPath(uint16_t tag,

                                               TiffPath& tiffPath,

                                               TiffComponent* const pRoot,

                                               TiffComponent::AutoPtr object)

    {

        return ifd_.addPath(tag, tiffPath, pRoot, object);

    }

    TiffComponent* TiffBinaryArray::doAddPath(uint16_t tag,

                                              TiffPath& tiffPath,

                                              TiffComponent* const pRoot,

                                              TiffComponent::AutoPtr object)

    {

        pRoot_ = pRoot;

        if (tiffPath.size() == 1) {

            // An unknown complex binary array has no children and acts like a standard TIFF entry

            return this;

        }

        tiffPath.pop();

        const TiffPathItem tpi = tiffPath.top();

        // Initialize the binary array (if it is a complex array)

        initialize(tpi.group());

        TiffComponent* tc = 0;

        // Todo: Duplicates are not allowed!

        // To allow duplicate entries, we only check if the new component already

        // exists if there is still at least one composite tag on the stack

        if (tiffPath.size() > 1) {

            for (Components::iterator i = elements_.begin(); i != elements_.end(); ++i) {

                if ((*i)->tag() == tpi.tag() && (*i)->group() == tpi.group()) {

                    tc = *i;

                    break;

                }

            }

        }

        if (tc == 0) {

            TiffComponent::AutoPtr atc;

            if (tiffPath.size() == 1 && object.get() != 0) {

                atc = object;

            }

            else {

                atc = TiffCreator::create(tpi.extendedTag(), tpi.group());

            }

            assert(atc.get() != 0);

            assert(tpi.extendedTag() != Tag::next);

            tc = addChild(atc);

            setCount(static_cast<uint32_t>(elements_.size()));

        }

        return tc->addPath(tag, tiffPath, pRoot, object);

    } // TiffBinaryArray::doAddPath

    TiffComponent* TiffComponent::addChild(TiffComponent::AutoPtr tiffComponent)

    {

        return doAddChild(tiffComponent);

    } // TiffComponent::addChild

    TiffComponent* TiffComponent::doAddChild(AutoPtr /*tiffComponent*/)

    {

        return 0;

    } // TiffComponent::doAddChild

    TiffComponent* TiffDirectory::doAddChild(TiffComponent::AutoPtr tiffComponent)

    {

        TiffComponent* tc = tiffComponent.release();

        components_.push_back(tc);

        return tc;

    } // TiffDirectory::doAddChild

    TiffComponent* TiffSubIfd::doAddChild(TiffComponent::AutoPtr tiffComponent)

    {

        TiffDirectory* d = dynamic_cast<TiffDirectory*>(tiffComponent.release());

        assert(d);

        ifds_.push_back(d);

        return d;

    } // TiffSubIfd::doAddChild

    TiffComponent* TiffMnEntry::doAddChild(TiffComponent::AutoPtr tiffComponent)

    {

        TiffComponent* tc = 0;

        if (mn_) {

            tc =  mn_->addChild(tiffComponent);

        }

        return tc;

    } // TiffMnEntry::doAddChild

    TiffComponent* TiffIfdMakernote::doAddChild(TiffComponent::AutoPtr tiffComponent)

    {

        return ifd_.addChild(tiffComponent);

    }

    TiffComponent* TiffBinaryArray::doAddChild(TiffComponent::AutoPtr tiffComponent)

    {

        TiffComponent* tc = tiffComponent.release();

        elements_.push_back(tc);

        setDecoded(true);

        return tc;

    } // TiffBinaryArray::doAddChild

    TiffComponent* TiffComponent::addNext(TiffComponent::AutoPtr tiffComponent)

    {

        return doAddNext(tiffComponent);

    } // TiffComponent::addNext

    TiffComponent* TiffComponent::doAddNext(AutoPtr /*tiffComponent*/)

    {

        return 0;

    } // TiffComponent::doAddNext

    TiffComponent* TiffDirectory::doAddNext(TiffComponent::AutoPtr tiffComponent)

    {

        TiffComponent* tc = 0;

        if (hasNext_) {

            tc = tiffComponent.release();

            pNext_ = tc;

        }

        return tc;

    } // TiffDirectory::doAddNext

    TiffComponent* TiffMnEntry::doAddNext(TiffComponent::AutoPtr tiffComponent)

    {

        TiffComponent* tc = 0;

        if (mn_) {

            tc = mn_->addNext(tiffComponent);

        }

        return tc;

    } // TiffMnEntry::doAddNext