Update exif.cpp from upstream

Signed-off-by: Robert C. Helling <helling@atdotde.de>

3 files changed, 958 insertions, 631 deletions

diff --git a/core/exif.cpp b/core/exif.cpp
index 0b1cda2bc..b2423ba20 100644
--- a/core/exif.cpp
+++ b/core/exif.cpp
@@ -1,9 +1,8 @@
-#include <stdio.h>
 /**************************************************************************
   exif.cpp  -- A simple ISO C++ library to parse basic EXIF
-	       information from a JPEG file.
+               information from a JPEG file.
 
-  Copyright (c) 2010-2013 Mayank Lahiri
+  Copyright (c) 2010-2015 Mayank Lahiri
   mlahiri@gmail.com
   All rights reserved (BSD License).
 
@@ -18,182 +17,455 @@
      this list of conditions and the following disclaimer in the documentation
      and/or other materials provided with the distribution.
 
-     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY EXPRESS
-     OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-     OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
-     NO EVENT SHALL THE FREEBSD PROJECT OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
-     INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-     BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-     DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
-     OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-     NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
-     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY EXPRESS
+  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
+  NO EVENT SHALL THE FREEBSD PROJECT OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+  OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
+#include "exif.h"
+
 #include <algorithm>
+#include <cstdint>
+#include <stdio.h>
+#include <vector>
 #include "dive.h"
-#include "exif.h"
 
 using std::string;
 
 namespace {
-	// IF Entry
-	struct IFEntry {
-		// Raw fields
-		unsigned short tag;
-		unsigned short format;
-		unsigned data;
-		unsigned length;
-
-		// Parsed fields
-		string val_string;
-		unsigned short val_16;
-		unsigned val_32;
-		double val_rational;
-		unsigned char val_byte;
-	};
-
-	// Helper functions
-	unsigned int parse32(const unsigned char *buf, bool intel)
-	{
-		if (intel)
-			return ((unsigned)buf[3] << 24) |
-			       ((unsigned)buf[2] << 16) |
-			       ((unsigned)buf[1] << 8) |
-			       buf[0];
-
-		return ((unsigned)buf[0] << 24) |
-		       ((unsigned)buf[1] << 16) |
-		       ((unsigned)buf[2] << 8) |
-		       buf[3];
-	}
-
-	unsigned short parse16(const unsigned char *buf, bool intel)
-	{
-		if (intel)
-			return ((unsigned)buf[1] << 8) | buf[0];
-		return ((unsigned)buf[0] << 8) | buf[1];
-	}
-
-	string parseEXIFString(const unsigned char *buf,
-			       const unsigned num_components,
-			       const unsigned data,
-			       const unsigned base,
-			       const unsigned len)
-	{
-		string value;
-		if (num_components <= 4)
-			value.assign((const char *)&data, num_components);
-		else {
-			if (base + data + num_components <= len)
-				value.assign((const char *)(buf + base + data), num_components);
-		}
-		return value;
-	}
-
-	double parseEXIFRational(const unsigned char *buf, bool intel)
-	{
-		double numerator = 0;
-		double denominator = 1;
-
-		numerator = (double)parse32(buf, intel);
-		denominator = (double)parse32(buf + 4, intel);
-		if (denominator < 1e-20)
-			return 0;
-		return numerator / denominator;
-	}
-
-	IFEntry parseIFEntry(const unsigned char *buf,
-			     const unsigned offs,
-			     const bool alignIntel,
-			     const unsigned base,
-			     const unsigned len)
-	{
-		IFEntry result;
-
-		// Each directory entry is composed of:
-		// 2 bytes: tag number (data field)
-		// 2 bytes: data format
-		// 4 bytes: number of components
-		// 4 bytes: data value or offset to data value
-		result.tag = parse16(buf + offs, alignIntel);
-		result.format = parse16(buf + offs + 2, alignIntel);
-		result.length = parse32(buf + offs + 4, alignIntel);
-		result.data = parse32(buf + offs + 8, alignIntel);
-
-		// Parse value in specified format
-		switch (result.format) {
-		case 1:
-			result.val_byte = (unsigned char)*(buf + offs + 8);
-			break;
-		case 2:
-			result.val_string = parseEXIFString(buf, result.length, result.data, base, len);
-			break;
-		case 3:
-			result.val_16 = parse16((const unsigned char *)buf + offs + 8, alignIntel);
-			break;
-		case 4:
-			result.val_32 = result.data;
-			break;
-		case 5:
-			if (base + result.data + 8 <= len)
-				result.val_rational = parseEXIFRational(buf + base + result.data, alignIntel);
-			break;
-		case 7:
-		case 9:
-		case 10:
-			break;
-		default:
-			result.tag = 0xFF;
-		}
-		return result;
-	}
+
+struct Rational {
+  uint32_t numerator, denominator;
+  operator double() const {
+    if (denominator < 1e-20) {
+      return 0;
+    }
+    return static_cast<double>(numerator) / static_cast<double>(denominator);
+  }
+};
+
+// IF Entry
+class IFEntry {
+ public:
+  using byte_vector = std::vector<uint8_t>;
+  using ascii_vector = std::string;
+  using short_vector = std::vector<uint16_t>;
+  using long_vector = std::vector<uint32_t>;
+  using rational_vector = std::vector<Rational>;
+
+  IFEntry()
+      : tag_(0xFF), format_(0xFF), data_(0), length_(0), val_byte_(nullptr) {}
+  IFEntry(const IFEntry &) = delete;
+  IFEntry &operator=(const IFEntry &) = delete;
+  IFEntry(IFEntry &&other)
+      : tag_(other.tag_),
+        format_(other.format_),
+        data_(other.data_),
+        length_(other.length_),
+        val_byte_(other.val_byte_) {
+    other.tag_ = 0xFF;
+    other.format_ = 0xFF;
+    other.data_ = 0;
+    other.length_ = 0;
+    other.val_byte_ = nullptr;
+  }
+  ~IFEntry() { delete_union(); }
+  unsigned short tag() const { return tag_; }
+  void tag(unsigned short tag) { tag_ = tag; }
+  unsigned short format() const { return format_; }
+  bool format(unsigned short format) {
+    switch (format) {
+      case 0x01:
+      case 0x02:
+      case 0x03:
+      case 0x04:
+      case 0x05:
+      case 0x07:
+      case 0x09:
+      case 0x0a:
+      case 0xff:
+        break;
+      default:
+        return false;
+    }
+    delete_union();
+    format_ = format;
+    new_union();
+    return true;
+  }
+  unsigned data() const { return data_; }
+  void data(unsigned data) { data_ = data; }
+  unsigned length() const { return length_; }
+  void length(unsigned length) { length_ = length; }
+
+  // functions to access the data
+  //
+  // !! it's CALLER responsibility to check that format !!
+  // !! is correct before accessing it's field          !!
+  //
+  // - getters are use here to allow future addition
+  //   of checks if format is correct
+  byte_vector &val_byte() { return *val_byte_; }
+  ascii_vector &val_string() { return *val_string_; }
+  short_vector &val_short() { return *val_short_; }
+  long_vector &val_long() { return *val_long_; }
+  rational_vector &val_rational() { return *val_rational_; }
+
+ private:
+  // Raw fields
+  unsigned short tag_;
+  unsigned short format_;
+  unsigned data_;
+  unsigned length_;
+
+  // Parsed fields
+  union {
+    byte_vector *val_byte_;
+    ascii_vector *val_string_;
+    short_vector *val_short_;
+    long_vector *val_long_;
+    rational_vector *val_rational_;
+  };
+
+  void delete_union() {
+    switch (format_) {
+      case 0x1:
+        delete val_byte_;
+        val_byte_ = nullptr;
+        break;
+      case 0x2:
+        delete val_string_;
+        val_string_ = nullptr;
+        break;
+      case 0x3:
+        delete val_short_;
+        val_short_ = nullptr;
+        break;
+      case 0x4:
+        delete val_long_;
+        val_long_ = nullptr;
+        break;
+      case 0x5:
+        delete val_rational_;
+        val_rational_ = nullptr;
+        break;
+      case 0xff:
+        break;
+      default:
+        // should not get here
+        // should I throw an exception or ...?
+        break;
+    }
+  }
+  void new_union() {
+    switch (format_) {
+      case 0x1:
+        val_byte_ = new byte_vector();
+        break;
+      case 0x2:
+        val_string_ = new ascii_vector();
+        break;
+      case 0x3:
+        val_short_ = new short_vector();
+        break;
+      case 0x4:
+        val_long_ = new long_vector();
+        break;
+      case 0x5:
+        val_rational_ = new rational_vector();
+        break;
+      case 0xff:
+        break;
+      default:
+        // should not get here
+        // should I throw an exception or ...?
+        break;
+    }
+  }
+};
+
+// Helper functions
+template <typename T, bool alignIntel>
+T parse(const unsigned char *buf);
+
+template <>
+uint8_t parse<uint8_t, false>(const unsigned char *buf) {
+  return *buf;
+}
+
+template <>
+uint8_t parse<uint8_t, true>(const unsigned char *buf) {
+  return *buf;
+}
+
+template <>
+uint16_t parse<uint16_t, false>(const unsigned char *buf) {
+  return (static_cast<uint16_t>(buf[0]) << 8) | buf[1];
+}
+
+template <>
+uint16_t parse<uint16_t, true>(const unsigned char *buf) {
+  return (static_cast<uint16_t>(buf[1]) << 8) | buf[0];
+}
+
+template <>
+uint32_t parse<uint32_t, false>(const unsigned char *buf) {
+  return (static_cast<uint32_t>(buf[0]) << 24) |
+         (static_cast<uint32_t>(buf[1]) << 16) |
+         (static_cast<uint32_t>(buf[2]) << 8) | buf[3];
+}
+
+template <>
+uint32_t parse<uint32_t, true>(const unsigned char *buf) {
+  return (static_cast<uint32_t>(buf[3]) << 24) |
+         (static_cast<uint32_t>(buf[2]) << 16) |
+         (static_cast<uint32_t>(buf[1]) << 8) | buf[0];
+}
+
+template <>
+Rational parse<Rational, true>(const unsigned char *buf) {
+  Rational r;
+  r.numerator = parse<uint32_t, true>(buf);
+  r.denominator = parse<uint32_t, true>(buf + 4);
+  return r;
+}
+
+template <>
+Rational parse<Rational, false>(const unsigned char *buf) {
+  Rational r;
+  r.numerator = parse<uint32_t, false>(buf);
+  r.denominator = parse<uint32_t, false>(buf + 4);
+  return r;
+}
+
+/**
+ * Try to read entry.length() values for this entry.
+ *
+ * Returns:
+ *  true  - entry.length() values were read
+ *  false - something went wrong, vec's content was not touched
+ */
+template <typename T, bool alignIntel, typename C>
+bool extract_values(C &container, const unsigned char *buf, const unsigned base,
+                    const unsigned len, const IFEntry &entry) {
+  const unsigned char *data;
+  uint32_t reversed_data;
+  // if data fits into 4 bytes, they are stored directly in
+  // the data field in IFEntry
+  if (sizeof(T) * entry.length() <= 4) {
+    if (alignIntel) {
+      reversed_data = entry.data();
+    } else {
+      reversed_data = entry.data();
+      // this reversing works, but is ugly
+      unsigned char *data = reinterpret_cast<unsigned char *>(&reversed_data);
+      unsigned char tmp;
+      tmp = data[0];
+      data[0] = data[3];
+      data[3] = tmp;
+      tmp = data[1];
+      data[1] = data[2];
+      data[2] = tmp;
+    }
+    data = reinterpret_cast<const unsigned char *>(&(reversed_data));
+  } else {
+    data = buf + base + entry.data();
+    if (data + sizeof(T) * entry.length() > buf + len) {
+      return false;
+    }
+  }
+  container.resize(entry.length());
+  for (size_t i = 0; i < entry.length(); ++i) {
+    container[i] = parse<T, alignIntel>(data + sizeof(T) * i);
+  }
+  return true;
+}
+
+template <bool alignIntel>
+void parseIFEntryHeader(const unsigned char *buf, unsigned short &tag,
+                        unsigned short &format, unsigned &length,
+                        unsigned &data) {
+  // Each directory entry is composed of:
+  // 2 bytes: tag number (data field)
+  // 2 bytes: data format
+  // 4 bytes: number of components
+  // 4 bytes: data value or offset to data value
+  tag = parse<uint16_t, alignIntel>(buf);
+  format = parse<uint16_t, alignIntel>(buf + 2);
+  length = parse<uint32_t, alignIntel>(buf + 4);
+  data = parse<uint32_t, alignIntel>(buf + 8);
+}
+
+template <bool alignIntel>
+void parseIFEntryHeader(const unsigned char *buf, IFEntry &result) {
+  unsigned short tag;
+  unsigned short format;
+  unsigned length;
+  unsigned data;
+
+  parseIFEntryHeader<alignIntel>(buf, tag, format, length, data);
+
+  result.tag(tag);
+  result.format(format);
+  result.length(length);
+  result.data(data);
+}
+
+template <bool alignIntel>
+IFEntry parseIFEntry_temp(const unsigned char *buf, const unsigned offs,
+                          const unsigned base, const unsigned len) {
+  IFEntry result;
+
+  // check if there even is enough data for IFEntry in the buffer
+  if (buf + offs + 12 > buf + len) {
+    result.tag(0xFF);
+    return result;
+  }
+
+  parseIFEntryHeader<alignIntel>(buf + offs, result);
+
+  // Parse value in specified format
+  switch (result.format()) {
+    case 1:
+      if (!extract_values<uint8_t, alignIntel>(result.val_byte(), buf, base,
+                                               len, result)) {
+        result.tag(0xFF);
+      }
+      break;
+    case 2:
+      // string is basically sequence of uint8_t (well, according to EXIF even
+      // uint7_t, but
+      // we don't have that), so just read it as bytes
+      if (!extract_values<uint8_t, alignIntel>(result.val_string(), buf, base,
+                                               len, result)) {
+        result.tag(0xFF);
+      }
+      // and cut zero byte at the end, since we don't want that in the
+      // std::string
+      if (result.val_string()[result.val_string().length() - 1] == '\0') {
+        result.val_string().resize(result.val_string().length() - 1);
+      }
+      break;
+    case 3:
+      if (!extract_values<uint16_t, alignIntel>(result.val_short(), buf, base,
+                                                len, result)) {
+        result.tag(0xFF);
+      }
+      break;
+    case 4:
+      if (!extract_values<uint32_t, alignIntel>(result.val_long(), buf, base,
+                                                len, result)) {
+        result.tag(0xFF);
+      }
+      break;
+    case 5:
+      if (!extract_values<Rational, alignIntel>(result.val_rational(), buf,
+                                                base, len, result)) {
+        result.tag(0xFF);
+      }
+      break;
+    case 7:
+    case 9:
+    case 10:
+      break;
+    default:
+      result.tag(0xFF);
+  }
+  return result;
+}
+
+// helper functions for convinience
+template <typename T>
+T parse_value(const unsigned char *buf, bool alignIntel) {
+  if (alignIntel) {
+    return parse<T, true>(buf);
+  } else {
+    return parse<T, false>(buf);
+  }
+}
+
+void parseIFEntryHeader(const unsigned char *buf, bool alignIntel,
+                        unsigned short &tag, unsigned short &format,
+                        unsigned &length, unsigned &data) {
+  if (alignIntel) {
+    parseIFEntryHeader<true>(buf, tag, format, length, data);
+  } else {
+    parseIFEntryHeader<false>(buf, tag, format, length, data);
+  }
+}
+
+IFEntry parseIFEntry(const unsigned char *buf, const unsigned offs,
+                     const bool alignIntel, const unsigned base,
+                     const unsigned len) {
+  if (alignIntel) {
+    return parseIFEntry_temp<true>(buf, offs, base, len);
+  } else {
+    return parseIFEntry_temp<false>(buf, offs, base, len);
+  }
+}
 }
 
 //
 // Locates the EXIF segment and parses it using parseFromEXIFSegment
 //
