#include "crwimage_int.hpp"

#include "canonmn_int.hpp"

#include "i18n.h"                // NLS support.

#include "timegm.h"

#include "unused.h"

#include "error.hpp"

#include "enforce.hpp"

#include <cassert>

#include <ctime>

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

// local declarations

namespace {

    //! Helper class to map Exif orientation values to CRW rotation degrees

    class RotationMap {

    public:

        //! Get the orientation number for a degree value

        static uint16_t orientation(int32_t degrees);

        //! Get the degree value for an orientation number

        static int32_t  degrees(uint16_t orientation);

    private:

        //! Helper structure for the mapping list

        struct OmList {

            uint16_t orientation; //!< Exif orientation value

            int32_t  degrees;     //!< CRW Rotation degrees

        };

        // DATA

        static const OmList omList_[];

    }; // class RotationMap

}

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

// local definitions

namespace {

    //! @cond IGNORE

    const RotationMap::OmList RotationMap::omList_[] = {

        { 1,    0 },

        { 3,  180 },

        { 3, -180 },

        { 6,   90 },

        { 6, -270 },

        { 8,  270 },

        { 8,  -90 },

        // last entry

        { 0,    0 }

    };

    uint16_t RotationMap::orientation(int32_t degrees)

    {

        uint16_t o = 1;

        for (int i = 0; omList_[i].orientation != 0; ++i) {

            if (omList_[i].degrees == degrees) {

                o = omList_[i].orientation;

                break;

            }

        }

        return o;

    }

    int32_t RotationMap::degrees(uint16_t orientation)

    {

        int32_t d = 0;

        for (int i = 0; omList_[i].orientation != 0; ++i) {

            if (omList_[i].orientation == orientation) {

                d = omList_[i].degrees;

                break;

            }

        }

        return d;

    }

    //! @endcond

}

namespace Exiv2 {

    namespace Internal {

    /*

      Mapping table used to decode and encode CIFF tags to/from Exif tags.  Only

      a subset of the Exif tags can be mapped to known tags found in CRW files

      and not all CIFF tags in the CRW files have a corresponding Exif tag. Tags

      which are not mapped in the table below are ignored.

      When decoding, each CIFF tag/directory pair in the CRW image is looked up

      in the table and if it has an entry, the corresponding decode function is

      called (CrwMap::decode). This function may or may not make use of the

      other parameters in the structure (such as the Exif tag and Ifd id).

      Encoding is done in a loop over the mapping table (CrwMap::encode). For

      each entry, the encode function is called, which looks up the (Exif)

      metadata to encode in the image. This function may or may not make use of

      the other parameters in the mapping structure.

    */

