Exiv2
tiffvisitor_int.hpp
1 // ***************************************************************** -*- C++ -*-
2 /*
3  * Copyright (C) 2004-2021 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  */
20 #ifndef TIFFVISITOR_INT_HPP_
21 #define TIFFVISITOR_INT_HPP_
22 
23 // *****************************************************************************
24 // included header files
25 #include "exif.hpp"
26 #include "tifffwd_int.hpp"
27 #include "types.hpp"
28 
29 // + standard includes
30 #include <memory>
31 #include <iostream>
32 #include <iomanip>
33 #include <cassert>
34 #include <map>
35 #include <set>
36 #include <vector>
37 
38 // *****************************************************************************
39 // namespace extensions
40 namespace Exiv2 {
41 
42  class IptcData;
43  class XmpData;
44 
45  namespace Internal {
46 
47 // *****************************************************************************
48 // class definitions
49 
65  class TiffVisitor {
66  public:
68  enum GoEvent {
73  // Note: If you add more events here, adjust the events_ constant too!
74  };
75 
76  private:
77  static const int events_ = 2;
78  bool go_[events_];
79 
80  public:
82 
83  TiffVisitor();
86  virtual ~TiffVisitor();
88 
90 
91 
102  void setGo(GoEvent event, bool go);
104  virtual void visitEntry(TiffEntry* object) =0;
106  virtual void visitDataEntry(TiffDataEntry* object) =0;
108  virtual void visitImageEntry(TiffImageEntry* object) =0;
110  virtual void visitSizeEntry(TiffSizeEntry* object) =0;
112  virtual void visitDirectory(TiffDirectory* object) =0;
117  virtual void visitDirectoryNext(TiffDirectory* object);
122  virtual void visitDirectoryEnd(TiffDirectory* object);
124  virtual void visitSubIfd(TiffSubIfd* object) =0;
126  virtual void visitMnEntry(TiffMnEntry* object) =0;
128  virtual void visitIfdMakernote(TiffIfdMakernote* object) =0;
130  virtual void visitIfdMakernoteEnd(TiffIfdMakernote* object);
132  virtual void visitBinaryArray(TiffBinaryArray* object) =0;
137  virtual void visitBinaryArrayEnd(TiffBinaryArray* object);
139  virtual void visitBinaryElement(TiffBinaryElement* object) =0;
141 
143 
144  bool go(GoEvent event) const;
147 
148  }; // class TiffVisitor
149 
156  class TiffFinder : public TiffVisitor {
157  public:
159 
160  TiffFinder(uint16_t tag, IfdId group)
162  : tag_(tag), group_(group), tiffComponent_(0) {}
164  virtual ~TiffFinder();
166 
168 
169  virtual void visitEntry(TiffEntry* object);
172  virtual void visitDataEntry(TiffDataEntry* object);
174  virtual void visitImageEntry(TiffImageEntry* object);
176  virtual void visitSizeEntry(TiffSizeEntry* object);
178  virtual void visitDirectory(TiffDirectory* object);
180  virtual void visitSubIfd(TiffSubIfd* object);
182  virtual void visitMnEntry(TiffMnEntry* object);
184  virtual void visitIfdMakernote(TiffIfdMakernote* object);
186  virtual void visitBinaryArray(TiffBinaryArray* object);
188  virtual void visitBinaryElement(TiffBinaryElement* object);
189 
191  void findObject(TiffComponent* object);
193  void init(uint16_t tag, IfdId group);
195 
197 
198 
202  TiffComponent* result() const { return tiffComponent_; }
204 
205  private:
206  uint16_t tag_;
207  IfdId group_;
208  TiffComponent* tiffComponent_;
209  }; // class TiffFinder
210 
216  class TiffCopier : public TiffVisitor {
217  public:
219 
220 
228  TiffCopier( TiffComponent* pRoot,
229  uint32_t root,
230  const TiffHeaderBase* pHeader,
231  const PrimaryGroups* pPrimaryGroups);
233  virtual ~TiffCopier();
235 
237 
238  virtual void visitEntry(TiffEntry* object);
241  virtual void visitDataEntry(TiffDataEntry* object);
243  virtual void visitImageEntry(TiffImageEntry* object);
245  virtual void visitSizeEntry(TiffSizeEntry* object);
247  virtual void visitDirectory(TiffDirectory* object);
249  virtual void visitSubIfd(TiffSubIfd* object);
251  virtual void visitMnEntry(TiffMnEntry* object);
253  virtual void visitIfdMakernote(TiffIfdMakernote* object);
255  virtual void visitBinaryArray(TiffBinaryArray* object);
257  virtual void visitBinaryElement(TiffBinaryElement* object);
258 
260  void copyObject(TiffComponent* object);
262 
263  private:
264  TiffComponent* pRoot_;
265  uint32_t root_;
266  const TiffHeaderBase* pHeader_;
267  const PrimaryGroups* pPrimaryGroups_;
268  }; // class TiffCopier
269 
276  class TiffDecoder : public TiffVisitor {
277  public:
279 
280 
285  TiffDecoder(
286  ExifData& exifData,
287  IptcData& iptcData,
288  XmpData& xmpData,
289  TiffComponent* const pRoot,
290  FindDecoderFct findDecoderFct
291  );
293  virtual ~TiffDecoder();
295 
297 
298  virtual void visitEntry(TiffEntry* object);
301  virtual void visitDataEntry(TiffDataEntry* object);
303  virtual void visitImageEntry(TiffImageEntry* object);
305  virtual void visitSizeEntry(TiffSizeEntry* object);
307  virtual void visitDirectory(TiffDirectory* object);
309  virtual void visitSubIfd(TiffSubIfd* object);
311  virtual void visitMnEntry(TiffMnEntry* object);
313  virtual void visitIfdMakernote(TiffIfdMakernote* object);
315  virtual void visitBinaryArray(TiffBinaryArray* object);
317  virtual void visitBinaryElement(TiffBinaryElement* object);
318 
320  void decodeTiffEntry(const TiffEntryBase* object);
322  void decodeStdTiffEntry(const TiffEntryBase* object);
324  void decodeIptc(const TiffEntryBase* object);
326  void decodeXmp(const TiffEntryBase* object);
328  void decodeCanonAFInfo(const TiffEntryBase* object);
330 
331  private:
333 
334 
342  void getObjData(byte const*& pData,
343  long& size,
344  uint16_t tag,
345  IfdId group,
346  const TiffEntryBase* object);
348 
349  private:
350  // DATA
351  ExifData& exifData_;
352  IptcData& iptcData_;
353  XmpData& xmpData_;
354  TiffComponent* const pRoot_;
355  const FindDecoderFct findDecoderFct_;
356  std::string make_;
357  bool decodedIptc_;
358 
359  }; // class TiffDecoder
360 
376  class TiffEncoder : public TiffVisitor {
377  public:
379 
380 
385  TiffEncoder(
386  const ExifData& exifData,
387  const IptcData& iptcData,
388  const XmpData& xmpData,
389  TiffComponent* pRoot,
390  const bool isNewImage,
391  const PrimaryGroups* pPrimaryGroups,
392  const TiffHeaderBase* pHeader,
393  FindEncoderFct findEncoderFct
394  );
396  virtual ~TiffEncoder();
398 
400 
401  virtual void visitEntry(TiffEntry* object);
404  virtual void visitDataEntry(TiffDataEntry* object);
406  virtual void visitImageEntry(TiffImageEntry* object);
408  virtual void visitSizeEntry(TiffSizeEntry* object);
410  virtual void visitDirectory(TiffDirectory* object);
412  virtual void visitDirectoryNext(TiffDirectory* object);
414  virtual void visitSubIfd(TiffSubIfd* object);
416  virtual void visitMnEntry(TiffMnEntry* object);
418  virtual void visitIfdMakernote(TiffIfdMakernote* object);
420  virtual void visitIfdMakernoteEnd(TiffIfdMakernote* object);
422  virtual void visitBinaryArray(TiffBinaryArray* object);
424  virtual void visitBinaryArrayEnd(TiffBinaryArray* object);
426  virtual void visitBinaryElement(TiffBinaryElement* object);
427 
447  void encodeTiffComponent(
448  TiffEntryBase* object,
449  const Exifdatum* datum =0
450  );
451 
453  void encodeBinaryElement(TiffBinaryElement* object, const Exifdatum* datum);
455  void encodeBinaryArray(TiffBinaryArray* object, const Exifdatum* datum);
457  void encodeDataEntry(TiffDataEntry* object, const Exifdatum* datum);
459  void encodeTiffEntry(TiffEntry* object, const Exifdatum* datum);
461  void encodeImageEntry(TiffImageEntry* object, const Exifdatum* datum);
463  void encodeMnEntry(TiffMnEntry* object, const Exifdatum* datum);
465  void encodeSizeEntry(TiffSizeEntry* object, const Exifdatum* datum);
467  void encodeSubIfd(TiffSubIfd* object, const Exifdatum* datum);
468 
470  void encodeTiffEntryBase(TiffEntryBase* object, const Exifdatum* datum);
472  void encodeOffsetEntry(TiffEntryBase* object, const Exifdatum* datum);
473 
475  // Todo void encodeNikonSubIfd(TiffEntryBase* object, const Exifdatum* datum);
476 
478  void encodeIptc(TiffEntryBase* object, const Exifdatum* datum);
491  void add(
492  TiffComponent* pRootDir,
493  TiffComponent* pSourceDir,
494  uint32_t root
495  );
497  void setDirty(bool flag =true);
499 
501 
502 
506  ByteOrder byteOrder() const { return byteOrder_; }
511  bool dirty() const;
513  WriteMethod writeMethod() const { return writeMethod_; }
515 
516  private:
518 
519 
524  void encodeIptc();
529  void encodeXmp();
531 
533 
534 
539  uint32_t updateDirEntry(byte* buf,
540  ByteOrder byteOrder,
541  TiffComponent* pTiffComponent) const;
551  bool isImageTag(uint16_t tag, IfdId group) const;
553 
554  private:
555  // DATA
556  ExifData exifData_;
557  const IptcData& iptcData_;
558  const XmpData& xmpData_;
559  bool del_;
560  const TiffHeaderBase* pHeader_;
561  TiffComponent* pRoot_;
562  const bool isNewImage_;
563  const PrimaryGroups* pPrimaryGroups_;
564  TiffComponent* pSourceTree_;
565  ByteOrder byteOrder_;
566  ByteOrder origByteOrder_;
567  const FindEncoderFct findEncoderFct_;
568  std::string make_;
569  bool dirty_;
570  WriteMethod writeMethod_;
571 
572  }; // class TiffEncoder
573 
580  class TiffRwState {
581  public:
583 
584  TiffRwState(ByteOrder byteOrder,
586  uint32_t baseOffset)
587  : byteOrder_(byteOrder),
588  baseOffset_(baseOffset) {}
590 
592 
593 
597  ByteOrder byteOrder() const { return byteOrder_; }
609  uint32_t baseOffset() const { return baseOffset_; }
611 
612  private:
613  ByteOrder byteOrder_;
614  uint32_t baseOffset_;
615  }; // TiffRwState
616 
622  class TiffReader : public TiffVisitor {
623  public:
625 
626 
635  TiffReader(const byte* pData,
636  uint32_t size,
637  TiffComponent* pRoot,
638  TiffRwState state);
639 
641  virtual ~TiffReader();
643 
645 
646  virtual void visitEntry(TiffEntry* object);
649  virtual void visitDataEntry(TiffDataEntry* object);
651  virtual void visitImageEntry(TiffImageEntry* object);
653  virtual void visitSizeEntry(TiffSizeEntry* object);
655  virtual void visitDirectory(TiffDirectory* object);
657  virtual void visitSubIfd(TiffSubIfd* object);
659  virtual void visitMnEntry(TiffMnEntry* object);
661  virtual void visitIfdMakernote(TiffIfdMakernote* object);
663  virtual void visitIfdMakernoteEnd(TiffIfdMakernote* object);
665  virtual void visitBinaryArray(TiffBinaryArray* object);
667  virtual void visitBinaryElement(TiffBinaryElement* object);
668 
670  void readTiffEntry(TiffEntryBase* object);
672  void readDataEntryBase(TiffDataEntryBase* object);
679  void setMnState(const TiffRwState* state =0);
681  void setOrigState();
683  bool circularReference(const byte* start, IfdId group);
685  int nextIdx(IfdId group);
686 
696  void postProcess();
698 
700 
701  ByteOrder byteOrder() const;
704  uint32_t baseOffset() const;
706 
707  private:
708  typedef std::map<const byte*, IfdId> DirList;
709  typedef std::map<uint16_t, int> IdxSeq;
710  typedef std::vector<TiffComponent*> PostList;
711 
712  // DATA
713  const byte* pData_;
714  const uint32_t size_;
715  const byte* pLast_;
716  TiffComponent* const pRoot_;
717  TiffRwState* pState_;
718  TiffRwState origState_;
719  TiffRwState mnState_;
720  DirList dirList_;
721  IdxSeq idxSeq_;
722  PostList postList_;
723  bool postProc_;
724  }; // class TiffReader
725 
726 }} // namespace Internal, Exiv2
727 
728 #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:1071
TIFF composite visitor to read the TIFF structure from a block of memory and build the composite from...
Definition: tiffvisitor_int.hpp:622
A container for XMP data. This is a top-level class of the Exiv2 library.
Definition: xmp_exiv2.hpp:166
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:112
Composite to model an array of different tags. The tag types as well as other aspects of the array ar...
Definition: tiffcomposite_int.hpp:1354
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:102
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:92
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:276
Search the composite for a component with tag and group. Return a pointer to the component or 0...
Definition: tiffvisitor_int.hpp:156
This abstract base class provides the common functionality of an IFD directory entry and defines an e...
Definition: tiffcomposite_int.hpp:411
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:85
uint8_t byte
1 byte unsigned integer type.
Definition: types.hpp:94
Abstract base class defining the interface of an image header. Used internally by classes for TIFF-ba...
Definition: tiffimage_int.hpp:52
A TIFF IFD entry containing the size of a data area of a related TiffDataEntry. This component is use...
Definition: tiffcomposite_int.hpp:816
A container for IPTC data. This is a top-level class of the Exiv2 library.
Definition: iptc.hpp:170
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:650
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:105
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:982
virtual void visitDirectoryEnd(TiffDirectory *object)
Operation to perform for a TIFF directory, at the end of the processing.
Definition: tiffvisitor_int.cpp:108
Interface class for components of a TIFF directory hierarchy (Composite pattern). Both TIFF directori...
Definition: tiffcomposite_int.hpp:171
WriteMethod writeMethod() const
Return the write method used.
Definition: tiffvisitor_int.hpp:513
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:216
Abstract base class defining the interface for TIFF composite visitors (Visitor pattern) ...
Definition: tiffvisitor_int.hpp:65
uint32_t baseOffset() const
Return the base offset.
Definition: tiffvisitor_int.hpp:609
A standard TIFF IFD entry.
Definition: tiffcomposite_int.hpp:563
virtual void visitBinaryArrayEnd(TiffBinaryArray *object)
Operation to perform for a TIFF binary array, at the end of the processing.
Definition: tiffvisitor_int.cpp:116
virtual void visitSizeEntry(TiffSizeEntry *object)=0
Operation to perform for a TIFF size entry.
virtual ~TiffVisitor()
Virtual destructor.
Definition: tiffvisitor_int.cpp:88
Signal used by TiffReader to signal an unknown makernote.
Definition: tiffvisitor_int.hpp:72
TiffComponent * result() const
Return the search result. 0 if no TIFF component was found for the tag and group combination.
Definition: tiffvisitor_int.hpp:202
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:68
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:506
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:595
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:1147
A standard TIFF IFD entry consisting of a value which is an array of offsets to image data areas...
Definition: tiffcomposite_int.hpp:733
bool go(GoEvent event) const
Check if stop flag for event is clear, return true if it&#39;s clear.
Definition: tiffvisitor_int.cpp:98
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:858
TIFF composite visitor to encode metadata from an image to the TIFF tree. The metadata containers and...
Definition: tiffvisitor_int.hpp:376
Signal to control traversing of the composite tree.
Definition: tiffvisitor_int.hpp:70
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:1493
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:104
std::vector< IfdId > PrimaryGroups
Type for a list of primary image groups.
Definition: tifffwd_int.hpp:107
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:91
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:597
IfdId
Type to specify the IFD to which a metadata belongs.
Definition: tags_int.hpp:46
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:580
TiffVisitor()
Default constructor. Initialises all stop/go flags to true.
Definition: tiffvisitor_int.cpp:81