Adding METADATA to piex and merging with upstream am: f85cc3c7c1 am: fb64679d7c am: 8eef416f69
Original change: https://android-review.googlesource.com/c/platform/external/piex/+/2224358
Change-Id: I53144eb84be0e63afbecca87f48ab367539a1973
Signed-off-by: Automerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
diff --git a/LICENSE b/LICENSE
new file mode 100755
index 0000000..7a4a3ea
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,202 @@
+
+ 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/METADATA b/METADATA
index d97975c..6af984a 100644
--- a/METADATA
+++ b/METADATA
@@ -1,3 +1,19 @@
+name: "piex"
+description: "The Preview Image Extractor (PIEX) is designed to find and extract the largest JPEG compressed preview image contained in a RAW file."
third_party {
+ url {
+ type: HOMEPAGE
+ value: "https://github.com/google/piex"
+ }
+ url {
+ type: GIT
+ value: "https://github.com/google/piex/"
+ }
+ version: "v0.27"
license_type: NOTICE
+ last_upgrade_date {
+ year: 2022
+ month: 9
+ day: 20
+ }
}
diff --git a/OWNERS b/OWNERS
new file mode 100644
index 0000000..5405e5a
--- /dev/null
+++ b/OWNERS
@@ -0,0 +1,3 @@
+chongsu@google.com
+mboehme@google.com
+nchusid@google.com
diff --git a/README b/README
new file mode 100755
index 0000000..b838fdf
--- /dev/null
+++ b/README
@@ -0,0 +1,2 @@
+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
new file mode 100755
index 0000000..91995b8
--- /dev/null
+++ b/internal_include_do_not_delete.gypi
@@ -0,0 +1,2 @@
+# Do NOT touch the file.
+{}
diff --git a/piex.gyp b/piex.gyp
new file mode 100755
index 0000000..15741dc
--- /dev/null
+++ b/piex.gyp
@@ -0,0 +1,95 @@
+# 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
new file mode 100755
index 0000000..83b6c03
--- /dev/null
+++ b/src/binary_parse/cached_paged_byte_array.cc
@@ -0,0 +1,79 @@
+// 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
new file mode 100755
index 0000000..26f0eae
--- /dev/null
+++ b/src/binary_parse/cached_paged_byte_array.h
@@ -0,0 +1,73 @@
+// 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
new file mode 100755
index 0000000..bbfdee2
--- /dev/null
+++ b/src/binary_parse/range_checked_byte_ptr.cc
@@ -0,0 +1,402 @@
+// 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
new file mode 100755
index 0000000..a0eadbb
--- /dev/null
+++ b/src/binary_parse/range_checked_byte_ptr.h
@@ -0,0 +1,609 @@
+// 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
new file mode 100755
index 0000000..5976f42
--- /dev/null
+++ b/src/image_type_recognition/image_type_recognition_lite.cc
@@ -0,0 +1,915 @@
+// 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
new file mode 100755
index 0000000..30db915
--- /dev/null
+++ b/src/image_type_recognition/image_type_recognition_lite.h
@@ -0,0 +1,89 @@
+// 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
new file mode 100755
index 0000000..ac2ef0b
--- /dev/null
+++ b/src/piex.cc
@@ -0,0 +1,740 @@
+// 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
new file mode 100755
index 0000000..8d74ca0
--- /dev/null
+++ b/src/piex.h
@@ -0,0 +1,96 @@
+// 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
new file mode 100755
index 0000000..4fa82b7
--- /dev/null
+++ b/src/piex_cr3.cc
@@ -0,0 +1,559 @@
+// 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
new file mode 100755
index 0000000..3108503
--- /dev/null
+++ b/src/piex_cr3.h
@@ -0,0 +1,43 @@
+// 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
new file mode 100755
index 0000000..2062136
--- /dev/null
+++ b/src/piex_types.h
@@ -0,0 +1,125 @@
+// 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
new file mode 100755
index 0000000..8db15a2
--- /dev/null
+++ b/src/tiff_directory/tiff_directory.cc
@@ -0,0 +1,282 @@
+// 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
new file mode 100755
index 0000000..855adfc
--- /dev/null
+++ b/src/tiff_directory/tiff_directory.h
@@ -0,0 +1,161 @@
+// 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
new file mode 100755
index 0000000..3ceaa75
--- /dev/null
+++ b/src/tiff_parser.cc
@@ -0,0 +1,755 @@
+// 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
new file mode 100755
index 0000000..e19dea2
--- /dev/null
+++ b/src/tiff_parser.h
@@ -0,0 +1,211 @@
+// 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_