    const CrwMapping CrwMap::crwMapping_[] = {

        //         CrwTag  CrwDir  Size ExifTag IfdId    decodeFct     encodeFct

        //         ------  ------  ---- ------- -----    ---------     ---------

        CrwMapping(0x0805, 0x300a,   0, 0,      canonId, decode0x0805, encode0x0805),

        CrwMapping(0x080a, 0x2807,   0, 0,      canonId, decode0x080a, encode0x080a),

        CrwMapping(0x080b, 0x3004,   0, 0x0007, canonId, decodeBasic,  encodeBasic),

        CrwMapping(0x0810, 0x2807,   0, 0x0009, canonId, decodeBasic,  encodeBasic),

        CrwMapping(0x0815, 0x2804,   0, 0x0006, canonId, decodeBasic,  encodeBasic),

        CrwMapping(0x1029, 0x300b,   0, 0x0002, canonId, decodeBasic,  encodeBasic),

        CrwMapping(0x102a, 0x300b,   0, 0x0004, canonId, decodeArray,  encodeArray),

        CrwMapping(0x102d, 0x300b,   0, 0x0001, canonId, decodeArray,  encodeArray),

        CrwMapping(0x1033, 0x300b,   0, 0x000f, canonId, decodeArray,  encodeArray),

        CrwMapping(0x1038, 0x300b,   0, 0x0012, canonId, decodeArray,  encodeArray),

        CrwMapping(0x10a9, 0x300b,   0, 0x00a9, canonId, decodeBasic,  encodeBasic),

        // Mapped to Exif.Photo.ColorSpace instead (see below)

        //CrwMapping(0x10b4, 0x300b,   0, 0x00b4, canonId, decodeBasic,  encodeBasic),

        CrwMapping(0x10b4, 0x300b,   0, 0xa001, exifId,  decodeBasic,  encodeBasic),

        CrwMapping(0x10b5, 0x300b,   0, 0x00b5, canonId, decodeBasic,  encodeBasic),

        CrwMapping(0x10c0, 0x300b,   0, 0x00c0, canonId, decodeBasic,  encodeBasic),

        CrwMapping(0x10c1, 0x300b,   0, 0x00c1, canonId, decodeBasic,  encodeBasic),

        CrwMapping(0x1807, 0x3002,   0, 0x9206, exifId,  decodeBasic,  encodeBasic),

        CrwMapping(0x180b, 0x3004,   0, 0x000c, canonId, decodeBasic,  encodeBasic),

        CrwMapping(0x180e, 0x300a,   0, 0x9003, exifId,  decode0x180e, encode0x180e),

        CrwMapping(0x1810, 0x300a,   0, 0xa002, exifId,  decode0x1810, encode0x1810),

        CrwMapping(0x1817, 0x300a,   4, 0x0008, canonId, decodeBasic,  encodeBasic),

        //CrwMapping(0x1818, 0x3002,   0, 0x9204, exifId, decodeBasic,  encodeBasic),

        CrwMapping(0x183b, 0x300b,   0, 0x0015, canonId, decodeBasic,  encodeBasic),

        CrwMapping(0x2008, 0x0000,   0, 0,      ifd1Id,  decode0x2008, encode0x2008),

        // End of list marker

        CrwMapping(0x0000, 0x0000,   0, 0x0000, ifdIdNotSet, 0,            0)

    }; // CrwMap::crwMapping_[]

    /*

      CIFF directory hierarchy

                root

                 |

                300a

                 |

       +----+----+----+----+

       |    |    |    |    |

      2804 2807 3002 3003 300b

            |

           3004

      The array is arranged bottom-up so that starting with a directory at the

      bottom, the (unique) path to root can be determined in a single loop.

    */

    const CrwSubDir CrwMap::crwSubDir_[] = {

        // dir,   parent

        { 0x3004, 0x2807 },

        { 0x300b, 0x300a },

        { 0x3003, 0x300a },

        { 0x3002, 0x300a },

        { 0x2807, 0x300a },

        { 0x2804, 0x300a },

        { 0x300a, 0x0000 },

        { 0x0000, 0xffff },

        // End of list marker

        { 0xffff, 0xffff }

    };

    const char CiffHeader::signature_[] = "HEAPCCDR";

    CiffHeader::~CiffHeader()

    {

        delete   pRootDir_;

        delete[] pPadding_;

    }

    CiffComponent::~CiffComponent()

    {

        if (isAllocated_) delete[] pData_;

    }

    CiffEntry::~CiffEntry()

    {

    }

    CiffDirectory::~CiffDirectory()

    {

        Components::iterator b = components_.begin();

        Components::iterator e = components_.end();

        for (Components::iterator i = b; i != e; ++i) {

            delete *i;

        }

    }

    void CiffComponent::add(AutoPtr component)

    {

        doAdd(component);

    }

    void CiffEntry::doAdd(AutoPtr /*component*/)

    {

        throw Error(kerFunctionNotSupported, "CiffEntry::add");

    } // CiffEntry::doAdd

    void CiffDirectory::doAdd(AutoPtr component)

    {

        components_.push_back(component.release());

    } // CiffDirectory::doAdd

    void CiffHeader::read(const byte* pData, uint32_t size)

