Exiv2
tiffvisitor_int.hpp
Go to the documentation of this file.
1 // ***************************************************************** -*- C++ -*-
2 /*
3  * Copyright (C) 2004-2018 Exiv2 authors
4  * This program is part of the Exiv2 distribution.
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, 5th Floor, Boston, MA 02110-1301 USA.
19  */
28 #ifndef TIFFVISITOR_INT_HPP_
29 #define TIFFVISITOR_INT_HPP_
30 
31 // *****************************************************************************
32 // included header files
33 #include "exif.hpp"
34 #include "tifffwd_int.hpp"
35 #include "types.hpp"
36 
37 // + standard includes
38 #include <memory>
39 #include <iostream>
40 #include <iomanip>
41 #include <cassert>
42 #include <map>
43 #include <set>
44 #include <vector>
45 
46 // *****************************************************************************
47 // namespace extensions
48 namespace Exiv2 {
49 
50  class IptcData;
51  class XmpData;
52 
53  namespace Internal {
54 
55 // *****************************************************************************
56 // class definitions
57 
73  class TiffVisitor {
74  public:
76  enum GoEvent {
81  // Note: If you add more events here, adjust the events_ constant too!
82  };
83 
84  private:
85  static const int events_ = 2;
86  bool go_[events_];
87 
88  public:
90 
91  TiffVisitor();
94  virtual ~TiffVisitor();
96 
98 
99 
110  void setGo(GoEvent event, bool go);
112  virtual void visitEntry(TiffEntry* object) =0;
114  virtual void visitDataEntry(TiffDataEntry* object) =0;
116  virtual void visitImageEntry(TiffImageEntry* object) =0;
118  virtual void visitSizeEntry(TiffSizeEntry* object) =0;
120  virtual void visitDirectory(TiffDirectory* object) =0;
125  virtual void visitDirectoryNext(TiffDirectory* object);
130  virtual void visitDirectoryEnd(TiffDirectory* object);
132  virtual void visitSubIfd(TiffSubIfd* object) =0;
134  virtual void visitMnEntry(TiffMnEntry* object) =0;
136  virtual void visitIfdMakernote(TiffIfdMakernote* object) =0;
138  virtual void visitIfdMakernoteEnd(TiffIfdMakernote* object);
140  virtual void visitBinaryArray(TiffBinaryArray* object) =0;
145  virtual void visitBinaryArrayEnd(TiffBinaryArray* object);
147  virtual void visitBinaryElement(TiffBinaryElement* object) =0;
149 
151 
152  bool go(GoEvent event) const;
155 
156  }; // class TiffVisitor
157 
164  class TiffFinder : public TiffVisitor {
165  public:
167 
168  TiffFinder(uint16_t tag, IfdId group)
170  : tag_(tag), group_(group), tiffComponent_(0) {}
172  virtual ~TiffFinder();
174 
176 
177  virtual void visitEntry(TiffEntry* object);
180  virtual void visitDataEntry(TiffDataEntry* object);
182  virtual void visitImageEntry(TiffImageEntry* object);
184  virtual void visitSizeEntry(TiffSizeEntry* object);
186  virtual void visitDirectory(TiffDirectory* object);
188  virtual void visitSubIfd(TiffSubIfd* object);
190  virtual void visitMnEntry(TiffMnEntry* object);
192  virtual void visitIfdMakernote(TiffIfdMakernote* object);
194  virtual void visitBinaryArray(TiffBinaryArray* object);
196  virtual void visitBinaryElement(TiffBinaryElement* object);
197 
199  void findObject(TiffComponent* object);
201  void init(uint16_t tag, IfdId group);
203 
205 
206 
210  TiffComponent* result() const { return tiffComponent_; }
212 
213  private:
214  uint16_t tag_;
215  IfdId group_;
216  TiffComponent* tiffComponent_;
217  }; // class TiffFinder
218 
224  class TiffCopier : public TiffVisitor {
225  public:
227 
228 
236  TiffCopier( TiffComponent* pRoot,
237  uint32_t root,
238  const TiffHeaderBase* pHeader,
239  const PrimaryGroups* pPrimaryGroups);
241  virtual ~TiffCopier();
243 
245 
246  virtual void visitEntry(TiffEntry* object);
249  virtual void visitDataEntry(TiffDataEntry* object);
251  virtual void visitImageEntry(TiffImageEntry* object);
253  virtual void visitSizeEntry(TiffSizeEntry* object);
255  virtual void visitDirectory(TiffDirectory* object);
257  virtual void visitSubIfd(TiffSubIfd* object);
259  virtual void visitMnEntry(TiffMnEntry* object);
261  virtual void visitIfdMakernote(TiffIfdMakernote* object);
263  virtual void visitBinaryArray(TiffBinaryArray* object);
265  virtual void visitBinaryElement(TiffBinaryElement* object);
266 
268  void copyObject(TiffComponent* object);
270 
271  private:
272  TiffComponent* pRoot_;
273  uint32_t root_;
274  const TiffHeaderBase* pHeader_;
275  const PrimaryGroups* pPrimaryGroups_;
276  }; // class TiffCopier
277 
284  class TiffDecoder : public TiffVisitor {
285  public:
287 
288 
293  TiffDecoder(
294  ExifData& exifData,
295  IptcData& iptcData,
296  XmpData& xmpData,
297  TiffComponent* const pRoot,
298  FindDecoderFct findDecoderFct
299  );
301  virtual ~TiffDecoder();
303 
305 
306  virtual void visitEntry(TiffEntry* object);
309  virtual void visitDataEntry(TiffDataEntry* object);
311  virtual void visitImageEntry(TiffImageEntry* object);
313  virtual void visitSizeEntry(TiffSizeEntry* object);
315  virtual void visitDirectory(TiffDirectory* object);
317  virtual void visitSubIfd(TiffSubIfd* object);
319  virtual void visitMnEntry(TiffMnEntry* object);
321  virtual void visitIfdMakernote(TiffIfdMakernote* object);
323  virtual void visitBinaryArray(TiffBinaryArray* object);
325  virtual void visitBinaryElement(TiffBinaryElement* object);
326 
328  void decodeTiffEntry(const TiffEntryBase* object);
330  void decodeStdTiffEntry(const TiffEntryBase* object);
332  void decodeIptc(const TiffEntryBase* object);
334  void decodeXmp(const TiffEntryBase* object);
336 
337  private:
339 
340 
348  void getObjData(byte const*& pData,
349  long& size,
350  uint16_t tag,
351  IfdId group,
352  const TiffEntryBase* object);
354 
355  private:
356  // DATA
357  ExifData& exifData_;
358  IptcData& iptcData_;
359  XmpData& xmpData_;
360  TiffComponent* const pRoot_;
361  const FindDecoderFct findDecoderFct_;
362  std::string make_;
363  bool decodedIptc_;
364 
365  }; // class TiffDecoder
366 
382  class TiffEncoder : public TiffVisitor {
383  public:
385 
386 
391  TiffEncoder(
392  const ExifData& exifData,
393  const IptcData& iptcData,
394  const XmpData& xmpData,
395  TiffComponent* pRoot,
396  const bool isNewImage,
397  const PrimaryGroups* pPrimaryGroups,
398  const TiffHeaderBase* pHeader,
399  FindEncoderFct findEncoderFct
400  );
402  virtual ~TiffEncoder();
404 
406 
407  virtual void visitEntry(TiffEntry* object);
410  virtual void visitDataEntry(TiffDataEntry* object);
412  virtual void visitImageEntry(TiffImageEntry* object);
414  virtual void visitSizeEntry(TiffSizeEntry* object);
416  virtual void visitDirectory(TiffDirectory* object);
418  virtual void visitDirectoryNext(TiffDirectory* object);
420  virtual void visitSubIfd(TiffSubIfd* object);
422  virtual void visitMnEntry(TiffMnEntry* object);
424  virtual void visitIfdMakernote(TiffIfdMakernote* object);
426  virtual void visitIfdMakernoteEnd(TiffIfdMakernote* object);
428  virtual void visitBinaryArray(TiffBinaryArray* object);
430  virtual void visitBinaryArrayEnd(TiffBinaryArray* object);
432  virtual void visitBinaryElement(TiffBinaryElement* object);
433 
453  void encodeTiffComponent(
454  TiffEntryBase* object,
455  const Exifdatum* datum =0
456  );
457 
459  void encodeBinaryElement(TiffBinaryElement* object, const Exifdatum* datum);
461  void encodeBinaryArray(TiffBinaryArray* object, const Exifdatum* datum);
463  void encodeDataEntry(TiffDataEntry* object, const Exifdatum* datum);
465  void encodeTiffEntry(TiffEntry* object, const Exifdatum* datum);
467  void encodeImageEntry(TiffImageEntry* object, const Exifdatum* datum);
469  void encodeMnEntry(TiffMnEntry* object, const Exifdatum* datum);
471  void encodeSizeEntry(TiffSizeEntry* object, const Exifdatum* datum);
473  void encodeSubIfd(TiffSubIfd* object, const Exifdatum* datum);
474 
476  void encodeTiffEntryBase(TiffEntryBase* object, const Exifdatum* datum);
478  void encodeOffsetEntry(TiffEntryBase* object, const Exifdatum* datum);
479 
481  // Todo void encodeNikonSubIfd(TiffEntryBase* object, const Exifdatum* datum);
482 
484  void encodeIptc(TiffEntryBase* object, const Exifdatum* datum);
497  void add(
498  TiffComponent* pRootDir,
499  TiffComponent* pSourceDir,
500  uint32_t root
501  );
503  void setDirty(bool flag =true);
505 
507 
508 
512  ByteOrder byteOrder() const { return byteOrder_; }
517  bool dirty() const;
519  WriteMethod writeMethod() const { return writeMethod_; }
521 
522  private:
524 
525 
530  void encodeIptc();
535  void encodeXmp();
537 
539 
540 
545  uint32_t updateDirEntry(byte* buf,
546  ByteOrder byteOrder,
547  TiffComponent* pTiffComponent) const;
557  bool isImageTag(uint16_t tag, IfdId group) const;
559 
560  private:
561  // DATA
562  ExifData exifData_;
563  const IptcData& iptcData_;
564  const XmpData& xmpData_;
565  bool del_;
566  const TiffHeaderBase* pHeader_;
567  TiffComponent* pRoot_;
568  const bool isNewImage_;
569  const PrimaryGroups* pPrimaryGroups_;
570  TiffComponent* pSourceTree_;
571  ByteOrder byteOrder_;
572  ByteOrder origByteOrder_;
573  const FindEncoderFct findEncoderFct_;
574  std::string make_;
575  bool dirty_;
576  WriteMethod writeMethod_;
577 
578  }; // class TiffEncoder
579 
586  class TiffRwState {
587  public:
589 
590  TiffRwState(ByteOrder byteOrder,
592  uint32_t baseOffset)
593  : byteOrder_(byteOrder),
594  baseOffset_(baseOffset) {}
596 
598 
599 
603  ByteOrder byteOrder() const { return byteOrder_; }
615  uint32_t baseOffset() const { return baseOffset_; }
617 
618  private:
619  ByteOrder byteOrder_;
620  uint32_t baseOffset_;
621  }; // TiffRwState
622 
628  class TiffReader : public TiffVisitor {
629  public:
631 
632 
641  TiffReader(const byte* pData,
642  uint32_t size,
643  TiffComponent* pRoot,
644  TiffRwState state);
645 
647  virtual ~TiffReader();
649 
651 
652  virtual void visitEntry(TiffEntry* object);
655  virtual void visitDataEntry(TiffDataEntry* object);
657  virtual void visitImageEntry(TiffImageEntry* object);
659  virtual void visitSizeEntry(TiffSizeEntry* object);
661  virtual void visitDirectory(TiffDirectory* object);
663  virtual void visitSubIfd(TiffSubIfd* object);
665  virtual void visitMnEntry(TiffMnEntry* object);
667  virtual void visitIfdMakernote(TiffIfdMakernote* object);
669  virtual void visitIfdMakernoteEnd(TiffIfdMakernote* object);
671  virtual void visitBinaryArray(TiffBinaryArray* object);
673  virtual void visitBinaryElement(TiffBinaryElement* object);
674 
676  void readTiffEntry(TiffEntryBase* object);
678  void readDataEntryBase(TiffDataEntryBase* object);
685  void setMnState(const TiffRwState* state =0);
687  void setOrigState();
689  bool circularReference(const byte* start, IfdId group);
691  int nextIdx(IfdId group);
692 
702  void postProcess();
704 
706 
707  ByteOrder byteOrder() const;
710  uint32_t baseOffset() const;
712 
713  private:
714  typedef std::map<const byte*, IfdId> DirList;
715  typedef std::map<uint16_t, int> IdxSeq;
716  typedef std::vector<TiffComponent*> PostList;
717 
718  // DATA
719  const byte* pData_;
720  const uint32_t size_;
721  const byte* pLast_;
722  TiffComponent* const pRoot_;
723  TiffRwState* pState_;
724  TiffRwState origState_;
725  TiffRwState mnState_;
726  DirList dirList_;
727  IdxSeq idxSeq_;
728  PostList postList_;
729  bool postProc_;
730  }; // class TiffReader
731 
732 }} // namespace Internal, Exiv2
733 
734 #endif // #ifndef TIFFVISITOR_INT_HPP_
This class is the basis for Makernote support in TIFF. It contains a pointer to a concrete Makernote...
Definition: tiffcomposite_int.hpp:1073
TIFF composite visitor to read the TIFF structure from a block of memory and build the composite from...
Definition: tiffvisitor_int.hpp:628
A container for XMP data. This is a top-level class of the Exiv2 library.
Definition: xmp_exiv2.hpp:173
A container for Exif data. This is a top-level class of the Exiv2 library. The container holds Exifda...
Definition: exif.hpp:434
virtual void visitIfdMakernoteEnd(TiffIfdMakernote *object)
Operation to perform after processing an IFD makernote.
Definition: tiffvisitor_int.cpp:115
Internal TIFF parser related typedefs and forward definitions.
Composite to model an array of different tags. The tag types as well as other aspects of the array ar...
Definition: tiffcomposite_int.hpp:1356
virtual void visitSubIfd(TiffSubIfd *object)=0
Operation to perform for a TIFF sub-IFD.
ByteOrder
Type to express the byte order (little or big endian)
Definition: types.hpp:113
virtual void visitImageEntry(TiffImageEntry *object)=0
Operation to perform for a TIFF image entry.
void setGo(GoEvent event, bool go)
Set the stop/go flag: true for go, false for stop.
Definition: tiffvisitor_int.cpp:95
TIFF composite visitor to decode metadata from the TIFF tree and add it to an Image, which is supplied in the constructor (Visitor pattern). Used by TiffParser to decode the metadata from a TIFF composite.
Definition: tiffvisitor_int.hpp:284
Search the composite for a component with tag and group. Return a pointer to the component or 0...
Definition: tiffvisitor_int.hpp:164
This abstract base class provides the common functionality of an IFD directory entry and defines an e...
Definition: tiffcomposite_int.hpp:414
DecoderFct(* FindDecoderFct)(const std::string &make, uint32_t extendedTag, IfdId group)
Type for a function pointer for a function to decode a TIFF component.
Definition: tifffwd_int.hpp:92
uint8_t byte
1 byte unsigned integer type.
Definition: types.hpp:105
Abstract base class defining the interface of an image header. Used internally by classes for TIFF-ba...
Definition: tiffimage_int.hpp:59
A TIFF IFD entry containing the size of a data area of a related TiffDataEntry. This component is use...
Definition: tiffcomposite_int.hpp:819
Type definitions for Exiv2 and related functionality.
A container for IPTC data. This is a top-level class of the Exiv2 library.
Definition: iptc.hpp:173
A standard TIFF IFD entry consisting of a value which is an offset to a data area and the data area...
Definition: tiffcomposite_int.hpp:653
virtual void visitMnEntry(TiffMnEntry *object)=0
Operation to perform for the makernote component.
WriteMethod
Type to indicate write method used by TIFF parsers.
Definition: types.hpp:116
This class models a TIFF sub-directory (sub-IFD). A sub-IFD is an entry with one or more values that ...
Definition: tiffcomposite_int.hpp:984
virtual void visitDirectoryEnd(TiffDirectory *object)
Operation to perform for a TIFF directory, at the end of the processing.
Definition: tiffvisitor_int.cpp:111
Interface class for components of a TIFF directory hierarchy (Composite pattern). Both TIFF directori...
Definition: tiffcomposite_int.hpp:174
WriteMethod writeMethod() const
Return the write method used.
Definition: tiffvisitor_int.hpp:519
virtual void visitDataEntry(TiffDataEntry *object)=0
Operation to perform for a TIFF data entry.
Copy all image tags from the source tree (the tree that is traversed) to a target tree...
Definition: tiffvisitor_int.hpp:224
Abstract base class defining the interface for TIFF composite visitors (Visitor pattern) ...
Definition: tiffvisitor_int.hpp:73
uint32_t baseOffset() const
Return the base offset.
Definition: tiffvisitor_int.hpp:615
A standard TIFF IFD entry.
Definition: tiffcomposite_int.hpp:566
virtual void visitBinaryArrayEnd(TiffBinaryArray *object)
Operation to perform for a TIFF binary array, at the end of the processing.
Definition: tiffvisitor_int.cpp:119
virtual void visitSizeEntry(TiffSizeEntry *object)=0
Operation to perform for a TIFF size entry.
virtual ~TiffVisitor()
Virtual destructor.
Definition: tiffvisitor_int.cpp:91
Signal used by TiffReader to signal an unknown makernote.
Definition: tiffvisitor_int.hpp:80
TiffComponent * result() const
Return the search result. 0 if no TIFF component was found for the tag and group combination.
Definition: tiffvisitor_int.hpp:210
virtual void visitBinaryArray(TiffBinaryArray *object)=0
Operation to perform for a binary array.
GoEvent
Events for the stop/go flag. See setGo().
Definition: tiffvisitor_int.hpp:76
ByteOrder byteOrder() const
Return the applicable byte order. May be different for the Makernote and the rest of the TIFF entries...
Definition: tiffvisitor_int.hpp:512
Interface for a standard TIFF IFD entry consisting of a value which is a set of offsets to a data are...
Definition: tiffcomposite_int.hpp:598
IPTC string type.
Definition: types.hpp:147
virtual void visitDirectory(TiffDirectory *object)=0
Operation to perform for a TIFF directory.
Tiff IFD Makernote. This is a concrete class suitable for all IFD makernotes.
Definition: tiffcomposite_int.hpp:1149
A standard TIFF IFD entry consisting of a value which is an array of offsets to image data areas...
Definition: tiffcomposite_int.hpp:736
bool go(GoEvent event) const
Check if stop flag for event is clear, return true if it&#39;s clear.
Definition: tiffvisitor_int.cpp:101
Provides classes and functions to encode and decode Exif and Iptc data. The libexiv2 API consists of ...
Definition: asfvideo.hpp:36
virtual void visitBinaryElement(TiffBinaryElement *object)=0
Operation to perform for an element of a binary array.
This class models a TIFF directory (Ifd). It is a composite component of the TIFF tree...
Definition: tiffcomposite_int.hpp:861
const uint32_t root
Special tag: root IFD.
Definition: tiffcomposite_int.hpp:80
TIFF composite visitor to encode metadata from an image to the TIFF tree. The metadata containers and...
Definition: tiffvisitor_int.hpp:382
Signal to control traversing of the composite tree.
Definition: tiffvisitor_int.hpp:78
An Exif metadatum, consisting of an ExifKey and a Value and methods to manipulate these...
Definition: exif.hpp:59
Element of a TiffBinaryArray.
Definition: tiffcomposite_int.hpp:1495
virtual void visitDirectoryNext(TiffDirectory *object)
Operation to perform for a TIFF directory, after all components and before the next entry is processe...
Definition: tiffvisitor_int.cpp:107
std::vector< IfdId > PrimaryGroups
Type for a list of primary image groups.
Definition: tifffwd_int.hpp:114
Encoding and decoding of Exif data.
EncoderFct(* FindEncoderFct)(const std::string &make, uint32_t extendedTag, IfdId group)
Type for a function pointer for a function to encode a TIFF component.
Definition: tifffwd_int.hpp:98
ByteOrder byteOrder() const
Return the applicable byte order. May be different for the Makernote and the rest of the TIFF entries...
Definition: tiffvisitor_int.hpp:603
IfdId
Type to specify the IFD to which a metadata belongs.
Definition: tags_int.hpp:54
virtual void visitIfdMakernote(TiffIfdMakernote *object)=0
Operation to perform for an IFD makernote.
virtual void visitEntry(TiffEntry *object)=0
Operation to perform for a TIFF entry.
Simple state class containing relevant state information for the TIFF reader. This is in a separate c...
Definition: tiffvisitor_int.hpp:586
TiffVisitor()
Default constructor. Initialises all stop/go flags to true.
Definition: tiffvisitor_int.cpp:84