Initial repository for piex am: d252584de7 am: 92d4dd9261

Original change: https://android-review.googlesource.com/c/platform/external/piex/+/2224357

Change-Id: I7f96940f03366837ba14b7cac1b7a6789a5813a0
Signed-off-by: Automerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>

20 files changed, 0 insertions, 5442 deletions

diff --git a/LICENSE b/LICENSE
deleted file mode 100644
index 7a4a3ea..0000000
--- a/LICENSE
+++ /dev/null
@@ -1,202 +0,0 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
\ No newline at end of file
diff --git a/OWNERS b/OWNERS
deleted file mode 100644
index 8743fba..0000000
--- a/OWNERS
+++ /dev/null
@@ -1,2 +0,0 @@
-chongsu@google.com
-nchusid@google.com
diff --git a/README b/README
deleted file mode 100644
index b838fdf..0000000
--- a/README
+++ /dev/null
@@ -1,2 +0,0 @@
-The Preview Image Extractor (PIEX) is designed to find and extract the largest
-JPEG compressed preview image contained in a RAW file.
\ No newline at end of file
diff --git a/internal_include_do_not_delete.gypi b/internal_include_do_not_delete.gypi
deleted file mode 100755
index 91995b8..0000000
--- a/internal_include_do_not_delete.gypi
+++ /dev/null
@@ -1,2 +0,0 @@
-# Do NOT touch the file.
-{}
diff --git a/piex.gyp b/piex.gyp
deleted file mode 100755
index 15741dc..0000000
--- a/piex.gyp
+++ /dev/null
@@ -1,95 +0,0 @@
-# Copyright 2015 Google Inc. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-{
-'includes': ['internal_include_do_not_delete.gypi'],
-'targets': [{
-  'target_name': 'piex',
-  'type': 'static_library',
-  'sources': [
-    'src/piex.cc',
-    'src/piex_cr3.cc',
-    'src/tiff_parser.cc',
-  ],
-  'variables': {
-    'headers': [
-      'src/piex.h',
-      'src/piex_cr3.h',
-      'src/piex_types.h',
-      'src/tiff_parser.h',
-    ],
-  },
-  'include_dirs': ['.'],
-  'cflags': [
-    '-Wsign-compare',
-    '-Wsign-conversion',
-    '-Wunused-parameter',
-  ],
-  'dependencies': [
-    'binary_parse',
-    'image_type_recognition',
-    'tiff_directory',
-  ],
-}, {
-  'target_name': 'binary_parse',
-  'type': 'static_library',
-  'sources': [
-      'src/binary_parse/cached_paged_byte_array.cc',
-      'src/binary_parse/range_checked_byte_ptr.cc',
-  ],
-  'variables': {
-    'headers': [
-      'src/binary_parse/cached_paged_byte_array.h',
-      'src/binary_parse/range_checked_byte_ptr.h',
-    ],
-  },
-  'include_dirs': ['.'],
-  'cflags': [
-    '-Wsign-compare',
-    '-Wsign-conversion',
-    '-Wunused-parameter',
-  ],
-}, {
-  'target_name': 'image_type_recognition',
-  'type': 'static_library',
-  'sources': [
-    'src/image_type_recognition/image_type_recognition_lite.cc',
-  ],
-  'variables': {
-    'headers': ['src/image_type_recognition/image_type_recognition_lite.h'],
-  },
-  'include_dirs': ['.'],
-  'cflags': [
-    '-Wsign-compare',
-    '-Wsign-conversion',
-    '-Wunused-parameter',
-  ],
-  'dependencies': ['binary_parse'],
-}, {
-  'target_name': 'tiff_directory',
-  'type': 'static_library',
-  'cflags': [
-    '-Wsign-compare',
-    '-Wsign-conversion',
-    '-Wunused-parameter',
-  ],
-  'sources': [
-    'src/tiff_directory/tiff_directory.cc',
-  ],
-  'variables': {
-    'headers': ['src/tiff_directory/tiff_directory.h'],
-  },
-  'include_dirs': ['.'],
-  'dependencies': ['binary_parse'],
-}],
-}
diff --git a/src/binary_parse/cached_paged_byte_array.cc b/src/binary_parse/cached_paged_byte_array.cc
deleted file mode 100644
index 83b6c03..0000000
--- a/src/binary_parse/cached_paged_byte_array.cc
+++ /dev/null
@@ -1,79 +0,0 @@
-// Copyright 2015 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-////////////////////////////////////////////////////////////////////////////////
-//
-// The cache layer works as follows:
-// The cache is implemented as a vector (of size 'cache_size') of shared
-// pointers to pages recently used. The least recently used page is stored
-// at the begining of the vector, the most recent at the end.
-
-#include "src/binary_parse/cached_paged_byte_array.h"
-
-#include <cstddef>
-
-namespace piex {
-namespace binary_parse {
-
-CachedPagedByteArray::CachedPagedByteArray(
-    const PagedByteArray* paged_byte_array, size_t cache_size)
-    : paged_byte_array_(paged_byte_array), cache_size_(cache_size) {}
-
-void CachedPagedByteArray::getPage(size_t page_index,
-                                   const unsigned char** begin,
-                                   const unsigned char** end,
-                                   PagedByteArray::PagePtr* page) const {
-  std::lock_guard<std::mutex> lock(mutex_);
-  size_t cache_index;
-  if (getFromCache(page_index, &cache_index)) {
-    // Cache hit, retrieve the page from the cache.
-    *begin = cached_pages_[cache_index].begin;
-    *end = cached_pages_[cache_index].end;
-    *page = cached_pages_[cache_index].page;
-
-    // Remove the page to insert it at the end of the cache later.
-    cached_pages_.erase(cached_pages_.begin() +
-                        static_cast<std::ptrdiff_t>(cache_index));
-  } else {
-    // Cache miss, ask PagedByteArray to load the page.
-    paged_byte_array_->getPage(page_index, begin, end, page);
-
-    // If the cache is full, remove the first (least recently used) page.
-    if (cached_pages_.size() >= cache_size_) {
-      cached_pages_.erase(cached_pages_.begin());
-    }
-  }
-
-  // Cache the most recently used page to the end of the vector.
-  CachedPage cache_page;
-  cache_page.index = page_index;
-  cache_page.page = *page;
-  cache_page.begin = *begin;
-  cache_page.end = *end;
-  cached_pages_.push_back(cache_page);
-}
-
-bool CachedPagedByteArray::getFromCache(size_t page_index,
-                                        size_t* cache_index) const {
-  for (size_t i = 0; i < cached_pages_.size(); ++i) {
-    if (cached_pages_[i].index == page_index) {
-      *cache_index = i;
-      return true;
-    }
-  }
-  return false;
-}
-
-}  // namespace binary_parse
-}  // namespace piex
diff --git a/src/binary_parse/cached_paged_byte_array.h b/src/binary_parse/cached_paged_byte_array.h
deleted file mode 100644
index 26f0eae..0000000
--- a/src/binary_parse/cached_paged_byte_array.h
+++ /dev/null
@@ -1,73 +0,0 @@
-// Copyright 2015 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-////////////////////////////////////////////////////////////////////////////////
-//
-// LRU cache decorator for binary_parse::PagedByteArray subclasses.
-
-#ifndef PIEX_BINARY_PARSE_CACHED_PAGED_BYTE_ARRAY_H_
-#define PIEX_BINARY_PARSE_CACHED_PAGED_BYTE_ARRAY_H_
-
-#include <mutex>
-#include <vector>
-
-#if !defined(WIN32_LEAN_AND_MEAN)
-#define WIN32_LEAN_AND_MEAN
-#endif
-#include "src/binary_parse/range_checked_byte_ptr.h"
-
-namespace piex {
-namespace binary_parse {
-
-class CachedPagedByteArray : public PagedByteArray {
- public:
-  // Decorates 'paged_byte_array' with a LRU cache layer of the size
-  // 'cache_size'.
-  explicit CachedPagedByteArray(const PagedByteArray* paged_byte_array,
-                                size_t cache_size);
-
-  virtual size_t length() const { return paged_byte_array_->length(); }
-
-  virtual size_t pageSize() const { return paged_byte_array_->pageSize(); }
-
-  virtual void getPage(size_t page_index, const unsigned char** begin,
-                       const unsigned char** end,
-                       PagedByteArray::PagePtr* page) const;
-
- private:
-  struct CachedPage {
-    size_t index;
-    PagedByteArray::PagePtr page;
-    const unsigned char* begin;
-    const unsigned char* end;
-  };
-
-  // Disallow copy construction and assignment.
-  CachedPagedByteArray(const CachedPagedByteArray&);
-  void operator=(const CachedPagedByteArray&);
-
-  // Gets the index of the page if it is in the cache and returns true, else
-  // returns false.
-  bool getFromCache(size_t page_index, size_t* cache_index) const;
-
-  mutable std::mutex mutex_;
-  const PagedByteArray* paged_byte_array_;
-  const size_t cache_size_;
-  mutable std::vector<CachedPage> cached_pages_;
-};
-
-}  // namespace binary_parse
-}  // namespace piex
-
-#endif  // PIEX_BINARY_PARSE_CACHED_PAGED_BYTE_ARRAY_H_
diff --git a/src/binary_parse/range_checked_byte_ptr.cc b/src/binary_parse/range_checked_byte_ptr.cc
deleted file mode 100644
index bbfdee2..0000000
--- a/src/binary_parse/range_checked_byte_ptr.cc
+++ /dev/null
@@ -1,402 +0,0 @@
-// Copyright 2015 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#include "src/binary_parse/range_checked_byte_ptr.h"
-
-#include <assert.h>
-#include <cstddef>
-#include <cstring>
-
-namespace piex {
-namespace binary_parse {
-
-#ifdef BREAK_IF_DEBUGGING_AND_OUT_OF_RANGE
-#define BREAK_IF_DEBUGGING() assert(false)
-#else
-#define BREAK_IF_DEBUGGING() assert(true)
-#endif
-
-namespace {
-class MemoryPagedByteArray : public PagedByteArray {
- public:
-  MemoryPagedByteArray(const unsigned char *buffer, const size_t len);
-
-  virtual size_t length() const;
-  virtual size_t pageSize() const;
-  virtual void getPage(size_t page_index, const unsigned char **begin,
-                       const unsigned char **end, PagePtr *page) const;
-
- private:
-  const unsigned char *buffer_;
-  const size_t len_;
-};
-
-MemoryPagedByteArray::MemoryPagedByteArray(const unsigned char *buffer,
-                                           const size_t len)
-    : buffer_(buffer), len_(len) {}
-
-size_t MemoryPagedByteArray::length() const { return len_; }
-
-size_t MemoryPagedByteArray::pageSize() const { return len_; }
-
-void MemoryPagedByteArray::getPage(size_t /* page_index */,
-                                   const unsigned char **begin,
-                                   const unsigned char **end,
-                                   PagePtr *page) const {
-  *begin = buffer_;
-  *end = buffer_ + len_;
-  *page = PagePtr();
-}
-
-// A functor that does nothing. This is used as a no-op shared pointer
-// deallocator below.
-class NullFunctor {
- public:
-  void operator()() {}
-  void operator()(PagedByteArray * /* p */) const {}
-};
-}  // namespace
-
-PagedByteArray::~PagedByteArray() {}
-
-RangeCheckedBytePtr::RangeCheckedBytePtr()
-    : array_(),
-      page_data_(NULL),
-      current_pos_(0),
-      sub_array_begin_(0),
-      sub_array_end_(0),
-      page_begin_offset_(0),
-      current_page_len_(0),
-      error_flag_(RANGE_CHECKED_BYTE_ERROR) {}
-
-RangeCheckedBytePtr::RangeCheckedBytePtr(const unsigned char *array,
-                                         const size_t len)
-    : array_(new MemoryPagedByteArray(array, len)),
-      page_data_(NULL),
-      current_pos_(0),
-      sub_array_begin_(0),
-      sub_array_end_(len),
-      page_begin_offset_(0),
-      current_page_len_(0),
-      error_flag_(RANGE_CHECKED_BYTE_SUCCESS) {
-  assert(array);
-  if (array == NULL) {
-    error_flag_ = RANGE_CHECKED_BYTE_ERROR;
-  }
-}
-
-RangeCheckedBytePtr::RangeCheckedBytePtr(PagedByteArray *array)
-    : array_(array, NullFunctor()),
-      page_data_(NULL),
-      current_pos_(0),
-      sub_array_begin_(0),
-      sub_array_end_(array->length()),
-      page_begin_offset_(0),
-      current_page_len_(0),
-      error_flag_(RANGE_CHECKED_BYTE_SUCCESS) {}
-
-RangeCheckedBytePtr RangeCheckedBytePtr::invalidPointer() {
-  return RangeCheckedBytePtr();
-}
-
-RangeCheckedBytePtr RangeCheckedBytePtr::pointerToSubArray(
-    size_t pos, size_t length) const {
-  RangeCheckedBytePtr sub_result = (*this) + pos;
-  if (!sub_result.errorOccurred() && length <= sub_result.remainingLength()) {
-    sub_result.sub_array_begin_ = sub_result.current_pos_;
-    sub_result.sub_array_end_ = sub_result.sub_array_begin_ + length;
-
-    // Restrict the boundaries of the current page to the newly set sub-array.
-    sub_result.restrictPageToSubArray();
-
-    return sub_result;
-  } else {
-    error_flag_ = RANGE_CHECKED_BYTE_ERROR;
-    return invalidPointer();
-  }
-}
-
-size_t RangeCheckedBytePtr::offsetInArray() const {
-  // sub_array_begin_ <= current_pos_ is a class invariant, but protect
-  // against violations of this invariant.
-  if (sub_array_begin_ <= current_pos_) {
-    return current_pos_ - sub_array_begin_;
-  } else {
-    assert(false);
-    return 0;
-  }
-}
-
-std::string RangeCheckedBytePtr::substr(size_t pos, size_t length) const {
-  std::vector<unsigned char> bytes = extractBytes(pos, length);
-  std::string result;
-  result.reserve(bytes.size());
-  for (size_t i = 0; i < bytes.size(); ++i) {
-    result.push_back(static_cast<char>(bytes[i]));
-  }
-  return result;
-}
-
-std::vector<unsigned char> RangeCheckedBytePtr::extractBytes(
-    size_t pos, size_t length) const {
-  std::vector<unsigned char> result;
-  if (pos + length < pos /* overflow */ || remainingLength() < pos + length) {
-    BREAK_IF_DEBUGGING();
-    error_flag_ = RANGE_CHECKED_BYTE_ERROR_OVERFLOW;
-    return result;
-  }
-  result.reserve(length);
-  for (size_t i = 0; i < length; ++i) {
-    result.push_back((*this)[pos + i]);
-  }
-  return result;
-}
-
-bool operator==(const RangeCheckedBytePtr &x, const RangeCheckedBytePtr &y) {
-  if (x.array_ != y.array_) {
-    assert(false);
-    return false;
-  }
-
-  return x.current_pos_ == y.current_pos_;
-}
-
-bool operator!=(const RangeCheckedBytePtr &x, const RangeCheckedBytePtr &y) {
-  return !(x == y);
-}
-
-void RangeCheckedBytePtr::loadPageForOffset(size_t offset) const {
-  // The offset should always lie within the bounds of the sub-array (this
-  // condition is enforced at the callsite). However, even if the offset lies
-  // outside the sub-array, the restrictPageToSubArray() call at the end
-  // ensures that the object is left in a consistent state that maintains the
-  // class invariants.
-  assert(offset >= sub_array_begin_ && offset < sub_array_end_);
-
-  // Ensure that offset lies within the array.
-  if (offset >= array_->length()) {
-    assert(false);
-    return;
-  }
-
-  // Determine the index of the page to request.
-  size_t page_index = offset / array_->pageSize();
-
-  // Get the page.
-  const unsigned char *page_begin;
-  const unsigned char *page_end;
-  array_->getPage(page_index, &page_begin, &page_end, &page_);
-
-  // Ensure that the page has the expected length (as specified in the
-  // PagedByteArray interface).
-  size_t expected_page_size = array_->pageSize();
-  if (page_index == (array_->length() - 1) / array_->pageSize()) {
-    expected_page_size = array_->length() - array_->pageSize() * page_index;
-  }
-  if ((page_end < page_begin) ||
-      (static_cast<size_t>(page_end - page_begin) != expected_page_size)) {
-    assert(false);
-    return;
-  }
-
-  // Remember information about page.
-  page_data_ = page_begin;
-  page_begin_offset_ = page_index * array_->pageSize();
-  current_page_len_ = static_cast<size_t>(page_end - page_begin);
-
-  // Restrict the boundaries of the page to lie within the sub-array.
-  restrictPageToSubArray();
-}
-
-void RangeCheckedBytePtr::restrictPageToSubArray() const {
-  // Restrict the current page's boundaries so that it is always contained
-  // completely within the extent of the sub-array.
-  // This function is purposely designed to work correctly in the following
-  // two special cases:
-  // a) The current page lies entirely outside the sub-array. In this case,
-  //    current_page_len_ will be set to zero. page_data_ may either remain
-  //    unchanged or may be changed to point one element beyond the end of the
-  //    page, depending on whether the current page lies before or after the
-  //    sub-array.
-  // b) The current page is in the state as initialized by the constructor
-  //    (i.e. page_data_ is NULL and current_page_len_ is zero). In this case,
-  //    page_data_ and current_page_len_ will remain unchanged.
-
-  // Does the beginning of the page lie before the beginning of the sub-array?
-  if (page_begin_offset_ < sub_array_begin_) {
-    // Compute amount by which to shorten page.
-    size_t amount_to_shorten = sub_array_begin_ - page_begin_offset_;
-    if (amount_to_shorten > current_page_len_) {
-      amount_to_shorten = current_page_len_;
-    }
-
-    // Adjust beginning of page accordingly.
-    page_begin_offset_ += amount_to_shorten;
-    page_data_ += amount_to_shorten;
-    current_page_len_ -= amount_to_shorten;
-  }
-
-  // Does the end of the page lie beyond the end of the sub-array?
-  if (page_begin_offset_ + current_page_len_ > sub_array_end_) {
-    // Reduce length of page accordingly.
-    size_t new_len = sub_array_end_ - page_begin_offset_;
-    if (new_len > current_page_len_) {
-      new_len = current_page_len_;
-    }
-    current_page_len_ = new_len;
-  }
-}
-
-int memcmp(const RangeCheckedBytePtr &x, const RangeCheckedBytePtr &y,
-           size_t num) {
-  std::vector<unsigned char> x_vec = x.extractBytes(0, num);
-  std::vector<unsigned char> y_vec = y.extractBytes(0, num);
-
-  if (!x.errorOccurred() && !y.errorOccurred()) {
-    return ::memcmp(&x_vec[0], &y_vec[0], num);
-  } else {
-    // return an arbitrary value
-    return -1;
-  }
-}
-
-int strcmp(const RangeCheckedBytePtr &x, const std::string &y) {
-  std::vector<unsigned char> x_vec = x.extractBytes(0, y.length());
-
-  if (!x.errorOccurred()) {
-    return ::memcmp(&x_vec[0], y.c_str(), y.length());
-  } else {
-    // return an arbitrary value
-    return -1;
-  }
-}
-
-size_t strlen(const RangeCheckedBytePtr &src) {
-  size_t len = 0;
-  RangeCheckedBytePtr str = src;
-  while (!str.errorOccurred() && (str[0] != '\0')) {
-    str++;
-    len++;
-  }
-  return len;
-}
-
-int16 Get16s(const RangeCheckedBytePtr &input, const bool big_endian,
-             MemoryStatus *status) {
-  const uint16 unsigned_value = Get16u(input, big_endian, status);
-  if (*status != RANGE_CHECKED_BYTE_SUCCESS) {
-    // Return an arbitrary value.
-    return 0;
-  }
-
-  // Convert the two's-complement signed integer encoded in 'unsigned_value'
-  // into a signed representation in the implementation's native representation
-  // for signed integers. An optimized Blaze build (x64) compiles all of the
-  // following code to a no-op (as of this writing).
-  // For further details, see the corresponding comment in Get32s().
-  if (unsigned_value == 0x8000u) {
-    return static_cast<int16>(-0x8000);
-  } else if (unsigned_value > 0x8000u) {
-    return -static_cast<int16>(0x10000u - unsigned_value);
-  } else {
-    return static_cast<int16>(unsigned_value);
-  }
-}
-
-uint16 Get16u(const RangeCheckedBytePtr &input, const bool big_endian,
-              MemoryStatus *status) {
-  if (input.remainingLength() < 2) {
-    if (status && *status == RANGE_CHECKED_BYTE_SUCCESS) {
-      *status = RANGE_CHECKED_BYTE_ERROR;
-    }
-    // Return an arbitrary value.
-    return 0;
-  }
-  if (big_endian) {
-    return (static_cast<uint16>(input[0]) << 8) | static_cast<uint16>(input[1]);
-  } else {
-    return (static_cast<uint16>(input[1]) << 8) | static_cast<uint16>(input[0]);
-  }
-}
-
-int32 Get32s(const RangeCheckedBytePtr &input, const bool big_endian,
-             MemoryStatus *status) {
-  const uint32 unsigned_value = Get32u(input, big_endian, status);
-  if (*status != RANGE_CHECKED_BYTE_SUCCESS) {
-    // Return an arbitrary value.
-    return 0;
-  }
-
-  // Convert the two's-complement signed integer encoded in 'unsigned_value'
-  // into a signed representation in the implementation's native representation
-  // for signed integers.
-  // For all practical purposes, the same result could be obtained simply by
-  // casting unsigned_value to int32; the result of this is
-  // implementation-defined, but on all of the platforms we care about, it does
-  // what we want.
-  // The code below, however, arguably has the aesthetic advantage of being
-  // independent of the representation for signed integers chosen by the
-  // implementation, as long as 'int' and 'unsigned' have the required range to
-  // represent all of the required values.
-  // An optimized Blaze build (x64) compiles all of the following code to a
-  // no-op (as of this writing); i.e. the value that Get32u() returned in %eax
-  // is left unchanged.
-  if (unsigned_value == 0x80000000u) {
-    // Read here on why the constant expression is written this way:
-    // http://stackoverflow.com/questions/14695118
-    return -0x7fffffff - 1;
-  } else if (unsigned_value > 0x80000000u) {
-    // The expression
-    //   0xffffffffu - unsigned_value + 1
-    // is a portable way of flipping the sign of a twos-complement signed
-    // integer whose binary representation is stored in an unsigned integer.
-    // '0xffffffffu + 1' is used in preference to simply '0' because it makes
-    // it clearer that the correct result will be obtained even if an int is
-    // greater than 32 bits. The '0xffffffffu + 1' is "spread out" around
-    // 'unsigned_value' to prevent the compiler from warning about an
-    // integral constant overflow. ('0' would produce the correct result in
-    // this case too but would rely in a more subtle way on the rules for
-    // unsigned wraparound.)
-    return -static_cast<int32>(0xffffffffu - unsigned_value + 1);
-  } else {
-    return static_cast<int32>(unsigned_value);
-  }
-}
-
-uint32 Get32u(const RangeCheckedBytePtr &input, const bool big_endian,
-              MemoryStatus *status) {
-  if (input.remainingLength() < 4) {
-    if (status && *status == RANGE_CHECKED_BYTE_SUCCESS) {
-      *status = RANGE_CHECKED_BYTE_ERROR;
-    }
-    // Return an arbitrary value.
-    return 0;
-  }
-  if (big_endian) {
-    return (static_cast<uint32>(input[0]) << 24) |
-           (static_cast<uint32>(input[1]) << 16) |
-           (static_cast<uint32>(input[2]) << 8) |
-           (static_cast<uint32>(input[3]) << 0);
-  } else {
-    return (static_cast<uint32>(input[3]) << 24) |
-           (static_cast<uint32>(input[2]) << 16) |
-           (static_cast<uint32>(input[1]) << 8) |
-           (static_cast<uint32>(input[0]) << 0);
-  }
-}
-
-}  // namespace binary_parse
-}  // namespace piex
diff --git a/src/binary_parse/range_checked_byte_ptr.h b/src/binary_parse/range_checked_byte_ptr.h
deleted file mode 100644
index a0eadbb..0000000
--- a/src/binary_parse/range_checked_byte_ptr.h
+++ /dev/null
@@ -1,609 +0,0 @@
-// Copyright 2015 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#ifndef PIEX_BINARY_PARSE_RANGE_CHECKED_BYTE_PTR_H_
-#define PIEX_BINARY_PARSE_RANGE_CHECKED_BYTE_PTR_H_
-
-#include <assert.h>
-
-#include <cstddef>
-#include <memory>
-#include <string>
-#include <vector>
-
-namespace piex {
-namespace binary_parse {
-
-// Since NaCl does not comply to C++11 we can not just use stdint.h.
-typedef unsigned short uint16;  // NOLINT
-typedef short int16;            // NOLINT
-typedef unsigned int uint32;
-typedef int int32;
-
-enum MemoryStatus {
-  RANGE_CHECKED_BYTE_SUCCESS = 0,
-  RANGE_CHECKED_BYTE_ERROR = 1,
-  RANGE_CHECKED_BYTE_ERROR_OVERFLOW = 2,
-  RANGE_CHECKED_BYTE_ERROR_UNDERFLOW = 3,
-};
-
-// Interface that RangeCheckedBytePtr uses to access the underlying array of
-// bytes. This allows RangeCheckedBytePtr to be used to access data as if it
-// were stored contiguously in memory, even if the data is in fact split up
-// into non-contiguous chunks and / or does not reside in memory.
-//
-// The only requirement is that the data can be read in pages of a fixed (but
-// configurable) size. Notionally, the byte array (which contains length()
-// bytes) is split up into non-overlapping pages of pageSize() bytes each.
-// (The last page may be shorter if length() is not a multiple of pageSize().)
-// There are therefore (length() - 1) / pageSize() + 1 such pages, with indexes
-// 0 through (length() - 1) / pageSize(). Page i contains the bytes from offset
-// i * pageSize() in the array up to and including the byte at offset
-// (i + 1) * pageSize() - 1 (or, in the case of the last page, length() - 1).
-//
-// In essence, RangeCheckedBytePtr and PagedByteArray together provide a poor
-// man's virtual-memory-and-memory-mapped-file work-alike in situations where
-// virtual memory cannot be used or would consume too much virtual address
-// space.
-//
-// Thread safety: In general, subclasses implementing this interface should
-// ensure that the member functions are thread-safe. It will then be safe to
-// access the same array from multiple threads. (Note that RangeCheckedBytePtr
-// itself is not thread-safe in the sense that a single instance of
-// RangeCheckedBytePtr cannot be used concurrently from multiple threads; it
-// is, however, safe to use different RangeCheckedBytePtr instances in
-// different threads to access the same PagedByteArray concurrently, assuming
-// that the PagedByteArray implementation is thread-safe.)
-class PagedByteArray {
- public:
-  // Base class for pages in the byte array. Implementations of PagedByteArray
-  // can create a subclass of the Page class to manage the lifetime of buffers
-  // associated with a page returned by getPage(). For example, a
-  // PagedByteArray backed by a file might define a Page subclass like this:
-  //
-  //  class FilePage : public Page {
-  //    std::vector<unsigned char> bytes;
-  //  };
-  //
-  // The corresponding getPage() implementation could then look like this:
-  //
-  //   void getPage(size_t page_index, const unsigned char** begin,
-  //       const unsigned char** end, std::shared_ptr<Page>* page)
-  //       {
-  //     // Create a new page.
-  //     std::shared_ptr<FilePage> file_page(new FilePage());
-  //
-  //     // Read contents of page from file into file_page->bytes.
-  //     [...]
-  //
-  //     // Set *begin and *end to point to beginning and end of
-  //     // file_page->bytes vector.
-  //     *begin = &file_page->bytes[0];
-  //     *end = *begin + file_page->bytes.size();
-  //
-  //     // Return page to caller
-  //     *page = file_page;
-  //   }
-  //
-  // In this way, the storage associated with the page (the FilePage::bytes
-  // vector) will be kept alive until the RangeCheckedBytePtr releases the
-  // shared pointer.
-  class Page {};
-
-  typedef std::shared_ptr<Page> PagePtr;
-
-  virtual ~PagedByteArray();
-
-  // Returns the length of the array in bytes. The value returned must remain
-  // the same on every call for the entire lifetime of the object.
-  virtual size_t length() const = 0;
-
-  // Returns the length of each page in bytes. (The last page may be shorter
-  // than pageSize() if length() is not a multiple of pageSize() -- see also
-  // the class-wide comment above.) The value returned must remain the same on
-  // every call for the entire lifetime of the object.
-  virtual size_t pageSize() const = 0;
-
-  // Returns a pointer to a memory buffer containing the data for the page
-  // with index "page_index".
-  //
-  // *begin is set to point to the first byte of the page; *end is set to point
-  // one byte beyond the last byte in the page. This implies that:
-  // - (*end - *begin) == pageSize() for every page except the last page
-  // - (*end - *begin) == length() - pageSize() * ((length() - 1) / pageSize())
-  //   for the last page
-  //
-  // *page will be set to a SharedPtr that the caller will hold on to until
-  // it no longer needs to access the memory buffer. The memory buffer will
-  // remain valid until the SharedPtr is released or the PagedByteArray object
-  // is destroyed. An implementation may choose to return a null SharedPtr;
-  // this indicates that the memory buffer will remain valid until the
-  // PagedByteArray object is destroyed, even if the caller does not hold on to
-  // the SharedPtr. (This is intended as an optimization that some
-  // implementations may choose to take advantage of, as a null SharedPtr is
-  // cheaper to copy.)
-  virtual void getPage(size_t page_index, const unsigned char **begin,
-                       const unsigned char **end, PagePtr *page) const = 0;
-};
-
-typedef std::shared_ptr<PagedByteArray> PagedByteArrayPtr;
-
-// Smart pointer that has the same semantics as a "const unsigned char *" (plus
-// some convenience functions) but provides range checking and the ability to
-// access arrays that are not contiguous in memory or do not reside entirely in
-// memory (through the PagedByteArray interface).
-//
-// In the following, we abbreviate RangeCheckedBytePtr as RCBP.
-//
-// The intent of this class is to allow easy security hardening of code that
-// parses binary data structures using raw byte pointers. To do this, only the
-// declarations of the pointers need to be changed; the code that uses the
-// pointers can remain unchanged.
-//
-// If an illegal operation occurs on a pointer, an error flag is set, and all
-// read operations from this point on return 0. This means that error checking
-// need not be done after every access; it is sufficient to check the error flag
-// (using errorOccurred()) once before the RCBP is destroyed. Again, this allows
-// the majority of the parsing code to remain unchanged. (Note caveats below
-// that apply if a copy of the pointer is created.)
-//
-// Legal operations are exactly the ones that would be legal on a raw C++
-// pointer. Read accesses are legal if they fall within the underlying array. A
-// RCBP may point to any element in the underlying array or one element beyond
-// the end of the array.
-//
-// For brevity, the documentation for individual member functions does not state
-// explicitly that the error flag will be set on out-of-range operations.
-//
-// Note:
-//
-// - Just as for raw pointers, it is legal for a pointer to point one element
-//   beyond the end of the array, but it is illegal to use operator*() on such a
-//   pointer.
-//
-// - If a copy of an RCBP is created, then performing illegal operations on the
-//   copy affects the error flag of the copy, but not of the original pointer.
-//   Note that using operator+ and operator- also creates a copy of the pointer.
-//   For example:
-//
-//     // Assume we have an RCBP called "p" and a size_t variable called
-//     // "offset".
-//     RangeCheckedBytePtr sub_data_structure = p + offset;
-//
-//   If "offset" is large enough to cause an out-of-range access, then
-//   sub_data_structure.errorOccurred() will be true, but p.errorOccurred() will
-//   still be false. The error flag for sub_data_structure therefore needs to be
-//   checked before it is destroyed.
-class RangeCheckedBytePtr {
- private:
-  // This class maintains the following class invariants:
-  // - page_data_ always points to a buffer of at least current_page_len_
-  //   bytes.
-  //
-  // - The current position lies within the sub-array, i.e.
-  //   sub_array_begin_ <= current_pos_ <= sub_array_end_
-  //
-  // - The sub-array is entirely contained within the array, i.e.
-  //   0 <= sub_array_begin <= sub_array_end <= array_->length()
-  //
-  // - If the current page is non-empty, it lies completely within the
-  //   sub-array, i.e.
-  //   if _current_page_len_ >= 0, then
-  //   sub_array_begin_ <= page_begin_offset_
-  //   and
-  //   page_begin_offset_ + current_page_len_ <= sub_array_end_
-  //   (See also restrictPageToSubArray().)
-  //   (If _current_page_len_ == 0, then page_begin_offset_ may lie outside
-  //   the sub-array; this condition is harmless. Additional logic would be
-  //   required to make page_begin_offset_ lie within the sub-array in this
-  //   case, and it would serve no purpose other than to make the invariant
-  //   slightly simpler.)
-  //
-  // Note that it is _not_ a class invariant that current_pos_ needs to lie
-  // within the current page. Making this an invariant would have two
-  // undesirable consequences:
-  // a) When operator[] is called with an index that lies beyond the end of
-  //    the current page, it would need to temporarily load the page that
-  //    contains this index, but it wouldn't be able to "retain" the page
-  //    (i.e. make it the current page) because that would violate the
-  //    proposed invariant. This would lead to inefficient behavior in the
-  //    case where code accesses a large range of indices beyond the end of
-  //    the page because a page would need to be loaded temporarily on each
-  //    access.
-  // b) It would require more code: loadPageForOffset() would need to be
-  //    called anywhere that current_pos_ changes (whereas, with the present
-  //    approach, loadPageForOffset() is only called in operator[]).
-
-  // PagedByteArray that is accessed by this pointer.
-  PagedByteArrayPtr array_;
-
-  // Pointer to the current page.
-  mutable PagedByteArray::PagePtr page_;
-
-  // Pointer to the current page's data buffer.
-  mutable const unsigned char *page_data_;
-
-  // All of the following offsets are defined relative to the beginning of
-  // the array defined by the PagedByteArray array_.
-
-  // Array offset that the pointer points to.
-  size_t current_pos_;
-
-  // Start offset of the current sub-array.
-  size_t sub_array_begin_;
-
-  // End offset of the current sub-array.
-  size_t sub_array_end_;
-
-  // Array offset corresponding to the "page_data_" pointer.
-  mutable size_t page_begin_offset_;
-
-  // Length of the current page.
-  mutable size_t current_page_len_;
-
-  // Error flag. This is mutable because methods that don't affect the value
-  // of the pointer itself (such as operator[]) nevertheless need to be able to
-  // signal error conditions.
-  mutable MemoryStatus error_flag_;
-
-  RangeCheckedBytePtr();
-
- public:
-  // Creates a pointer that points to the first element of 'array', which has a
-  // length of 'len'. The caller must ensure that the array remains valid until
-  // this pointer and any pointers created from it have been destroyed.
-  // Note: 'len' may be zero, but 'array' must in this case still be a valid,
-  // non-null pointer.
-  explicit RangeCheckedBytePtr(const unsigned char *array, const size_t len);
-
-  // Creates a pointer that points to the first element of the given
-  // PagedByteArray. The caller must ensure that this PagedByteArray remains
-  // valid until this pointer and any pointers created from it have been
-  // destroyed.
-  explicit RangeCheckedBytePtr(PagedByteArray *array);
-
-  // Creates an invalid RangeCheckedBytePtr. Calling errorOccurred() on the
-  // result of invalidPointer() always returns true.
-  // Do not check a RangeCheckedBytePtr for validity by comparing against
-  // invalidPointer(); use errorOccurred() instead.
-  static RangeCheckedBytePtr invalidPointer();
-
-  // Returns a RangeCheckedBytePtr that points to a sub-array of this pointer's
-  // underlying array. The sub-array starts at position 'pos' relative to this
-  // pointer and is 'length' bytes long. The sub-array must lie within this
-  // pointer's array, i.e. pos + length <= remainingLength() must hold. If this
-  // condition is violated, an invalid pointer is returned.
-  RangeCheckedBytePtr pointerToSubArray(size_t pos, size_t length) const;
-
-  // Returns the number of bytes remaining in the array from this pointer's
-  // present position.
-  inline size_t remainingLength() const;
-
-  // Returns the offset (or index) in the underlying array that this pointer
-  // points to. If this pointer was created using pointerToSubArray(), the
-  // offset is relative to the beginning of the sub-array (and not relative to
-  // the beginning of the original array).
-  size_t offsetInArray() const;
-
-  // Returns whether an out-of-bounds error has ever occurred on this pointer in
-  // the past. An error occurs if a caller attempts to read from a position
-  // outside the bounds of the array or to move the pointer outside the bounds
-  // of the array.
-  //
-  // The error flag is never reset. Once an error has occurred,
-  // all subsequent attempts to read from the pointer (even within the bounds of
-  // the array) return 0.
-  //
-  // Note that it is permissible for a pointer to point one element past the end
-  // of the array, but it is not permissible to read from this position. This is
-  // equivalent to the semantics of raw C++ pointers.
-  inline bool errorOccurred() const;
-
-  // Returns the substring of length 'length' located at position 'pos' relative
-  // to this pointer.
-  std::string substr(size_t pos, size_t length) const;
-
-  // Returns 'length' number of bytes from the array starting at position 'pos'
-  // relative to this pointer.
-  std::vector<unsigned char> extractBytes(size_t pos, size_t length) const;
-
-  // Equivalent to calling convert(0, output).
-  template <class T>
-  bool convert(T *output) const {
-    union {
-      T t;
-      unsigned char ch[sizeof(T)];
-    } buffer;
-    for (size_t i = 0; i < sizeof(T); i++) {
-      buffer.ch[i] = (*this)[i];
-    }
-    if (!errorOccurred()) {
-      *output = buffer.t;
-    }
-    return !errorOccurred();
-  }
-
-  // Reinterprets this pointer as a pointer to an array of T, then returns the
-  // element at position 'index' in this array of T. (Note that this position
-  // corresponds to position index * sizeof(T) in the underlying byte array.)
-  //
-  // Returns true if successful; false if an out-of-range error occurred or if
-  // the error flag was already set on the pointer when calling convert().
-  //
-  // The conversion from a sequence of sizeof(T) bytes to a T is performed in an
-  // implementation-defined fashion. This conversion is equivalent to the one
-  // obtained using the following union by filling the array 'ch' and then
-  // reading the member 't':
-  //
-  //   union {
-  //     T t;
-  //     unsigned char ch[sizeof(T)];
-  //   };
-  //
-  // Callers should note that, among other things, the conversion is not
-  // endian-agnostic with respect to the endianness of T.
-  template <class T>
-  bool convert(size_t index, T *output) const {
-    RangeCheckedBytePtr p = (*this) + index * sizeof(T);
-    bool valid = p.convert(output);
-    if (!valid) {
-      error_flag_ = p.error_flag_;
-    }
-    return valid;
-  }
-
-  // Operators. Unless otherwise noted, these operators have the same semantics
-  // as the same operators on an unsigned char pointer.
-
-  // If an out-of-range access is attempted, returns 0 (and sets the error
-  // flag).
-  inline unsigned char operator[](size_t i) const;
-
-  inline unsigned char operator*() const;
-
-  inline RangeCheckedBytePtr &operator++();
-
-  inline RangeCheckedBytePtr operator++(int);
-
-  inline RangeCheckedBytePtr &operator--();
-
-  inline RangeCheckedBytePtr operator--(int);
-
-  inline RangeCheckedBytePtr &operator+=(size_t x);
-
-  inline RangeCheckedBytePtr &operator-=(size_t x);
-
-  inline friend RangeCheckedBytePtr operator+(const RangeCheckedBytePtr &p,
-                                              size_t x);
-
-  inline friend RangeCheckedBytePtr operator-(const RangeCheckedBytePtr &p,
-                                              size_t x);
-
-  // Tests whether x and y point at the same position in the underlying array.
-  // Two pointers that point at the same position but have different
-  // sub-arrays still compare equal. It is not legal to compare two pointers
-  // that point into different paged byte arrays.
-  friend bool operator==(const RangeCheckedBytePtr &x,
-                         const RangeCheckedBytePtr &y);
-
-  // Returns !(x == y).
-  friend bool operator!=(const RangeCheckedBytePtr &x,
-                         const RangeCheckedBytePtr &y);
-
- private:
-  void loadPageForOffset(size_t offset) const;
-  void restrictPageToSubArray() const;
-};
-
-// Returns the result of calling std::memcmp() on the sequences of 'num' bytes
-// pointed to by 'x' and 'y'. The result is undefined if either
-// x.remainingLength() or y.remainingLength() is less than 'num'.
-int memcmp(const RangeCheckedBytePtr &x, const RangeCheckedBytePtr &y,
-           size_t num);
-
-// Returns the result of calling std::memcmp() (note: _not_ strcmp()) on the
-// y.length() number of bytes pointed to by 'x' and the string 'y'. The result
-// is undefined if x.remainingLength() is less than y.length().
-int strcmp(const RangeCheckedBytePtr &x, const std::string &y);
-
-// Returns the length of the zero-terminated string starting at 'src' (not
-// including the '\0' terminator). If no '\0' occurs before the end of the
-// array, the result is undefined.
-size_t strlen(const RangeCheckedBytePtr &src);
-
-// Integer decoding functions.
-//
-// These functions read signed (Get16s, Get32s) or unsigned (Get16u, Get32u)
-// integers from 'input'. The integer read from the input can be specified to be
-// either big-endian (big_endian == true) or little-endian
-// (little_endian == false). Signed integers are read in two's-complement
-// representation. The integer read in the specified format is then converted to
-// the implementation's native integer representation and returned. In other
-// words, the semantics of these functions are independent of the
-// implementation's endianness and signed integer representation.
-//
-// If an out-of-range error occurs, these functions do _not_ set the error flag
-// on 'input'. Instead, they set 'status' to RANGE_CHECKED_BYTE_ERROR and return
-// 0.
-//
-// Note:
-// - If an error occurs and 'status' is already set to an error value (i.e. a
-//   value different from RANGE_CHECKED_BYTE_SUCCESS), the value of 'status' is
-//   left unchanged.
-// - If the operation is successful, 'status' is left unchanged (i.e. it is not
-//   actively set to RANGE_CHECKED_BYTE_SUCCESS).
-//
-// Together, these two properties mean that these functions can be used to read
-// a number of integers in succession with only a single error check, like this:
-//
-//   MemoryStatus status = RANGE_CHECKED_BYTE_SUCCESS;
-//   int16 val1 = Get16s(input, false, &status);
-//   int32 val2 = Get32s(input + 2, false, &status);
-//   uint32 val3 = Get32u(input + 6, false, &status);
-//   if (status != RANGE_CHECKED_BYTE_SUCCESS) {
-//     // error handling
-//   }
-int16 Get16s(const RangeCheckedBytePtr &input, const bool big_endian,
-             MemoryStatus *status);
-uint16 Get16u(const RangeCheckedBytePtr &input, const bool big_endian,
-              MemoryStatus *status);
-int32 Get32s(const RangeCheckedBytePtr &input, const bool big_endian,
-             MemoryStatus *status);
-uint32 Get32u(const RangeCheckedBytePtr &input, const bool big_endian,
-              MemoryStatus *status);
-
-size_t RangeCheckedBytePtr::remainingLength() const {
-  if (!errorOccurred()) {
-    // current_pos_ <= sub_array_end_ is a class invariant, but protect
-    // against violations of this invariant.
-    if (current_pos_ <= sub_array_end_) {
-      return sub_array_end_ - current_pos_;
-    } else {
-      assert(false);
-      return 0;
-    }
-  } else {
-    return 0;
-  }
-}
-
-bool RangeCheckedBytePtr::errorOccurred() const {
-  return error_flag_ != RANGE_CHECKED_BYTE_SUCCESS;
-}
-
-unsigned char RangeCheckedBytePtr::operator[](size_t i) const {
-  // Check that pointer doesn't have an error flag set.
-  if (!errorOccurred()) {
-    // Offset in array to read from.
-    const size_t read_offset = current_pos_ + i;
-
-    // Check for the common case first: The byte we want to read lies in the
-    // current page. For performance reasons, we don't check for the case
-    // "read_offset < page_begin_offset_" explicitly; if it occurs, it will
-    // lead to wraparound (which is well-defined for unsigned quantities), and
-    // this will cause the test "pos_in_page < current_page_len_" to fail.
-    size_t pos_in_page = read_offset - page_begin_offset_;
-    if (pos_in_page < current_page_len_) {
-      return page_data_[pos_in_page];
-    }
-
-    // Check that the offset we're trying to read lies within the sub-array
-    // we're allowed to access.
-    if (read_offset >= sub_array_begin_ && read_offset < sub_array_end_) {
-      // Read the page that contains the offset "read_offset".
-      loadPageForOffset(read_offset);
-
-      // Compute the position within the new page from which we need to read.
-      pos_in_page = read_offset - page_begin_offset_;
-
-      // After the call to loadPageForOffset(), read_offset must lie within
-      // the current page, and therefore pos_in_page must be less than the
-      // length of the page. We nevertheless check for this to protect against
-      // potential bugs in loadPageForOffset().
-      assert(pos_in_page < current_page_len_);
-      if (pos_in_page < current_page_len_) {
-        return page_data_[pos_in_page];
-      }
-    }
-  }
-
-// All error cases fall through to here.
-#ifdef BREAK_IF_DEBUGGING_AND_OUT_OF_RANGE
-  assert(false);
-#endif
-  error_flag_ = RANGE_CHECKED_BYTE_ERROR_OVERFLOW;
-  // return 0, which represents the invalid value
-  return static_cast<unsigned char>(0);
-}
-
-unsigned char RangeCheckedBytePtr::operator*() const { return (*this)[0]; }
-
-RangeCheckedBytePtr &RangeCheckedBytePtr::operator++() {
-  if (current_pos_ < sub_array_end_) {
-    current_pos_++;
-  } else {
-#ifdef BREAK_IF_DEBUGGING_AND_OUT_OF_RANGE
-    assert(false);
-#endif
-    error_flag_ = RANGE_CHECKED_BYTE_ERROR_OVERFLOW;
-  }
-  return *this;
-}
-
-RangeCheckedBytePtr RangeCheckedBytePtr::operator++(int) {
-  RangeCheckedBytePtr result(*this);
-  ++(*this);
-  return result;
-}
-
-RangeCheckedBytePtr &RangeCheckedBytePtr::operator--() {
-  if (current_pos_ > sub_array_begin_) {
-    current_pos_--;
-  } else {
-#ifdef BREAK_IF_DEBUGGING_AND_OUT_OF_RANGE
-    assert(false);
-#endif
-    error_flag_ = RANGE_CHECKED_BYTE_ERROR_UNDERFLOW;
-  }
-  return *this;
-}
-
-RangeCheckedBytePtr RangeCheckedBytePtr::operator--(int) {
-  RangeCheckedBytePtr result(*this);
-  --(*this);
-  return result;
-}
-
-RangeCheckedBytePtr &RangeCheckedBytePtr::operator+=(size_t x) {
-  if (remainingLength() >= x) {
-    current_pos_ += x;
-  } else {
-#ifdef BREAK_IF_DEBUGGING_AND_OUT_OF_RANGE
-    assert(false);
-#endif
-    error_flag_ = RANGE_CHECKED_BYTE_ERROR_OVERFLOW;
-  }
-  return *this;
-}
-
-RangeCheckedBytePtr &RangeCheckedBytePtr::operator-=(size_t x) {
-  if (x <= current_pos_ - sub_array_begin_) {
-    current_pos_ -= x;
-  } else {
-#ifdef BREAK_IF_DEBUGGING_AND_OUT_OF_RANGE
-    assert(false);
-#endif
-    error_flag_ = RANGE_CHECKED_BYTE_ERROR_UNDERFLOW;
-  }
-  return *this;
-}
-
-RangeCheckedBytePtr operator+(const RangeCheckedBytePtr &p, size_t x) {
-  RangeCheckedBytePtr result(p);
-  result += x;
-  return result;
-}
-
-RangeCheckedBytePtr operator-(const RangeCheckedBytePtr &p, size_t x) {
-  RangeCheckedBytePtr result(p);
-  result -= x;
-  return result;
-}
-
-}  // namespace binary_parse
-}  // namespace piex
-
-#endif  // PIEX_BINARY_PARSE_RANGE_CHECKED_BYTE_PTR_H_
diff --git a/src/image_type_recognition/image_type_recognition_lite.cc b/src/image_type_recognition/image_type_recognition_lite.cc
deleted file mode 100644
index 5976f42..0000000
--- a/src/image_type_recognition/image_type_recognition_lite.cc
+++ /dev/null
@@ -1,915 +0,0 @@
-// Copyright 2015 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-////////////////////////////////////////////////////////////////////////////////
-//
-// This file implements the image type recognition algorithm. Functions, which
-// will check each single image type, are implemented based on the comparisons
-// of magic numbers or signature strings. Other checks (e.g endianness, general
-// tiff magic number "42", etc.) could also be used in some of those functions
-// to make the type recognition more stable. Those checks are designed
-// according to the format spcifications and our own experiments. Notice that
-// the magic numbers and signature strings may have different binary values
-// according to different endiannesses.
-#include "src/image_type_recognition/image_type_recognition_lite.h"
-
-#include <algorithm>
-#include <cassert>
-#include <string>
-#include <vector>
-
-#include "src/binary_parse/range_checked_byte_ptr.h"
-
-namespace piex {
-namespace image_type_recognition {
-namespace {
-
-using std::string;
-using binary_parse::MemoryStatus;
-using binary_parse::RangeCheckedBytePtr;
-
-// Base class for checking image type. For each image type, one should create an
-// inherited class and do the implementation.
-class TypeChecker {
- public:
-  // Comparing function, whihc is used for sorting.
-  static bool Compare(const TypeChecker* a, const TypeChecker* b) {
-    assert(a);
-    assert(b);
-    return a->RequestedSize() < b->RequestedSize();
-  }
-
-  virtual ~TypeChecker() {}
-
-  // Returns the type of current checker.
-  virtual RawImageTypes Type() const = 0;
-
-  // Returns the requested data size (in bytes) for current checker. The checker
-  // guarantees that it will not read more than this size.
-  virtual size_t RequestedSize() const = 0;
-
-  // Checks if source data belongs to current checker type.
-  virtual bool IsMyType(const RangeCheckedBytePtr& source) const = 0;
-
- protected:
-  // Limits the source length to the RequestedSize(), using it guarantees that
-  // we will not read more than this size from the source.
-  RangeCheckedBytePtr LimitSource(const RangeCheckedBytePtr& source) const {
-    return source.pointerToSubArray(0 /* pos */, RequestedSize());
-  }
-};
-
-// Check if the uint16 value at (source + offset) is equal to the target value.
-bool CheckUInt16Value(const RangeCheckedBytePtr& source,
-                      const size_t source_offset, const bool use_big_endian,
-                      const unsigned short target_value) {  // NOLINT
-  MemoryStatus status = binary_parse::RANGE_CHECKED_BYTE_SUCCESS;
-  const unsigned short value = binary_parse::Get16u(  // NOLINT
-      source + source_offset, use_big_endian, &status);
-  if (status != binary_parse::RANGE_CHECKED_BYTE_SUCCESS) {
-    return false;
-  }
-  return (target_value == value);
-}
-
-// Check if the uint32 value at (source + offset) is equal to the target value.
-bool CheckUInt32Value(const RangeCheckedBytePtr& source,
-                      const size_t source_offset, const bool use_big_endian,
-                      const unsigned int target_value) {
-  MemoryStatus status = binary_parse::RANGE_CHECKED_BYTE_SUCCESS;
-  const unsigned int value =
-      binary_parse::Get32u(source + source_offset, use_big_endian, &status);
-  if (status != binary_parse::RANGE_CHECKED_BYTE_SUCCESS) {
-    return false;
-  }
-  return (target_value == value);
-}
-
-// Determine the endianness. The return value is NOT the endianness indicator,
-// it's just that this function was successful.
-bool DetermineEndianness(const RangeCheckedBytePtr& source,
-                         bool* is_big_endian) {
-  if (source.remainingLength() < 2) {
-    return false;
-  }
-
-  if (source[0] == 0x49 && source[1] == 0x49) {
-    *is_big_endian = false;
-  } else if (source[0] == 0x4D && source[1] == 0x4D) {
-    *is_big_endian = true;
-  } else {
-    return false;
-  }
-  return true;
-}
-
-// Check if signature string can match to the same length string start from
-// (source + offset). The signature string will be used as longer magic number
-// series.
-bool IsSignatureMatched(const RangeCheckedBytePtr& source,
-                        const size_t source_offset, const string& signature) {
-  return source.substr(source_offset, signature.size()) == signature;
-}
-
-// Check if signature is found in [source + offset, source + offset + range].
-bool IsSignatureFound(const RangeCheckedBytePtr& source,
-                      const size_t search_offset, const size_t search_range,
-                      const string& signature, size_t* first_matched) {
-  if (source.remainingLength() < search_offset + search_range) {
-    return false;
-  }
-
-  // The index must be in range [offset, offset + range - sizeof(signature)], so
-  // that it can guarantee that it will not read outside of range.
-  for (size_t i = search_offset;
-       i < search_offset + search_range - signature.size(); ++i) {
-    if (IsSignatureMatched(source, i, signature)) {
-      if (first_matched) {
-        *first_matched = i;
-      }
-      return true;
-    }
-  }
-  return false;
-}
-
-// Sony RAW format.
-class ArwTypeChecker : public TypeChecker {
- public:
-  virtual RawImageTypes Type() const { return kArwImage; }
-
-  virtual size_t RequestedSize() const { return 10000; }
-
-  // Check multiple points:
-  // 1. valid endianness at the beginning of the file;
-  // 2. correct tiff magic number at the (offset == 8) position of the file;
-  // 3. signature "SONY" in first requested bytes;
-  // 4. correct signature for (section + version) in first requested bytes.
-  virtual bool IsMyType(const RangeCheckedBytePtr& source) const {
-    RangeCheckedBytePtr limited_source = LimitSource(source);
-
-    bool use_big_endian;
-    if (!DetermineEndianness(limited_source, &use_big_endian)) {
-      return false;
-    }
-
-    const unsigned short kTiffMagic = 0x2A;  // NOLINT
-    const unsigned int kTiffOffset = 8;
-    if (!CheckUInt16Value(limited_source, 2 /* offset */, use_big_endian,
-                          kTiffMagic) ||
-        !CheckUInt32Value(limited_source, 4 /* offset */, use_big_endian,
-                          kTiffOffset)) {
-      return false;
-    }
-
-    // Search for kSignatureSony in first requested bytes
-    const string kSignatureSony("SONY");
-    if (!IsSignatureFound(limited_source, 0 /* offset */, RequestedSize(),
-                          kSignatureSony, NULL)) {
-      return false;
-    }
-
-    // Search for (kSignatureFileTypeSection + kSignatureVersions[i]) in first
-    // requested bytes
-    const string kSignatureSection("\x00\xb0\x01\x00\x04\x00\x00\x00", 8);
-    const int kSignatureVersionsSize = 6;
-    const string kSignatureVersions[kSignatureVersionsSize] = {
-        string("\x02\x00", 2),  // ARW 1.0
-        string("\x03\x00", 2),  // ARW 2.0
-        string("\x03\x01", 2),  // ARW 2.1
-        string("\x03\x02", 2),  // ARW 2.2
-        string("\x03\x03", 2),  // ARW 2.3
-        string("\x04\x00", 2),  // ARW 4.0
-    };
-    bool matched = false;
-    for (int i = 0; i < kSignatureVersionsSize; ++i) {
-      matched = matched || IsSignatureFound(
-                               limited_source, 0 /* offset */, RequestedSize(),
-                               kSignatureSection + kSignatureVersions[i], NULL);
-    }
-    return matched;
-  }
-};
-
-// Canon RAW (CR3 extension).
-class Cr3TypeChecker : public TypeChecker {
- public:
-  static constexpr size_t kSignatureOffset = 4;
-  static constexpr const char* kSignature = "ftypcrx ";
-
-  virtual RawImageTypes Type() const { return kCr3Image; }
-
-  virtual size_t RequestedSize() const {
-    return kSignatureOffset + strlen(kSignature);
-  }
-
-  // Checks for the ftyp box w/ brand 'crx '.
-  virtual bool IsMyType(const RangeCheckedBytePtr& source) const {
-    RangeCheckedBytePtr limited_source = LimitSource(source);
-    return IsSignatureMatched(limited_source, kSignatureOffset, kSignature);
-  }
-};
-
-// Canon RAW (CR2 extension).
-class Cr2TypeChecker : public TypeChecker {
- public:
-  virtual RawImageTypes Type() const { return kCr2Image; }
-
-  virtual size_t RequestedSize() const { return 16; }
-
-  // Check multiple points:
-  // 1. valid endianness at the beginning of the file;
-  // 2. magic number "42" at the (offset == 2) position of the file;
-  // 3. signature "CR2" at the (offset == 8) position of the file.
-  virtual bool IsMyType(const RangeCheckedBytePtr& source) const {
-    RangeCheckedBytePtr limited_source = LimitSource(source);
-
-    bool use_big_endian;
-    if (!DetermineEndianness(limited_source, &use_big_endian)) {
-      return false;
-    }
-
-    const unsigned short kTag = 42;  // NOLINT
-    if (!CheckUInt16Value(limited_source, 2 /* offset */, use_big_endian,
-                          kTag)) {
-      return false;
-    }
-
-    const string kSignature("CR\2\0", 4);
-    return IsSignatureMatched(limited_source, 8 /* offset */, kSignature);
-  }
-};
-
-// Canon RAW (CRW extension).
-class CrwTypeChecker : public TypeChecker {
- public:
-  virtual RawImageTypes Type() const { return kCrwImage; }
-
-  virtual size_t RequestedSize() const { return 14; }
-
-  // Check only the signature at the (offset == 6) position of the file.
-  virtual bool IsMyType(const RangeCheckedBytePtr& source) const {
-    RangeCheckedBytePtr limited_source = LimitSource(source);
-
-    bool use_big_endian;
-    if (!DetermineEndianness(limited_source, &use_big_endian)) {
-      return false;
-    }
-
-    string signature;
-    if (use_big_endian) {
-      signature = string("\x00\x10\xba\xb0\xac\xbb\x00\x02", 8);
-    } else {
-      signature = string("HEAPCCDR");
-    }
-    return IsSignatureMatched(limited_source, 6 /* offset */, signature);
-  }
-};
-
-// Kodak RAW.
-class DcrTypeChecker : public TypeChecker {
- public:
-  virtual RawImageTypes Type() const { return kDcrImage; }
-
-  virtual size_t RequestedSize() const { return 5000; }
-
-  // Check two different cases, only need to fulfill one of the two:
-  // 1. signature at the (offset == 16) position of the file;
-  // 2. two tags (OriginalFileName and FirmwareVersion) can be found in the
-  // first requested bytes of the file.
-  virtual bool IsMyType(const RangeCheckedBytePtr& source) const {
-    RangeCheckedBytePtr limited_source = LimitSource(source);
-
-    bool use_big_endian;
-    if (!DetermineEndianness(limited_source, &use_big_endian)) {
-      return false;
-    }
-
-    // Case 1: has signature
-    const string kSignature(
-        "\x4b\x4f\x44\x41\x4b\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20", 16);
-    if (IsSignatureMatched(limited_source, 16 /* offset */, kSignature)) {
-      return true;
-    }
-
-    // Case 2: search for tags in first requested bytes
-    string kIfdTags[2];
-    if (use_big_endian) {
-      kIfdTags[0] = string("\x03\xe9\x00\x02", 4);  // OriginalFileName
-      kIfdTags[1] = string("\x0c\xe5\x00\x02", 4);  // FirmwareVersion
-    } else {
-      kIfdTags[0] = string("\xe9\x03\x02\x00", 4);  // OriginalFileName
-      kIfdTags[1] = string("\xe5\x0c\x02\x00", 4);  // FirmwareVersion
-    }
-    return IsSignatureFound(limited_source, 0 /* offset */, RequestedSize(),
-                            kIfdTags[0], NULL) &&
-           IsSignatureFound(limited_source, 0 /* offset */, RequestedSize(),
-                            kIfdTags[1], NULL);
-  }
-};
-
-// Digital Negative RAW.
-class DngTypeChecker : public TypeChecker {
- public:
-  virtual RawImageTypes Type() const { return kDngImage; }
-
-  virtual size_t RequestedSize() const { return 1024; }
-
-  // Check multiple points:
-  // 1. valid endianness at the beginning of the file;
-  // 2. at least two dng specific tags in the first requested bytes of the
-  // file
-  virtual bool IsMyType(const RangeCheckedBytePtr& source) const {
-    RangeCheckedBytePtr limited_source = LimitSource(source);
-
-    bool use_big_endian;
-    if (!DetermineEndianness(limited_source, &use_big_endian)) {
-      return false;
-    }
-
-    // Search tags in first requested bytes and verify the order of them.
-    const int kTagsCount = 5;
-    string dng_tags[kTagsCount];
-    if (use_big_endian) {
-      dng_tags[0] =
-          string("\xc6\x12\x00\x01\x00\x00\x00\x04", 8);  // tag: 50706
-      dng_tags[1] =
-          string("\xc6\x13\x00\x01\x00\x00\x00\x04", 8);  // tag: 50707
-      dng_tags[2] = string("\xc6\x14\x00\x02", 4);        // tag: 50708
-      dng_tags[3] = string("\xc6\x20", 2);                // tag: 50720
-      dng_tags[4] =
-          string("\xc6\x2d\x00\x04\x00\x00\x00\x01", 8);  // tag: 50733
-    } else {
-      dng_tags[0] =
-          string("\x12\xc6\x01\x00\x04\x00\x00\x00", 8);  // tag: 50706
-      dng_tags[1] =
-          string("\x13\xc6\x01\x00\x04\x00\x00\x00", 8);  // tag: 50707
-      dng_tags[2] = string("\x14\xc6\x02\x00", 4);        // tag: 50708
-      dng_tags[3] = string("\x20\xc6", 2);                // tag: 50720
-      dng_tags[4] =
-          string("\x2d\xc6\x04\x00\x01\x00\x00\x00", 8);  // tag: 50733
-    }
-    int tags_found = 0;
-    for (int i = 0; i < kTagsCount; ++i) {
-      if (IsSignatureFound(limited_source, 0 /* offset */, RequestedSize(),
-                           dng_tags[i], NULL)) {
-        tags_found++;
-      }
-    }
-    return tags_found >= 2;
-  }
-};
-
-// Kodak RAW.
-class KdcTypeChecker : public TypeChecker {
- public:
-  virtual RawImageTypes Type() const { return kKdcImage; }
-
-  virtual size_t RequestedSize() const { return 5000; }
-
-  // Check two points:
-  // 1. valid endianness at the beginning of the file;
-  // 2. two tags (WhiteBalance and SerialNumber) in the first requested bytes.
-  virtual bool IsMyType(const RangeCheckedBytePtr& source) const {
-    RangeCheckedBytePtr limited_source = LimitSource(source);
-
-    bool use_big_endian;
-    if (!DetermineEndianness(limited_source, &use_big_endian)) {
-      return false;
-    }
-
-    // Search in first requested bytes
-    const size_t kIfdTagsSize = 2;
-    string kIfdTags[kIfdTagsSize];
-    if (use_big_endian) {
-      kIfdTags[0] = string("\xfa\x0d\x00\x01", 4);  // WhiteBalance
-      kIfdTags[1] = string("\xfa\x00\x00\x02", 4);  // SerialNumber
-    } else {
-      kIfdTags[0] = string("\x0d\xfa\x01\x00", 4);  // WhiteBalance
-      kIfdTags[1] = string("\x00\xfa\x02\x00", 4);  // SerialNumber
-    }
-
-    return IsSignatureFound(limited_source, 0 /* offset */, RequestedSize(),
-                            kIfdTags[0], NULL) &&
-           IsSignatureFound(limited_source, 0 /* offset */, RequestedSize(),
-                            kIfdTags[1], NULL);
-  }
-};
-
-// Leaf RAW.
-class MosTypeChecker : public TypeChecker {
- public:
-  virtual RawImageTypes Type() const { return kMosImage; }
-
-  virtual size_t RequestedSize() const { return 5000; }
-
-  // Check two points:
-  // 1. valid endianness at the beginning of the file;
-  // 2. signature "PKTS    " in the first requested bytes. Note the
-  // "whitespace". It's important as they are special binary values.
-  virtual bool IsMyType(const RangeCheckedBytePtr& source) const {
-    RangeCheckedBytePtr limited_source = LimitSource(source);
-
-    bool use_big_endian;
-    if (!DetermineEndianness(source, &use_big_endian)) {
-      return false;
-    }
-
-    // Search kSignaturePKTS in first requested bytes
-    const string kSignaturePKTS("PKTS\x00\x00\x00\x001", 8);
-    return IsSignatureFound(limited_source, 0 /* offset */, RequestedSize(),
-                            kSignaturePKTS, NULL);
-  }
-};
-
-// Minolta RAW.
-class MrwTypeChecker : public TypeChecker {
- public:
-  virtual RawImageTypes Type() const { return kMrwImage; }
-
-  virtual size_t RequestedSize() const { return 4; }
-
-  // Check only the signature at the beginning of the file.
-  virtual bool IsMyType(const RangeCheckedBytePtr& source) const {
-    // Limits the source length to the RequestedSize(), using it guarantees that
-    // we will not read more than this size from the source.
-    RangeCheckedBytePtr limited_source =
-        source.pointerToSubArray(0 /* pos */, RequestedSize());
-
-    const string kSignature("\0MRM", 4);
-    return IsSignatureMatched(limited_source, 0 /* offset */, kSignature);
-  }
-};
-
-// Check if the file contains a NRW signature "NRW   " in the first requested
-// bytes. Note the "whitespace". It's important as they are special binary
-// values.
-const size_t kRequestedSizeForNrwSignature = 4000;
-bool ContainsNrwSignature(const RangeCheckedBytePtr& source) {
-  // Search for kSignatureNrw.
-  const string kSignatureNrw("NRW\x20\x20\x20", 6);
-  return IsSignatureFound(source, 0 /* offset */, kRequestedSizeForNrwSignature,
-                          kSignatureNrw, NULL);
-}
-
-// Checks if the file contains the signatures for Nikon formats:
-// * the general Nikon singature "NIKON" string.
-// * the ReferenceBlackWhite tag.
-const size_t kRequestedSizeForNikonSignatures = 4000;
-bool ContainsNikonSignatures(const RangeCheckedBytePtr& source,
-                             const bool use_big_endian) {
-  const string kSignatureNikon("NIKON");
-  const string kReferenceBlackWhiteTag = use_big_endian
-                                             ? string("\x02\x14\x00\x05", 4)
-                                             : string("\x14\x02\x05\x00", 4);
-  const std::vector<string> kSignatures = {kSignatureNikon,
-                                           kReferenceBlackWhiteTag};
-  for (auto const& signature : kSignatures) {
-    if (!IsSignatureFound(source, 0, kRequestedSizeForNikonSignatures,
-                          signature, NULL)) {
-      return false;
-    }
-  }
-  return true;
-}
-
-// Nikon RAW (NEF extension).
-class NefTypeChecker : public TypeChecker {
- public:
-  virtual RawImageTypes Type() const { return kNefImage; }
-
-  virtual size_t RequestedSize() const {
-    return std::max(kRequestedSizeForNikonSignatures,
-                    kRequestedSizeForNrwSignature);
-  }
-
-  // Check multiple points:
-  // 1. valid endianness at the beginning of the file;
-  // 2. magic number at the (offset == 2) position of the file;
-  // 3. the signature "NIKON" in the requested bytes of the file;
-  // 4. the ReferenceBlackWhite tag in the requested bytes of the file;
-  // 5. does not contain the NRW signature. We may also check a special
-  // signature "RAW   " similar to the NRW case, but we got issues in some
-  // special images that the signature locates in the middle of the file, and it
-  // costs too  long time to check;
-  virtual bool IsMyType(const RangeCheckedBytePtr& source) const {
-    RangeCheckedBytePtr limited_source = LimitSource(source);
-
-    bool use_big_endian;
-    if (!DetermineEndianness(limited_source, &use_big_endian)) {
-      return false;
-    }
-
-    const unsigned short kTiffMagic = 0x2A;  // NOLINT
-    if (!CheckUInt16Value(limited_source, 2 /* offset */, use_big_endian,
-                          kTiffMagic)) {
-      return false;
-    }
-
-    return ContainsNikonSignatures(limited_source, use_big_endian) &&
-           !ContainsNrwSignature(limited_source);  // not NRW
-  }
-};
-
-// Nikon RAW (NRW extension).
-class NrwTypeChecker : public TypeChecker {
- public:
-  virtual RawImageTypes Type() const { return kNrwImage; }
-
-  virtual size_t RequestedSize() const {
-    return std::max(kRequestedSizeForNikonSignatures,
-                    kRequestedSizeForNrwSignature);
-  }
-
-  // Check multiple points:
-  // 1. valid endianness at the beginning of the file;
-  // 2. magic numbers at the (offset == 2 and offset == 4) positions of the
-  // file;
-  // 3. the signature "NIKON" in the first requested bytes of the file;
-  // 4. the ReferenceBlackWhite tag in the requested bytes of the file;
-  // 5. contains the NRW signature;
-  virtual bool IsMyType(const RangeCheckedBytePtr& source) const {
-    RangeCheckedBytePtr limited_source = LimitSource(source);
-
-    bool use_big_endian;
-    if (!DetermineEndianness(limited_source, &use_big_endian)) {
-      return false;
-    }
-
-    const unsigned short kTiffMagic = 0x2A;  // NOLINT
-    const unsigned int kTiffOffset = 8;
-    if (!CheckUInt16Value(limited_source, 2 /* offset */, use_big_endian,
-                          kTiffMagic) ||
-        !CheckUInt32Value(limited_source, 4 /* offset */, use_big_endian,
-                          kTiffOffset)) {
-      return false;
-    }
-
-    return ContainsNikonSignatures(limited_source, use_big_endian) &&
-           ContainsNrwSignature(limited_source);
-  }
-};
-
-// Olympus RAW.
-class OrfTypeChecker : public TypeChecker {
- public:
-  virtual RawImageTypes Type() const { return kOrfImage; }
-
-  virtual size_t RequestedSize() const { return 3000; }
-
-  // Check multiple points:
-  // 1. valid endianness at the beginning of the file;
-  // 2. tag at the (offset == 2) position of the file;
-  // 3. signature "OLYMP" in the first requested bytes.
-  virtual bool IsMyType(const RangeCheckedBytePtr& source) const {
-    RangeCheckedBytePtr limited_source = LimitSource(source);
-
-    bool use_big_endian;
-    if (!DetermineEndianness(limited_source, &use_big_endian)) {
-      return false;
-    }
-
-    const size_t kTagSize = 2;
-    const unsigned short kTag[kTagSize] = {0x4F52, 0x5352};  // NOLINT
-    if (!(CheckUInt16Value(limited_source, 2 /* offset */, use_big_endian,
-                           kTag[0]) ||
-          CheckUInt16Value(limited_source, 2 /* offset */, use_big_endian,
-                           kTag[1]))) {
-      return false;
-    }
-
-    // Search for kSignatureOlymp in first requested bytes
-    const string kSignatureOlymp("OLYMP");
-    return IsSignatureFound(limited_source, 0 /* offset */, RequestedSize(),
-                            kSignatureOlymp, NULL);
-  }
-};
-
-// Pentax RAW.
-class PefTypeChecker : public TypeChecker {
- public:
-  virtual RawImageTypes Type() const { return kPefImage; }
-
-  virtual size_t RequestedSize() const { return 1280; }
-
-  // Check multiple points:
-  // 1. valid big endianness at the beginning of the file;
-  // 2. magic numbers at the (offset == 2 and offset==4) positions of the file;
-  // 3. signature "AOC   " or "PENTAX  " in first requested bytes.
-  virtual bool IsMyType(const RangeCheckedBytePtr& source) const {
-    RangeCheckedBytePtr limited_source = LimitSource(source);
-
-    bool use_big_endian;
-    if (!DetermineEndianness(limited_source, &use_big_endian)) {
-      return false;
-    }
-
-    const unsigned short kTiffMagic = 0x2A;  // NOLINT
-    const unsigned int kTiffOffset = 8;
-    if (!CheckUInt16Value(limited_source, 2 /* offset */, use_big_endian,
-                          kTiffMagic) ||
-        !CheckUInt32Value(limited_source, 4 /* offset */, use_big_endian,
-                          kTiffOffset)) {
-      return false;
-    }
-
-    // Search for kSignatureAOC or kSignaturePENTAX in first requested bytes
-    const string kSignatureAOC("\x41\x4f\x43\x00\x4d\x4d", 6);
-    const string kSignaturePENTAX("\x50\x45\x4e\x54\x41\x58\x20\x00", 8);
-    return IsSignatureFound(limited_source, 0 /* offset */, RequestedSize(),
-                            kSignatureAOC, NULL) ||
-           IsSignatureFound(limited_source, 0 /* offset */, RequestedSize(),
-                            kSignaturePENTAX, NULL);
-  }
-};
-
-// Apple format.
-class QtkTypeChecker : public TypeChecker {
- public:
-  virtual RawImageTypes Type() const { return kQtkImage; }
-
-  virtual size_t RequestedSize() const { return 8; }
-
-  // Check only the signature at the beginning of the file.
-  virtual bool IsMyType(const RangeCheckedBytePtr& source) const {
-    RangeCheckedBytePtr limited_source = LimitSource(source);
-
-    const size_t kSignatureSize = 2;
-    const string kSignature[kSignatureSize] = {
-        string("qktk\x00\x00\x00\x08", 8), string("qktn\x00\x00\x00\x08", 8),
-    };
-    return IsSignatureMatched(limited_source, 0 /* offset */, kSignature[0]) ||
-           IsSignatureMatched(limited_source, 0 /* offset */, kSignature[1]);
-  }
-};
-
-// Fuji RAW.
-class RafTypeChecker : public TypeChecker {
- public:
-  virtual RawImageTypes Type() const { return kRafImage; }
-
-  virtual size_t RequestedSize() const { return 8; }
-
-  // Check only the signature at the beginning of the file.
-  virtual bool IsMyType(const RangeCheckedBytePtr& source) const {
-    RangeCheckedBytePtr limited_source = LimitSource(source);
-
-    const string kSignature("FUJIFILM");
-    return IsSignatureMatched(limited_source, 0 /* offset */, kSignature);
-  }
-};
-
-// Contax N RAW.
-class RawContaxNTypeChecker : public TypeChecker {
- public:
-  virtual RawImageTypes Type() const { return kRawContaxNImage; }
-
-  virtual size_t RequestedSize() const { return 36; }
-
-  // Check only the signature at the (offset == 25) position of the
-  // file.
-  virtual bool IsMyType(const RangeCheckedBytePtr& source) const {
-    RangeCheckedBytePtr limited_source = LimitSource(source);
-
-    const string kSignature("ARECOYK");
-    return IsSignatureMatched(limited_source, 25, kSignature);
-  }
-};
-
-// Panasonic RAW.
-class Rw2TypeChecker : public TypeChecker {
- public:
-  virtual RawImageTypes Type() const { return kRw2Image; }
-
-  virtual size_t RequestedSize() const { return 4; }
-
-  // Check two points: 1. valid endianness at the beginning of the
-  // file; 2. tag at the (offset == 2) position of the file.
-  virtual bool IsMyType(const RangeCheckedBytePtr& source) const {
-    RangeCheckedBytePtr limited_source = LimitSource(source);
-
-    bool use_big_endian;
-    if (!DetermineEndianness(source, &use_big_endian)) {
-      return false;
-    }
-
-    const unsigned short kTag = 0x55;  // NOLINT
-    return CheckUInt16Value(limited_source, 2 /* offset */, use_big_endian,
-                            kTag);
-  }
-};
-
-// Samsung RAW.
-class SrwTypeChecker : public TypeChecker {
- public:
-  virtual RawImageTypes Type() const { return kSrwImage; }
-
-  virtual size_t RequestedSize() const { return 256; }
-
-  // Check multiple points:
-  // 1. valid big endianness at the beginning of the file;
-  // 2. magic numbers at the (offset == 2 and offset==4) positions of the file;
-  // 3. the signature "SAMSUNG" in the requested bytes of the file;
-  virtual bool IsMyType(const RangeCheckedBytePtr& source) const {
-    RangeCheckedBytePtr limited_source = LimitSource(source);
-
-    bool use_big_endian;
-    if (!DetermineEndianness(source, &use_big_endian)) {
-      return false;
-    }
-
-    const unsigned short kTiffMagic = 0x2A;  // NOLINT
-    const unsigned int kTiffOffset = 8;
-    if (!CheckUInt16Value(limited_source, 2 /* offset */, use_big_endian,
-                          kTiffMagic) ||
-        !CheckUInt32Value(limited_source, 4 /* offset */, use_big_endian,
-                          kTiffOffset)) {
-      return false;
-    }
-
-    const string kSignature("SAMSUNG");
-    if (!IsSignatureFound(source, 0, RequestedSize(), kSignature, NULL)) {
-      return false;
-    }
-    return true;
-  }
-};
-
-// Sigma / Polaroid RAW.
-class X3fTypeChecker : public TypeChecker {
- public:
-  virtual RawImageTypes Type() const { return kX3fImage; }
-
-  virtual size_t RequestedSize() const { return 4; }
-
-  // Check only the signature at the beginning of the file.
-  virtual bool IsMyType(const RangeCheckedBytePtr& source) const {
-    RangeCheckedBytePtr limited_source = LimitSource(source);
-
-    const string kSignature("FOVb", 4);
-    return IsSignatureMatched(limited_source, 0 /* offset */, kSignature);
-  }
-};
-
-// This class contains the list of all type checkers. One should used this list
-// as a whole to execute the image type recognition.
-class TypeCheckerList {
- public:
-  TypeCheckerList() {
-    // Add all supported RAW type checkers here.
-    checkers_.push_back(new ArwTypeChecker());
-    checkers_.push_back(new Cr3TypeChecker());
-    checkers_.push_back(new Cr2TypeChecker());
-    checkers_.push_back(new CrwTypeChecker());
-    checkers_.push_back(new DcrTypeChecker());
-    checkers_.push_back(new DngTypeChecker());
-    checkers_.push_back(new KdcTypeChecker());
-    checkers_.push_back(new MosTypeChecker());
-    checkers_.push_back(new MrwTypeChecker());
-    checkers_.push_back(new NefTypeChecker());
-    checkers_.push_back(new NrwTypeChecker());
-    checkers_.push_back(new OrfTypeChecker());
-    checkers_.push_back(new PefTypeChecker());
-    checkers_.push_back(new QtkTypeChecker());
-    checkers_.push_back(new RafTypeChecker());
-    checkers_.push_back(new RawContaxNTypeChecker());
-    checkers_.push_back(new Rw2TypeChecker());
-    checkers_.push_back(new SrwTypeChecker());
-    checkers_.push_back(new X3fTypeChecker());
-
-    // Sort the checkers by the ascending RequestedSize() to get better
-    // performance when checking type.
-    std::sort(checkers_.begin(), checkers_.end(), TypeChecker::Compare);
-  }
-
-  ~TypeCheckerList() {
-    for (size_t i = 0; i < checkers_.size(); ++i) {
-      delete checkers_[i];
-      checkers_[i] = NULL;
-    }
-  }
-
-  // Returns the type of source data. If it can not be identified, returns
-  // kNonRawImage.
-  RawImageTypes GetType(const RangeCheckedBytePtr& source) const {
-    for (size_t i = 0; i < checkers_.size(); ++i) {
-      if (checkers_[i]->IsMyType(source)) {
-        return checkers_[i]->Type();
-      }
-    }
-    return kNonRawImage;
-  }
-
-  // Returns the maximum size of requested size of data for identifying image
-  // type using this class. The class guarantees that it will not read more than
-  // this size.
-  size_t RequestedSize() const {
-    assert(!checkers_.empty());
-    // The checkers_ is ascending sorted. The last element is the maximum.
-    return checkers_.back()->RequestedSize();
-  }
-
-  bool IsOfType(const RangeCheckedBytePtr& source, const RawImageTypes type) {
-    const TypeChecker* type_checker = GetTypeCheckerForType(type);
-    if (type_checker) {
-      return type_checker->IsMyType(source);
-    } else {
-      return false;
-    }
-  }
-
-  size_t RequestedSizeForType(const RawImageTypes type) {
-    const TypeChecker* type_checker = GetTypeCheckerForType(type);
-    if (type_checker) {
-      return type_checker->RequestedSize();
-    } else {
-      return 0;
-    }
-  }
-
- private:
-  const TypeChecker* GetTypeCheckerForType(const RawImageTypes type) {
-    for (const auto* type_checker : checkers_) {
-      if (type_checker->Type() == type) {
-        return type_checker;
-      }
-    }
-    return nullptr;
-  }
-
-  std::vector<TypeChecker*> checkers_;
-};
-
-}  // namespace
-
-bool IsRaw(const RawImageTypes type) {
-  switch (type) {
-    // Non-RAW-image type
-    case kNonRawImage: {
-      return false;
-    }
-
-    // Raw image types
-    case kArwImage:
-    case kCr3Image:
-    case kCr2Image:
-    case kCrwImage:
-    case kDcrImage:
-    case kDngImage:
-    case kKdcImage:
-    case kMosImage:
-    case kMrwImage:
-    case kNefImage:
-    case kNrwImage:
-    case kOrfImage:
-    case kPefImage:
-    case kQtkImage:
-    case kRafImage:
-    case kRawContaxNImage:
-    case kRw2Image:
-    case kSrwImage:
-    case kX3fImage: {
-      return true;
-    }
-
-    default: {
-      // Unsupported type!
-      assert(false);
-    }
-  }
-  return false;
-}
-
-bool IsOfType(const RangeCheckedBytePtr& source, const RawImageTypes type) {
-  return TypeCheckerList().IsOfType(source, type);
-}
-
-RawImageTypes RecognizeRawImageTypeLite(const RangeCheckedBytePtr& source) {
-  return TypeCheckerList().GetType(source);
-}
-
-size_t GetNumberOfBytesForIsRawLite() {
-  return TypeCheckerList().RequestedSize();
-}
-
-size_t GetNumberOfBytesForIsOfType(const RawImageTypes type) {
-  return TypeCheckerList().RequestedSizeForType(type);
-}
-
-bool IsRawLite(const RangeCheckedBytePtr& source) {
-  return IsRaw(RecognizeRawImageTypeLite(source));
-}
-
-}  // namespace image_type_recognition
-}  // namespace piex
diff --git a/src/image_type_recognition/image_type_recognition_lite.h b/src/image_type_recognition/image_type_recognition_lite.h
deleted file mode 100644
index 30db915..0000000
--- a/src/image_type_recognition/image_type_recognition_lite.h
+++ /dev/null
@@ -1,89 +0,0 @@
-// Copyright 2015 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-////////////////////////////////////////////////////////////////////////////////
-//
-// This file offers functions to determine the type of binary input source. The
-// type recognition here is not 100% accurate, it only offers a quick and rough
-// check about the input source. The general functions use RangeCheckedBytePtr
-// as input, there are also linux only functions that use StringPiece as input.
-// A linux only IsRawLite() method is also implemented.
-// The "lite" implementation focuses on performance and guarantees to not read
-// more than specified by GetNumberOfBytesForIsRawLite.
-
-#ifndef PIEX_IMAGE_TYPE_RECOGNITION_IMAGE_TYPE_RECOGNITION_LITE_H_
-#define PIEX_IMAGE_TYPE_RECOGNITION_IMAGE_TYPE_RECOGNITION_LITE_H_
-
-#include <stddef.h>
-
-#include "src/binary_parse/range_checked_byte_ptr.h"
-
-namespace piex {
-namespace image_type_recognition {
-
-// Type of RAW images. Keep the order in alphabet.
-enum RawImageTypes {
-  // Non-RAW-image type
-  kNonRawImage = 0,
-
-  // raw image types
-  kArwImage,
-  kCr2Image,
-  kCr3Image,
-  kCrwImage,
-  kDcrImage,
-  kDngImage,
-  kKdcImage,
-  kMosImage,
-  kMrwImage,
-  kNefImage,
-  kNrwImage,
-  kOrfImage,
-  kPefImage,
-  kQtkImage,
-  kRafImage,
-  kRawContaxNImage,
-  kRw2Image,
-  kSrwImage,
-  kX3fImage,
-};
-
-// Checks if the given type is a RAW image type.
-bool IsRaw(const RawImageTypes type);
-
-// Checks if the given source is from given type.
-bool IsOfType(const binary_parse::RangeCheckedBytePtr& source,
-              const RawImageTypes type);
-
-// This function will check the source and return the corresponding image type.
-// If the source is not a recognizable type, this function will return
-// kNonRawImage.
-RawImageTypes RecognizeRawImageTypeLite(
-    const binary_parse::RangeCheckedBytePtr& source);
-
-// Returns the maximum number of bytes needed to recognize a RAW image type in
-// IsRawLite().
-size_t GetNumberOfBytesForIsRawLite();
-
-// Returns the maximum number of bytes needed to recognize a RAF image type in
-// IsOfType().
-size_t GetNumberOfBytesForIsOfType(const RawImageTypes type);
-
-// This function will check if the source belongs to one of the known RAW types.
-bool IsRawLite(const binary_parse::RangeCheckedBytePtr& source);
-
-}  // namespace image_type_recognition
-}  // namespace piex
-
-#endif  // PIEX_IMAGE_TYPE_RECOGNITION_IMAGE_TYPE_RECOGNITION_LITE_H_
diff --git a/src/piex.cc b/src/piex.cc
deleted file mode 100644
index ac2ef0b..0000000
--- a/src/piex.cc
+++ /dev/null
@@ -1,740 +0,0 @@
-// Copyright 2015 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#include "src/piex.h"
-
-#include <cstdint>
-#include <limits>
-#include <set>
-#include <vector>
-
-#include "src/binary_parse/range_checked_byte_ptr.h"
-#include "src/image_type_recognition/image_type_recognition_lite.h"
-#include "src/piex_cr3.h"
-#include "src/tiff_parser.h"
-
-namespace piex {
-namespace {
-
-using binary_parse::RangeCheckedBytePtr;
-using image_type_recognition::RawImageTypes;
-using image_type_recognition::RecognizeRawImageTypeLite;
-using tiff_directory::Endian;
-using tiff_directory::TiffDirectory;
-
-const std::uint32_t kRafOffsetToPreviewOffset = 84;
-
-bool GetDngInformation(const tiff_directory::TiffDirectory& tiff_directory,
-                       std::uint32_t* width, std::uint32_t* height,
-                       std::vector<std::uint32_t>* cfa_pattern_dim) {
-  if (!GetFullDimension32(tiff_directory, width, height) || *width == 0 ||
-      *height == 0) {
-    return false;
-  }
-
-  if (!tiff_directory.Get(kTiffTagCfaPatternDim, cfa_pattern_dim) ||
-      cfa_pattern_dim->size() != 2) {
-    return false;
-  }
-  return true;
-}
-
-bool GetDngInformation(const TagSet& extended_tags, StreamInterface* data,
-                       std::uint32_t* width, std::uint32_t* height,
-                       std::vector<std::uint32_t>* cfa_pattern_dim) {
-  TagSet desired_tags = {kExifTagDefaultCropSize, kTiffTagCfaPatternDim,
-                         kTiffTagExifIfd, kTiffTagSubFileType};
-  desired_tags.insert(extended_tags.cbegin(), extended_tags.cend());
-
-  TiffParser tiff_parser(data, 0 /* offset */);
-
-  TiffContent tiff_content;
-  if (!tiff_parser.Parse(desired_tags, 1, &tiff_content) ||
-      tiff_content.tiff_directory.empty()) {
-    return false;
-  }
-
-  // If IFD0 contains already the full dimensions we do not parse into the sub
-  // IFD.
-  const TiffDirectory& tiff_directory = tiff_content.tiff_directory[0];
-  if (tiff_directory.GetSubDirectories().empty()) {
-    return GetDngInformation(tiff_directory, width, height, cfa_pattern_dim);
-  } else {
-    return GetDngInformation(tiff_directory.GetSubDirectories()[0], width,
-                             height, cfa_pattern_dim);
-  }
-}
-
-bool GetPreviewData(const TagSet& extended_tags,
-                    const std::uint32_t tiff_offset,
-                    const std::uint32_t number_of_ifds, StreamInterface* stream,
-                    TiffContent* tiff_content,
-                    PreviewImageData* preview_image_data) {
-  TagSet desired_tags = {
-      kExifTagColorSpace, kExifTagDateTimeOriginal, kExifTagExposureTime,
-      kExifTagFnumber,    kExifTagFocalLength,      kExifTagGps,
-      kExifTagIsoSpeed,   kTiffTagCompression,      kTiffTagDateTime,
-      kTiffTagExifIfd,    kTiffTagCfaPatternDim,    kTiffTagMake,
-      kTiffTagModel,      kTiffTagOrientation,      kTiffTagPhotometric};
-  desired_tags.insert(extended_tags.cbegin(), extended_tags.cend());
-
-  TiffParser tiff_parser(stream, tiff_offset);
-
-  if (!tiff_parser.Parse(desired_tags, number_of_ifds, tiff_content)) {
-    return false;
-  }
-  if (tiff_content->tiff_directory.empty()) {
-    // Returns false if the stream does not contain any TIFF structure.
-    return false;
-  }
-  return tiff_parser.GetPreviewImageData(*tiff_content, preview_image_data);
-}
-
-bool GetPreviewData(const TagSet& extended_tags,
-                    const std::uint32_t number_of_ifds, StreamInterface* stream,
-                    PreviewImageData* preview_image_data) {
-  const std::uint32_t kTiffOffset = 0;
-  TiffContent tiff_content;
-  return GetPreviewData(extended_tags, kTiffOffset, number_of_ifds, stream,
-                        &tiff_content, preview_image_data);
-}
-
-bool GetExifData(const std::uint32_t exif_offset, StreamInterface* stream,
-                 PreviewImageData* preview_image_data) {
-  const TagSet kExtendedTags = {kTiffTagJpegByteCount, kTiffTagJpegOffset};
-  const std::uint32_t kNumberOfIfds = 2;
-  TiffContent tiff_content;
-  return GetPreviewData(kExtendedTags, exif_offset, kNumberOfIfds, stream,
-                        &tiff_content, preview_image_data);
-}
-
-// Reads the jpeg compressed thumbnail information.
-void GetThumbnailOffsetAndLength(const TagSet& extended_tags,
-                                 StreamInterface* stream,
-                                 PreviewImageData* preview_image_data) {
-  TagSet desired_tags = {kTiffTagJpegByteCount, kTiffTagJpegOffset};
-  desired_tags.insert(extended_tags.cbegin(), extended_tags.cend());
-
-  const std::uint32_t kNumberOfIfds = 2;
-  PreviewImageData thumbnail_data;
-  if (GetPreviewData(desired_tags, kNumberOfIfds, stream, &thumbnail_data)) {
-    preview_image_data->thumbnail = thumbnail_data.thumbnail;
-  }
-}
-
-bool GetExifIfd(const Endian endian, StreamInterface* stream,
-                TiffDirectory* exif_ifd) {
-  const std::uint32_t kTiffOffset = 0;
-  std::uint32_t offset_to_ifd;
-  if (!Get32u(stream, sizeof(offset_to_ifd), endian, &offset_to_ifd)) {
-    return false;
-  }
-
-  std::uint32_t next_ifd_offset;
-  TiffDirectory tiff_ifd(endian);
-  if (!ParseDirectory(kTiffOffset, offset_to_ifd, endian, {kTiffTagExifIfd},
-                      stream, &tiff_ifd, &next_ifd_offset)) {
-    return false;
-  }
-
-  std::uint32_t exif_offset;
-  if (tiff_ifd.Get(kTiffTagExifIfd, &exif_offset)) {
-    return ParseDirectory(kTiffOffset, exif_offset, endian,
-                          {kExifTagMakernotes}, stream, exif_ifd,
-                          &next_ifd_offset);
-  }
-
-  return true;
-}
-
-bool GetMakernoteIfd(const TiffDirectory& exif_ifd, const Endian endian,
-                     const std::uint32_t skip_offset, StreamInterface* stream,
-                     std::uint32_t* makernote_offset,
-                     TiffDirectory* makernote_ifd) {
-  std::uint32_t makernote_length;
-  if (!exif_ifd.GetOffsetAndLength(kExifTagMakernotes,
-                                   tiff_directory::TIFF_TYPE_UNDEFINED,
-                                   makernote_offset, &makernote_length)) {
-    return false;
-  }
-
-  std::uint32_t next_ifd_offset;
-  return ParseDirectory(*makernote_offset, *makernote_offset + skip_offset,
-                        endian, {kTiffTagImageWidth, kOlymTagCameraSettings,
-                                 kOlymTagRawProcessing, kPentaxTagColorSpace},
-                        stream, makernote_ifd, &next_ifd_offset);
-}
-
-bool GetCameraSettingsIfd(const TiffDirectory& makernote_ifd,
-                          const std::uint32_t makernote_offset,
-                          const Endian endian, StreamInterface* stream,
-                          TiffDirectory* camera_settings_ifd) {
-  std::uint32_t camera_settings_offset;
-  std::uint32_t camera_settings_length;
-  if (!makernote_ifd.GetOffsetAndLength(
-          kOlymTagCameraSettings, tiff_directory::TIFF_IFD,
-          &camera_settings_offset, &camera_settings_length)) {
-    return false;
-  }
-
-  std::uint32_t next_ifd_offset;
-  if (!Get32u(stream, camera_settings_offset, endian,
-              &camera_settings_offset)) {
-    return false;
-  }
-  return ParseDirectory(makernote_offset,
-                        makernote_offset + camera_settings_offset, endian,
-                        {kTiffTagBitsPerSample, kTiffTagImageLength}, stream,
-                        camera_settings_ifd, &next_ifd_offset);
-}
-
-bool GetRawProcessingIfd(const TagSet& desired_tags,
-                         const TiffDirectory& makernote_ifd,
-                         const std::uint32_t makernote_offset,
-                         const Endian endian, StreamInterface* stream,
-                         TiffDirectory* raw_processing_ifd) {
-  std::uint32_t raw_processing_offset;
-  std::uint32_t raw_processing_length;
-  if (!makernote_ifd.GetOffsetAndLength(
-          kOlymTagRawProcessing, tiff_directory::TIFF_IFD,
-          &raw_processing_offset, &raw_processing_length)) {
-    return false;
-  }
-
-  std::uint32_t next_ifd_offset;
-  if (!Get32u(stream, raw_processing_offset, endian, &raw_processing_offset)) {
-    return false;
-  }
-
-  return ParseDirectory(
-      makernote_offset, makernote_offset + raw_processing_offset, endian,
-      desired_tags, stream, raw_processing_ifd, &next_ifd_offset);
-}
-
-// Retrieves the preview image offset and length from the camera settings and
-// the 'full_width' and 'full_height' from the raw processing ifd in 'stream'.
-// Returns false if anything is wrong.
-bool GetOlympusPreviewImage(StreamInterface* stream,
-                            PreviewImageData* preview_image_data) {
-  Endian endian;
-  if (!GetEndianness(0 /* tiff offset */, stream, &endian)) {
-    return false;
-  }
-
-  TiffDirectory exif_ifd(endian);
-  if (!GetExifIfd(endian, stream, &exif_ifd)) {
-    return false;
-  }
-
-  std::uint32_t makernote_offset;
-  TiffDirectory makernote_ifd(endian);
-  const std::uint32_t kSkipMakernoteStart = 12;
-  if (!GetMakernoteIfd(exif_ifd, endian, kSkipMakernoteStart, stream,
-                       &makernote_offset, &makernote_ifd)) {
-    return false;
-  }
-
-  const std::uint32_t kThumbnailTag = 0x0100;
-  if (makernote_ifd.Has(kThumbnailTag)) {
-    if (!makernote_ifd.GetOffsetAndLength(
-            kThumbnailTag, tiff_directory::TIFF_TYPE_UNDEFINED,
-            &preview_image_data->thumbnail.offset,
-            &preview_image_data->thumbnail.length)) {
-      return false;
-    }
-  }
-
-  TiffDirectory camera_settings_ifd(endian);
-  if (!GetCameraSettingsIfd(makernote_ifd, makernote_offset, endian, stream,
-                            &camera_settings_ifd)) {
-    return false;
-  }
-
-  const std::uint32_t kPreviewOffset = 0x0101;
-  const std::uint32_t kPreviewLength = 0x0102;
-  if (!camera_settings_ifd.Has(kPreviewOffset) ||
-      !camera_settings_ifd.Has(kPreviewLength)) {
-    return false;
-  }
-
-  camera_settings_ifd.Get(kPreviewOffset, &preview_image_data->preview.offset);
-  preview_image_data->preview.offset += makernote_offset;
-  camera_settings_ifd.Get(kPreviewLength, &preview_image_data->preview.length);
-
-  // Get the crop size from the raw processing ifd.
-  TiffDirectory raw_processing_ifd(endian);
-  if (!GetRawProcessingIfd({kOlymTagAspectFrame}, makernote_ifd,
-                           makernote_offset, endian, stream,
-                           &raw_processing_ifd)) {
-    return false;
-  }
-
-  if (raw_processing_ifd.Has(kOlymTagAspectFrame)) {
-    std::vector<std::uint32_t> aspect_frame;
-    if (raw_processing_ifd.Get(kOlymTagAspectFrame, &aspect_frame) &&
-        aspect_frame.size() == 4 && aspect_frame[2] > aspect_frame[0] &&
-        aspect_frame[3] > aspect_frame[1]) {
-      preview_image_data->full_width = aspect_frame[2] - aspect_frame[0] + 1;
-      preview_image_data->full_height = aspect_frame[3] - aspect_frame[1] + 1;
-      if (preview_image_data->full_width < preview_image_data->full_height) {
-        std::swap(preview_image_data->full_width,
-                  preview_image_data->full_height);
-      }
-    }
-  }
-
-  return true;
-}
-
-bool PefGetColorSpace(StreamInterface* stream,
-                      PreviewImageData* preview_image_data) {
-  Endian endian;
-  if (!GetEndianness(0 /* tiff offset */, stream, &endian)) {
-    return false;
-  }
-
-  TiffDirectory exif_ifd(endian);
-  if (!GetExifIfd(endian, stream, &exif_ifd)) {
-    return false;
-  }
-
-  std::uint32_t makernote_offset;
-  TiffDirectory makernote_ifd(endian);
-  const std::uint32_t kSkipMakernoteStart = 6;
-  if (!GetMakernoteIfd(exif_ifd, endian, kSkipMakernoteStart, stream,
-                       &makernote_offset, &makernote_ifd)) {
-    return false;
-  }
-  if (makernote_ifd.Has(kPentaxTagColorSpace)) {
-    std::uint32_t color_space;
-    if (!makernote_ifd.Get(kPentaxTagColorSpace, &color_space)) {
-      return false;
-    }
-    preview_image_data->color_space = color_space == 0
-                                          ? PreviewImageData::kSrgb
-                                          : PreviewImageData::kAdobeRgb;
-  }
-  return true;
-}
-
-bool RafGetOrientation(StreamInterface* stream, std::uint32_t* orientation) {
-  // Parse the Fuji RAW header to get the offset and length of the preview
-  // image, which contains the Exif information.
-  const Endian endian = tiff_directory::kBigEndian;
-  std::uint32_t preview_offset = 0;
-  if (!Get32u(stream, kRafOffsetToPreviewOffset, endian, &preview_offset)) {
-    return false;
-  }
-
-  const std::uint32_t exif_offset = preview_offset + 12;
-  return GetExifOrientation(stream, exif_offset, orientation);
-}
-
-// Parses the Fuji Cfa header for the image width and height.
-bool RafGetDimension(StreamInterface* stream, std::uint32_t* width,
-                     std::uint32_t* height) {
-  const Endian endian = tiff_directory::kBigEndian;
-  std::uint32_t cfa_header_index = 0;  // actual position in the cfa header.
-  std::uint32_t cfa_header_entries = 0;
-  if (!Get32u(stream, 92 /* cfa header offset */, endian, &cfa_header_index) ||
-      !Get32u(stream, cfa_header_index, endian, &cfa_header_entries)) {
-    return false;
-  }
-
-  // Add 4 to point to the actual read position in the cfa header.
-  cfa_header_index += 4;
-
-  for (std::uint32_t i = 0; i < cfa_header_entries; ++i) {
-    std::uint16_t id = 0;
-    std::uint16_t length = 0;
-    if (!Get16u(stream, cfa_header_index, endian, &id) ||
-        !Get16u(stream, cfa_header_index + 2, endian, &length)) {
-      return false;
-    }
-
-    std::uint16_t tmp_width = 0;
-    std::uint16_t tmp_height = 0;
-    if (id == 0x0111 /* tags the crop dimensions */ &&
-        Get16u(stream, cfa_header_index + 4, endian, &tmp_height) &&
-        Get16u(stream, cfa_header_index + 6, endian, &tmp_width)) {
-      *width = tmp_width;
-      *height = tmp_height;
-      return true;
-    }
-    cfa_header_index += 4u + length;
-  }
-  return false;
-}
-
-Error ArwGetPreviewData(StreamInterface* stream,
-                        PreviewImageData* preview_image_data) {
-  const TagSet extended_tags = {kExifTagHeight, kExifTagWidth,
-                                kTiffTagJpegByteCount, kTiffTagJpegOffset,
-                                kTiffTagSubIfd};
-
-  GetThumbnailOffsetAndLength(TagSet(), stream, preview_image_data);
-
-  const std::uint32_t kNumberOfIfds = 1;
-  if (GetPreviewData(extended_tags, kNumberOfIfds, stream,
-                     preview_image_data)) {
-    return kOk;
-  }
-  return kFail;
-}
-
-Error Cr2GetPreviewData(StreamInterface* stream,
-                        PreviewImageData* preview_image_data) {
-  const TagSet extended_tags = {kExifTagHeight, kExifTagWidth,
-                                kTiffTagStripByteCounts, kTiffTagStripOffsets};
-
-  GetThumbnailOffsetAndLength(TagSet(), stream, preview_image_data);
-
-  const std::uint32_t kNumberOfIfds = 1;
-  if (GetPreviewData(extended_tags, kNumberOfIfds, stream,
-                     preview_image_data)) {
-    return kOk;
-  }
-  return kFail;
-}
-
-Error DngGetPreviewData(StreamInterface* stream,
-                        PreviewImageData* preview_image_data) {
-  // Some thumbnails from DngCreator are larger than the specified 256 pixel.
-  const int kDngThumbnailMaxDimension = 512;
-
-  const TagSet extended_tags = {
-      kExifTagDefaultCropSize, kTiffTagImageWidth,   kTiffTagImageLength,
-      kTiffTagStripByteCounts, kTiffTagStripOffsets, kTiffTagSubIfd};
-
-  TiffContent tiff_content;
-  const std::uint32_t kNumberOfIfds = 3;
-  if (!GetPreviewData(extended_tags, 0, kNumberOfIfds, stream, &tiff_content,
-                      preview_image_data)) {
-    return kFail;
-  }
-
-  const TiffDirectory& tiff_directory = tiff_content.tiff_directory[0];
-
-  if (!GetFullCropDimension(tiff_directory, &preview_image_data->full_width,
-                            &preview_image_data->full_height)) {
-    return kFail;
-  }
-
-  // Find the jpeg compressed thumbnail and preview image.
-  Image preview;
-  Image thumbnail;
-
-  // Search for images in IFD0
-  Image temp_image;
-  if (GetImageData(tiff_directory, stream, &temp_image)) {
-    if (IsThumbnail(temp_image, kDngThumbnailMaxDimension)) {
-      thumbnail = temp_image;
-    } else if (temp_image.format == Image::kJpegCompressed) {
-      preview = temp_image;
-    }
-  }
-
-  // Search for images in other IFDs
-  for (const auto& ifd : tiff_directory.GetSubDirectories()) {
-    if (GetImageData(ifd, stream, &temp_image)) {
-      // Try to find the largest thumbnail/preview.
-      if (IsThumbnail(temp_image, kDngThumbnailMaxDimension)) {
-        if (temp_image > thumbnail) {
-          thumbnail = temp_image;
-        }
-      } else {
-        if (temp_image > preview &&
-            temp_image.format == Image::kJpegCompressed) {
-          preview = temp_image;
-        }
-      }
-    }
-  }
-  preview_image_data->preview = preview;
-  preview_image_data->thumbnail = thumbnail;
-
-  return kOk;
-}
-
-Error NefGetPreviewData(StreamInterface* stream,
-                        PreviewImageData* preview_image_data) {
-  const TagSet extended_tags = {kTiffTagImageWidth,      kTiffTagImageLength,
-                                kTiffTagJpegByteCount,   kTiffTagJpegOffset,
-                                kTiffTagStripByteCounts, kTiffTagStripOffsets,
-                                kTiffTagSubIfd};
-  const std::uint32_t kNumberOfIfds = 2;
-  if (!GetPreviewData(extended_tags, kNumberOfIfds, stream,
-                      preview_image_data)) {
-    return kFail;
-  }
-
-  if (preview_image_data->thumbnail.length == 0) {
-    PreviewImageData thumbnail_data;
-    GetThumbnailOffsetAndLength(TagSet(), stream, &thumbnail_data);
-    preview_image_data->thumbnail = thumbnail_data.thumbnail;
-  }
-
-  // The Nikon RAW data provides the dimensions of the sensor image, which are
-  // slightly larger than the dimensions of the preview image. In order to
-  // determine the correct full width and height of the image, the preview image
-  // size needs to be taken into account. Based on experiments the preview image
-  // dimensions must be at least 90% of the sensor image dimensions to let it be
-  // a full size preview image.
-  if (preview_image_data->preview.length > 0) {  // when preview image exists
-    const float kEpsilon = 0.9f;
-
-    std::uint16_t width;
-    std::uint16_t height;
-    if (!GetJpegDimensions(preview_image_data->preview.offset, stream, &width,
-                           &height) ||
-        preview_image_data->full_width == 0 ||
-        preview_image_data->full_height == 0) {
-      return kUnsupported;
-    }
-
-    if (static_cast<float>(width) /
-                static_cast<float>(preview_image_data->full_width) >
-            kEpsilon ||
-        static_cast<float>(height) /
-                static_cast<float>(preview_image_data->full_height) >
-            kEpsilon) {
-      preview_image_data->full_width = width;
-      preview_image_data->full_height = height;
-    }
-  }
-  return kOk;
-}
-
-Error OrfGetPreviewData(StreamInterface* stream,
-                        PreviewImageData* preview_image_data) {
-  if (!GetExifData(0, stream, preview_image_data)) {
-    return kFail;
-  }
-  // Omit errors, because some images do not contain any preview data.
-  GetOlympusPreviewImage(stream, preview_image_data);
-  return kOk;
-}
-
-Error PefGetPreviewData(StreamInterface* stream,
-                        PreviewImageData* preview_image_data) {
-  const TagSet extended_tags = {kTiffTagImageWidth, kTiffTagImageLength,
-                                kTiffTagJpegByteCount, kTiffTagJpegOffset,
-                                kTiffTagSubIfd};
-  const std::uint32_t kNumberOfIfds = 3;
-  if (!GetPreviewData(extended_tags, kNumberOfIfds, stream,
-                      preview_image_data) ||
-      !PefGetColorSpace(stream, preview_image_data)) {
-    return kFail;
-  }
-
-  PreviewImageData thumbnail_data;
-  GetThumbnailOffsetAndLength(TagSet(), stream, &thumbnail_data);
-  preview_image_data->thumbnail = thumbnail_data.thumbnail;
-
-  return kOk;
-}
-
-Error RafGetPreviewData(StreamInterface* stream,
-                        PreviewImageData* preview_image_data) {
-  // Parse the Fuji RAW header to get the offset and length of the preview
-  // image, which contains the Exif information.
-  const Endian endian = tiff_directory::kBigEndian;
-  std::uint32_t preview_offset = 0;
-  std::uint32_t preview_length = 0;
-  if (!Get32u(stream, kRafOffsetToPreviewOffset, endian, &preview_offset) ||
-      !Get32u(stream, kRafOffsetToPreviewOffset + 4, endian, &preview_length)) {
-    return kFail;
-  }
-
-  if (!RafGetDimension(stream, &preview_image_data->full_width,
-                       &preview_image_data->full_height)) {
-    return kFail;
-  }
-
-  if (preview_length > 0) {  // when preview image exists
-    // Parse the Exif information from the preview image.
-    const std::uint32_t exif_offset = preview_offset + 12;
-    if (!GetExifData(exif_offset, stream, preview_image_data)) {
-      return kFail;
-    }
-  }
-
-  // Merge the Exif data with the RAW data to form the preview_image_data.
-  preview_image_data->thumbnail.offset += 160;  // Skip the cfa header.
-  preview_image_data->preview.offset = preview_offset;
-  preview_image_data->preview.length = preview_length;
-  return kOk;
-}
-
-Error Rw2GetPreviewData(StreamInterface* stream,
-                        PreviewImageData* preview_image_data) {
-  const TagSet extended_tags = {kPanaTagTopBorder,     kPanaTagLeftBorder,
-                                kPanaTagBottomBorder,  kPanaTagRightBorder,
-                                kPanaTagIso,           kPanaTagJpegImage,
-                                kTiffTagJpegByteCount, kTiffTagJpegOffset};
-  // Parse the RAW data to get the ISO, offset and length of the preview image,
-  // which contains the Exif information.
-  const std::uint32_t kNumberOfIfds = 1;
-  PreviewImageData preview_data;
-  if (!GetPreviewData(extended_tags, kNumberOfIfds, stream, &preview_data)) {
-    return kFail;
-  }
-
-  if (preview_data.preview.length > 0) {  // when preview image exists
-    // Parse the Exif information from the preview image.
-    const std::uint32_t exif_offset = preview_data.preview.offset + 12;
-    if (!GetExifData(exif_offset, stream, preview_image_data)) {
-      return kFail;
-    }
-    preview_image_data->thumbnail.offset += exif_offset;
-  }
-
-  // Merge the Exif data with the RAW data to form the preview_image_data.
-  preview_image_data->preview = preview_data.preview;
-  preview_image_data->iso = preview_data.iso;
-  preview_image_data->full_width = preview_data.full_width;
-  preview_image_data->full_height = preview_data.full_height;
-
-  return kOk;
-}
-
-Error SrwGetPreviewData(StreamInterface* stream,
-                        PreviewImageData* preview_image_data) {
-  GetThumbnailOffsetAndLength({kTiffTagSubIfd}, stream, preview_image_data);
-
-  const TagSet extended_tags = {kExifTagWidth, kExifTagHeight,
-                                kTiffTagJpegByteCount, kTiffTagJpegOffset,
-                                kTiffTagSubIfd};
-  const std::uint32_t kNumberOfIfds = 1;
-  if (!GetPreviewData(extended_tags, kNumberOfIfds, stream,
-                      preview_image_data)) {
-    return kFail;
-  }
-  return kOk;
-}
-
-}  // namespace
-
-size_t BytesRequiredForIsRaw() {
-  return image_type_recognition::GetNumberOfBytesForIsRawLite();
-}
-
-bool IsRaw(StreamInterface* data) {
-  const size_t bytes = BytesRequiredForIsRaw();
-  if (data == nullptr) {
-    return false;
-  }
-
-  // Read required number of bytes into a vector.
-  std::vector<std::uint8_t> file_header(bytes);
-  if (data->GetData(0, file_header.size(), file_header.data()) != kOk) {
-    return false;
-  }
-
-  RangeCheckedBytePtr data_buffer(file_header.data(), file_header.size());
-
-  return image_type_recognition::IsRawLite(data_buffer);
-}
-
-Error GetPreviewImageData(StreamInterface* data,
-                          PreviewImageData* preview_image_data,
-                          RawImageTypes* output_type) {
-  const size_t bytes = BytesRequiredForIsRaw();
-  if (data == nullptr || bytes == 0) {
-    return kFail;
-  }
-
-  std::vector<std::uint8_t> file_header(bytes);
-  Error error = data->GetData(0, file_header.size(), file_header.data());
-  if (error != kOk) {
-    return error;
-  }
-  RangeCheckedBytePtr header_buffer(file_header.data(), file_header.size());
-
-  RawImageTypes type = RecognizeRawImageTypeLite(header_buffer);
-  if (output_type != nullptr) *output_type = type;
-  switch (type) {
-    case image_type_recognition::kArwImage:
-      return ArwGetPreviewData(data, preview_image_data);
-    case image_type_recognition::kCr2Image:
-      return Cr2GetPreviewData(data, preview_image_data);
-    case image_type_recognition::kCr3Image:
-      return Cr3GetPreviewData(data, preview_image_data);
-    case image_type_recognition::kDngImage:
-      return DngGetPreviewData(data, preview_image_data);
-    case image_type_recognition::kNefImage:
-    case image_type_recognition::kNrwImage:
-      return NefGetPreviewData(data, preview_image_data);
-    case image_type_recognition::kOrfImage:
-      return OrfGetPreviewData(data, preview_image_data);
-    case image_type_recognition::kPefImage:
-      return PefGetPreviewData(data, preview_image_data);
-    case image_type_recognition::kRafImage:
-      return RafGetPreviewData(data, preview_image_data);
-    case image_type_recognition::kRw2Image:
-      return Rw2GetPreviewData(data, preview_image_data);
-    case image_type_recognition::kSrwImage:
-      return SrwGetPreviewData(data, preview_image_data);
-    default:
-      return kUnsupported;
-  }
-}
-
-bool GetDngInformation(StreamInterface* data, std::uint32_t* width,
-                       std::uint32_t* height,
-                       std::vector<std::uint32_t>* cfa_pattern_dim) {
-  // If IFD0 contains already the full dimensions we do not parse into the sub
-  // IFD.
-  if (!GetDngInformation({}, data, width, height, cfa_pattern_dim)) {
-    return GetDngInformation({kTiffTagSubIfd}, data, width, height,
-                             cfa_pattern_dim);
-  }
-  return true;
-}
-
-bool GetOrientation(StreamInterface* data, std::uint32_t* orientation) {
-  using image_type_recognition::GetNumberOfBytesForIsOfType;
-  using image_type_recognition::IsOfType;
-
-  size_t min_header_bytes =
-      std::max(GetNumberOfBytesForIsOfType(image_type_recognition::kRafImage),
-               GetNumberOfBytesForIsOfType(image_type_recognition::kCr3Image));
-
-  std::vector<std::uint8_t> file_header(min_header_bytes);
-  if (data->GetData(0, file_header.size(), file_header.data()) != kOk) {
-    return false;
-  }
-
-  // For RAF and CR# files a special routine is necessary to get orientation.
-  // For others the general approach is sufficient.
-  if (IsOfType(RangeCheckedBytePtr(file_header.data(), file_header.size()),
-               image_type_recognition::kRafImage)) {
-    return RafGetOrientation(data, orientation);
-  } else if (IsOfType(
-                 RangeCheckedBytePtr(file_header.data(), file_header.size()),
-                 image_type_recognition::kCr3Image)) {
-    return Cr3GetOrientation(data, orientation);
-  } else {
-    return GetExifOrientation(data, 0 /* offset */, orientation);
-  }
-}
-
-std::vector<std::string> SupportedExtensions() {
-  return {"ARW", "CR2", "CR3", "DNG", "NEF", "NRW",
-          "ORF", "PEF", "RAF", "RW2", "SRW"};
-}
-
-}  // namespace piex
diff --git a/src/piex.h b/src/piex.h
deleted file mode 100644
index 8d74ca0..0000000
--- a/src/piex.h
+++ /dev/null
@@ -1,96 +0,0 @@
-// Copyright 2015 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-////////////////////////////////////////////////////////////////////////////////
-//
-// The purpose of the preview-image-extractor (piex) is to find and extract the
-// largest JPEG compressed preview image contained in a RAW file.
-//
-// Even for unsupported RAW files we want to provide high quality images using a
-// dedicated, small and portable library. That is possible by taking the preview
-// image contained in all RAW files.
-//
-// Typically a preview image is stored as JPEG compressed, full size (or at
-// least half size) image in a RAW file.
-//
-// A typical client code snippet:
-//
-//   // In C++
-//   PreviewImageData image_data;
-//   unique_ptr<StreamInterface> data_stream(new DataStream(file));
-//   Error err = GetPreviewImageData(data_stream.get(), &image_data));
-//   if (err == Error::kFail) {
-//     // The input data seems to be broken.
-//     return;
-//   } else if (err == Error::kUnsupported) {
-//     // The input data is not supported.
-//     return;
-//   }
-//
-//   // Uncompress the JPEG as usual, e.g. on Android with the BitmapFactory:
-//   // In Java
-//   Bitmap bitmap = BitmapFactory.decodeByteArray(
-//       file.at(image_data.preview_offset), image_data.preview_length);
-
-#ifndef PIEX_PIEX_H_
-#define PIEX_PIEX_H_
-
-#include <string>
-#include <vector>
-
-#include "src/image_type_recognition/image_type_recognition_lite.h"
-#include "src/piex_types.h"
-
-namespace piex {
-
-// Returns the maximum number of bytes IsRaw() will read from the stream.
-size_t BytesRequiredForIsRaw();
-
-// Returns true if 'data' contains a RAW file format, even if it is not
-// supported by Piex, false otherwise. Reads at most BytesRequiredForIsRaw()
-// from the stream.
-bool IsRaw(StreamInterface* data);
-
-// Gets the largest JPEG compressed preview image data. On success
-// 'preview_image_data' contains image metadata, the unverified length and the
-// offset to a JPEG compressed image from the beginning of the file.
-//
-// Returns 'kFail' when something with the data is wrong.
-// Returns 'kUnsupported' if file format is not supported.
-//
-// One could check the "preview_image_data->preview_length != 0" for the
-// existance of a preview image.
-//
-// Updates output_type based on data, if output_type is non-null.
-Error GetPreviewImageData(
-    StreamInterface* data, PreviewImageData* preview_image_data,
-    image_type_recognition::RawImageTypes* output_type = nullptr);
-
-// Returns true if the full width and height and the mosaic pattern dimension of
-// a DNG image could be obtained. False otherwise.
-bool GetDngInformation(StreamInterface* data, std::uint32_t* width,
-                       std::uint32_t* height,
-                       std::vector<std::uint32_t>* cfa_pattern_dim);
-
-// Returns true if Exif orientation for the image can be obtained. False
-// otherwise.
-bool GetOrientation(StreamInterface* data, std::uint32_t* orientation);
-
-// Returns a vector of upper case file extensions, which are used as a first
-// step to quickly guess a supported file format.
-std::vector<std::string> SupportedExtensions();
-
-}  // namespace piex
-
-#endif  // PIEX_PIEX_H_
diff --git a/src/piex_cr3.cc b/src/piex_cr3.cc
deleted file mode 100644
index 4fa82b7..0000000
--- a/src/piex_cr3.cc
+++ /dev/null
@@ -1,559 +0,0 @@
-// Copyright 2020 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#include "src/piex_cr3.h"
-
-#include <array>
-#include <cstddef>
-#include <cstdint>
-#include <limits>
-#include <unordered_set>
-
-#include "src/binary_parse/range_checked_byte_ptr.h"
-#include "src/piex_types.h"
-#include "src/tiff_directory/tiff_directory.h"
-#include "src/tiff_parser.h"
-
-namespace piex {
-namespace {
-
-constexpr size_t kUuidSize = 16;
-using Uuid = std::array<std::uint8_t, kUuidSize>;
-// Uuid of uuid box under the moov box.
-constexpr Uuid kUuidMoov = {0x85, 0xc0, 0xb6, 0x87, 0x82, 0x0f, 0x11, 0xe0,
-                            0x81, 0x11, 0xf4, 0xce, 0x46, 0x2b, 0x6a, 0x48};
-
-// Uuid of uuid box containing PRVW box.
-constexpr Uuid kUuidPrvw = {0xea, 0xf4, 0x2b, 0x5e, 0x1c, 0x98, 0x4b, 0x88,
-                            0xb9, 0xfb, 0xb7, 0xdc, 0x40, 0x6e, 0x4d, 0x16};
-
-constexpr size_t kTagSize = 4;
-using BoxTag = std::array<char, kTagSize>;
-
-constexpr BoxTag NewTag(const char s[kTagSize + 1]) {
-  return BoxTag{s[0], s[1], s[2], s[3]};
-}
-
-constexpr BoxTag kUuidTag = NewTag("uuid");
-constexpr BoxTag kPrvwTag = NewTag("PRVW");
-constexpr BoxTag kThmbTag = NewTag("THMB");
-constexpr BoxTag kCmt1Tag = NewTag("CMT1");
-constexpr BoxTag kCmt2Tag = NewTag("CMT2");
-constexpr BoxTag kStblTag = NewTag("stbl");
-constexpr BoxTag kStsdTag = NewTag("stsd");
-constexpr BoxTag kCrawTag = NewTag("CRAW");
-constexpr BoxTag kStszTag = NewTag("stsz");
-constexpr BoxTag kCo64Tag = NewTag("co64");
-constexpr BoxTag kMdatTag = NewTag("mdat");
-
-// Convenience class for a box.
-class Box {
- public:
-  Box()
-      : is_valid_(false),
-        tag_(BoxTag()),
-        offset_(0),
-        header_offset_(0),
-        next_box_offset_(0) {}
-  Box(const BoxTag& tag, size_t offset, size_t header_length, size_t length)
-      : is_valid_(true),
-        tag_(tag),
-        offset_(offset),
-        header_offset_(offset + header_length),
-        next_box_offset_(offset + length) {}
-
-  bool IsValid() const { return is_valid_ && next_box_offset_ > offset_; }
-  const BoxTag& tag() const { return tag_; }
-
-  // Returns offset from start of file.
-  size_t offset() const { return offset_; }
-  // Returns offset from start of file, including box's header.
-  size_t header_offset() const { return header_offset_; }
-  // Returns offset from start of file of the next box, accounting for size of
-  // this box.
-  size_t next_box_offset() const { return next_box_offset_; }
-
- private:
-  bool is_valid_;
-  BoxTag tag_;
-  size_t offset_;
-  size_t header_offset_;
-  size_t next_box_offset_;
-};
-
-struct ProcessData {
-  PreviewImageData* preview_image_data = nullptr;
-  Image mdat_image;
-  Image prvw_image;
-};
-
-// Wraps Get16u w/ assumption that CR3 is always big endian, based on
-// ISO/IEC 14496-12 specification that all box fields are big endian.
-bool Get16u(StreamInterface* stream, size_t offset, std::uint16_t* value) {
-  return Get16u(stream, offset, tiff_directory::kBigEndian, value);
-}
-
-// Wraps Get32u w/ assumption that CR3 is always big endian, based on
-// ISO/IEC 14496-12 specification that all box fields are big endian.
-bool Get32u(StreamInterface* stream, size_t offset, std::uint32_t* value) {
-  return Get32u(stream, offset, tiff_directory::kBigEndian, value);
-}
-
-// Always big endian, based on ISO/IEC 14496-12 specification that all box
-// fields are big endian.
-bool Get64u(StreamInterface* stream, size_t offset, std::uint64_t* value) {
-  std::uint8_t data[8];
-  if (stream->GetData(offset, 8, data) == kOk) {
-    *value = (data[0] * 0x1000000u) | (data[1] * 0x10000u) |
-             (data[2] * 0x100u) | data[3];
-    *value <<= 32;
-    *value = (data[4] * 0x1000000u) | (data[5] * 0x10000u) |
-             (data[6] * 0x100u) | data[7];
-    return true;
-  } else {
-    return false;
-  }
-}
-
-// Jpeg box offsets based on the box tag. The expected layout is as follows:
-//        Byte Offset Type     Meaning
-//                  0 [long]   size of box
-//                  4 [char[]] box tag
-//       offset.width [short]  width of jpeg
-//      offset.height [short]  height of jpeg
-//   offset.jpeg_size [long]   number of bytes in jpeg
-//   offset.jpeg_data [byte[]] start of jpeg data
-struct JpegBoxOffset {
-  size_t width = 0;
-  size_t height = 0;
-  size_t jpeg_size = 0;
-  size_t jpeg_data = 0;
-};
-
-// Processes box w/ JPEG data. Box must be PRVW and THMB boxes.
-bool ProcessJpegBox(StreamInterface* stream, const Box& box, Image* image) {
-  static constexpr JpegBoxOffset kPrvwJpegOffsets{14, 16, 20, 24};
-  static constexpr JpegBoxOffset kThmbJpegOffsets{12, 14, 16, 24};
-  if (box.tag() != kPrvwTag && box.tag() != kThmbTag) {
-    return false;
-  }
-  const JpegBoxOffset& offsets =
-      box.tag() == kPrvwTag ? kPrvwJpegOffsets : kThmbJpegOffsets;
-  uint16_t width, height;
-  uint32_t jpeg_size;
-  if (!Get16u(stream, box.offset() + offsets.width, &width)) {
-    return false;
-  }
-  if (!Get16u(stream, box.offset() + offsets.height, &height)) {
-    return false;
-  }
-  if (!Get32u(stream, box.offset() + offsets.jpeg_size, &jpeg_size)) {
-    return false;
-  }
-  image->format = Image::kJpegCompressed;
-  image->width = width;
-  image->height = height;
-  image->offset = box.offset() + offsets.jpeg_data;
-  image->length = jpeg_size;
-  return true;
-}
-
-// Parses the Exif IFD0 tags at tiff_offset.
-bool ParseExifIfd0(StreamInterface* stream, size_t tiff_offset,
-                   PreviewImageData* preview_image_data) {
-  static const TagSet kIfd0TagSet = {kTiffTagModel, kTiffTagMake,
-                                     kTiffTagOrientation, kTiffTagImageWidth,
-                                     kTiffTagImageLength};
-  TiffContent content;
-  TiffParser(stream, tiff_offset).Parse(kIfd0TagSet, 1, &content);
-  if (content.tiff_directory.size() != 1) {
-    return false;
-  }
-
-  content.tiff_directory[0].Get(kTiffTagModel, &preview_image_data->model);
-  content.tiff_directory[0].Get(kTiffTagMake, &preview_image_data->maker);
-  content.tiff_directory[0].Get(kTiffTagOrientation,
-                                &preview_image_data->exif_orientation);
-  content.tiff_directory[0].Get(kTiffTagImageWidth,
-                                &preview_image_data->full_width);
-  content.tiff_directory[0].Get(kTiffTagImageLength,
-                                &preview_image_data->full_height);
-  return true;
-}
-
-// Parses the Exif Exif IFD tags at tiff_offset.
-bool ParseExifExifIfd(StreamInterface* stream, size_t tiff_offset,
-                      PreviewImageData* preview_image_data) {
-  static const TagSet kExifIfdTagSet = {kExifTagDateTimeOriginal,
-                                        kExifTagExposureTime, kExifTagFnumber,
-                                        kExifTagFocalLength, kExifTagIsoSpeed};
-  TiffContent content;
-  TiffParser(stream, tiff_offset).Parse(kExifIfdTagSet, 1, &content);
-  if (content.tiff_directory.size() != 1) {
-    return false;
-  }
-
-  content.tiff_directory[0].Get(kExifTagDateTimeOriginal,
-                                &preview_image_data->date_time);
-  GetRational(kExifTagExposureTime, content.tiff_directory[0], 1,
-              &preview_image_data->exposure_time);
-  GetRational(kExifTagFnumber, content.tiff_directory[0], 1,
-              &preview_image_data->fnumber);
-  GetRational(kExifTagFocalLength, content.tiff_directory[0], 1,
-              &preview_image_data->focal_length);
-  content.tiff_directory[0].Get(kExifTagIsoSpeed, &preview_image_data->iso);
-  return true;
-}
-
-// Returns the next box or an invalid box.
-//
-// Based on ISO/IEC 14496-12: boxes start with a header: size and type. The size
-// can be compact (32-bits) or extended (64-bit, e.g. mdat box).
-// The type can be compact (32 bits) or extended (full UUID, e.g. uuid boxes).
-// values are stored after the compact size/type.
-//
-// Fields in a box are big-endian.
-Box GetNextBox(StreamInterface* stream, size_t offset) {
-  uint32_t length_32;
-  if (!Get32u(stream, offset, &length_32)) {
-    return Box();
-  }
-  BoxTag tag;
-  Error status = stream->GetData(offset + sizeof(length_32), kTagSize,
-                                 reinterpret_cast<std::uint8_t*>(tag.data()));
-  if (status != kOk) {
-    return Box();
-  }
-  size_t length;
-  size_t header_offset = sizeof(length_32) + sizeof(tag);
-  if (length_32 == 1) {
-    // Magic number of 1 implies extended size.
-    uint64_t length_64 = 0;
-    if (!Get64u(stream, offset + header_offset, &length_64)) {
-      return Box();
-    }
-    length = length_64;
-    header_offset += sizeof(length_64);
-  } else {
-    // Compact size.
-    length = length_32;
-  }
-  return Box(tag, offset, header_offset, length);
-}
-
-// Searches for the next box with the given tag.
-Box GetNextBoxWithTag(StreamInterface* stream, size_t offset,
-                      const BoxTag& expected_tag) {
-  while (true) {
-    Box box = GetNextBox(stream, offset);
-    if (!box.IsValid() || box.tag() == expected_tag) {
-      return box;
-    }
-    offset = box.next_box_offset();
-  }
-}
-
-// Returns the width, height, and content type from the CRAW box.
-bool ProcessCrawBox(StreamInterface* stream, const Box& craw_box,
-                    uint16_t* width, uint16_t* height, uint16_t* content_type) {
-  constexpr size_t kWidthOffset = 32;
-  if (!Get16u(stream, craw_box.offset() + kWidthOffset, width)) {
-    return false;
-  }
-
-  constexpr size_t kHeightOffset = 34;
-  if (!Get16u(stream, craw_box.offset() + kHeightOffset, height)) {
-    return false;
-  }
-
-  constexpr size_t kTypeOffset = 86;
-  if (!Get16u(stream, craw_box.offset() + kTypeOffset, content_type)) {
-    return false;
-  }
-  return true;
-}
-
-// stsz box offset:
-//        Byte Offset Type     Meaning
-//                  0 [long]   size of box
-//                  4 [char[]] box tag
-//                  8 [long]   version/flags
-//                 12 [long]   sample size
-//                 16 [long]   number of entries in sample table
-//                 20 [long[]] sample table if samples size is 0
-bool ProcessStszBox(StreamInterface* stream, const Box& stsz_box,
-                    uint32_t* image_size) {
-  uint32_t sample_size;
-  if (!Get32u(stream, stsz_box.offset() + 12, &sample_size)) {
-    return false;
-  }
-  if (sample_size > 0) {
-    *image_size = sample_size;
-    return true;
-  }
-  // sample_size of 0 implies the data is in the sample table. We expect only
-  // one entry. This is true of Canon EOS RP Cr3 files.
-  uint32_t count;
-  if (!Get32u(stream, stsz_box.offset() + 16, &count)) {
-    return false;
-  }
-  if (count != 1) {
-    // Expect at most one entry in the table.
-    return false;
-  }
-  return Get32u(stream, stsz_box.offset() + 20, image_size);
-}
-
-// co64 box offsets:
-//        Byte Offset Type     Meaning
-//                  0 [long]   size of box
-//                  4 [char[]] box tag
-//                  8 [long]   version
-//                 12 [long]   count (expect to be value 1)
-//                 16 [long]   offset of image data in mdat
-bool ProcessCo64(StreamInterface* stream, const Box& co64_box,
-                 uint32_t* image_offset) {
-  uint32_t count = 0;
-  if (!Get32u(stream, co64_box.header_offset() + 4, &count)) {
-    return false;
-  }
-  if (count != 1) {
-    return false;
-  }
-  return Get32u(stream, co64_box.header_offset() + 8, image_offset);
-}
-
-// Process the stbl box. Expected box layout:
-// stbl
-//   stsd
-//     CRAW  (embedded image (JPEG) information)
-//   (0 or more skipped boxes)
-//   stsz (embedded image byte size)
-//   (0 or more skipped boxes)
-//   co64 (offset of embedded image, relative to mdat box)
-bool ProcessStblBox(StreamInterface* stream, const Box& stbl_box,
-                    ProcessData* data) {
-  Box stsd_box = GetNextBoxWithTag(stream, stbl_box.header_offset(), kStsdTag);
-  if (!stsd_box.IsValid()) {
-    return false;
-  }
-  // This is either CRAW or CTMD. Skip when CTMD.
-  Box craw_box = GetNextBox(stream, stsd_box.header_offset() + 8);
-  if (!craw_box.IsValid()) {
-    return false;
-  }
-  if (craw_box.tag() != kCrawTag) {
-    return true;
-  }
-  // CRAW contains info about the full-size image embedded in the mdat box.
-  // The image is either JPEG or HEVC.
-  uint16_t image_width = 0;
-  uint16_t image_height = 0;
-  uint16_t content_type = 0;
-  if (!ProcessCrawBox(stream, craw_box, &image_width, &image_height,
-                      &content_type)) {
-    return false;
-  }
-  // Only continue if JPEG or HEVC content.
-  constexpr uint16_t kJpegContentType = 3;
-  constexpr uint16_t kHevcContentType = 4;
-  if (content_type != kJpegContentType && content_type != kHevcContentType) {
-    return true;
-  }
-
-  // Skip until we find stsz, contains the size (# of bytes) of image data.
-  Box stsz_box =
-      GetNextBoxWithTag(stream, stsd_box.next_box_offset(), kStszTag);
-  if (!stsz_box.IsValid()) {
-    return false;
-  }
-  uint32_t image_size;
-  if (!ProcessStszBox(stream, stsz_box, &image_size)) {
-    return false;
-  }
-
-  // Skip until we find co64, contains the offset of image data.
-  Box co64_box =
-      GetNextBoxWithTag(stream, stsz_box.next_box_offset(), kCo64Tag);
-  if (!co64_box.IsValid()) {
-    return false;
-  }
-
-  uint32_t image_offset = 0;
-  if (!ProcessCo64(stream, co64_box, &image_offset)) {
-    return false;
-  }
-
-  data->mdat_image.format = content_type == kJpegContentType
-                                ? Image::kJpegCompressed
-                                : Image::kHevcCompressed;
-  data->mdat_image.width = image_width;
-  data->mdat_image.height = image_height;
-  data->mdat_image.length = image_size;
-  // This offset is relative to the position of the mdat box. The value will
-  // be updated once mdat's offset is found.
-  data->mdat_image.offset = image_offset;
-  return true;
-}
-
-// Returns true if we should parse the children of the box.
-bool DoProcessChildren(const BoxTag& tag) {
-  static const std::set<BoxTag> kTags = {NewTag("trak"), NewTag("moov"),
-                                         NewTag("mdia"), NewTag("minf")};
-  return kTags.find(tag) != kTags.end();
-}
-
-// Processes box and returns offset of the next box to process.
-// A return value of 0 indicates an error.
-//
-// Outline of hierarchy and important boxes:
-// ftyp
-// moov
-//   uuid (id is kUuidMoov)
-//     ... boxes we skip ...
-//     CMT1 (EXIF data)
-//     CMT2 (EXIF data)
-//     ... boxes we skip ...
-//     THMB (160x120 JPEG thumbnail, embedded in this box)
-//   trak
-//     tkhd
-//     mdia
-//     ... boxes we skip ...
-//     minf
-//       ... boxes we skip ...
-//       stbl
-//         stsd
-//           CRAW (Full image preview, type (JPEG or HEVC), width, height. The
-//                 image data is found in mdat box, below.)
-//       ... boxes we skip ...
-//       stsz (Size of preview, in bytes)
-//       ... boxes we skip ...
-//       co64 (Location/offset of full preview data in mdat)
-//   .. boxes we skip ...
-// uuid (id is kUuidPrvw)
-//   PRVW (1620x1080 JPEG preview, embedded in this box)
-// mdat
-//   Full image preview (JPEG or HEVC)
-//   ... RAW image data ...
-size_t ProcessBox(StreamInterface* stream, const Box& box, ProcessData* data) {
-  // Parse child boxes.
-  if (box.tag() == kUuidTag) {
-    // Uuid box have extended box types.
-    Uuid uuid;
-    if (stream->GetData(box.header_offset(), uuid.size(), uuid.data()) != kOk) {
-      return 0;
-    }
-    if (uuid == kUuidPrvw) {
-      return box.header_offset() + uuid.size() + 8;
-    } else if (uuid == kUuidMoov) {
-      return box.header_offset() + uuid.size();
-    }  // else skip the box, below.
-  } else if (DoProcessChildren(box.tag())) {
-    return box.header_offset();
-  }
-
-  // Potentially process the data contained in the box.
-  bool success;
-  if (box.tag() == kMdatTag) {
-    // mdat_image.offset is relative to mdat's header, update it to be absolute
-    // offset to the image data.
-    data->mdat_image.offset += box.header_offset();
-    success = true;
-  } else if (box.tag() == kStblTag) {
-    success = ProcessStblBox(stream, box, data);
-  } else if (box.tag() == kPrvwTag) {
-    // Preview jpeg. 1620x1080 for EOS R.
-    success = ProcessJpegBox(stream, box, &data->prvw_image);
-  } else if (box.tag() == kThmbTag) {
-    // Thumbnail jpeg. 160x120 for EOS R.
-    success = ProcessJpegBox(stream, box, &data->preview_image_data->thumbnail);
-  } else if (box.tag() == kCmt1Tag) {
-    success =
-        ParseExifIfd0(stream, box.header_offset(), data->preview_image_data);
-  } else if (box.tag() == kCmt2Tag) {
-    success =
-        ParseExifExifIfd(stream, box.header_offset(), data->preview_image_data);
-  } else {
-    // This box isn't interesting, skip it.
-    success = true;
-  }
-  return success ? box.next_box_offset() : 0;
-}
-
-bool ProcessStream(StreamInterface* stream, const BoxTag& last_chunk,
-                   ProcessData* data) {
-  size_t offset = 0;
-  while (true) {
-    Box box = GetNextBox(stream, offset);
-    if (!box.IsValid()) {
-      return false;
-    }
-    size_t new_offset = ProcessBox(stream, box, data);
-    if (new_offset <= offset) {
-      return false;
-    }
-    if (box.tag() == last_chunk) {
-      return true;
-    }
-    offset = new_offset;
-  }
-}
-
-bool IsImage(StreamInterface* stream, const Image& image) {
-  if (image.format != Image::kJpegCompressed) {
-    // Pass responsibility to the caller.
-    return true;
-  }
-  // Check for JPEG magic number at start. This could be HEVC data.
-  constexpr std::array<uint8_t, 3> kJpegMagicNumber = {0xFF, 0xD8, 0xFF};
-  std::array<uint8_t, 3> magic_number;
-  if (stream->GetData(image.offset, magic_number.size(), magic_number.data()) !=
-      kOk) {
-    return false;
-  }
-  return magic_number == kJpegMagicNumber;
-}
-
-}  // namespace
-
-Error Cr3GetPreviewData(StreamInterface* stream,
-                        PreviewImageData* preview_image_data) {
-  ProcessData data{.preview_image_data = preview_image_data};
-  if (!ProcessStream(stream, kMdatTag, &data)) {
-    return kFail;
-  }
-  // Prefer image in mdata box, as spec ensures it is the largest image.
-  if (data.mdat_image.length > 0 && IsImage(stream, data.mdat_image)) {
-    preview_image_data->preview = data.mdat_image;
-  } else if (data.prvw_image.length > 0 && IsImage(stream, data.prvw_image)) {
-    preview_image_data->preview = data.prvw_image;
-  } else {
-    return kFail;
-  }
-  return kOk;
-}
-
-bool Cr3GetOrientation(StreamInterface* stream, std::uint32_t* orientation) {
-  PreviewImageData preview_image_data;
-  ProcessData data{.preview_image_data = &preview_image_data};
-  if (ProcessStream(stream, kCmt1Tag, &data)) {
-    *orientation = preview_image_data.exif_orientation;
-    return true;
-  }
-  return false;
-}
-
-}  // namespace piex
diff --git a/src/piex_cr3.h b/src/piex_cr3.h
deleted file mode 100644
index 3108503..0000000
--- a/src/piex_cr3.h
+++ /dev/null
@@ -1,43 +0,0 @@
-// Copyright 2020 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#include "src/piex_types.h"
-
-#ifndef PIEX_PIEX_CR3_H_
-#define PIEX_PIEX_CR3_H_
-
-namespace piex {
-
-// Gets the EXIF orientation of a CR3 stream, returning true on success.
-bool Cr3GetOrientation(StreamInterface* stream, std::uint32_t* orientation);
-
-// Gets preview images of a CR3 stream, returning kOk on success. Assumes the
-// stream is a CR3 stream.
-//
-// Canon's CR3 is based on ISO/IEC 14496-12: ISO base media file format. (CR2 is
-// TIFF based.) A Canon CR3 contains multiple embedded images. Most cameras
-// output CR3 files that contain a full-size JPEG, a 1620x1080 preview JPEG, and
-// a 160x120 thumbnail JPEG.
-// The Canon EOS 1D X Mark III, though, contains a full-size HEVC image, a
-// 1620x1080 preview JPEG, and a 160x120 thumbnail JPEG.
-// Until support for HEVC is added, this method returns the largest embedded
-// JPEG in preview_image_data->preview.
-//
-Error Cr3GetPreviewData(StreamInterface* stream,
-                        PreviewImageData* preview_image_data);
-}  // namespace piex
-
-#endif  // PIEX_PIEX_CR3_H_
diff --git a/src/piex_types.h b/src/piex_types.h
deleted file mode 100644
index 2062136..0000000
--- a/src/piex_types.h
+++ /dev/null
@@ -1,125 +0,0 @@
-// Copyright 2015 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#ifndef PIEX_PIEX_TYPES_H_
-#define PIEX_PIEX_TYPES_H_
-
-#include <cstdint>
-#include <string>
-#include <vector>
-
-namespace piex {
-
-// Defines the error codes used by piex.
-enum Error {
-  kOk,
-  kFail,
-  kUnsupported,
-};
-
-// Defines the properties of an image. width and height are required for
-// uncompressed images, but are optional for compressed images. An image is
-// invalid when its length is 0.
-struct Image {
-  enum Format {
-    kJpegCompressed,
-    kUncompressedRgb,
-    kHevcCompressed,
-  };
-
-  std::uint16_t width = 0;
-  std::uint16_t height = 0;
-  std::uint32_t length = 0;
-  std::uint32_t offset = 0;
-  Format format = kJpegCompressed;
-
-  bool operator>(const Image& rhs) const {
-    return width > rhs.width && height > rhs.height;
-  }
-};
-
-// Contains relevant image information as well as the 'preview_offset' and the
-// 'preview_length' which are used to obtain the JPEG compressed preview image.
-// 'full_width' and 'full_height' are correctly cropped but not rotated.
-struct PreviewImageData {
-  enum ColorSpace {
-    kSrgb,
-    kAdobeRgb,
-  };
-  struct Rational {
-    std::uint32_t numerator = 0;
-    std::uint32_t denominator = 1;
-  };
-  struct Gps {
-    // Indicates if the gps data is valid to use.
-    bool is_valid = false;
-
-    char latitude_ref;  // Either 'N' or 'S'
-    Rational latitude[3];
-    char longitude_ref;  // Either 'E' or 'W'
-    Rational longitude[3];
-    bool altitude_ref = false;  // true is above, false below sea level
-    Rational altitude;
-
-    Rational time_stamp[3];  // Giving hour, minute and second.
-    std::string date_stamp;  // Giving as "YYYY:MM:DD" format.
-  };
-
-  // Optional data to find the preview and thumbnail image to handle them
-  // correctly. A thumbnail is typically 160x120 pixel small and usually
-  // has black borders at the top and bottom. If length is 0 the image could not
-  // be extracted.
-  Image preview;
-  Image thumbnail;
-
-  std::uint32_t exif_orientation = 1;  // horizontal as default
-  ColorSpace color_space = kSrgb;
-
-  // Optional Exif metadata that describes the image.
-  std::uint32_t full_width = 0;
-  std::uint32_t full_height = 0;
-  std::string maker;
-  std::string model;
-  std::string date_time;
-  std::uint32_t iso = 0;
-  Rational exposure_time;
-  Rational fnumber;
-  Rational focal_length;
-  Gps gps;
-
-  // Hint for the mosaic pattern dimension of the RAW image data. (0, 0) implies
-  // that no mosaic info found. It is valid for DNG, NEF and NRW files.
-  std::vector<std::uint32_t> cfa_pattern_dim = std::vector<std::uint32_t>(2, 0);
-};
-
-// Defines the StreamInterface that needs to be implemented by the client.
-class StreamInterface {
- public:
-  virtual ~StreamInterface() {}
-
-  // Reads 'length' amount of bytes from 'offset' to 'data'. The 'data' buffer
-  // provided by the caller, guaranteed to be at least "length" bytes long.
-  // On 'kOk' the 'data' pointer contains 'length' valid bytes beginning at
-  // 'offset' bytes from the start of the stream.
-  // Returns 'kFail' if 'offset' + 'length' exceeds the stream and does not
-  // change the contents of 'data'.
-  virtual Error GetData(const size_t offset, const size_t length,
-                        std::uint8_t* data) = 0;
-};
-
-}  // namespace piex
-
-#endif  // PIEX_PIEX_TYPES_H_
diff --git a/src/tiff_directory/tiff_directory.cc b/src/tiff_directory/tiff_directory.cc
deleted file mode 100644
index 8db15a2..0000000
--- a/src/tiff_directory/tiff_directory.cc
+++ /dev/null
@@ -1,282 +0,0 @@
-// Copyright 2015 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#include "src/tiff_directory/tiff_directory.h"
-
-#include <assert.h>
-#include <climits>
-
-#include "src/binary_parse/range_checked_byte_ptr.h"
-
-namespace piex {
-namespace tiff_directory {
-namespace {
-
-using binary_parse::Get16s;
-using binary_parse::Get16u;
-using binary_parse::Get32s;
-using binary_parse::Get32u;
-using binary_parse::MemoryStatus;
-using binary_parse::RANGE_CHECKED_BYTE_SUCCESS;
-using binary_parse::RangeCheckedBytePtr;
-
-}  // namespace
-
-TiffDirectory::TiffDirectory(Endian endian) : endian_(endian) {}
-
-bool TiffDirectory::Has(const Tag tag) const {
-  return directory_entries_.count(tag) == 1;
-}
-
-bool TiffDirectory::Get(const Tag tag, std::vector<std::uint8_t>* value) const {
-  const DirectoryEntry* directory_entry = Find(tag);
-  if (directory_entry == NULL ||
-      (directory_entry->type != TIFF_TYPE_BYTE &&
-       directory_entry->type != TIFF_TYPE_UNDEFINED)) {
-    return false;
-  }
-
-  *value = directory_entry->value;
-  return true;
-}
-
-bool TiffDirectory::Get(const Tag tag, std::string* value) const {
-  const DirectoryEntry* directory_entry = Find(tag);
-  if (directory_entry == NULL || directory_entry->type != TIFF_TYPE_ASCII) {
-    return false;
-  }
-  *value =
-      std::string(directory_entry->value.begin(), directory_entry->value.end());
-  return true;
-}
-
-bool TiffDirectory::Get(const Tag tag, std::uint32_t* value) const {
-  std::vector<std::uint32_t> my_values;
-  if (!Get(tag, &my_values) || my_values.size() != 1) {
-    return false;
-  }
-  *value = my_values[0];
-  return true;
-}
-
-bool TiffDirectory::Get(const Tag tag,
-                        std::vector<std::uint32_t>* value) const {
-  const DirectoryEntry* directory_entry = Find(tag);
-  if (directory_entry == NULL || (directory_entry->type != TIFF_TYPE_SHORT &&
-                                  directory_entry->type != TIFF_TYPE_LONG)) {
-    return false;
-  }
-
-  RangeCheckedBytePtr value_ptr(&directory_entry->value[0],
-                                directory_entry->value.size());
-  std::vector<std::uint32_t> my_value(directory_entry->count);
-  const bool is_big_endian = (endian_ == kBigEndian);
-
-  MemoryStatus err = RANGE_CHECKED_BYTE_SUCCESS;
-  for (std::uint32_t c = 0; c < directory_entry->count; ++c) {
-    if (directory_entry->type == TIFF_TYPE_SHORT) {
-      my_value[c] = Get16u(value_ptr + c * 2, is_big_endian, &err);
-    } else {
-      my_value[c] = Get32u(value_ptr + c * 4, is_big_endian, &err);
-    }
-  }
-  if (err != RANGE_CHECKED_BYTE_SUCCESS) {
-    return false;
-  }
-
-  *value = my_value;
-  return true;
-}
-
-bool TiffDirectory::Get(const Tag tag, Rational* value) const {
-  std::vector<Rational> my_values;
-  if (!Get(tag, &my_values) || my_values.size() != 1) {
-    return false;
-  }
-  *value = my_values[0];
-  return true;
-}
-
-bool TiffDirectory::Get(const Tag tag, std::vector<Rational>* value) const {
-  const DirectoryEntry* directory_entry = Find(tag);
-  if (directory_entry == NULL ||
-      (directory_entry->type != TIFF_TYPE_SHORT &&
-       directory_entry->type != TIFF_TYPE_LONG &&
-       directory_entry->type != TIFF_TYPE_RATIONAL)) {
-    return false;
-  }
-
-  RangeCheckedBytePtr value_ptr(&directory_entry->value[0],
-                                directory_entry->value.size());
-  std::vector<Rational> my_value(directory_entry->count);
-  const bool is_big_endian = (endian_ == kBigEndian);
-
-  MemoryStatus err = RANGE_CHECKED_BYTE_SUCCESS;
-  for (std::uint32_t c = 0; c < directory_entry->count; ++c) {
-    switch (directory_entry->type) {
-      case TIFF_TYPE_SHORT: {
-        my_value[c].numerator = Get16u(value_ptr + c * 2, is_big_endian, &err);
-        my_value[c].denominator = 1;
-        break;
-      }
-      case TIFF_TYPE_LONG: {
-        my_value[c].numerator = Get32u(value_ptr + c * 4, is_big_endian, &err);
-        my_value[c].denominator = 1;
-        break;
-      }
-      case TIFF_TYPE_RATIONAL: {
-        my_value[c].numerator = Get32u(value_ptr + c * 8, is_big_endian, &err);
-        my_value[c].denominator =
-            Get32u(value_ptr + c * 8 + 4, is_big_endian, &err);
-        if (my_value[c].denominator == 0) {
-          return false;
-        }
-        break;
-      }
-    }
-  }
-  if (err != RANGE_CHECKED_BYTE_SUCCESS) {
-    return false;
-  }
-
-  *value = my_value;
-  return true;
-}
-
-bool TiffDirectory::Get(const Tag tag, SRational* value) const {
-  std::vector<SRational> my_values;
-  if (!Get(tag, &my_values) || my_values.size() != 1) {
-    return false;
-  }
-  *value = my_values[0];
-  return true;
-}
-
-bool TiffDirectory::Get(const Tag tag, std::vector<SRational>* value) const {
-  const DirectoryEntry* directory_entry = Find(tag);
-  if (directory_entry == NULL ||
-      (directory_entry->type != TIFF_TYPE_SSHORT &&
-       directory_entry->type != TIFF_TYPE_SLONG &&
-       directory_entry->type != TIFF_TYPE_SRATIONAL)) {
-    return false;
-  }
-
-  RangeCheckedBytePtr value_ptr(&directory_entry->value[0],
-                                directory_entry->value.size());
-  std::vector<SRational> my_value(directory_entry->count);
-  const bool is_big_endian = (endian_ == kBigEndian);
-
-  MemoryStatus err = RANGE_CHECKED_BYTE_SUCCESS;
-  for (std::uint32_t c = 0; c < directory_entry->count; ++c) {
-    switch (directory_entry->type) {
-      case TIFF_TYPE_SSHORT: {
-        my_value[c].numerator = Get16s(value_ptr + c * 2, is_big_endian, &err);
-        my_value[c].denominator = 1;
-        break;
-      }
-      case TIFF_TYPE_SLONG: {
-        my_value[c].numerator = Get32s(value_ptr + c * 4, is_big_endian, &err);
-        my_value[c].denominator = 1;
-        break;
-      }
-      case TIFF_TYPE_SRATIONAL: {
-        my_value[c].numerator = Get32s(value_ptr + c * 8, is_big_endian, &err);
-        my_value[c].denominator =
-            Get32s(value_ptr + c * 8 + 4, is_big_endian, &err);
-        if (my_value[c].denominator == 0) {
-          return false;
-        }
-        break;
-      }
-    }
-  }
-  if (err != RANGE_CHECKED_BYTE_SUCCESS) {
-    return false;
-  }
-
-  *value = my_value;
-  return true;
-}
-
-bool TiffDirectory::GetOffsetAndLength(const Tag tag, const Type type,
-                                       std::uint32_t* offset,
-                                       std::uint32_t* length) const {
-  const DirectoryEntry* directory_entry = Find(tag);
-  if (directory_entry == NULL || directory_entry->type != type) {
-    return false;
-  }
-  *offset = directory_entry->offset;
-  *length = static_cast<std::uint32_t>(directory_entry->value.size());
-  return true;
-}
-
-void TiffDirectory::AddEntry(const Tag tag, const Type type,
-                             const std::uint32_t count,
-                             const std::uint32_t offset,
-                             const std::vector<std::uint8_t>& value) {
-  assert(SizeOfType(type, NULL /* success */) * count == value.size());
-
-  const DirectoryEntry directory_entry = {type, count, offset, value};
-  directory_entries_[tag] = directory_entry;
-  tag_order_.push_back(tag);
-}
-
-void TiffDirectory::AddSubDirectory(const TiffDirectory& sub_directory) {
-  sub_directories_.push_back(sub_directory);
-}
-
-const std::vector<TiffDirectory>& TiffDirectory::GetSubDirectories() const {
-  return sub_directories_;
-}
-
-const TiffDirectory::DirectoryEntry* TiffDirectory::Find(const Tag tag) const {
-  std::map<Tag, DirectoryEntry>::const_iterator iter =
-      directory_entries_.find(tag);
-  if (iter == directory_entries_.end()) {
-    return NULL;
-  }
-  return &iter->second;
-}
-
-size_t SizeOfType(const TiffDirectory::Type type, bool* success) {
-  switch (type) {
-    case TIFF_TYPE_BYTE:
-    case TIFF_TYPE_ASCII:
-    case TIFF_TYPE_SBYTE:
-    case TIFF_TYPE_UNDEFINED:
-      return 1;
-    case TIFF_TYPE_SHORT:
-    case TIFF_TYPE_SSHORT:
-      return 2;
-    case TIFF_TYPE_LONG:
-    case TIFF_TYPE_SLONG:
-    case TIFF_TYPE_FLOAT:
-    case TIFF_IFD:
-      return 4;
-    case TIFF_TYPE_RATIONAL:
-    case TIFF_TYPE_SRATIONAL:
-    case TIFF_TYPE_DOUBLE:
-      return 8;
-  }
-
-  if (success != NULL) {
-    *success = false;
-  }
-  return 0;
-}
-
-}  // namespace tiff_directory
-}  // namespace piex
diff --git a/src/tiff_directory/tiff_directory.h b/src/tiff_directory/tiff_directory.h
deleted file mode 100644
index 855adfc..0000000
--- a/src/tiff_directory/tiff_directory.h
+++ /dev/null
@@ -1,161 +0,0 @@
-// Copyright 2015 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-////////////////////////////////////////////////////////////////////////////////
-//
-// TiffDirectory contains an abstraction of an image file directory (IFD) as
-// proposed by the TIFF specification.
-
-#ifndef PIEX_TIFF_DIRECTORY_TIFF_DIRECTORY_H_
-#define PIEX_TIFF_DIRECTORY_TIFF_DIRECTORY_H_
-
-#include <cstdint>
-#include <map>
-#include <string>
-#include <vector>
-
-namespace piex {
-namespace tiff_directory {
-
-enum Endian {
-  kLittleEndian = 0,
-  kBigEndian = 1,
-};
-
-struct Rational {
-  std::uint32_t numerator;
-  std::uint32_t denominator;
-};
-
-struct SRational {
-  std::int32_t numerator;
-  std::int32_t denominator;
-};
-
-enum TiffTypes {
-  TIFF_TYPE_NONE = 0,
-  TIFF_TYPE_BYTE,      /* 8bit unsigned */
-  TIFF_TYPE_ASCII,     /* Ascii string (terminated by \0) */
-  TIFF_TYPE_SHORT,     /* 16bit unsigned  */
-  TIFF_TYPE_LONG,      /* 32bit unsigned  */
-  TIFF_TYPE_RATIONAL,  /* 32bit/32bit unsigned  */
-  TIFF_TYPE_SBYTE,     /* 8bit signed */
-  TIFF_TYPE_UNDEFINED, /* undefined (depend of tag) */
-  TIFF_TYPE_SSHORT,    /* 16bit signed*/
-  TIFF_TYPE_SLONG,     /* 32bit signed  */
-  TIFF_TYPE_SRATIONAL, /* 32bit/32bit signed */
-  TIFF_TYPE_FLOAT,     /* 32-bit IEEE float */
-  TIFF_TYPE_DOUBLE,    /* 64-bit IEEE float */
-  TIFF_IFD,            /* IFD type */
-};
-
-// The TiffDirectory class stores all information necessary to interpret TIFF
-// tags and manages also potential sub directories.
-class TiffDirectory {
- public:
-  typedef std::uint32_t Tag;
-  typedef std::uint32_t Type;
-
-  explicit TiffDirectory(Endian endianness);
-
-  // Returns true if the directory contains the specified tag.
-  bool Has(const Tag tag) const;
-
-  // Gets the value of a tag of byte vector type.
-  // Returns false if the tag is not part of the directory or if the
-  // type is not BYTE or UNDEFINED.
-  bool Get(const Tag tag, std::vector<std::uint8_t>* value) const;
-
-  // Gets the value of a tag of type "ASCII".
-  // Returns false if the tag is not part of the directory or if its
-  // type is not ASCII.
-  // If *err is not equal to ERR_OK initially, this method does nothing.
-  bool Get(const Tag tag, std::string* value) const;
-
-  // Gets the value of a tag of type "SHORT" or "LONG".
-  // Returns false
-  // - if the tag is not part of the directory or
-  // - if the type is not SHORT or LONG, or
-  // - if, for the non-vector version, the number of elements is unequal to 1.
-  bool Get(const Tag tag, std::uint32_t* value) const;
-  bool Get(const Tag tag, std::vector<std::uint32_t>* value) const;
-
-  // Gets the value of a tag of type "SHORT", "LONG" or "RATIONAL".
-  // Returns false
-  // - if the tag is not part of the directory or
-  // - if the type is not SHORT, LONG or RATIONAL, or
-  // - if, for the non-vector version, the number of elements is unequal to 1.
-  bool Get(const Tag tag, Rational* value) const;
-  bool Get(const Tag tag, std::vector<Rational>* value) const;
-
-  // Gets the value of a tag of type "SSHORT", "SLONG" or "SRATIONAL".
-  // Returns false
-  // - if the tag is not part of the directory or
-  // - if the type is not SSHORT, SLONG or SRATIONAL, or
-  // - if, for the non-vector version, the number of elements is unequal to 1.
-  bool Get(const Tag tag, SRational* value) const;
-  bool Get(const Tag tag, std::vector<SRational>* value) const;
-
-  // Gets the 'offset' to the value data in the file and its 'length' in bytes.
-  // Returns false if the 'tag' is not part of the directory or if its type does
-  // not match the desired 'type'.
-  bool GetOffsetAndLength(const Tag tag, const Type type, std::uint32_t* offset,
-                          std::uint32_t* length) const;
-
-  // Adds a tag to the directory, setting its type, number of elements
-  // ('count'), the offset to the binary data in the file ('offset') and the
-  // associated binary data ('value'). The binary data is encoded according to
-  // the TIFF specification with the endianness that was specified when this
-  // object was constructed. The caller must ensure that the size of 'value' and
-  // the data it contains are consistent with 'type' and 'count'. It is not
-  // legal to call this method with a tag that is already contained in the
-  // directory.
-  void AddEntry(const Tag tag, const Type type, const std::uint32_t count,
-                const std::uint32_t offset,
-                const std::vector<std::uint8_t>& value);
-
-  // Add a subdirectory to the directory.
-  void AddSubDirectory(const TiffDirectory& sub_directory);
-
-  // Returns a vector of all subdirectories contained in this directory.
-  const std::vector<TiffDirectory>& GetSubDirectories() const;
-
- private:
-  struct DirectoryEntry {
-    Type type;
-    std::uint32_t count;   // The number of values of type, not a byte count.
-    std::uint32_t offset;  // Offset of the entry's data in the file. '0' means
-                           // the offset is not set.
-    std::vector<std::uint8_t> value;
-  };
-
-  const DirectoryEntry* Find(const Tag tag) const;
-
-  std::map<Tag, DirectoryEntry> directory_entries_;
-  std::vector<Tag> tag_order_;
-  std::vector<TiffDirectory> sub_directories_;
-  Endian endian_;
-};
-
-// Returns the number of bytes a single value of 'type' requires; this is
-// guaranteed to be in the range of 0 to 8.
-// Returns 0 if 'type' is TIFF_TYPE_NONE or invalid. Sets 'success' to false if
-// 'type' is invalid. If you are not interested in 'success' you can set it to
-// a nullptr.
-size_t SizeOfType(const TiffDirectory::Type type, bool* success);
-
-}  // namespace tiff_directory
-}  // namespace piex
-
-#endif  // PIEX_TIFF_DIRECTORY_TIFF_DIRECTORY_H_
diff --git a/src/tiff_parser.cc b/src/tiff_parser.cc
deleted file mode 100644
index 3ceaa75..0000000
--- a/src/tiff_parser.cc
+++ /dev/null
@@ -1,755 +0,0 @@
-// Copyright 2015 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#include "src/tiff_parser.h"
-
-#include <cstring>
-#include <limits>
-#include <numeric>
-
-#include "src/tiff_directory/tiff_directory.h"
-
-namespace piex {
-namespace {
-
-using tiff_directory::Endian;
-using tiff_directory::Rational;
-using tiff_directory::SizeOfType;
-using tiff_directory::TIFF_TYPE_LONG;
-using tiff_directory::TIFF_TYPE_UNDEFINED;
-using tiff_directory::TiffDirectory;
-using tiff_directory::kBigEndian;
-using tiff_directory::kLittleEndian;
-
-// Specifies all tags that might be of interest to parse JPEG data.
-const std::uint32_t kStartOfFrame = 0xFFC0;
-const std::uint32_t kStartOfImage = 0xFFD8;
-const std::uint32_t kStartOfScan = 0xFFDA;
-
-bool GetFullDimension16(const TiffDirectory& tiff_directory,
-                        std::uint16_t* width, std::uint16_t* height) {
-  std::uint32_t tmp_width = 0;
-  std::uint32_t tmp_height = 0;
-  if (!GetFullDimension32(tiff_directory, &tmp_width, &tmp_height) ||
-      tmp_width > std::numeric_limits<std::uint16_t>::max() ||
-      tmp_height > std::numeric_limits<std::uint16_t>::max()) {
-    return false;
-  }
-  *width = static_cast<std::uint16_t>(tmp_width);
-  *height = static_cast<std::uint16_t>(tmp_height);
-  return true;
-}
-
-void FillGpsPreviewImageData(const TiffDirectory& gps_directory,
-                             PreviewImageData* preview_image_data) {
-  if (gps_directory.Has(kGpsTagLatitudeRef) &&
-      gps_directory.Has(kGpsTagLatitude) &&
-      gps_directory.Has(kGpsTagLongitudeRef) &&
-      gps_directory.Has(kGpsTagLongitude) &&
-      gps_directory.Has(kGpsTagTimeStamp) &&
-      gps_directory.Has(kGpsTagDateStamp)) {
-    preview_image_data->gps.is_valid = false;
-    std::string value;
-    if (!gps_directory.Get(kGpsTagLatitudeRef, &value) || value.empty() ||
-        (value[0] != 'N' && value[0] != 'S') ||
-        !GetRational(kGpsTagLatitude, gps_directory, 3 /* data size */,
-                     preview_image_data->gps.latitude)) {
-      return;
-    }
-    preview_image_data->gps.latitude_ref = value[0];
-
-    if (!gps_directory.Get(kGpsTagLongitudeRef, &value) || value.empty() ||
-        (value[0] != 'E' && value[0] != 'W') ||
-        !GetRational(kGpsTagLongitude, gps_directory, 3 /* data size */,
-                     preview_image_data->gps.longitude)) {
-      return;
-    }
-    preview_image_data->gps.longitude_ref = value[0];
-
-    if (!GetRational(kGpsTagTimeStamp, gps_directory, 3 /* data size */,
-                     preview_image_data->gps.time_stamp)) {
-      return;
-    }
-
-    const size_t kGpsDateStampSize = 11;
-    if (!gps_directory.Get(kGpsTagDateStamp,
-                           &preview_image_data->gps.date_stamp)) {
-      return;
-    }
-    if (preview_image_data->gps.date_stamp.size() == kGpsDateStampSize) {
-      // Resize the date_stamp to remove the "NULL" at the end of string.
-      preview_image_data->gps.date_stamp.resize(kGpsDateStampSize - 1);
-    } else {
-      return;
-    }
-
-    if (gps_directory.Has(kGpsTagAltitudeRef) &&
-        gps_directory.Has(kGpsTagAltitude)) {
-      std::vector<std::uint8_t> bytes;
-      if (!gps_directory.Get(kGpsTagAltitudeRef, &bytes) || bytes.empty() ||
-          !GetRational(kGpsTagAltitude, gps_directory, 1,
-                       &preview_image_data->gps.altitude)) {
-        return;
-      }
-      preview_image_data->gps.altitude_ref = bytes[0] != 0;
-    }
-    preview_image_data->gps.is_valid = true;
-  }
-}
-
-void GetImageSize(const TiffDirectory& tiff_directory, StreamInterface* stream,
-                  Image* image) {
-  switch (image->format) {
-    case Image::kUncompressedRgb: {
-      GetFullDimension16(tiff_directory, &image->width, &image->height);
-      break;
-    }
-    case Image::kJpegCompressed: {
-      GetJpegDimensions(image->offset, stream, &image->width, &image->height);
-      break;
-    }
-    default: { return; }
-  }
-}
-
-bool FillPreviewImageData(const TiffDirectory& tiff_directory,
-                          StreamInterface* stream,
-                          PreviewImageData* preview_image_data) {
-  bool success = true;
-  // Get preview or thumbnail. The code assumes that only thumbnails can be
-  // uncompressed. Preview images are always JPEG compressed.
-  Image image;
-  if (GetImageData(tiff_directory, stream, &image)) {
-    if (IsThumbnail(image)) {
-      preview_image_data->thumbnail = image;
-    } else if (image.format == Image::kJpegCompressed) {
-      preview_image_data->preview = image;
-    }
-  }
-
-  // Get exif_orientation if it was not set already.
-  if (tiff_directory.Has(kTiffTagOrientation) &&
-      preview_image_data->exif_orientation == 1) {
-    success &= tiff_directory.Get(kTiffTagOrientation,
-                                  &preview_image_data->exif_orientation);
-  }
-
-  // Get color_space
-  if (tiff_directory.Has(kExifTagColorSpace)) {
-    std::uint32_t color_space;
-    if (tiff_directory.Get(kExifTagColorSpace, &color_space)) {
-      if (color_space == 1) {
-        preview_image_data->color_space = PreviewImageData::kSrgb;
-      } else if (color_space == 65535 || color_space == 2) {
-        preview_image_data->color_space = PreviewImageData::kAdobeRgb;
-      }
-    } else {
-      success = false;
-    }
-  }
-
-  success &= GetFullDimension32(tiff_directory, &preview_image_data->full_width,
-                                &preview_image_data->full_height);
-
-  if (tiff_directory.Has(kTiffTagMake)) {
-    success &= tiff_directory.Get(kTiffTagMake, &preview_image_data->maker);
-  }
-
-  if (tiff_directory.Has(kTiffTagModel)) {
-    success &= tiff_directory.Get(kTiffTagModel, &preview_image_data->model);
-  }
-
-  if (tiff_directory.Has(kTiffTagCfaPatternDim)) {
-    std::vector<std::uint32_t> cfa_pattern_dim;
-    if (tiff_directory.Get(kTiffTagCfaPatternDim, &cfa_pattern_dim) &&
-        cfa_pattern_dim.size() == 2) {
-      preview_image_data->cfa_pattern_dim[0] = cfa_pattern_dim[0];
-      preview_image_data->cfa_pattern_dim[1] = cfa_pattern_dim[1];
-    }
-  }
-
-  if (tiff_directory.Has(kExifTagDateTimeOriginal)) {
-    success &= tiff_directory.Get(kExifTagDateTimeOriginal,
-                                  &preview_image_data->date_time);
-  }
-
-  if (tiff_directory.Has(kExifTagIsoSpeed)) {
-    success &= tiff_directory.Get(kExifTagIsoSpeed, &preview_image_data->iso);
-  } else if (tiff_directory.Has(kPanaTagIso)) {
-    success &= tiff_directory.Get(kPanaTagIso, &preview_image_data->iso);
-  }
-
-  if (tiff_directory.Has(kExifTagExposureTime)) {
-    success &= GetRational(kExifTagExposureTime, tiff_directory, 1,
-                           &preview_image_data->exposure_time);
-  }
-
-  if (tiff_directory.Has(kExifTagFnumber)) {
-    success &= GetRational(kExifTagFnumber, tiff_directory, 1,
-                           &preview_image_data->fnumber);
-  }
-
-  if (tiff_directory.Has(kExifTagFocalLength)) {
-    success &= GetRational(kExifTagFocalLength, tiff_directory, 1,
-                           &preview_image_data->focal_length);
-  }
-
-  return success;
-}
-
-const TiffDirectory* FindFirstTagInIfds(const TiffDirectory::Tag& tag,
-                                        const IfdVector& tiff_directory) {
-  for (std::uint32_t i = 0; i < tiff_directory.size(); ++i) {
-    if (tiff_directory[i].Has(tag)) {
-      return &tiff_directory[i];
-    }
-
-    // Recursively search sub directories.
-    const TiffDirectory* sub_directory =
-        FindFirstTagInIfds(tag, tiff_directory[i].GetSubDirectories());
-    if (sub_directory != NULL) {
-      return sub_directory;
-    }
-  }
-  return NULL;
-}
-
-// Return true if all data blocks are ordered one after the other without gaps.
-bool OffsetsAreConsecutive(
-    const std::vector<std::uint32_t>& strip_offsets,
-    const std::vector<std::uint32_t>& strip_byte_counts) {
-  if (strip_offsets.size() != strip_byte_counts.size() ||
-      strip_offsets.empty()) {
-    return false;
-  }
-
-  for (size_t i = 0; i < strip_offsets.size() - 1; ++i) {
-    if (strip_offsets[i] + strip_byte_counts[i] != strip_offsets[i + 1]) {
-      return false;
-    }
-  }
-  return true;
-}
-
-// Gets the SubIfd content.
-bool ParseSubIfds(const std::uint32_t tiff_offset, const TagSet& desired_tags,
-                  const std::uint32_t max_number_ifds, const Endian endian,
-                  StreamInterface* stream, TiffDirectory* tiff_ifd) {
-  if (tiff_ifd->Has(kTiffTagSubIfd)) {
-    std::uint32_t offset = 0;
-    std::uint32_t length = 0;
-    tiff_ifd->GetOffsetAndLength(kTiffTagSubIfd, TIFF_TYPE_LONG, &offset,
-                                 &length);
-    length /= 4;  // length in bytes divided by 4 gives number of IFDs.
-    for (std::uint32_t j = 0; j < length && j < max_number_ifds; ++j) {
-      std::uint32_t sub_offset;
-      if (!Get32u(stream, offset + 4 * j, endian, &sub_offset)) {
-        return false;
-      }
-
-      std::uint32_t next_ifd_offset;
-      TiffDirectory sub_ifd(static_cast<Endian>(endian));
-      if (!ParseDirectory(tiff_offset, sub_offset, endian, desired_tags, stream,
-                          &sub_ifd, &next_ifd_offset)) {
-        return false;
-      }
-
-      tiff_ifd->AddSubDirectory(sub_ifd);
-    }
-  }
-  return true;
-}
-
-}  // namespace
-
-bool Get16u(StreamInterface* stream, const std::uint32_t offset,
-            const Endian& endian, std::uint16_t* value) {
-  std::uint8_t data[2];
-  if (stream->GetData(offset, 2, data) == kOk) {
-    if (endian == kBigEndian) {
-      *value = (data[0] * 0x100) | data[1];
-    } else {
-      *value = (data[1] * 0x100) | data[0];
-    }
-    return true;
-  } else {
-    return false;
-  }
-}
-
-bool Get32u(StreamInterface* stream, const std::uint32_t offset,
-            const Endian& endian, std::uint32_t* value) {
-  std::uint8_t data[4];
-  if (stream->GetData(offset, 4, data) == kOk) {
-    if (endian == kBigEndian) {
-      *value = (data[0] * 0x1000000u) | (data[1] * 0x10000u) |
-               (data[2] * 0x100u) | data[3];
-    } else {
-      *value = (data[3] * 0x1000000u) | (data[2] * 0x10000u) |
-               (data[1] * 0x100u) | data[0];
-    }
-    return true;
-  } else {
-    return false;
-  }
-}
-
-std::vector<std::uint8_t> GetData(const size_t offset, const size_t length,
-                                  StreamInterface* stream, Error* error) {
-  // Read in chunks with a maximum size of 1 MiB.
-  const size_t kChunkSize = 1048576;
-
-  std::vector<std::uint8_t> data;
-  size_t processed_data = 0;
-  while (*error == kOk && processed_data < length) {
-    size_t chunk_length = kChunkSize;
-    if (length - data.size() < kChunkSize) {
-      chunk_length = length - data.size();
-    }
-
-    data.resize(processed_data + chunk_length);
-    *error = stream->GetData(offset + processed_data, chunk_length,
-                             &data[processed_data]);
-
-    processed_data += chunk_length;
-  }
-  return data;
-}
-
-bool GetEndianness(const std::uint32_t tiff_offset, StreamInterface* stream,
-                   Endian* endian) {
-  const std::uint8_t kTiffBigEndianMagic[] = {'M', 'M'};
-  const std::uint8_t kTiffLittleEndianMagic[] = {'I', 'I'};
-  std::uint8_t tiff_endian[sizeof(kTiffBigEndianMagic)];
-  if (stream->GetData(tiff_offset, sizeof(tiff_endian), &tiff_endian[0]) !=
-      kOk) {
-    return false;
-  }
-
-  if (!memcmp(tiff_endian, kTiffLittleEndianMagic, sizeof(tiff_endian))) {
-    *endian = kLittleEndian;
-    return true;
-  } else if (!memcmp(tiff_endian, kTiffBigEndianMagic, sizeof(tiff_endian))) {
-    *endian = kBigEndian;
-    return true;
-  } else {
-    return false;
-  }
-}
-
-bool GetImageData(const TiffDirectory& tiff_directory, StreamInterface* stream,
-                  Image* image) {
-  std::uint32_t length = 0;
-  std::uint32_t offset = 0;
-
-  if (tiff_directory.Has(kTiffTagJpegOffset) &&
-      tiff_directory.Has(kTiffTagJpegByteCount)) {
-    if (!tiff_directory.Get(kTiffTagJpegOffset, &offset) ||
-        !tiff_directory.Get(kTiffTagJpegByteCount, &length)) {
-      return false;
-    }
-    image->format = Image::kJpegCompressed;
-  } else if (tiff_directory.Has(kTiffTagStripOffsets) &&
-             tiff_directory.Has(kTiffTagStripByteCounts)) {
-    std::vector<std::uint32_t> strip_offsets;
-    std::vector<std::uint32_t> strip_byte_counts;
-    if (!tiff_directory.Get(kTiffTagStripOffsets, &strip_offsets) ||
-        !tiff_directory.Get(kTiffTagStripByteCounts, &strip_byte_counts)) {
-      return false;
-    }
-
-    std::uint32_t compression = 0;
-    if (!OffsetsAreConsecutive(strip_offsets, strip_byte_counts) ||
-        !tiff_directory.Get(kTiffTagCompression, &compression)) {
-      return false;
-    }
-
-    std::uint32_t photometric_interpretation = 0;
-    if (tiff_directory.Get(kTiffTagPhotometric, &photometric_interpretation) &&
-        photometric_interpretation != 2 /* RGB */ &&
-        photometric_interpretation != 6 /* YCbCr */) {
-      return false;
-    }
-
-    switch (compression) {
-      case 1: /*uncompressed*/
-        image->format = Image::kUncompressedRgb;
-        break;
-      case 6: /* JPEG(old) */
-      case 7: /* JPEG */
-        image->format = Image::kJpegCompressed;
-        break;
-      default:
-        return false;
-    }
-    length = static_cast<std::uint32_t>(std::accumulate(
-        strip_byte_counts.begin(), strip_byte_counts.end(), 0U));
-    offset = strip_offsets[0];
-  } else if (tiff_directory.Has(kPanaTagJpegImage)) {
-    if (!tiff_directory.GetOffsetAndLength(
-            kPanaTagJpegImage, TIFF_TYPE_UNDEFINED, &offset, &length)) {
-      return false;
-    }
-    image->format = Image::kJpegCompressed;
-  } else {
-    return false;
-  }
-
-  image->length = length;
-  image->offset = offset;
-  GetImageSize(tiff_directory, stream, image);
-  return true;
-}
-
-bool GetJpegDimensions(const std::uint32_t jpeg_offset, StreamInterface* stream,
-                       std::uint16_t* width, std::uint16_t* height) {
-  const Endian endian = kBigEndian;
-  std::uint32_t offset = jpeg_offset;
-  std::uint16_t segment;
-
-  // Parse the JPEG header until we find Frame0 which contains the image width
-  // and height or the actual image data starts (StartOfScan)
-  do {
-    if (!Get16u(stream, offset, endian, &segment)) {
-      return false;
-    }
-    offset += 2;
-
-    switch (segment) {
-      case kStartOfImage:
-        break;
-      case kStartOfFrame:
-        return Get16u(stream, offset + 3, endian, height) &&
-               Get16u(stream, offset + 5, endian, width);
-      default: {
-        std::uint16_t length;
-        if (!Get16u(stream, offset, endian, &length)) {
-          return false;
-        }
-        offset += length;
-      }
-    }
-  } while (segment != kStartOfScan);
-
-  // No width and hight information found.
-  return false;
-}
-
-bool GetRational(const TiffDirectory::Tag& tag, const TiffDirectory& directory,
-                 const int data_size, PreviewImageData::Rational* data) {
-  std::vector<Rational> value;
-  if (directory.Get(tag, &value) &&
-      value.size() == static_cast<size_t>(data_size)) {
-    for (size_t i = 0; i < value.size(); ++i) {
-      data[i].numerator = value[i].numerator;
-      data[i].denominator = value[i].denominator;
-    }
-    return true;
-  }
-  return false;
-}
-
-bool IsThumbnail(const Image& image, const int max_dimension) {
-  return image.width <= max_dimension && image.height <= max_dimension;
-}
-
-bool ParseDirectory(const std::uint32_t tiff_offset,
-                    const std::uint32_t ifd_offset, const Endian endian,
-                    const TagSet& desired_tags, StreamInterface* stream,
-                    TiffDirectory* tiff_directory,
-                    std::uint32_t* next_ifd_offset) {
-  std::uint16_t number_of_entries;
-  if (!Get16u(stream, ifd_offset, endian, &number_of_entries)) {
-    return false;
-  }
-
-  for (std::uint32_t i = 0;
-       i < static_cast<std::uint32_t>(number_of_entries) * 12; i += 12) {
-    std::uint16_t tag;
-    std::uint16_t type;
-    std::uint32_t number_of_elements;
-    if (Get16u(stream, ifd_offset + 2 + i, endian, &tag) &&
-        Get16u(stream, ifd_offset + 4 + i, endian, &type) &&
-        Get32u(stream, ifd_offset + 6 + i, endian, &number_of_elements)) {
-      // Check if the current tag should be handled.
-      if (desired_tags.count(static_cast<TiffDirectory::Tag>(tag)) != 1) {
-        continue;
-      }
-    } else {
-      return false;
-    }
-
-    const size_t type_size = SizeOfType(type, nullptr /* no error */);
-
-    // Check that type_size * number_of_elements does not exceed UINT32_MAX.
-    if (type_size != 0 && number_of_elements > UINT32_MAX / type_size) {
-      return false;
-    }
-    const size_t byte_count =
-        type_size * static_cast<size_t>(number_of_elements);
-
-    std::uint32_t value_offset;
-    if (byte_count > 4 &&
-        Get32u(stream, ifd_offset + 10 + i, endian, &value_offset)) {
-      value_offset += tiff_offset;
-    } else if (byte_count != 0) {
-      value_offset = ifd_offset + 10 + i;
-    } else {
-      // Ignore entries with an invalid byte count.
-      continue;
-    }
-
-    Error error = kOk;
-    const std::vector<std::uint8_t> data =
-        GetData(value_offset, byte_count, stream, &error);
-    if (error != kOk) {
-      return false;
-    }
-    tiff_directory->AddEntry(tag, type, number_of_elements, value_offset, data);
-  }
-
-  return Get32u(stream, ifd_offset + 2u + number_of_entries * 12u, endian,
-                next_ifd_offset);
-}
-
-bool GetExifOrientation(StreamInterface* stream, const std::uint32_t offset,
-                        std::uint32_t* orientation) {
-  const TagSet kOrientationTagSet = {kTiffTagOrientation};
-  const std::uint32_t kNumberOfIfds = 1;
-
-  TiffContent tiff_content;
-  if (!TiffParser(stream, offset)
-           .Parse(kOrientationTagSet, kNumberOfIfds, &tiff_content)) {
-    return false;
-  }
-
-  for (const auto& tiff_directory : tiff_content.tiff_directory) {
-    if (tiff_directory.Has(kTiffTagOrientation) &&
-        tiff_directory.Get(kTiffTagOrientation, orientation)) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
-bool GetFullDimension32(const TiffDirectory& tiff_directory,
-                        std::uint32_t* width, std::uint32_t* height) {
-  // The sub file type needs to be 0 (main image) to contain a valid full
-  // dimensions. This is important in particular for DNG.
-  if (tiff_directory.Has(kTiffTagSubFileType)) {
-    std::uint32_t sub_file_type;
-    if (!tiff_directory.Get(kTiffTagSubFileType, &sub_file_type) ||
-        sub_file_type != 0) {
-      return false;
-    }
-  }
-
-  if (tiff_directory.Has(kExifTagDefaultCropSize)) {
-    if (!GetFullCropDimension(tiff_directory, width, height)) {
-      return false;
-    }
-  } else if (tiff_directory.Has(kExifTagWidth) &&
-             tiff_directory.Has(kExifTagHeight)) {
-    if (!tiff_directory.Get(kExifTagWidth, width) ||
-        !tiff_directory.Get(kExifTagHeight, height)) {
-      return false;
-    }
-  } else if (tiff_directory.Has(kTiffTagImageWidth) &&
-             tiff_directory.Has(kTiffTagImageLength)) {
-    if (!tiff_directory.Get(kTiffTagImageWidth, width) ||
-        !tiff_directory.Get(kTiffTagImageLength, height)) {
-      return false;
-    }
-  } else if (tiff_directory.Has(kPanaTagTopBorder) &&
-             tiff_directory.Has(kPanaTagLeftBorder) &&
-             tiff_directory.Has(kPanaTagBottomBorder) &&
-             tiff_directory.Has(kPanaTagRightBorder)) {
-    std::uint32_t left;
-    std::uint32_t right;
-    std::uint32_t top;
-    std::uint32_t bottom;
-    if (tiff_directory.Get(kPanaTagLeftBorder, &left) &&
-        tiff_directory.Get(kPanaTagRightBorder, &right) &&
-        tiff_directory.Get(kPanaTagTopBorder, &top) &&
-        tiff_directory.Get(kPanaTagBottomBorder, &bottom) && bottom > top &&
-        right > left) {
-      *height = bottom - top;
-      *width = right - left;
-    } else {
-      return false;
-    }
-  }
-  return true;
-}
-
-bool GetFullCropDimension(const tiff_directory::TiffDirectory& tiff_directory,
-                          std::uint32_t* width, std::uint32_t* height) {
-  if (!tiff_directory.Has(kExifTagDefaultCropSize)) {
-    // This doesn't look right to return true here, as we have not written
-    // anything to *width and *height. However, changing the return value here
-    // causes a whole bunch of tests to fail.
-    // TODO(timurrrr): Return false and fix the tests.
-    // In fact, this whole if() seems to be not needed,
-    // as tiff_directory(kExifTagDefaultCropSize) will return false below.
-    return true;
-  }
-
-  std::vector<std::uint32_t> crop(2);
-  if (tiff_directory.Get(kExifTagDefaultCropSize, &crop)) {
-    if (crop.size() == 2 && crop[0] > 0 && crop[1] > 0) {
-      *width = crop[0];
-      *height = crop[1];
-      return true;
-    } else {
-      return false;
-    }
-  }
-
-  std::vector<Rational> crop_rational(2);
-  if (tiff_directory.Get(kExifTagDefaultCropSize, &crop_rational)) {
-    if (crop_rational.size() == 2 && crop_rational[0].numerator > 0 &&
-        crop_rational[0].denominator > 0 && crop_rational[1].numerator > 0 &&
-        crop_rational[1].denominator > 0) {
-      *width = crop_rational[0].numerator / crop_rational[0].denominator;
-      *height = crop_rational[1].numerator / crop_rational[1].denominator;
-      return true;
-    } else {
-      return false;
-    }
-  }
-
-  return false;
-}
-
-TiffParser::TiffParser(StreamInterface* stream) : stream_(stream) {}
-
-TiffParser::TiffParser(StreamInterface* stream, const std::uint32_t offset)
-    : stream_(stream), tiff_offset_(offset) {}
-
-bool TiffParser::GetPreviewImageData(const TiffContent& tiff_content,
-                                     PreviewImageData* preview_image_data) {
-  bool success = true;
-  for (const auto& tiff_directory : tiff_content.tiff_directory) {
-    success = FillPreviewImageData(tiff_directory, stream_, preview_image_data);
-    if (success && tiff_directory.Has(kTiffTagExifIfd) &&
-        tiff_content.exif_directory) {
-      success = FillPreviewImageData(*tiff_content.exif_directory, stream_,
-                                     preview_image_data);
-    }
-    if (success && tiff_directory.Has(kExifTagGps) &&
-        tiff_content.gps_directory) {
-      FillGpsPreviewImageData(*tiff_content.gps_directory, preview_image_data);
-    }
-    for (const auto& sub_directory : tiff_directory.GetSubDirectories()) {
-      if (success) {
-        success =
-            FillPreviewImageData(sub_directory, stream_, preview_image_data);
-      }
-    }
-  }
-  return success;
-}
-
-bool TiffParser::Parse(const TagSet& desired_tags,
-                       const std::uint16_t max_number_ifds,
-                       TiffContent* tiff_content) {
-  if (!tiff_content->tiff_directory.empty()) {
-    return false;  // You shall call Parse() only once.
-  }
-
-  const std::uint32_t kTiffIdentifierSize = 4;
-  std::uint32_t offset_to_ifd = 0;
-  if (!GetEndianness(tiff_offset_, stream_, &endian_) ||
-      !Get32u(stream_, tiff_offset_ + kTiffIdentifierSize, endian_,
-              &offset_to_ifd)) {
-    return false;
-  }
-
-  if (!ParseIfd(tiff_offset_ + offset_to_ifd, desired_tags, max_number_ifds,
-                &tiff_content->tiff_directory)) {
-    return false;
-  }
-
-  // Get the Exif data.
-  if (FindFirstTagInIfds(kTiffTagExifIfd, tiff_content->tiff_directory) !=
-      nullptr) {
-    const TiffDirectory* tiff_ifd =
-        FindFirstTagInIfds(kTiffTagExifIfd, tiff_content->tiff_directory);
-    std::uint32_t offset;
-    if (tiff_ifd->Get(kTiffTagExifIfd, &offset)) {
-      tiff_content->exif_directory.reset(new TiffDirectory(endian_));
-      std::uint32_t next_ifd_offset;
-      if (!ParseDirectory(
-              tiff_offset_, tiff_offset_ + offset, endian_, desired_tags,
-              stream_, tiff_content->exif_directory.get(), &next_ifd_offset)) {
-        return false;
-      }
-
-      return ParseGpsData(tiff_ifd, tiff_content);
-    }
-  }
-
-  // Get the GPS data from the tiff ifd.
-  if (FindFirstTagInIfds(kExifTagGps, tiff_content->tiff_directory) !=
-      nullptr) {
-    const TiffDirectory* tiff_ifd =
-        FindFirstTagInIfds(kExifTagGps, tiff_content->tiff_directory);
-    return ParseGpsData(tiff_ifd, tiff_content);
-  }
-
-  return true;
-}
-
-bool TiffParser::ParseIfd(const std::uint32_t ifd_offset,
-                          const TagSet& desired_tags,
-                          const std::uint16_t max_number_ifds,
-                          IfdVector* tiff_directory) {
-  std::uint32_t next_ifd_offset;
-  TiffDirectory tiff_ifd(static_cast<Endian>(endian_));
-  if (!ParseDirectory(tiff_offset_, ifd_offset, endian_, desired_tags, stream_,
-                      &tiff_ifd, &next_ifd_offset) ||
-      !ParseSubIfds(tiff_offset_, desired_tags, max_number_ifds, endian_,
-                    stream_, &tiff_ifd)) {
-    return false;
-  }
-
-  tiff_directory->push_back(tiff_ifd);
-  if (next_ifd_offset != 0 && tiff_directory->size() < max_number_ifds) {
-    return ParseIfd(tiff_offset_ + next_ifd_offset, desired_tags,
-                    max_number_ifds, tiff_directory);
-  }
-  return true;
-}
-
-bool TiffParser::ParseGpsData(const TiffDirectory* tiff_ifd,
-                              TiffContent* tiff_content) {
-  std::uint32_t offset;
-  if (tiff_ifd->Get(kExifTagGps, &offset)) {
-    tiff_content->gps_directory.reset(new TiffDirectory(endian_));
-    const TagSet gps_tags = {kGpsTagLatitudeRef,  kGpsTagLatitude,
-                             kGpsTagLongitudeRef, kGpsTagLongitude,
-                             kGpsTagAltitudeRef,  kGpsTagAltitude,
-                             kGpsTagTimeStamp,    kGpsTagDateStamp};
-    std::uint32_t next_ifd_offset;
-    return ParseDirectory(tiff_offset_, tiff_offset_ + offset, endian_,
-                          gps_tags, stream_, tiff_content->gps_directory.get(),
-                          &next_ifd_offset);
-  }
-  return true;
-}
-
-}  // namespace piex
diff --git a/src/tiff_parser.h b/src/tiff_parser.h
deleted file mode 100644
index e19dea2..0000000
--- a/src/tiff_parser.h
+++ /dev/null
@@ -1,211 +0,0 @@
-// Copyright 2015 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#ifndef PIEX_TIFF_PARSER_H_
-#define PIEX_TIFF_PARSER_H_
-
-#include <cstdint>
-#include <memory>
-#include <set>
-#include <vector>
-
-#include "src/piex_types.h"
-#include "src/tiff_directory/tiff_directory.h"
-
-namespace piex {
-
-// Specifies the maximum number of pixels for thumbnails in each direction.
-const int kThumbnailMaxDimension = 512;
-
-// Specifies all tags that might be of interest to get the preview data.
-enum GpsTags {
-  kGpsTagLatitudeRef = 1,
-  kGpsTagLatitude = 2,
-  kGpsTagLongitudeRef = 3,
-  kGpsTagLongitude = 4,
-  kGpsTagAltitudeRef = 5,
-  kGpsTagAltitude = 6,
-  kGpsTagTimeStamp = 7,
-  kGpsTagDateStamp = 29,
-};
-
-enum TiffTags {
-  kExifTagColorSpace = 0xA001,
-  kExifTagDateTimeOriginal = 0x9003,
-  kExifTagDefaultCropSize = 0xC620,
-  kExifTagExposureTime = 0x829a,
-  kExifTagFnumber = 0x829d,
-  kExifTagFocalLength = 0x920A,
-  kExifTagGps = 0x8825,
-  kExifTagHeight = 0xA003,
-  kExifTagIsoSpeed = 0x8827,
-  kExifTagMakernotes = 0x927C,
-  kExifTagWidth = 0xA002,
-  kOlymTagAspectFrame = 0x1113,
-  kOlymTagCameraSettings = 0x2020,
-  kOlymTagRawProcessing = 0x2040,
-  kPanaTagBottomBorder = 0x006,
-  kPanaTagIso = 0x0017,
-  kPanaTagJpegImage = 0x002E,
-  kPanaTagLeftBorder = 0x0005,
-  kPanaTagRightBorder = 0x007,
-  kPanaTagTopBorder = 0x0004,
-  kPentaxTagColorSpace = 0x0037,
-  kTiffTagArtist = 0x013B,
-  kTiffTagBitsPerSample = 0x0102,
-  kTiffTagCfaPatternDim = 0x828D,
-  kTiffTagCompression = 0x0103,
-  kTiffTagDateTime = 0x0132,
-  kTiffTagExifIfd = 0x8769,
-  kTiffTagImageDescription = 0x010E,
-  kTiffTagImageLength = 0x0101,
-  kTiffTagImageWidth = 0x0100,
-  kTiffTagJpegByteCount = 0x0202,
-  kTiffTagJpegOffset = 0x0201,
-  kTiffTagMake = 0x010F,
-  kTiffTagModel = 0x0110,
-  kTiffTagOrientation = 0x0112,
-  kTiffTagPhotometric = 0x0106,
-  kTiffTagPlanarConfig = 0x011C,
-  kTiffTagResolutionUnit = 0x0128,
-  kTiffTagRowsPerStrip = 0x0116,
-  kTiffTagSamplesPerPixel = 0x0115,
-  kTiffTagSoftware = 0x0131,
-  kTiffTagStripByteCounts = 0x0117,
-  kTiffTagStripOffsets = 0x0111,
-  kTiffTagSubFileType = 0x00FE,
-  kTiffTagSubIfd = 0x014A,
-  kTiffTagTileByteCounts = 0x0145,
-  kTiffTagTileLength = 0x0143,
-  kTiffTagTileOffsets = 0x0144,
-  kTiffTagTileWidth = 0x0142,
-  kTiffTagXresolution = 0x011A,
-  kTiffTagYresolution = 0x011B,
-};
-
-typedef std::set<tiff_directory::TiffDirectory::Tag> TagSet;
-typedef std::vector<tiff_directory::TiffDirectory> IfdVector;
-
-struct TiffContent {
-  IfdVector tiff_directory;
-  std::unique_ptr<tiff_directory::TiffDirectory> exif_directory;
-  std::unique_ptr<tiff_directory::TiffDirectory> gps_directory;
-};
-
-// Reads 2 bytes, an unsigned 16bit from 'stream' at a certain 'offset'. The
-// bytes get swapped according to the desired endianness returning true on
-// success. Returns false when something is wrong.
-bool Get16u(StreamInterface* stream, const std::uint32_t offset,
-            const tiff_directory::Endian& endian, std::uint16_t* value);
-
-// Reads 4 bytes, an unsigned 32bit 'value' from 'stream' at a certain 'offset'.
-// The bytes get swapped according to the desired endianness returning true on
-// success. Returns false when something is wrong.
-bool Get32u(StreamInterface* stream, const std::uint32_t offset,
-            const tiff_directory::Endian& endian, std::uint32_t* value);
-
-// Retrieves a byte vector of size 'length' from 'stream' beginning at some
-// 'offset' reading the data in chunks of one MiB.
-// If 'error' is not set to kOk the returned value is invalid.
-std::vector<std::uint8_t> GetData(const size_t offset, const size_t length,
-                                  StreamInterface* stream, Error* error);
-
-// Retrieves the endianness of TIFF compliant data at 'tiff_offset' from
-// 'stream' returning true on success. Returns false when something is wrong.
-bool GetEndianness(const std::uint32_t tiff_offset, StreamInterface* stream,
-                   tiff_directory::Endian* endian);
-
-// Retrieves an image from tiff_directory. Return false when something is wrong.
-bool GetImageData(const tiff_directory::TiffDirectory& tiff_directory,
-                  StreamInterface* stream, Image* image);
-
-// Retrieves the width and height from the jpeg image returning true on
-// success. Returns false when something is wrong.
-bool GetJpegDimensions(const std::uint32_t jpeg_offset, StreamInterface* stream,
-                       std::uint16_t* width, std::uint16_t* height);
-
-// According to Tiff/EP a thumbnail has max 256 pixels per dimension.
-// http://standardsproposals.bsigroup.com/Home/getPDF/567
-bool IsThumbnail(const Image& image,
-                 const int max_dimension = kThumbnailMaxDimension);
-
-// Parses through a Tiff IFD and writes all 'desired_tags' to a
-// 'tiff_directory'.
-// Returns false if something with the Tiff data is wrong.
-bool ParseDirectory(const std::uint32_t tiff_offset,
-                    const std::uint32_t ifd_offset,
-                    const tiff_directory::Endian endian,
-                    const TagSet& desired_tags, StreamInterface* stream,
-                    tiff_directory::TiffDirectory* tiff_directory,
-                    std::uint32_t* next_ifd_offset);
-
-// Returns true if Exif orientation for the image can be obtained. False
-// otherwise.
-bool GetExifOrientation(StreamInterface* stream, const std::uint32_t offset,
-                        std::uint32_t* orientation);
-
-// Reads the width and height of the full resolution image. The tag groups are
-// exclusive.
-bool GetFullDimension32(const tiff_directory::TiffDirectory& tiff_directory,
-                        std::uint32_t* width, std::uint32_t* height);
-
-// Reads the width and height of the crop information if available.
-// Returns false if an error occurred.
-bool GetFullCropDimension(const tiff_directory::TiffDirectory& tiff_directory,
-                          std::uint32_t* width, std::uint32_t* height);
-
-// Reads 1 or more rational values for a tag and stores results into data.
-// Returns false if an error occurred.
-bool GetRational(const tiff_directory::TiffDirectory::Tag& tag,
-                 const tiff_directory::TiffDirectory& directory,
-                 const int data_size, PreviewImageData::Rational* data);
-
-// Enables us to parse through data that complies to the Tiff/EP specification.
-class TiffParser {
- public:
-  // The caller owns 'stream' and is responsible to keep it alive while the
-  // TiffParser object is used.
-  explicit TiffParser(StreamInterface* stream);
-  TiffParser(StreamInterface* stream, const std::uint32_t offset);
-
-  // Runs over the Tiff IFD, Exif IFD and subIFDs to get the preview image data.
-  // Returns false if something with the Tiff tags is wrong.
-  bool GetPreviewImageData(const TiffContent& tiff_content,
-                           PreviewImageData* preview_image_data);
-
-  // Returns false if called more that once or something with the Tiff data is
-  // wrong.
-  bool Parse(const TagSet& desired_tags, const std::uint16_t max_number_ifds,
-             TiffContent* tiff_content);
-
- private:
-  // Disallow copy and assignment.
-  TiffParser(const TiffParser&) = delete;
-  TiffParser& operator=(const TiffParser&) = delete;
-
-  bool ParseIfd(const std::uint32_t ifd_offset, const TagSet& desired_tags,
-                const std::uint16_t max_number_ifds, IfdVector* tiff_directory);
-  bool ParseGpsData(const tiff_directory::TiffDirectory* tiff_ifd,
-                    TiffContent* tiff_content);
-
-  StreamInterface* stream_ = nullptr;
-  std::uint32_t tiff_offset_ = 0;
-  tiff_directory::Endian endian_;
-};
-
-}  // namespace piex
-
-#endif  // PIEX_TIFF_PARSER_H_