    {

        if (size < 14) throw Error(kerNotACrwImage);

        if (pData[0] == 'I' && pData[0] == pData[1]) {

            byteOrder_ = littleEndian;

        }

        else if (pData[0] == 'M' && pData[0] == pData[1]) {

            byteOrder_ = bigEndian;

        }

        else {

            throw Error(kerNotACrwImage);

        }

        offset_ = getULong(pData + 2, byteOrder_);

        if (offset_ < 14 || offset_ > size) throw Error(kerNotACrwImage);

        if (std::memcmp(pData + 6, signature(), 8) != 0) {

            throw Error(kerNotACrwImage);

        }

        delete[] pPadding_;

        pPadding_ = new byte[offset_ - 14];

        padded_ = offset_ - 14;

        std::memcpy(pPadding_, pData + 14, padded_);

        pRootDir_ = new CiffDirectory;

        pRootDir_->readDirectory(pData + offset_, size - offset_, byteOrder_);

    } // CiffHeader::read

    void CiffComponent::read(const byte* pData,

                             uint32_t    size,

                             uint32_t    start,

                             ByteOrder   byteOrder)

    {

        doRead(pData, size, start, byteOrder);

    }

    void CiffComponent::doRead(const byte* pData,

                               uint32_t    size,

                               uint32_t    start,

                               ByteOrder   byteOrder)

    {

        // We're going read 10 bytes. Make sure they won't be out-of-bounds.

        enforce(size >= 10 && start <= size - 10, kerNotACrwImage);

        tag_ = getUShort(pData + start, byteOrder);

        DataLocId dl = dataLocation();

        assert(dl == directoryData || dl == valueData);

        if (dl == valueData) {

            size_   = getULong(pData + start + 2, byteOrder);

            offset_ = getULong(pData + start + 6, byteOrder);

            // Make sure that the sub-region does not overlap with the 10 bytes

            // that we just read. (Otherwise a malicious file could cause an

            // infinite recursion.) There are two cases two consider because

            // the sub-region is allowed to be either before or after the 10

            // bytes in memory.

            if (offset_ < start) {

              // Sub-region is before in memory.

              enforce(size_ <= start - offset_, kerOffsetOutOfRange);

            } else {

              // Sub-region is after in memory.

              enforce(offset_ >= start + 10, kerOffsetOutOfRange);

              enforce(offset_ <= size, kerOffsetOutOfRange);

              enforce(size_ <= size - offset_, kerOffsetOutOfRange);

            }

        }

        if (dl == directoryData) {

            size_ = 8;

            offset_ = start + 2;

        }

        pData_ = pData + offset_;

#ifdef EXIV2_DEBUG_MESSAGES

        std::cout << "  Entry for tag 0x"

                  << std::hex << tagId() << " (0x" << tag()

                  << "), " << std::dec << size_

                  << " Bytes, Offset is " << offset_ << "\n";

#endif

    } // CiffComponent::doRead

    void CiffDirectory::doRead(const byte* pData,

                               uint32_t    size,

                               uint32_t    start,

                               ByteOrder   byteOrder)

    {

        CiffComponent::doRead(pData, size, start, byteOrder);

#ifdef EXIV2_DEBUG_MESSAGES

        std::cout << "Reading directory 0x" << std::hex << tag() << "\n";

#endif

        if (this->offset() + this->size() > size)

            throw Error(kerOffsetOutOfRange);

        readDirectory(pData + offset(), this->size(), byteOrder);

#ifdef EXIV2_DEBUG_MESSAGES

        std::cout << "<---- 0x" << std::hex << tag() << "\n";

#endif

    } // CiffDirectory::doRead

    void CiffDirectory::readDirectory(const byte* pData,

                                      uint32_t    size,

                                      ByteOrder   byteOrder)