-int EXIFInfo::parseFrom(const unsigned char *buf, unsigned len)
-{
-	// Sanity check: all JPEG files start with 0xFFD8 and end with 0xFFD9
-	// This check also ensures that the user has supplied a correct value for len.
-	if (!buf || len < 4)
-		return PARSE_EXIF_ERROR_NO_EXIF;
-	if (buf[0] != 0xFF || buf[1] != 0xD8)
-		return PARSE_EXIF_ERROR_NO_JPEG;
-	if (buf[len - 2] != 0xFF || buf[len - 1] != 0xD9)
-		return PARSE_EXIF_ERROR_NO_JPEG;
-	clear();
-
-	// Scan for EXIF header (bytes 0xFF 0xE1) and do a sanity check by
-	// looking for bytes "Exif\0\0". The marker length data is in Motorola
-	// byte order, which results in the 'false' parameter to parse16().
-	// The marker has to contain at least the TIFF header, otherwise the
-	// EXIF data is corrupt. So the minimum length specified here has to be:
-	//   2 bytes: section size
-	//   6 bytes: "Exif\0\0" string
-	//   2 bytes: TIFF header (either "II" or "MM" string)
-	//   2 bytes: TIFF magic (short 0x2a00 in Motorola byte order)
-	//   4 bytes: Offset to first IFD
-	// =========
-	//  16 bytes
-	unsigned offs = 0; // current offset into buffer
-	for (offs = 0; offs < len - 1; offs++)
-		if (buf[offs] == 0xFF && buf[offs + 1] == 0xE1)
-			break;
-	if (offs + 4 > len)
-		return PARSE_EXIF_ERROR_NO_EXIF;
-	offs += 2;
-	unsigned short section_length = parse16(buf + offs, false);
-	if (offs + section_length > len || section_length < 16)
-		return PARSE_EXIF_ERROR_CORRUPT;
-	offs += 2;
-
-	return parseFromEXIFSegment(buf + offs, len - offs);
+int easyexif::EXIFInfo::parseFrom(const unsigned char *buf, unsigned len) {
+  // Sanity check: all JPEG files start with 0xFFD8.
+  if (!buf || len < 4) return PARSE_EXIF_ERROR_NO_JPEG;
+  if (buf[0] != 0xFF || buf[1] != 0xD8) return PARSE_EXIF_ERROR_NO_JPEG;
+
+  // Sanity check: some cameras pad the JPEG image with null bytes at the end.
+  // Normally, we should able to find the JPEG end marker 0xFFD9 at the end
+  // of the image, but not always. As long as there are null/0xFF bytes at the
+  // end of the image buffer, keep decrementing len until an 0xFFD9 is found,
+  // or some other bytes are. If the first non-zero/0xFF bytes from the end are
+  // not 0xFFD9, then we can be reasonably sure that the buffer is not a JPEG.
+  while (len > 2) {
+    if (buf[len - 1] == 0 || buf[len - 1] == 0xFF) {
+      len--;
+    } else {
+      if (buf[len - 1] != 0xD9 || buf[len - 2] != 0xFF) {
+        return PARSE_EXIF_ERROR_NO_JPEG;
+      } else {
+        break;
+      }
+    }
+  }
+  clear();
+
+  // Scan for EXIF header (bytes 0xFF 0xE1) and do a sanity check by
+  // looking for bytes "Exif\0\0". The marker length data is in Motorola
+  // byte order, which results in the 'false' parameter to parse16().
+  // The marker has to contain at least the TIFF header, otherwise the
+  // EXIF data is corrupt. So the minimum length specified here has to be:
+  //   2 bytes: section size
+  //   6 bytes: "Exif\0\0" string
+  //   2 bytes: TIFF header (either "II" or "MM" string)
+  //   2 bytes: TIFF magic (short 0x2a00 in Motorola byte order)
+  //   4 bytes: Offset to first IFD
+  // =========
+  //  16 bytes
+  unsigned offs = 0;  // current offset into buffer
+  for (offs = 0; offs < len - 1; offs++)
+    if (buf[offs] == 0xFF && buf[offs + 1] == 0xE1) break;
+  if (offs + 4 > len) return PARSE_EXIF_ERROR_NO_EXIF;
+  offs += 2;
+  unsigned short section_length = parse_value<uint16_t>(buf + offs, false);
+  if (offs + section_length > len || section_length < 16)
+    return PARSE_EXIF_ERROR_CORRUPT;
+  offs += 2;
+
+  return parseFromEXIFSegment(buf + offs, len - offs);
 }
 
-int EXIFInfo::parseFrom(const string &data)
-{
-	return parseFrom((const unsigned char *)data.data(), data.length());
+int easyexif::EXIFInfo::parseFrom(const string &data) {
+  return parseFrom(
+      reinterpret_cast<const unsigned char *>(data.data()), static_cast<unsigned>(data.length()));
 }
 
 //
@@ -202,373 +474,431 @@ int EXIFInfo::parseFrom(const string &data)
 // PARAM: 'buf' start of the EXIF TIFF, which must be the bytes "Exif\0\0".
 // PARAM: 'len' length of buffer
 //
-int EXIFInfo::parseFromEXIFSegment(const unsigned char *buf, unsigned len)
-{
-	bool alignIntel = true; // byte alignment (defined in EXIF header)
-	unsigned offs = 0;      // current offset into buffer
-	if (!buf || len < 6)
-		return PARSE_EXIF_ERROR_NO_EXIF;
-
-	if (!std::equal(buf, buf + 6, "Exif\0\0"))
-		return PARSE_EXIF_ERROR_NO_EXIF;
-	offs += 6;
-
-	// Now parsing the TIFF header. The first two bytes are either "II" or
-	// "MM" for Intel or Motorola byte alignment. Sanity check by parsing
-	// the unsigned short that follows, making sure it equals 0x2a. The
-	// last 4 bytes are an offset into the first IFD, which are added to
-	// the global offset counter. For this block, we expect the following
-	// minimum size:
-	//  2 bytes: 'II' or 'MM'
-	//  2 bytes: 0x002a
-	//  4 bytes: offset to first IDF
-	// -----------------------------
-	//  8 bytes
-	if (offs + 8 > len)
-		return PARSE_EXIF_ERROR_CORRUPT;
-	unsigned tiff_header_start = offs;
-	if (buf[offs] == 'I' && buf[offs + 1] == 'I')
-		alignIntel = true;
-	else {
-		if (buf[offs] == 'M' && buf[offs + 1] == 'M')
-			alignIntel = false;
-		else
-			return PARSE_EXIF_ERROR_UNKNOWN_BYTEALIGN;
-	}
-	this->ByteAlign = alignIntel;
-	offs += 2;
-	if (0x2a != parse16(buf + offs, alignIntel))
-		return PARSE_EXIF_ERROR_CORRUPT;
-	offs += 2;
-	unsigned first_ifd_offset = parse32(buf + offs, alignIntel);
-	offs += first_ifd_offset - 4;
-	if (offs >= len)
-		return PARSE_EXIF_ERROR_CORRUPT;
-
-	// Now parsing the first Image File Directory (IFD0, for the main image).
-	// An IFD consists of a variable number of 12-byte directory entries. The
-	// first two bytes of the IFD section contain the number of directory
-	// entries in the section. The last 4 bytes of the IFD contain an offset
-	// to the next IFD, which means this IFD must contain exactly 6 + 12 * num
-	// bytes of data.
-	if (offs + 2 > len)
-		return PARSE_EXIF_ERROR_CORRUPT;
-	int num_entries = parse16(buf + offs, alignIntel);
-	if (offs + 6 + 12 * num_entries > len)
-		return PARSE_EXIF_ERROR_CORRUPT;
-	offs += 2;
-	unsigned exif_sub_ifd_offset = len;
-	unsigned gps_sub_ifd_offset = len;
-	while (--num_entries >= 0) {
-		IFEntry result = parseIFEntry(buf, offs, alignIntel, tiff_header_start, len);
-		offs += 12;
-		switch (result.tag) {
-		case 0x102:
-			// Bits per sample
-			if (result.format == 3)
-				this->BitsPerSample = result.val_16;
-			break;
-
-		case 0x10E:
-			// Image description
-			if (result.format == 2)
-				this->ImageDescription = result.val_string;
-			break;
-
-		case 0x10F:
-			// Digicam make
-			if (result.format == 2)
-				this->Make = result.val_string;
-			break;
-
-		case 0x110:
-			// Digicam model
-			if (result.format == 2)
-				this->Model = result.val_string;
-			break;
-
-		case 0x112:
-			// Orientation of image
-			if (result.format == 3)
-				this->Orientation = result.val_16;
-			break;
-
-		case 0x131:
-			// Software used for image
-			if (result.format == 2)
-				this->Software = result.val_string;
-			break;
-
-		case 0x132:
-			// EXIF/TIFF date/time of image modification
-			if (result.format == 2)
-				this->DateTime = result.val_string;
-			break;
-
-		case 0x8298:
-			// Copyright information
-			if (result.format == 2)
-				this->Copyright = result.val_string;
-			break;
-
-		case 0x8825:
-			// GPS IFS offset
-			gps_sub_ifd_offset = tiff_header_start + result.data;
-			break;
-
-		case 0x8769:
-			// EXIF SubIFD offset
-			exif_sub_ifd_offset = tiff_header_start + result.data;
-			break;
-		}
-	}
-
-	// Jump to the EXIF SubIFD if it exists and parse all the information
-	// there. Note that it's possible that the EXIF SubIFD doesn't exist.
-	// The EXIF SubIFD contains most of the interesting information that a
-	// typical user might want.
-	if (exif_sub_ifd_offset + 4 <= len) {
-		offs = exif_sub_ifd_offset;
-		int num_entries = parse16(buf + offs, alignIntel);
-		if (offs + 6 + 12 * num_entries > len)
-			return PARSE_EXIF_ERROR_CORRUPT;
-		offs += 2;
-		while (--num_entries >= 0) {
-			IFEntry result = parseIFEntry(buf, offs, alignIntel, tiff_header_start, len);
-			switch (result.tag) {
-			case 0x829a:
-				// Exposure time in seconds
-				if (result.format == 5)
-					this->ExposureTime = result.val_rational;
-				break;
-
-			case 0x829d:
-				// FNumber
-				if (result.format == 5)
-					this->FNumber = result.val_rational;
-				break;
-
-			case 0x8827:
-				// ISO Speed Rating
-				if (result.format == 3)
-					this->ISOSpeedRatings = result.val_16;
-				break;
-
-			case 0x9003:
-				// Original date and time
-				if (result.format == 2)
-					this->DateTimeOriginal = result.val_string;
-				break;
-
-			case 0x9004:
-				// Digitization date and time
-				if (result.format == 2)
-					this->DateTimeDigitized = result.val_string;
-				break;
-
-			case 0x9201:
-				// Shutter speed value
-				if (result.format == 5)
-					this->ShutterSpeedValue = result.val_rational;
-				break;
-
-			case 0x9204:
-				// Exposure bias value
-				if (result.format == 5)
-					this->ExposureBiasValue = result.val_rational;
-				break;
-
-			case 0x9206:
-				// Subject distance
-				if (result.format == 5)
-					this->SubjectDistance = result.val_rational;
-				break;
-
-			case 0x9209:
-				// Flash used
-				if (result.format == 3)
-					this->Flash = result.data ? 1 : 0;
-				break;
-
-			case 0x920a:
-				// Focal length
-				if (result.format == 5)
-					this->FocalLength = result.val_rational;
-				break;
-
-			case 0x9207:
-				// Metering mode
-				if (result.format == 3)
-					this->MeteringMode = result.val_16;
-				break;
-
-			case 0x9291:
-				// Subsecond original time
-				if (result.format == 2)
-					this->SubSecTimeOriginal = result.val_string;
-				break;
-
-			case 0xa002:
-				// EXIF Image width
-				if (result.format == 4)
-					this->ImageWidth = result.val_32;
-				if (result.format == 3)
-					this->ImageWidth = result.val_16;
-				break;
-
-			case 0xa003:
-				// EXIF Image height
-				if (result.format == 4)
-					this->ImageHeight = result.val_32;
-				if (result.format == 3)
-					this->ImageHeight = result.val_16;
-				break;
-
-			case 0xa405:
-				// Focal length in 35mm film
-				if (result.format == 3)
-					this->FocalLengthIn35mm = result.val_16;
-				break;
-			}
-			offs += 12;
-		}
-	}
-
-	// Jump to the GPS SubIFD if it exists and parse all the information
-	// there. Note that it's possible that the GPS SubIFD doesn't exist.
-	if (gps_sub_ifd_offset + 4 <= len) {
-		offs = gps_sub_ifd_offset;
-		int num_entries = parse16(buf + offs, alignIntel);
-		if (offs + 6 + 12 * num_entries > len)
-			return PARSE_EXIF_ERROR_CORRUPT;
-		offs += 2;
-		while (--num_entries >= 0) {
-			unsigned short tag = parse16(buf + offs, alignIntel);
-			unsigned short format = parse16(buf + offs + 2, alignIntel);
-			unsigned length = parse32(buf + offs + 4, alignIntel);
-			unsigned data = parse32(buf + offs + 8, alignIntel);
-			switch (tag) {
-			case 1:
-				// GPS north or south
-				this->GeoLocation.LatComponents.direction = *(buf + offs + 8);
-				if ('S' == this->GeoLocation.LatComponents.direction)
-					this->GeoLocation.Latitude = -this->GeoLocation.Latitude;
-				break;
-
-			case 2:
-				// GPS latitude
-				if (format == 5 && length == 3) {
-					this->GeoLocation.LatComponents.degrees =
-						parseEXIFRational(buf + data + tiff_header_start, alignIntel);
-					this->GeoLocation.LatComponents.minutes =
-						parseEXIFRational(buf + data + tiff_header_start + 8, alignIntel);
-					this->GeoLocation.LatComponents.seconds =
-						parseEXIFRational(buf + data + tiff_header_start + 16, alignIntel);
-					this->GeoLocation.Latitude =
-						this->GeoLocation.LatComponents.degrees +
-						this->GeoLocation.LatComponents.minutes / 60 +
-						this->GeoLocation.LatComponents.seconds / 3600;
-					if ('S' == this->GeoLocation.LatComponents.direction)
-						this->GeoLocation.Latitude = -this->GeoLocation.Latitude;
-				}
-				break;
-
-			case 3:
-				// GPS east or west
-				this->GeoLocation.LonComponents.direction = *(buf + offs + 8);
-				if ('W' == this->GeoLocation.LonComponents.direction)
-					this->GeoLocation.Longitude = -this->GeoLocation.Longitude;
-				break;
-
-			case 4:
-				// GPS longitude
-				if (format == 5 && length == 3) {
-					this->GeoLocation.LonComponents.degrees =
-						parseEXIFRational(buf + data + tiff_header_start, alignIntel);
-					this->GeoLocation.LonComponents.minutes =
-						parseEXIFRational(buf + data + tiff_header_start + 8, alignIntel);
-					this->GeoLocation.LonComponents.seconds =
-						parseEXIFRational(buf + data + tiff_header_start + 16, alignIntel);
-					this->GeoLocation.Longitude =
-						this->GeoLocation.LonComponents.degrees +
-						this->GeoLocation.LonComponents.minutes / 60 +
-						this->GeoLocation.LonComponents.seconds / 3600;
-					if ('W' == this->GeoLocation.LonComponents.direction)
-						this->GeoLocation.Longitude = -this->GeoLocation.Longitude;
-				}
-				break;
-
-			case 5:
-				// GPS altitude reference (below or above sea level)
-				this->GeoLocation.AltitudeRef = *(buf + offs + 8);
-				if (1 == this->GeoLocation.AltitudeRef)
-					this->GeoLocation.Altitude = -this->GeoLocation.Altitude;
-				break;
-
-			case 6:
-				// GPS altitude reference
-				if (format == 5) {
-					this->GeoLocation.Altitude =
-						parseEXIFRational(buf + data + tiff_header_start, alignIntel);
-					if (1 == this->GeoLocation.AltitudeRef)
-						this->GeoLocation.Altitude = -this->GeoLocation.Altitude;
-				}
-				break;
-			}
-			offs += 12;
-		}
-	}
-
-	return PARSE_EXIF_SUCCESS;
+int easyexif::EXIFInfo::parseFromEXIFSegment(const unsigned char *buf,
+                                             unsigned len) {
+  bool alignIntel = true;  // byte alignment (defined in EXIF header)
+  unsigned offs = 0;       // current offset into buffer
+  if (!buf || len < 6) return PARSE_EXIF_ERROR_NO_EXIF;
+
+  if (!std::equal(buf, buf + 6, "Exif\0\0")) return PARSE_EXIF_ERROR_NO_EXIF;
+  offs += 6;
+
+  // Now parsing the TIFF header. The first two bytes are either "II" or
+  // "MM" for Intel or Motorola byte alignment. Sanity check by parsing
+  // the unsigned short that follows, making sure it equals 0x2a. The
+  // last 4 bytes are an offset into the first IFD, which are added to
+  // the global offset counter. For this block, we expect the following
+  // minimum size:
+  //  2 bytes: 'II' or 'MM'
+  //  2 bytes: 0x002a
+  //  4 bytes: offset to first IDF
+  // -----------------------------
+  //  8 bytes
+  if (offs + 8 > len) return PARSE_EXIF_ERROR_CORRUPT;
+  unsigned tiff_header_start = offs;
+  if (buf[offs] == 'I' && buf[offs + 1] == 'I')
+    alignIntel = true;
+  else {
+    if (buf[offs] == 'M' && buf[offs + 1] == 'M')
+      alignIntel = false;
+    else
+      return PARSE_EXIF_ERROR_UNKNOWN_BYTEALIGN;
+  }
+  this->ByteAlign = alignIntel;
+  offs += 2;
+  if (0x2a != parse_value<uint16_t>(buf + offs, alignIntel))
+    return PARSE_EXIF_ERROR_CORRUPT;
+  offs += 2;
+  unsigned first_ifd_offset = parse_value<uint32_t>(buf + offs, alignIntel);
+  offs += first_ifd_offset - 4;
+  if (offs >= len) return PARSE_EXIF_ERROR_CORRUPT;
+
+  // Now parsing the first Image File Directory (IFD0, for the main image).
+  // An IFD consists of a variable number of 12-byte directory entries. The
+  // first two bytes of the IFD section contain the number of directory
+  // entries in the section. The last 4 bytes of the IFD contain an offset
+  // to the next IFD, which means this IFD must contain exactly 6 + 12 * num
+  // bytes of data.
+  if (offs + 2 > len) return PARSE_EXIF_ERROR_CORRUPT;
+  int num_entries = parse_value<uint16_t>(buf + offs, alignIntel);
+  if (offs + 6 + 12 * num_entries > len) return PARSE_EXIF_ERROR_CORRUPT;
+  offs += 2;
+  unsigned exif_sub_ifd_offset = len;
+  unsigned gps_sub_ifd_offset = len;
+  while (--num_entries >= 0) {
+    IFEntry result =
+        parseIFEntry(buf, offs, alignIntel, tiff_header_start, len);
+    offs += 12;
+    switch (result.tag()) {
+      case 0x102:
+        // Bits per sample
+        if (result.format() == 3 && result.val_short().size())
+          this->BitsPerSample = result.val_short().front();
+        break;
+
+      case 0x10E:
+        // Image description
+        if (result.format() == 2) this->ImageDescription = result.val_string();
+        break;
+
+      case 0x10F:
+        // Digicam make
+        if (result.format() == 2) this->Make = result.val_string();
+        break;
+
+      case 0x110:
+        // Digicam model
+        if (result.format() == 2) this->Model = result.val_string();
+        break;
+
+      case 0x112:
+        // Orientation of image
+        if (result.format() == 3 && result.val_short().size())
+          this->Orientation = result.val_short().front();
+        break;
+
+      case 0x131:
+        // Software used for image
+        if (result.format() == 2) this->Software = result.val_string();
+        break;
+
+      case 0x132:
+        // EXIF/TIFF date/time of image modification
+        if (result.format() == 2) this->DateTime = result.val_string();
+        break;
+
+      case 0x8298:
+        // Copyright information
+        if (result.format() == 2) this->Copyright = result.val_string();
+        break;
+
+      case 0x8825:
+        // GPS IFS offset
+        gps_sub_ifd_offset = tiff_header_start + result.data();
+        break;
+
+      case 0x8769:
+        // EXIF SubIFD offset
+        exif_sub_ifd_offset = tiff_header_start + result.data();
+        break;
+    }
+  }
+
+  // Jump to the EXIF SubIFD if it exists and parse all the information
+  // there. Note that it's possible that the EXIF SubIFD doesn't exist.
+  // The EXIF SubIFD contains most of the interesting information that a
+  // typical user might want.
+  if (exif_sub_ifd_offset + 4 <= len) {
+    offs = exif_sub_ifd_offset;
+    int num_entries = parse_value<uint16_t>(buf + offs, alignIntel);
+    if (offs + 6 + 12 * num_entries > len) return PARSE_EXIF_ERROR_CORRUPT;
+    offs += 2;
+    while (--num_entries >= 0) {
+      IFEntry result =
+          parseIFEntry(buf, offs, alignIntel, tiff_header_start, len);
+      switch (result.tag()) {
+        case 0x829a:
+          // Exposure time in seconds
+          if (result.format() == 5 && result.val_rational().size())
+            this->ExposureTime = result.val_rational().front();
+          break;
+
+        case 0x829d:
+          // FNumber
+          if (result.format() == 5 && result.val_rational().size())
+            this->FNumber = result.val_rational().front();
+          break;
+
+        case 0x8827:
+          // ISO Speed Rating
+          if (result.format() == 3 && result.val_short().size())
+            this->ISOSpeedRatings = result.val_short().front();
+          break;
+
+        case 0x9003:
+          // Original date and time
+          if (result.format() == 2)
+            this->DateTimeOriginal = result.val_string();
+          break;
+
+        case 0x9004:
+          // Digitization date and time
+          if (result.format() == 2)
+            this->DateTimeDigitized = result.val_string();
+          break;
+
+        case 0x9201:
+          // Shutter speed value
+          if (result.format() == 5 && result.val_rational().size())
+            this->ShutterSpeedValue = result.val_rational().front();
+          break;
+
+        case 0x9204:
+          // Exposure bias value
+          if (result.format() == 5 && result.val_rational().size())
+            this->ExposureBiasValue = result.val_rational().front();
+          break;
+
+        case 0x9206:
+          // Subject distance
+          if (result.format() == 5 && result.val_rational().size())
+            this->SubjectDistance = result.val_rational().front();
+          break;
+
+        case 0x9209:
+          // Flash used
+          if (result.format() == 3) this->Flash = result.data() ? 1 : 0;
+          break;
+
+        case 0x920a:
+          // Focal length
+          if (result.format() == 5 && result.val_rational().size())
+            this->FocalLength = result.val_rational().front();
+          break;
+
+        case 0x9207:
+          // Metering mode
+          if (result.format() == 3 && result.val_short().size())
+            this->MeteringMode = result.val_short().front();
+          break;
+
+        case 0x9291:
+          // Subsecond original time
+          if (result.format() == 2)
+            this->SubSecTimeOriginal = result.val_string();
+          break;
+
+        case 0xa002:
+          // EXIF Image width
+          if (result.format() == 4 && result.val_long().size())
+            this->ImageWidth = result.val_long().front();
+          if (result.format() == 3 && result.val_short().size())
+            this->ImageWidth = result.val_short().front();
+          break;
+
+        case 0xa003:
+          // EXIF Image height
+          if (result.format() == 4 && result.val_long().size())
+            this->ImageHeight = result.val_long().front();
+          if (result.format() == 3 && result.val_short().size())
+            this->ImageHeight = result.val_short().front();
+          break;
+
+        case 0xa20e:
+          // EXIF Focal plane X-resolution
+          if (result.format() == 5) {
+            this->LensInfo.FocalPlaneXResolution = result.val_rational()[0];
+          }
+          break;
+
+        case 0xa20f:
+          // EXIF Focal plane Y-resolution
+          if (result.format() == 5) {
+            this->LensInfo.FocalPlaneYResolution = result.val_rational()[0];
+          }
+          break;
+
+        case 0xa405:
+          // Focal length in 35mm film
+          if (result.format() == 3 && result.val_short().size())
+            this->FocalLengthIn35mm = result.val_short().front();
+          break;
+
+        case 0xa432:
+          // Focal length and FStop.
+          if (result.format() == 5) {
+            int sz = static_cast<unsigned>(result.val_rational().size());
+            if (sz)
+              this->LensInfo.FocalLengthMin = result.val_rational()[0];
+            if (sz > 1)
+              this->LensInfo.FocalLengthMax = result.val_rational()[1];
+            if (sz > 2)
+              this->LensInfo.FStopMin = result.val_rational()[2];
+            if (sz > 3)
+              this->LensInfo.FStopMax = result.val_rational()[3];
+          }
+          break;
+
+        case 0xa433:
+          // Lens make.
+          if (result.format() == 2) {
+            this->LensInfo.Make = result.val_string();
+          }
+          break;
+
+        case 0xa434:
+          // Lens model.
+          if (result.format() == 2) {
+            this->LensInfo.Model = result.val_string();
+          }
+          break;
+      }
+      offs += 12;
+    }
+  }
+
+  // Jump to the GPS SubIFD if it exists and parse all the information
+  // there. Note that it's possible that the GPS SubIFD doesn't exist.
+  if (gps_sub_ifd_offset + 4 <= len) {
+    offs = gps_sub_ifd_offset;
+    int num_entries = parse_value<uint16_t>(buf + offs, alignIntel);
+    if (offs + 6 + 12 * num_entries > len) return PARSE_EXIF_ERROR_CORRUPT;
+    offs += 2;
+    while (--num_entries >= 0) {
+      unsigned short tag, format;
+      unsigned length, data;
+      parseIFEntryHeader(buf + offs, alignIntel, tag, format, length, data);
+      switch (tag) {
+        case 1:
+          // GPS north or south
+          this->GeoLocation.LatComponents.direction = *(buf + offs + 8);
+          if (this->GeoLocation.LatComponents.direction == 0) {
+            this->GeoLocation.LatComponents.direction = '?';
+          }
+          if ('S' == this->GeoLocation.LatComponents.direction) {
+            this->GeoLocation.Latitude = -this->GeoLocation.Latitude;
+          }
+          break;
+
+        case 2:
+          // GPS latitude
+          if ((format == 5 || format == 10) && length == 3) {
+            this->GeoLocation.LatComponents.degrees = parse_value<Rational>(
+                buf + data + tiff_header_start, alignIntel);
+            this->GeoLocation.LatComponents.minutes = parse_value<Rational>(
+                buf + data + tiff_header_start + 8, alignIntel);
+            this->GeoLocation.LatComponents.seconds = parse_value<Rational>(
+                buf + data + tiff_header_start + 16, alignIntel);
+            this->GeoLocation.Latitude =
+                this->GeoLocation.LatComponents.degrees +
+                this->GeoLocation.LatComponents.minutes / 60 +
+                this->GeoLocation.LatComponents.seconds / 3600;
+            if ('S' == this->GeoLocation.LatComponents.direction) {
+              this->GeoLocation.Latitude = -this->GeoLocation.Latitude;
+            }
+          }
+          break;
+
+        case 3:
+          // GPS east or west
+          this->GeoLocation.LonComponents.direction = *(buf + offs + 8);
+          if (this->GeoLocation.LonComponents.direction == 0) {
+            this->GeoLocation.LonComponents.direction = '?';
+          }
+          if ('W' == this->GeoLocation.LonComponents.direction) {
+            this->GeoLocation.Longitude = -this->GeoLocation.Longitude;
+          }
+          break;
+
+        case 4:
+          // GPS longitude
+          if ((format == 5 || format == 10) && length == 3) {
+            this->GeoLocation.LonComponents.degrees = parse_value<Rational>(
+                buf + data + tiff_header_start, alignIntel);
+            this->GeoLocation.LonComponents.minutes = parse_value<Rational>(
+                buf + data + tiff_header_start + 8, alignIntel);
+            this->GeoLocation.LonComponents.seconds = parse_value<Rational>(
+                buf + data + tiff_header_start + 16, alignIntel);
+            this->GeoLocation.Longitude =
+                this->GeoLocation.LonComponents.degrees +
+                this->GeoLocation.LonComponents.minutes / 60 +
+                this->GeoLocation.LonComponents.seconds / 3600;
+            if ('W' == this->GeoLocation.LonComponents.direction)
+              this->GeoLocation.Longitude = -this->GeoLocation.Longitude;
+          }
+          break;
+
+        case 5:
+          // GPS altitude reference (below or above sea level)
+          this->GeoLocation.AltitudeRef = *(buf + offs + 8);
+          if (1 == this->GeoLocation.AltitudeRef) {
+            this->GeoLocation.Altitude = -this->GeoLocation.Altitude;
+          }
+          break;
+
+        case 6:
+          // GPS altitude
+          if ((format == 5 || format == 10)) {
+            this->GeoLocation.Altitude = parse_value<Rational>(
+                buf + data + tiff_header_start, alignIntel);
+            if (1 == this->GeoLocation.AltitudeRef) {
+              this->GeoLocation.Altitude = -this->GeoLocation.Altitude;
+            }
+          }
+          break;
+
+        case 11:
+          // GPS degree of precision (DOP)
+          if ((format == 5 || format == 10)) {
+            this->GeoLocation.DOP = parse_value<Rational>(
+                buf + data + tiff_header_start, alignIntel);
+          }
+          break;
+      }
+      offs += 12;
+    }
+  }
+
+  return PARSE_EXIF_SUCCESS;
 }
 
-void EXIFInfo::clear()
-{
-	// Strings
-	ImageDescription.clear();
-	Make.clear();
-	Model.clear();
-	Software.clear();
-	DateTime.clear();
-	DateTimeOriginal.clear();
-	DateTimeDigitized.clear();
-	SubSecTimeOriginal.clear();
-	Copyright.clear();
-
-	// Shorts / unsigned / double
-	ByteAlign = 0;
-	Orientation = 0;
-
-	BitsPerSample = 0;
-	ExposureTime = 0;
-	FNumber = 0;
-	ISOSpeedRatings = 0;
-	ShutterSpeedValue = 0;
-	ExposureBiasValue = 0;
-	SubjectDistance = 0;
-	FocalLength = 0;
-	FocalLengthIn35mm = 0;
-	Flash = 0;
-	MeteringMode = 0;
-	ImageWidth = 0;
-	ImageHeight = 0;
-
-	// Geolocation
-	GeoLocation.Latitude = 0;
-	GeoLocation.Longitude = 0;
-	GeoLocation.Altitude = 0;
-	GeoLocation.AltitudeRef = 0;
-	GeoLocation.LatComponents.degrees = 0;
-	GeoLocation.LatComponents.minutes = 0;
-	GeoLocation.LatComponents.seconds = 0;
-	GeoLocation.LatComponents.direction = 0;
-	GeoLocation.LonComponents.degrees = 0;
-	GeoLocation.LonComponents.minutes = 0;
-	GeoLocation.LonComponents.seconds = 0;
-	GeoLocation.LonComponents.direction = 0;
+void easyexif::EXIFInfo::clear() {
+  // Strings
+  ImageDescription = "";
+  Make = "";
+  Model = "";
+  Software = "";
+  DateTime = "";
+  DateTimeOriginal = "";
+  DateTimeDigitized = "";
+  SubSecTimeOriginal = "";
+  Copyright = "";
+
+  // Shorts / unsigned / double
+  ByteAlign = 0;
+  Orientation = 0;
+
+  BitsPerSample = 0;
+  ExposureTime = 0;
+  FNumber = 0;
+  ISOSpeedRatings = 0;
+  ShutterSpeedValue = 0;
+  ExposureBiasValue = 0;
+  SubjectDistance = 0;
+  FocalLength = 0;
+  FocalLengthIn35mm = 0;
+  Flash = 0;
+  MeteringMode = 0;
+  ImageWidth = 0;
+  ImageHeight = 0;
+
+  // Geolocation
+  GeoLocation.Latitude = 0;
+  GeoLocation.Longitude = 0;
+  GeoLocation.Altitude = 0;
+  GeoLocation.AltitudeRef = 0;
+  GeoLocation.DOP = 0;
+  GeoLocation.LatComponents.degrees = 0;
+  GeoLocation.LatComponents.minutes = 0;
+  GeoLocation.LatComponents.seconds = 0;
+  GeoLocation.LatComponents.direction = '?';
+  GeoLocation.LonComponents.degrees = 0;
+  GeoLocation.LonComponents.minutes = 0;
+  GeoLocation.LonComponents.seconds = 0;
+  GeoLocation.LonComponents.direction = '?';
+
+  // LensInfo
+  LensInfo.FocalLengthMax = 0;
+  LensInfo.FocalLengthMin = 0;
+  LensInfo.FStopMax = 0;
+  LensInfo.FStopMin = 0;
+  LensInfo.FocalPlaneYResolution = 0;
+  LensInfo.FocalPlaneXResolution = 0;
+  LensInfo.Make = "";
+  LensInfo.Model = "";
 }
 
-time_t EXIFInfo::epoch()
+time_t easyexif::EXIFInfo::epoch()
 {
 	struct tm tm;
 	int year, month, day, hour, min, sec;
@@ -585,3 +915,4 @@ time_t EXIFInfo::epoch()
 	tm.tm_sec = sec;
 	return (utc_mktime(&tm));
 }
+
diff --git a/core/exif.h b/core/exif.h
index 0fb3a7d4a..7c0ac5385 100644
--- a/core/exif.h
+++ b/core/exif.h
@@ -1,34 +1,16 @@
 /**************************************************************************
   exif.h  -- A simple ISO C++ library to parse basic EXIF
-	     information from a JPEG file.
+             information from a JPEG file.
 
   Based on the description of the EXIF file format at:
   -- http://park2.wakwak.com/~tsuruzoh/Computer/Digicams/exif-e.html
   -- http://www.media.mit.edu/pia/Research/deepview/exif.html
   -- http://www.exif.org/Exif2-2.PDF
 
-  Copyright (c) 2010-2013 Mayank Lahiri
+  Copyright (c) 2010-2016 Mayank Lahiri
   mlahiri@gmail.com
   All rights reserved.
 
-  VERSION HISTORY:
-  ================
-
-  2.1: Released July 2013
-	 -- fixed a bug where JPEGs without an EXIF SubIFD would not be parsed
-	 -- fixed a bug in parsing GPS coordinate seconds
-	 -- fixed makefile bug
-	 -- added two pathological test images from Matt Galloway
-	  http://www.galloway.me.uk/2012/01/uiimageorientation-exif-orientation-sample-images/
-	 -- split main parsing routine for easier integration into Firefox
-
-  2.0: Released February 2013
-	 -- complete rewrite
-	 -- no new/delete
-	 -- added GPS support
-
-  1.0: Released 2010
-
   Redistribution and use in source and binary forms, with or without
   modification, are permitted provided that the following conditions are met:
 
@@ -49,99 +31,113 @@
    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
    EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
-#ifndef EXIF_H
-#define EXIF_H
+#ifndef __EXIF_H
+#define __EXIF_H
 
 #include <string>
 
+namespace easyexif {
+
 //
 // Class responsible for storing and parsing EXIF information from a JPEG blob
 //
 class EXIFInfo {
-public:
-	// Parsing function for an entire JPEG image buffer.
-	//
-	// PARAM 'data': A pointer to a JPEG image.
-	// PARAM 'length': The length of the JPEG image.
-	// RETURN:  PARSE_EXIF_SUCCESS (0) on succes with 'result' filled out
-	//          error code otherwise, as defined by the PARSE_EXIF_ERROR_* macros
-	int parseFrom(const unsigned char *data, unsigned length);
-	int parseFrom(const std::string &data);
-
-	// Parsing function for an EXIF segment. This is used internally by parseFrom()
-	// but can be called for special cases where only the EXIF section is
-	// available (i.e., a blob starting with the bytes "Exif\0\0").
-	int parseFromEXIFSegment(const unsigned char *buf, unsigned len);
-
-	// Set all data members to default values.
-	void clear();
-
-	// Data fields filled out by parseFrom()
-	char ByteAlign;			  // 0 = Motorola byte alignment, 1 = Intel
-	std::string ImageDescription;     // Image description
-	std::string Make;		  // Camera manufacturer's name
-	std::string Model;		  // Camera model
-	unsigned short Orientation;       // Image orientation, start of data corresponds to
-					  // 0: unspecified in EXIF data
-					  // 1: upper left of image
-					  // 3: lower right of image
-					  // 6: upper right of image
-					  // 8: lower left of image
-					  // 9: undefined
-	unsigned short BitsPerSample;     // Number of bits per component
-	std::string Software;		  // Software used
-	std::string DateTime;		  // File change date and time
-	std::string DateTimeOriginal;     // Original file date and time (may not exist)
-	std::string DateTimeDigitized;    // Digitization date and time (may not exist)
-	std::string SubSecTimeOriginal;   // Sub-second time that original picture was taken
-	std::string Copyright;		  // File copyright information
-	double ExposureTime;		  // Exposure time in seconds
-	double FNumber;			  // F/stop
-	unsigned short ISOSpeedRatings;   // ISO speed
-	double ShutterSpeedValue;	 // Shutter speed (reciprocal of exposure time)
-	double ExposureBiasValue;	 // Exposure bias value in EV
-	double SubjectDistance;		  // Distance to focus point in meters
-	double FocalLength;		  // Focal length of lens in millimeters
-	unsigned short FocalLengthIn35mm; // Focal length in 35mm film
-	char Flash;			  // 0 = no flash, 1 = flash used
-	unsigned short MeteringMode;      // Metering mode
-					  // 1: average
-					  // 2: center weighted average
-					  // 3: spot
-					  // 4: multi-spot
-					  // 5: multi-segment
-	unsigned ImageWidth;		  // Image width reported in EXIF data
-	unsigned ImageHeight;		  // Image height reported in EXIF data
-	struct Geolocation_t
-	{			  // GPS information embedded in file
-		double Latitude;  // Image latitude expressed as decimal
-		double Longitude; // Image longitude expressed as decimal
-		double Altitude;  // Altitude in meters, relative to sea level
-		char AltitudeRef; // 0 = above sea level, -1 = below sea level
-		struct Coord_t {
-			double degrees;
-			double minutes;
-			double seconds;
-			char direction;
-		} LatComponents, LonComponents; // Latitude, Longitude expressed in deg/min/sec
-	} GeoLocation;
-	EXIFInfo()
-	{
-		clear();
-	}
-
-	time_t epoch();
+ public:
+  // Parsing function for an entire JPEG image buffer.
+  //
+  // PARAM 'data': A pointer to a JPEG image.
+  // PARAM 'length': The length of the JPEG image.
+  // RETURN:  PARSE_EXIF_SUCCESS (0) on succes with 'result' filled out
+  //          error code otherwise, as defined by the PARSE_EXIF_ERROR_* macros
+  int parseFrom(const unsigned char *data, unsigned length);
+  int parseFrom(const std::string &data);
+
+  // Parsing function for an EXIF segment. This is used internally by parseFrom()
+  // but can be called for special cases where only the EXIF section is
+  // available (i.e., a blob starting with the bytes "Exif\0\0").
+  int parseFromEXIFSegment(const unsigned char *buf, unsigned len);
+
+  // Set all data members to default values.
+  void clear();
+
+  // Data fields filled out by parseFrom()
+  char ByteAlign;                   // 0 = Motorola byte alignment, 1 = Intel
+  std::string ImageDescription;     // Image description
+  std::string Make;                 // Camera manufacturer's name
+  std::string Model;                // Camera model
+  unsigned short Orientation;       // Image orientation, start of data corresponds to
+                                    // 0: unspecified in EXIF data
+                                    // 1: upper left of image
+                                    // 3: lower right of image
+                                    // 6: upper right of image
+                                    // 8: lower left of image
+                                    // 9: undefined
+  unsigned short BitsPerSample;     // Number of bits per component
+  std::string Software;             // Software used
+  std::string DateTime;             // File change date and time
+  std::string DateTimeOriginal;     // Original file date and time (may not exist)
+  std::string DateTimeDigitized;    // Digitization date and time (may not exist)
+  std::string SubSecTimeOriginal;   // Sub-second time that original picture was taken
+  std::string Copyright;            // File copyright information
+  double ExposureTime;              // Exposure time in seconds
+  double FNumber;                   // F/stop
+  unsigned short ISOSpeedRatings;   // ISO speed
+  double ShutterSpeedValue;         // Shutter speed (reciprocal of exposure time)
+  double ExposureBiasValue;         // Exposure bias value in EV
+  double SubjectDistance;           // Distance to focus point in meters
+  double FocalLength;               // Focal length of lens in millimeters
+  unsigned short FocalLengthIn35mm; // Focal length in 35mm film
+  char Flash;                       // 0 = no flash, 1 = flash used
+  unsigned short MeteringMode;      // Metering mode
+                                    // 1: average
+                                    // 2: center weighted average
+                                    // 3: spot
+                                    // 4: multi-spot
+                                    // 5: multi-segment
+  unsigned ImageWidth;              // Image width reported in EXIF data
+  unsigned ImageHeight;             // Image height reported in EXIF data
+  struct Geolocation_t {            // GPS information embedded in file
+    double Latitude;                  // Image latitude expressed as decimal
+    double Longitude;                 // Image longitude expressed as decimal
+    double Altitude;                  // Altitude in meters, relative to sea level
+    char AltitudeRef;                 // 0 = above sea level, -1 = below sea level
+    double DOP;                       // GPS degree of precision (DOP)
+    struct Coord_t {
+      double degrees;
+      double minutes;
+      double seconds;
+      char direction;
+    } LatComponents, LonComponents;   // Latitude, Longitude expressed in deg/min/sec
+  } GeoLocation;
+  struct LensInfo_t {               // Lens information
+    double FStopMin;                // Min aperture (f-stop)
+    double FStopMax;                // Max aperture (f-stop)
+    double FocalLengthMin;          // Min focal length (mm)
+    double FocalLengthMax;          // Max focal length (mm)
+    double FocalPlaneXResolution;   // Focal plane X-resolution
+    double FocalPlaneYResolution;   // Focal plane Y-resolution
+    std::string Make;               // Lens manufacturer
+    std::string Model;              // Lens model
+  } LensInfo;
+
+
+  EXIFInfo() {
+    clear();
+  }
+  time_t epoch();
 };
 
+}
+
 // Parse was successful
-#define PARSE_EXIF_SUCCESS 0
+#define PARSE_EXIF_SUCCESS                    0
 // No JPEG markers found in buffer, possibly invalid JPEG file
-#define PARSE_EXIF_ERROR_NO_JPEG 1982
+#define PARSE_EXIF_ERROR_NO_JPEG              1982
 // No EXIF header found in JPEG file.
-#define PARSE_EXIF_ERROR_NO_EXIF 1983
+#define PARSE_EXIF_ERROR_NO_EXIF              1983
 // Byte alignment specified in EXIF file was unknown (not Motorola or Intel).
-#define PARSE_EXIF_ERROR_UNKNOWN_BYTEALIGN 1984
+#define PARSE_EXIF_ERROR_UNKNOWN_BYTEALIGN    1984
 // EXIF header was found, but data was corrupted.
-#define PARSE_EXIF_ERROR_CORRUPT 1985
+#define PARSE_EXIF_ERROR_CORRUPT              1985
 
-#endif // EXIF_H
+#endif
diff --git a/core/qthelper.cpp b/core/qthelper.cpp
index f9e504ece..39461c7eb 100644
--- a/core/qthelper.cpp
+++ b/core/qthelper.cpp
@@ -354,7 +354,7 @@ extern "C" xsltStylesheetPtr get_stylesheet(const char *name)
 
 extern "C" timestamp_t picture_get_timestamp(char *filename)
 {
-	EXIFInfo exif;
+	easyexif::EXIFInfo exif;
 	memblock mem;
 	int retval;
 
@@ -1211,7 +1211,7 @@ extern "C" void savePictureLocal(struct picture *picture, const char *data, int
 
 extern "C" void picture_load_exif_data(struct picture *p)
 {
-	EXIFInfo exif;
+	easyexif::EXIFInfo exif;
 	memblock mem;
 
 	if (readfile(localFilePath(QString(p->filename)).toUtf8().data(), &mem) <= 0)