Exiv2
types.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 TYPES_HPP_
21 #define TYPES_HPP_
22 
23 #include "exiv2lib_export.h"
24 
25 // included header files
26 #include "config.h"
27 #include "slice.hpp"
28 
29 // + standard includes
30 #include <string>
31 #include <vector>
32 #include <limits>
33 #include <algorithm>
34 #include <sstream>
35 
36 #ifdef _MSC_VER
37 // Visual Studio 2010 and later has stdint.h
38 # if _MSC_VER >= _MSC_VER_2010
39 # include <stdint.h>
40 # else
41 // Earlier compilers have MS C99 equivalents such as __int8
42  typedef unsigned __int8 uint8_t;
43  typedef unsigned __int16 uint16_t;
44  typedef unsigned __int32 uint32_t;
45  typedef unsigned __int64 uint64_t;
46  typedef __int8 int8_t;
47  typedef __int16 int16_t;
48  typedef __int32 int32_t;
49  typedef __int64 int64_t;
50 # endif
51 #else
52  # include <stdint.h>
53 #endif
54 
55 
56 // MSVC macro to convert a string to a wide string
57 #ifdef EXV_UNICODE_PATH
58 # define EXV_WIDEN(t) L ## t
59 #endif
60 
66 #define EXV_CALL_MEMBER_FN(object,ptrToMember) ((object).*(ptrToMember))
67 
68 // Simple min and max macros
70 #define EXV_MIN(a,b) ((a) < (b) ? (a) : (b))
72 #define EXV_MAX(a,b) ((a) > (b) ? (a) : (b))
73 
74 #if defined(__GNUC__) && (__GNUC__ >= 4) || defined(__clang__)
75 #define EXV_WARN_UNUSED_RESULT __attribute__ ((warn_unused_result))
76 #elif defined(_MSC_VER) && (_MSC_VER >= 1700)
77 #define EXV_WARN_UNUSED_RESULT _Check_return_
78 #else
79 #define EXV_WARN_UNUSED_RESULT
80 #endif
81 
82 // *****************************************************************************
83 // forward declarations
84 struct tm;
85 
86 // *****************************************************************************
87 // namespace extensions
88 namespace Exiv2 {
89 
90 // *****************************************************************************
91 // type definitions
92 
94  typedef uint8_t byte;
95 
97  typedef std::pair<uint32_t, uint32_t> URational;
99  typedef std::pair<int32_t, int32_t> Rational;
100 
102  enum ByteOrder { invalidByteOrder, littleEndian, bigEndian };
103 
105  enum WriteMethod { wmIntrusive, wmNonIntrusive };
106 
108  enum MetadataId { mdNone=0, mdExif=1, mdIptc=2, mdComment=4, mdXmp=8, mdIccProfile=16 };
109 
111  enum AccessMode { amNone=0, amRead=1, amWrite=2, amReadWrite=3 };
112 
119  enum TypeId {
126  undefined = 7,
130  tiffFloat =11,
132  tiffIfd =13,
135  tiffIfd8 =18,
136  string =0x10000,
137  date =0x10001,
138  time =0x10002,
139  comment =0x10003,
140  directory =0x10004,
141  xmpText =0x10005,
142  xmpAlt =0x10006,
143  xmpBag =0x10007,
144  xmpSeq =0x10008,
145  langAlt =0x10009,
146  invalidTypeId =0x1fffe,
147  lastTypeId =0x1ffff
148  };
149 
151  typedef std::vector<byte> Blob;
152 
153 // *****************************************************************************
154 // class definitions
155 
157  class EXIV2API TypeInfo {
159  TypeInfo();
161  TypeInfo(const TypeInfo& rhs);
163  TypeInfo& operator=(const TypeInfo& rhs);
164 
165  public:
167  static const char* typeName(TypeId typeId);
169  static TypeId typeId(const std::string& typeName);
171  static long typeSize(TypeId typeId);
172 
173  };
174 
180  struct EXIV2API DataBufRef {
182  explicit DataBufRef(std::pair<byte*, long> rhs) : p(rhs) {}
184  std::pair<byte*, long> p;
185  };
186 
193  class EXIV2API DataBuf {
194  public:
196 
197  DataBuf();
200  explicit DataBuf(long size);
202  DataBuf(const byte* pData, long size);
208  DataBuf(DataBuf& rhs);
210  ~DataBuf();
212 
214 
215 
220  DataBuf& operator=(DataBuf& rhs);
226  void alloc(long size);
232  EXV_WARN_UNUSED_RESULT std::pair<byte*, long> release();
233 
237  void free();
238 
240  void reset(std::pair<byte*, long> =std::make_pair((byte*)(0),long(0)));
242 
251  DataBuf(const DataBufRef& rhs);
252  DataBuf& operator=(DataBufRef rhs);
253  operator DataBufRef();
255 
256  // DATA
258  byte* pData_;
260  long size_;
261  }; // class DataBuf
262 
274  EXIV2API Slice<byte*> makeSlice(DataBuf& buf, size_t begin, size_t end);
275 
277  EXIV2API Slice<const byte*> makeSlice(const DataBuf& buf, size_t begin, size_t end);
278 
279 // *****************************************************************************
280 // free functions
281 
283  EXIV2API uint16_t getUShort(const byte* buf, ByteOrder byteOrder);
285  template <typename T>
286  uint16_t getUShort(const Slice<T>& buf, ByteOrder byteOrder)
287  {
288  if (byteOrder == littleEndian) {
289  return static_cast<byte>(buf.at(1)) << 8 | static_cast<byte>(buf.at(0));
290  } else {
291  return static_cast<byte>(buf.at(0)) << 8 | static_cast<byte>(buf.at(1));
292  }
293  }
294 
296  EXIV2API uint32_t getULong(const byte* buf, ByteOrder byteOrder);
298  EXIV2API uint64_t getULongLong(const byte* buf, ByteOrder byteOrder);
300  EXIV2API URational getURational(const byte* buf, ByteOrder byteOrder);
302  EXIV2API int16_t getShort(const byte* buf, ByteOrder byteOrder);
304  EXIV2API int32_t getLong(const byte* buf, ByteOrder byteOrder);
306  EXIV2API Rational getRational(const byte* buf, ByteOrder byteOrder);
308  EXIV2API float getFloat(const byte* buf, ByteOrder byteOrder);
310  EXIV2API double getDouble(const byte* buf, ByteOrder byteOrder);
311 
313  EXIV2API std::ostream& operator<<(std::ostream& os, const Rational& r);
315  EXIV2API std::istream& operator>>(std::istream& is, Rational& r);
317  EXIV2API std::ostream& operator<<(std::ostream& os, const URational& r);
319  EXIV2API std::istream& operator>>(std::istream& is, URational& r);
320 
325  EXIV2API long us2Data(byte* buf, uint16_t s, ByteOrder byteOrder);
330  EXIV2API long ul2Data(byte* buf, uint32_t l, ByteOrder byteOrder);
335  EXIV2API long ur2Data(byte* buf, URational l, ByteOrder byteOrder);
340  EXIV2API long s2Data(byte* buf, int16_t s, ByteOrder byteOrder);
345  EXIV2API long l2Data(byte* buf, int32_t l, ByteOrder byteOrder);
350  EXIV2API long r2Data(byte* buf, Rational l, ByteOrder byteOrder);
355  EXIV2API long f2Data(byte* buf, float f, ByteOrder byteOrder);
360  EXIV2API long d2Data(byte* buf, double d, ByteOrder byteOrder);
361 
367  EXIV2API void hexdump(std::ostream& os, const byte* buf, long len, long offset =0);
368 
374  EXIV2API bool isHex(const std::string& str,
375  size_t size =0,
376  const std::string& prefix ="");
377 
383  EXIV2API int exifTime(const char* buf, struct tm* tm);
384 
389  EXIV2API const char* exvGettext(const char* str);
390 
391 #ifdef EXV_UNICODE_PATH
393  EXIV2API std::wstring s2ws(const std::string& s);
395  EXIV2API std::string ws2s(const std::wstring& s);
396 #endif
409  EXIV2API long parseLong(const std::string& s, bool& ok);
410 
423  EXIV2API float parseFloat(const std::string& s, bool& ok);
424 
439  EXIV2API Rational parseRational(const std::string& s, bool& ok);
440 
447  EXIV2API Rational floatToRationalCast(float f);
448 
449 // *****************************************************************************
450 // template and inline definitions
451 
496  template<typename T, typename K, int N>
497  const T* find(T (&src)[N], const K& key)
498  {
499  const T* rc = std::find(src, src + N, key);
500  return rc == src + N ? 0 : rc;
501  }
502 
504  template <typename T, int N> char (&sizer(T (&)[N]))[N];
506 #define EXV_COUNTOF(a) (sizeof(Exiv2::sizer(a)))
507 
509  template<typename T>
510  std::string toString(const T& arg)
511  {
512  std::ostringstream os;
513  os << arg;
514  return os.str();
515  }
516 
528  template<typename T>
529  T stringTo(const std::string& s, bool& ok)
530  {
531  std::istringstream is(s);
532  T tmp = T();
533  ok = (is >> tmp) ? true : false;
534  std::string rest;
535  is >> std::skipws >> rest;
536  if (!rest.empty()) ok = false;
537  return tmp;
538  }
539 
547  template<>
548  bool stringTo<bool>(const std::string& s, bool& ok);
549 
558  template <typename IntType>
559  IntType gcd(IntType n, IntType m)
560  {
561  // Avoid repeated construction
562  IntType zero(0);
563 
564  // This is abs() - given the existence of broken compilers with Koenig
565  // lookup issues and other problems, I code this explicitly. (Remember,
566  // IntType may be a user-defined type).
567 #ifdef _MSC_VER
568 #pragma warning( disable : 4146 )
569 #undef max
570 #undef min
571 #endif
572  if (n < zero) {
573  if (n == std::numeric_limits<IntType>::min()) {
574  n = std::numeric_limits<IntType>::max();
575  } else {
576  n = -n;
577  }
578  }
579  if (m < zero)
580  m = -m;
581 #ifdef _MSC_VER
582 #pragma warning( default : 4146 )
583 #endif
584 
585  // As n and m are now positive, we can be sure that %= returns a
586  // positive value (the standard guarantees this for built-in types,
587  // and we require it of user-defined types).
588  for(;;) {
589  if(m == zero)
590  return n;
591  n %= m;
592  if(n == zero)
593  return m;
594  m %= n;
595  }
596  }
597 
598 } // namespace Exiv2
599 
600 #endif // #ifndef TYPES_HPP_
Utility class containing a character array. All it does is to take care of memory allocation and dele...
Definition: types.hpp:193
long size_
The current size of the buffer.
Definition: types.hpp:260
byte * pData_
Pointer to the buffer, 0 if none has been allocated.
Definition: types.hpp:258
Type information lookup functions. Implemented as a static class.
Definition: types.hpp:157
Provides classes and functions to encode and decode Exif and Iptc data. The libexiv2 API consists of ...
Definition: asfvideo.hpp:36
EXIV2API std::ostream & operator<<(std::ostream &os, const DataSet &dataSet)
Output operator for dataSet.
Definition: datasets.cpp:709
EXIV2API double getDouble(const byte *buf, ByteOrder byteOrder)
Read an 8 byte double precision floating point value (IEEE 754 binary64) from the data buffer.
Definition: types.cpp:356
EXIV2API void hexdump(std::ostream &os, const byte *buf, long len, long offset=0)
Print len bytes from buf in hex and ASCII format to the given stream, prefixed with the position in t...
Definition: types.cpp:513
EXIV2API long f2Data(byte *buf, float f, ByteOrder byteOrder)
Convert a single precision floating point (IEEE 754 binary32) float to data, write the data to the bu...
Definition: types.cpp:464
EXIV2API long d2Data(byte *buf, double d, ByteOrder byteOrder)
Convert a double precision floating point (IEEE 754 binary64) double to data, write the data to the b...
Definition: types.cpp:478
uint8_t byte
1 byte unsigned integer type.
Definition: types.hpp:94
EXIV2API long parseLong(const std::string &s, bool &ok)
Return a long set to the value represented by s.
Definition: types.cpp:626
EXIV2API float getFloat(const byte *buf, ByteOrder byteOrder)
Read a 4 byte single precision floating point value (IEEE 754 binary32) from the data buffer.
Definition: types.cpp:342
EXIV2API float parseFloat(const std::string &s, bool &ok)
Return a float set to the value represented by s.
Definition: types.cpp:650
EXIV2API bool isHex(const std::string &str, size_t size=0, const std::string &prefix="")
Return true if str is a hex number starting with prefix followed by size hex digits,...
Definition: types.cpp:538
EXIV2API Rational floatToRationalCast(float f)
Very simple conversion of a float to a Rational.
Definition: types.cpp:689
EXIV2API long l2Data(byte *buf, int32_t l, ByteOrder byteOrder)
Convert a signed long to data, write the data to the buffer, return number of bytes written.
Definition: types.cpp:440
IntType gcd(IntType n, IntType m)
Return the greatest common denominator of n and m. (Implementation from Boost rational....
Definition: types.hpp:559
EXIV2API const char * exvGettext(const char *str)
Translate a string using the gettext framework. This wrapper hides all the implementation details fro...
Definition: types.cpp:571
EXIV2API int16_t getShort(const byte *buf, ByteOrder byteOrder)
Read a 2 byte signed short value from the data buffer.
Definition: types.cpp:313
EXIV2API uint32_t getULong(const byte *buf, ByteOrder byteOrder)
Read a 4 byte unsigned long value from the data buffer.
Definition: types.cpp:278
EXIV2API long ul2Data(byte *buf, uint32_t l, ByteOrder byteOrder)
Convert an unsigned long to data, write the data to the buffer, return number of bytes written.
Definition: types.cpp:403
TypeId
Exiv2 value type identifiers.
Definition: types.hpp:119
@ unsignedShort
Exif SHORT type, 16-bit (2-byte) unsigned integer.
Definition: types.hpp:122
@ date
IPTC date type.
Definition: types.hpp:137
@ signedRational
Exif SRATIONAL type, two SLONGs: numerator and denumerator of a fraction.
Definition: types.hpp:129
@ tiffIfd8
TIFF IFD type, 64-bit (8-byte) unsigned integer.
Definition: types.hpp:135
@ lastTypeId
Last type id.
Definition: types.hpp:147
@ unsignedLongLong
Exif LONG LONG type, 64-bit (8-byte) unsigned integer.
Definition: types.hpp:133
@ unsignedLong
Exif LONG type, 32-bit (4-byte) unsigned integer.
Definition: types.hpp:123
@ signedShort
Exif SSHORT type, a 16-bit (2-byte) signed (twos-complement) integer.
Definition: types.hpp:127
@ signedLongLong
Exif LONG LONG type, 64-bit (8-byte) signed integer.
Definition: types.hpp:134
@ signedLong
Exif SLONG type, a 32-bit (4-byte) signed (twos-complement) integer.
Definition: types.hpp:128
@ langAlt
XMP language alternative type.
Definition: types.hpp:145
@ xmpAlt
XMP alternative type.
Definition: types.hpp:142
@ unsignedByte
Exif BYTE type, 8-bit unsigned integer.
Definition: types.hpp:120
@ signedByte
Exif SBYTE type, an 8-bit signed (twos-complement) integer.
Definition: types.hpp:125
@ asciiString
Exif ASCII type, 8-bit byte.
Definition: types.hpp:121
@ xmpText
XMP text type.
Definition: types.hpp:141
@ time
IPTC time type.
Definition: types.hpp:138
@ xmpSeq
XMP sequence type.
Definition: types.hpp:144
@ comment
Exiv2 type for the Exif user comment.
Definition: types.hpp:139
@ tiffDouble
TIFF DOUBLE type, double precision (8-byte) IEEE format.
Definition: types.hpp:131
@ undefined
Exif UNDEFINED type, an 8-bit byte that may contain anything.
Definition: types.hpp:126
@ xmpBag
XMP bag type.
Definition: types.hpp:143
@ tiffFloat
TIFF FLOAT type, single precision (4-byte) IEEE format.
Definition: types.hpp:130
@ unsignedRational
Exif RATIONAL type, two LONGs: numerator and denumerator of a fraction.
Definition: types.hpp:124
@ tiffIfd
TIFF IFD type, 32-bit (4-byte) unsigned integer.
Definition: types.hpp:132
@ invalidTypeId
Invalid type id.
Definition: types.hpp:146
@ directory
Exiv2 type for a CIFF directory.
Definition: types.hpp:140
bool stringTo< bool >(const std::string &s, bool &ok)
Specialization of stringTo(const std::string& s, bool& ok) for bool.
Definition: types.cpp:607
EXIV2API uint16_t getUShort(const byte *buf, ByteOrder byteOrder)
Read a 2 byte unsigned short value from the data buffer.
Definition: types.cpp:273
EXIV2API Rational parseRational(const std::string &s, bool &ok)
Return a Rational set to the value represented by s.
Definition: types.cpp:671
std::vector< byte > Blob
Container for binary data.
Definition: types.hpp:151
char(& sizer(T(&)[N]))[N]
Template used in the COUNTOF macro to determine the size of an array.
Slice< T > makeSlice(T &cont, size_t begin, size_t end)
Return a new slice with the given bounds.
Definition: slice.hpp:665
ByteOrder
Type to express the byte order (little or big endian)
Definition: types.hpp:102
T stringTo(const std::string &s, bool &ok)
Utility function to convert a string to a value of type T.
Definition: types.hpp:529
std::pair< int32_t, int32_t > Rational
8 byte signed rational type.
Definition: types.hpp:99
EXIV2API uint64_t getULongLong(const byte *buf, ByteOrder byteOrder)
Read a 8 byte unsigned long value from the data buffer.
Definition: types.cpp:290
WriteMethod
Type to indicate write method used by TIFF parsers.
Definition: types.hpp:105
EXIV2API Rational getRational(const byte *buf, ByteOrder byteOrder)
Read an 8 byte signed rational value from the data buffer.
Definition: types.cpp:335
EXIV2API long r2Data(byte *buf, Rational l, ByteOrder byteOrder)
Convert a signed rational to data, write the data to the buffer, return number of bytes written.
Definition: types.cpp:457
MetadataId
An identifier for each type of metadata.
Definition: types.hpp:108
EXIV2API long ur2Data(byte *buf, URational l, ByteOrder byteOrder)
Convert an unsigned rational to data, write the data to the buffer, return number of bytes written.
Definition: types.cpp:420
EXIV2API std::istream & operator>>(std::istream &is, Rational &r)
Input operator for our fake rational.
Definition: types.cpp:223
EXIV2API int32_t getLong(const byte *buf, ByteOrder byteOrder)
Read a 4 byte signed long value from the data buffer.
Definition: types.cpp:323
EXIV2API long s2Data(byte *buf, int16_t s, ByteOrder byteOrder)
Convert a signed short to data, write the data to the buffer, return number of bytes written.
Definition: types.cpp:427
const T * find(T(&src)[N], const K &key)
Find an element that matches key in the array src.
Definition: types.hpp:497
std::string toString(const T &arg)
Utility function to convert the argument of any type to a string.
Definition: types.hpp:510
std::pair< uint32_t, uint32_t > URational
8 byte unsigned rational type.
Definition: types.hpp:97
EXIV2API URational getURational(const byte *buf, ByteOrder byteOrder)
Read an 8 byte unsigned rational value from the data buffer.
Definition: types.cpp:306
AccessMode
An identifier for each mode of metadata support.
Definition: types.hpp:111
EXIV2API int exifTime(const char *buf, struct tm *tm)
Converts a string in the form "%Y:%m:%d %H:%M:%S", e.g., "2007:05:24 12:31:55" to broken down time fo...
Definition: types.cpp:551
EXIV2API long us2Data(byte *buf, uint16_t s, ByteOrder byteOrder)
Convert an unsigned short to data, write the data to the buffer, return number of bytes written.
Definition: types.cpp:390
Auxiliary type to enable copies and assignments, similar to std::auto_ptr_ref. See http://www....
Definition: types.hpp:180
DataBufRef(std::pair< byte *, long > rhs)
Constructor.
Definition: types.hpp:182
std::pair< byte *, long > p
Pointer to a byte array and its size.
Definition: types.hpp:184
value_type & at(size_t index)
Definition: slice.hpp:261
Slice (= view) for STL containers.
Definition: slice.hpp:522