    {

        if (size < 4)

            throw Error(kerCorruptedMetadata);

        uint32_t o = getULong(pData + size - 4, byteOrder);

        if ( o > size-2 )

            throw Error(kerCorruptedMetadata);

        uint16_t count = getUShort(pData + o, byteOrder);

#ifdef EXIV2_DEBUG_MESSAGES

        std::cout << "Directory at offset " << std::dec << o

                  <<", " << count << " entries \n";

#endif

        o += 2;

        if ( static_cast<uint32_t>(count) * 10 > size-o )

            throw Error(kerCorruptedMetadata);

        for (uint16_t i = 0; i < count; ++i) {

            uint16_t tag = getUShort(pData + o, byteOrder);

            CiffComponent::AutoPtr m;

            switch (CiffComponent::typeId(tag)) {

            case directory: m = CiffComponent::AutoPtr(new CiffDirectory); break;

            default: m = CiffComponent::AutoPtr(new CiffEntry); break;

            }

            m->setDir(this->tag());

            m->read(pData, size, o, byteOrder);

            add(m);

            o += 10;

        }

    }  // CiffDirectory::readDirectory

    void CiffHeader::decode(Image& image) const

    {

        // Nothing to decode from the header itself, just add correct byte order

        if (pRootDir_) pRootDir_->decode(image, byteOrder_);

    } // CiffHeader::decode

    void CiffComponent::decode(Image& image, ByteOrder byteOrder) const

    {

        doDecode(image, byteOrder);

    }

    void CiffEntry::doDecode(Image& image, ByteOrder byteOrder) const

    {

        CrwMap::decode(*this, image, byteOrder);

    } // CiffEntry::doDecode

    void CiffDirectory::doDecode(Image& image, ByteOrder byteOrder) const

    {

        Components::const_iterator b = components_.begin();

        Components::const_iterator e = components_.end();

        for (Components::const_iterator i = b; i != e; ++i) {

            (*i)->decode(image, byteOrder);

        }

    } // CiffDirectory::doDecode

    void CiffHeader::write(Blob& blob) const

    {

        assert(   byteOrder_ == littleEndian

               || byteOrder_ == bigEndian);

        if (byteOrder_ == littleEndian) {

            blob.push_back('I');

            blob.push_back('I');

        }

        else {

            blob.push_back('M');

            blob.push_back('M');

        }

        uint32_t o = 2;

        byte buf[4];

        ul2Data(buf, offset_, byteOrder_);

        append(blob, buf, 4);

        o += 4;

        append(blob, reinterpret_cast<const byte*>(signature_), 8);

        o += 8;

        // Pad as needed

        if (pPadding_) {

            assert(padded_ == offset_ - o);

            append(blob, pPadding_, padded_);

        }

        else {

            for (uint32_t i = o; i < offset_; ++i) {

                blob.push_back(0);

                ++o;

            }

        }

        if (pRootDir_) {

            pRootDir_->write(blob, byteOrder_, offset_);

        }

    }

    uint32_t CiffComponent::write(Blob&     blob,

                                  ByteOrder byteOrder,

                                  uint32_t  offset)

    {

        return doWrite(blob, byteOrder, offset);

    }

    uint32_t CiffEntry::doWrite(Blob&     blob,

                                ByteOrder /*byteOrder*/,

                                uint32_t  offset)

    {

        return writeValueData(blob, offset);

    } // CiffEntry::doWrite

    uint32_t CiffComponent::writeValueData(Blob& blob, uint32_t offset)

    {

        if (dataLocation() == valueData) {

#ifdef EXIV2_DEBUG_MESSAGES

            std::cout << "  Data for tag 0x" << std::hex << tagId()

                      << ", " << std::dec << size_ << " Bytes\n";

#endif

            offset_ = offset;

            append(blob, pData_, size_);

            offset += size_;

            // Pad the value to an even number of bytes

            if (size_ % 2 == 1) {

                blob.push_back(0);

                ++offset;

            }

        }

        return offset;

    } // CiffComponent::writeValueData

    uint32_t CiffDirectory::doWrite(Blob&     blob,

                                    ByteOrder byteOrder,

                                    uint32_t  offset)

