tiffimage_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 TIFFIMAGE_INT_HPP_
#define TIFFIMAGE_INT_HPP_
 
// *****************************************************************************
// included header files
#include "tifffwd_int.hpp"
#include "tiffcomposite_int.hpp"
#include "image.hpp"
#include "tags_int.hpp"
#include "types.hpp"
 
// + standard includes
#include <map>
#include <utility>
 
// *****************************************************************************
// namespace extensions
namespace Exiv2 {
    namespace Internal {
 
// *****************************************************************************
// class definitions
 
    class TiffHeaderBase {
    public:
 
 
        TiffHeaderBase(uint16_t  tag,
                       uint32_t  size,
                       ByteOrder byteOrder,
                       uint32_t  offset);
        virtual ~TiffHeaderBase() =0;
 
 
 
        virtual bool read(const byte* pData, uint32_t size);
        virtual void setByteOrder(ByteOrder byteOrder);
        virtual void setOffset(uint32_t offset);
 
 
 
        virtual DataBuf write() const;
        virtual void print(std::ostream& os, const std::string& prefix ="") const;
        virtual ByteOrder byteOrder() const;
        virtual uint32_t offset() const;
        virtual uint32_t size() const;
        virtual uint16_t tag() const;
        virtual bool isImageTag(      uint16_t       tag,
                                      IfdId          group,
                                const PrimaryGroups* pPrimaryGroups) const;
 
    private:
        // DATA
        const uint16_t tag_;       
        const uint32_t size_;      
        ByteOrder      byteOrder_; 
        uint32_t       offset_;    
 
    }; // class TiffHeaderBase
 
    bool isTiffImageTag(uint16_t tag, IfdId group);
 
    class TiffHeader : public TiffHeaderBase {
    public:
 
 
        TiffHeader(ByteOrder byteOrder    =littleEndian,
                   uint32_t  offset       =0x00000008,
                   bool      hasImageTags =true);
        ~TiffHeader();
 
 
        bool isImageTag(      uint16_t       tag,
                              IfdId          group,
                        const PrimaryGroups* pPrimaryGroups) const;
 
    private:
        // DATA
        bool           hasImageTags_;   
    }; // class TiffHeader
 
    struct TiffImgTagStruct {
        struct Key {
            Key(uint16_t t, IfdId g) : t_(t), g_(g) {}
            uint16_t t_;                    
            IfdId    g_;                    
        };
 
        bool operator==(const Key& key) const
        {
            return key.g_ == group_ && key.t_ == tag_;
        }
 
        // DATA
        uint16_t       tag_;            
        IfdId          group_;          
    }; // struct TiffImgTagStruct
 
    struct TiffGroupStruct {
        struct Key {
            Key(uint32_t e, IfdId g) : e_(e), g_(g) {}
            uint32_t e_;                    
            IfdId    g_;                    
        };
 
        bool operator==(const Key& key) const
        {
            return    key.g_ == group_
                   && (Tag::all == extendedTag_ || key.e_ == extendedTag_);
        }
        uint16_t tag() const { return static_cast<uint16_t>(extendedTag_ & 0xffff); }
 
        // DATA
        uint32_t       extendedTag_;    
        IfdId          group_;          
        NewTiffCompFct newTiffCompFct_; 
    };
 
    struct TiffTreeStruct {
        struct Key;
        bool operator==(const Key& key) const;
 
        // DATA
        uint32_t       root_;           
        IfdId          group_;          
        IfdId          parentGroup_;    
        uint32_t       parentExtTag_;   
    };
 
    struct TiffTreeStruct::Key {
        Key(uint32_t r, IfdId g) : r_(r), g_(g) {}
        uint32_t r_;                    
        IfdId    g_;                    
    };
 
    class TiffCreator {
    public:
        static std::auto_ptr<TiffComponent> create(uint32_t extendedTag,
                                                   IfdId    group);
        static void getPath(TiffPath& tiffPath,
                            uint32_t  extendedTag,
                            IfdId     group,
                            uint32_t  root);
 
    private:
        static const TiffTreeStruct  tiffTreeStruct_[];  //<! TIFF tree structure
        static const TiffGroupStruct tiffGroupStruct_[]; //<! TIFF group structure
 
    }; // class TiffCreator
 
    class TiffParserWorker {
    public:
        static ByteOrder decode(
                  ExifData&          exifData,
                  IptcData&          iptcData,
                  XmpData&           xmpData,
            const byte*              pData,
                  uint32_t           size,
                  uint32_t           root,
                  FindDecoderFct     findDecoderFct,
                  TiffHeaderBase*    pHeader =0
        );
        static WriteMethod encode(
                  BasicIo&           io,
            const byte*              pData,
                  uint32_t           size,
            const ExifData&          exifData,
            const IptcData&          iptcData,
            const XmpData&           xmpData,
                  uint32_t           root,
                  FindEncoderFct     findEncoderFct,
                  TiffHeaderBase*    pHeader,
                  OffsetWriter*      pOffsetWriter
        );
 
    private:
        static std::auto_ptr<TiffComponent> parse(
            const byte*              pData,
                  uint32_t           size,
                  uint32_t           root,
                  TiffHeaderBase*    pHeader
        );
        static void findPrimaryGroups(
            PrimaryGroups& primaryGroups,
            TiffComponent* pSourceDir
        );
 
    }; // class TiffParserWorker
 
    class TiffMapping {
    public:
        static DecoderFct findDecoder(const std::string& make,
                                            uint32_t     extendedTag,
                                            IfdId        group);
        static EncoderFct findEncoder(
            const std::string& make,
                  uint32_t     extendedTag,
                  IfdId        group
        );
 
    private:
        static const TiffMappingInfo tiffMappingInfo_[]; //<! TIFF mapping table
 
    }; // class TiffMapping
 
    class OffsetWriter {
    public:
        enum OffsetId {
            cr2RawIfdOffset  
        };
 
 
        void setOrigin(OffsetId id, uint32_t origin, ByteOrder byteOrder);
        void setTarget(OffsetId id, uint32_t target);
 
 
 
        void writeOffsets(BasicIo& io) const;
    private:
        struct OffsetData {
            OffsetData() : origin_(0), target_(0), byteOrder_(littleEndian) {}
            OffsetData(uint32_t origin, ByteOrder byteOrder) : origin_(origin), target_(0), byteOrder_(byteOrder) {}
            // DATA
            uint32_t origin_;     
            uint32_t target_;     
            ByteOrder byteOrder_; 
        };
        typedef std::map<OffsetId, OffsetData> OffsetList;
 
        // DATA
        OffsetList offsetList_; 
 
    }; // class OffsetWriter
 
    // Todo: Move this class to metadatum_int.hpp or tags_int.hpp
    class FindExifdatum {
    public:
        explicit FindExifdatum(Exiv2::Internal::IfdId ifdId) : ifdId_(ifdId) {}
        bool operator()(const Exiv2::Exifdatum& md) const { return ifdId_ == md.ifdId(); }
 
    private:
        Exiv2::Internal::IfdId ifdId_;
 
    }; // class FindExifdatum
 
}}                                      // namespace Internal, Exiv2
 
#endif                                  // #ifndef TIFFIMAGE_INT_HPP_