    {

#ifdef EXIV2_DEBUG_MESSAGES

        std::cout << "Writing directory 0x" << std::hex << tag() << "---->\n";

#endif

        // Ciff offsets are relative to the start of the directory

        uint32_t dirOffset = 0;

        // Value data

        const Components::iterator b = components_.begin();

        const Components::iterator e = components_.end();

        for (Components::iterator i = b; i != e; ++i) {

            dirOffset = (*i)->write(blob, byteOrder, dirOffset);

        }

        const uint32_t dirStart = dirOffset;

        // Number of directory entries

        byte buf[4];

        us2Data(buf, static_cast<uint16_t>(components_.size()), byteOrder);

        append(blob, buf, 2);

        dirOffset += 2;

        // Directory entries

        for (Components::iterator i = b; i != e; ++i) {

            (*i)->writeDirEntry(blob, byteOrder);

            dirOffset += 10;

        }

        // Offset of directory

        ul2Data(buf, dirStart, byteOrder);

        append(blob, buf, 4);

        dirOffset += 4;

        // Update directory entry

        setOffset(offset);

        setSize(dirOffset);

#ifdef EXIV2_DEBUG_MESSAGES

        std::cout << "Directory is at offset " << std::dec << dirStart

                  << ", " << components_.size() << " entries\n"

                  << "<---- 0x" << std::hex << tag() << "\n";

#endif

        return offset + dirOffset;

    } // CiffDirectory::doWrite

    void CiffComponent::writeDirEntry(Blob& blob, ByteOrder byteOrder) const

    {

#ifdef EXIV2_DEBUG_MESSAGES

        std::cout << "  Directory entry for tag 0x"

                  << std::hex << tagId() << " (0x" << tag()

                  << "), " << std::dec << size_

                  << " Bytes, Offset is " << offset_ << "\n";

#endif

        byte buf[4];

        DataLocId dl = dataLocation();

        assert(dl == directoryData || dl == valueData);

        if (dl == valueData) {

            us2Data(buf, tag_, byteOrder);

            append(blob, buf, 2);

            ul2Data(buf, size_, byteOrder);

            append(blob, buf, 4);

            ul2Data(buf, offset_, byteOrder);

            append(blob, buf, 4);

        }

        if (dl == directoryData) {

            // Only 8 bytes fit in the directory entry

            assert(size_ <= 8);

            us2Data(buf, tag_, byteOrder);

            append(blob, buf, 2);

            // Copy value instead of size and offset

            append(blob, pData_, size_);

            // Pad with 0s

            for (uint32_t i = size_; i < 8; ++i) {

                blob.push_back(0);

            }

        }

    } // CiffComponent::writeDirEntry

    void CiffHeader::print(std::ostream& os, const std::string& prefix) const

    {

        std::ios::fmtflags f( os.flags() );

        os << prefix

           << _("Header, offset") << " = 0x" << std::setw(8) << std::setfill('0')

           << std::hex << std::right << offset_ << "\n";

        if (pRootDir_) pRootDir_->print(os, byteOrder_, prefix);

        os.flags(f);

    } // CiffHeader::print

    void CiffComponent::print(std::ostream&      os,

                              ByteOrder          byteOrder,

                              const std::string& prefix) const

    {

        doPrint(os, byteOrder, prefix);

    }

    void CiffComponent::doPrint(std::ostream&      os,

                                ByteOrder          byteOrder,

                                const std::string& prefix) const

    {

        os << prefix

           << _("tag") << " = 0x" << std::setw(4) << std::setfill('0')

           << std::hex << std::right << tagId()

           << ", " << _("dir") << " = 0x" << std::setw(4) << std::setfill('0')

           << std::hex << std::right << dir()

           << ", " << _("type") << " = " << TypeInfo::typeName(typeId())

           << ", " << _("size") << " = " << std::dec << size_

           << ", " << _("offset") << " = " << offset_ << "\n";

        Value::AutoPtr value;

        if (typeId() != directory) {

            value = Value::create(typeId());

            value->read(pData_, size_, byteOrder);

            if (value->size() < 100) {

                os << prefix << *value << "\n";

            }

        }

    } // CiffComponent::doPrint

    void CiffDirectory::doPrint(std::ostream&      os,

                                ByteOrder          byteOrder,

                                const std::string& prefix) const

    {

        CiffComponent::doPrint(os, byteOrder, prefix);

        Components::const_iterator b = components_.begin();

        Components::const_iterator e = components_.end();

        for (Components::const_iterator i = b; i != e; ++i) {

            (*i)->print(os, byteOrder, prefix + "   ");

        }

    } // CiffDirectory::doPrint

    void CiffComponent::setValue(DataBuf buf)

    {

        if (isAllocated_) {

            delete[] pData_;

            pData_ = 0;

            size_ = 0;

        }

        isAllocated_ = true;

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

        pData_ = p.first;

        size_  = p.second;

        if (size_ > 8 && dataLocation() == directoryData) {

            tag_ &= 0x3fff;

        }

    } // CiffComponent::setValue

    TypeId CiffComponent::typeId(uint16_t tag)

    {

        TypeId ti = invalidTypeId;

        switch (tag & 0x3800) {

        case 0x0000: ti = unsignedByte; break;

        case 0x0800: ti = asciiString; break;

        case 0x1000: ti = unsignedShort; break;

        case 0x1800: ti = unsignedLong; break;

        case 0x2000: ti = undefined; break;

        case 0x2800: // fallthrough

        case 0x3000: ti = directory; break;

        }

        return ti;

    } // CiffComponent::typeId

    DataLocId CiffComponent::dataLocation(uint16_t tag)

    {

        switch (tag & 0xc000) {

        case 0x0000: return valueData;

        case 0x4000: return directoryData;

        default: throw Error(kerCorruptedMetadata);

        }

    } // CiffComponent::dataLocation

    /*!

      @brief Finds \em crwTagId in directory \em crwDir, returning a pointer to

             the component or 0 if not found.

     */

    CiffComponent* CiffHeader::findComponent(uint16_t crwTagId,

                                             uint16_t crwDir) const

    {

        if (pRootDir_ == 0) return 0;

        return pRootDir_->findComponent(crwTagId, crwDir);

    } // CiffHeader::findComponent

    CiffComponent* CiffComponent::findComponent(uint16_t crwTagId,

                                                uint16_t crwDir) const

    {

        return doFindComponent(crwTagId, crwDir);

    } // CiffComponent::findComponent

    CiffComponent* CiffComponent::doFindComponent(uint16_t crwTagId,

                                                  uint16_t crwDir) const

    {

        if (tagId() == crwTagId && dir() == crwDir) {

            return const_cast<CiffComponent*>(this);

        }

        return 0;

    } // CiffComponent::doFindComponent

    CiffComponent* CiffDirectory::doFindComponent(uint16_t crwTagId,

                                                  uint16_t crwDir) const

    {

        CiffComponent* cc = NULL;

        const Components::const_iterator b = components_.begin();

        const Components::const_iterator e = components_.end();

        for (Components::const_iterator i = b; i != e; ++i) {

            cc = (*i)->findComponent(crwTagId, crwDir);

            if (cc) return cc;

        }

        return 0;

    } // CiffDirectory::doFindComponent

    void CiffHeader::add(uint16_t crwTagId, uint16_t crwDir, DataBuf buf)

    {

        CrwDirs crwDirs;

        CrwMap::loadStack(crwDirs, crwDir);

        uint16_t rootDirectory = crwDirs.top().crwDir_;

        UNUSED(rootDirectory);

        assert(rootDirectory == 0x0000);

        crwDirs.pop();

        if (!pRootDir_) pRootDir_ = new CiffDirectory;

        if ( pRootDir_) {

            CiffComponent* child = pRootDir_->add(crwDirs, crwTagId);

            if ( child )   child->setValue(buf);

        }

    } // CiffHeader::add

    CiffComponent* CiffComponent::add(CrwDirs& crwDirs, uint16_t crwTagId)

    {

        return doAdd(crwDirs, crwTagId);

    } // CiffComponent::add

    CiffComponent* CiffComponent::doAdd(CrwDirs& /*crwDirs*/, uint16_t /*crwTagId*/)

    {

        return 0;

    } // CiffComponent::doAdd

    CiffComponent* CiffDirectory::doAdd(CrwDirs& crwDirs, uint16_t crwTagId)

    {

        /*

          add()

            if stack not empty

              pop from stack

              find dir among components

              if not found, create it

              add()

            else

              find tag among components

              if not found, create it

              set value

        */

        const Components::iterator b = components_.begin();

        const Components::iterator e = components_.end();

        if (!crwDirs.empty()) {

            CrwSubDir csd = crwDirs.top();

            crwDirs.pop();

            // Find the directory

            for (Components::iterator i = b; i != e; ++i) {

                if ((*i)->tag() == csd.crwDir_) {

                    cc_ = *i;

                    break;

                }

            }

            if (cc_ == 0) {

                // Directory doesn't exist yet, add it

                m_ = AutoPtr(new CiffDirectory(csd.crwDir_, csd.parent_));

                cc_ = m_.get();

                add(m_);

            }

            // Recursive call to next lower level directory

            cc_ = cc_->add(crwDirs, crwTagId);

        }

        else {

            // Find the tag

            for (Components::iterator i = b; i != e; ++i) {

                if ((*i)->tagId() == crwTagId) {

                    cc_ = *i;

                    break;

                }

            }

            if (cc_ == 0) {

                // Tag doesn't exist yet, add it

                m_ = AutoPtr(new CiffEntry(crwTagId, tag()));

                cc_ = m_.get();

                add(m_);

            }

        }

        return cc_;

    } // CiffDirectory::doAdd

    void CiffHeader::remove(uint16_t crwTagId, uint16_t crwDir)

    {

        if (pRootDir_) {

            CrwDirs crwDirs;

            CrwMap::loadStack(crwDirs, crwDir);

            uint16_t rootDirectory = crwDirs.top().crwDir_;

            UNUSED(rootDirectory);

            assert(rootDirectory == 0x0000);

            crwDirs.pop();

            pRootDir_->remove(crwDirs, crwTagId);

        }

    } // CiffHeader::remove

    void CiffComponent::remove(CrwDirs& crwDirs, uint16_t crwTagId)

    {

        return doRemove(crwDirs, crwTagId);

    } // CiffComponent::remove

    void CiffComponent::doRemove(CrwDirs& /*crwDirs*/, uint16_t /*crwTagId*/)

    {

        // do nothing

    } // CiffComponent::doRemove

    void CiffDirectory::doRemove(CrwDirs& crwDirs, uint16_t crwTagId)

    {

        const Components::iterator b = components_.begin();

        const Components::iterator e = components_.end();

        Components::iterator i;

        if (!crwDirs.empty()) {

            CrwSubDir csd = crwDirs.top();

            crwDirs.pop();

            // Find the directory

            for (i = b; i != e; ++i) {

                if ((*i)->tag() == csd.crwDir_) {

                    // Recursive call to next lower level directory

                    (*i)->remove(crwDirs, crwTagId);

                    if ((*i)->empty()) components_.erase(i);

                    break;

                }

            }

        }

        else {

            // Find the tag

            for (i = b; i != e; ++i) {

                if ((*i)->tagId() == crwTagId) {

                    // Remove the entry and abort the loop

                    delete *i;

                    components_.erase(i);

                    break;

                }

            }

        }

    } // CiffDirectory::doRemove

    bool CiffComponent::empty() const

    {

        return doEmpty();

    }

    bool CiffComponent::doEmpty() const

    {

        return size_ == 0;

    }

    bool CiffDirectory::doEmpty() const

    {

        return components_.empty();

    }

    void CrwMap::decode(const CiffComponent& ciffComponent,

                        Image&               image,

                        ByteOrder            byteOrder)

    {

        const CrwMapping* cmi = crwMapping(ciffComponent.dir(),

                                           ciffComponent.tagId());

        if (cmi && cmi->toExif_) {

            cmi->toExif_(ciffComponent, cmi, image, byteOrder);

        }

    } // CrwMap::decode

    const CrwMapping* CrwMap::crwMapping(uint16_t crwDir, uint16_t crwTagId)

    {

        for (int i = 0; crwMapping_[i].ifdId_ != ifdIdNotSet; ++i) {

            if (   crwMapping_[i].crwDir_ == crwDir

                && crwMapping_[i].crwTagId_ == crwTagId) {

                return &(crwMapping_[i]);

            }

        }

        return 0;

    } // CrwMap::crwMapping

    void CrwMap::decode0x0805(const CiffComponent& ciffComponent,

                              const CrwMapping*    /*pCrwMapping*/,

                                    Image&         image,

                                    ByteOrder      /*byteOrder*/)

    {

        std::string s(reinterpret_cast<const char*>(ciffComponent.pData()));

        image.setComment(s);

    } // CrwMap::decode0x0805

    void CrwMap::decode0x080a(const CiffComponent& ciffComponent,

                              const CrwMapping*    /*pCrwMapping*/,

                                    Image&         image,

                                    ByteOrder      byteOrder)

    {

        if (ciffComponent.typeId() != asciiString) return;

        // Make

        ExifKey key1("Exif.Image.Make");

        Value::AutoPtr value1 = Value::create(ciffComponent.typeId());

        uint32_t i = 0;

        for (;    i < ciffComponent.size()

               && ciffComponent.pData()[i] != '\0'; ++i) {

            // empty

        }

        value1->read(ciffComponent.pData(), ++i, byteOrder);

        image.exifData().add(key1, value1.get());

        // Model

        ExifKey key2("Exif.Image.Model");

        Value::AutoPtr value2 = Value::create(ciffComponent.typeId());

        uint32_t j = i;

        for (;    i < ciffComponent.size()

               && ciffComponent.pData()[i] != '\0'; ++i) {

            // empty

        }

        value2->read(ciffComponent.pData() + j, i - j + 1, byteOrder);

        image.exifData().add(key2, value2.get());

    } // CrwMap::decode0x080a

    void CrwMap::decodeArray(const CiffComponent& ciffComponent,

                             const CrwMapping*    pCrwMapping,

                                   Image&         image,

                                   ByteOrder      byteOrder)

    {

        if (ciffComponent.typeId() != unsignedShort) {

            return decodeBasic(ciffComponent, pCrwMapping, image, byteOrder);

        }

        long aperture = 0;

        long shutterSpeed = 0;

        IfdId ifdId = ifdIdNotSet;

        switch (pCrwMapping->tag_) {

        case 0x0001: ifdId = canonCsId; break;

        case 0x0004: ifdId = canonSiId; break;

        case 0x000f: ifdId = canonCfId; break;

        case 0x0012: ifdId = canonPiId; break;

        }

        assert(ifdId != ifdIdNotSet);

        std::string groupName(Internal::groupName(ifdId));

        uint16_t c = 1;

        while (uint32_t(c)*2 < ciffComponent.size()) {

            uint16_t n = 1;

            ExifKey key(c, groupName);

            UShortValue value;

            if (ifdId == canonCsId && c == 23 && ciffComponent.size() > 50) n = 3;

            value.read(ciffComponent.pData() + c*2, n*2, byteOrder);

            image.exifData().add(key, &value);

            if (ifdId == canonSiId && c == 21) aperture = value.toLong();

            if (ifdId == canonSiId && c == 22) shutterSpeed = value.toLong();