diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 0000000..ce831e6
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,36 @@
+# Copyright (c) 2021, Alliance for Open Media. All rights reserved
+#
+# This source code is subject to the terms of the BSD 2 Clause License and the
+# Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License was
+# not distributed with this source code in the LICENSE file, you can obtain it
+# at www.aomedia.org/license/software. If the Alliance for Open Media Patent
+# License 1.0 was not distributed with this source code in the PATENTS file, you
+# can obtain it at www.aomedia.org/license/patent.
+
+cmake_minimum_required(VERSION 3.6)
+project(avifinfo C CXX)
+set(CMAKE_C_STANDARD 11)
+
+option(AVIFINFO_BUILD_TESTS
+       "Build and enable tests (GoogleTest must be installed)" OFF)
+
+# C library
+
+add_library(avifinfo avifinfo.c)
+
+# C++ tests
+
+if(AVIFINFO_BUILD_TESTS)
+  find_package(Threads REQUIRED) # Needed by GoogleTest
+  find_package(GTest REQUIRED)
+
+  enable_testing()
+  add_executable(avifinfo_test tests/avifinfo_test.cc)
+  target_include_directories(avifinfo_test PRIVATE ${GTEST_INCLUDE_DIRS}
+                                                   ${CMAKE_CURRENT_SOURCE_DIR})
+  target_link_libraries(avifinfo_test PRIVATE ${GTEST_BOTH_LIBRARIES} avifinfo)
+  add_test(
+    NAME avifinfo_test
+    COMMAND ${CMAKE_CURRENT_BINARY_DIR}/avifinfo_test
+    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests)
+endif()
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..330b6b8
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,26 @@
+Copyright (c) 2021, Alliance for Open Media. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in
+   the documentation and/or other materials provided with the
+   distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
diff --git a/PATENTS b/PATENTS
new file mode 100644
index 0000000..826644b
--- /dev/null
+++ b/PATENTS
@@ -0,0 +1,107 @@
+Alliance for Open Media Patent License 1.0
+
+1. License Terms.
+
+1.1. Patent License. Subject to the terms and conditions of this License, each
+     Licensor, on behalf of itself and successors in interest and assigns,
+     grants Licensee a non-sublicensable, perpetual, worldwide, non-exclusive,
+     no-charge, royalty-free, irrevocable (except as expressly stated in this
+     License) patent license to its Necessary Claims to make, use, sell, offer
+     for sale, import or distribute any Implementation.
+
+1.2. Conditions.
+
+1.2.1. Availability. As a condition to the grant of rights to Licensee to make,
+       sell, offer for sale, import or distribute an Implementation under
+       Section 1.1, Licensee must make its Necessary Claims available under
+       this License, and must reproduce this License with any Implementation
+       as follows:
+
+       a. For distribution in source code, by including this License in the
+          root directory of the source code with its Implementation.
+
+       b. For distribution in any other form (including binary, object form,
+          and/or hardware description code (e.g., HDL, RTL, Gate Level Netlist,
+          GDSII, etc.)), by including this License in the documentation, legal
+          notices, and/or other written materials provided with the
+          Implementation.
+
+1.2.2. Additional Conditions. This license is directly from Licensor to
+       Licensee.  Licensee acknowledges as a condition of benefiting from it
+       that no rights from Licensor are received from suppliers, distributors,
+       or otherwise in connection with this License.
+
+1.3. Defensive Termination. If any Licensee, its Affiliates, or its agents
+     initiates patent litigation or files, maintains, or voluntarily
+     participates in a lawsuit against another entity or any person asserting
+     that any Implementation infringes Necessary Claims, any patent licenses
+     granted under this License directly to the Licensee are immediately
+     terminated as of the date of the initiation of action unless 1) that suit
+     was in response to a corresponding suit regarding an Implementation first
+     brought against an initiating entity, or 2) that suit was brought to
+     enforce the terms of this License (including intervention in a third-party
+     action by a Licensee).
+
+1.4. Disclaimers. The Reference Implementation and Specification are provided
+     "AS IS" and without warranty. The entire risk as to implementing or
+     otherwise using the Reference Implementation or Specification is assumed
+     by the implementer and user. Licensor expressly disclaims any warranties
+     (express, implied, or otherwise), including implied warranties of
+     merchantability, non-infringement, fitness for a particular purpose, or
+     title, related to the material. IN NO EVENT WILL LICENSOR BE LIABLE TO
+     ANY OTHER PARTY FOR LOST PROFITS OR ANY FORM OF INDIRECT, SPECIAL,
+     INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY CHARACTER FROM ANY CAUSES OF
+     ACTION OF ANY KIND WITH RESPECT TO THIS LICENSE, WHETHER BASED ON BREACH
+     OF CONTRACT, TORT (INCLUDING NEGLIGENCE), OR OTHERWISE, AND WHETHER OR
+     NOT THE OTHER PARTRY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+2. Definitions.
+
+2.1. Affiliate.  "Affiliate" means an entity that directly or indirectly
+     Controls, is Controlled by, or is under common Control of that party.
+
+2.2. Control. "Control" means direct or indirect control of more than 50% of
+     the voting power to elect directors of that corporation, or for any other
+     entity, the power to direct management of such entity.
+
+2.3. Decoder.  "Decoder" means any decoder that conforms fully with all
+     non-optional portions of the Specification.
+
+2.4. Encoder.  "Encoder" means any encoder that produces a bitstream that can
+     be decoded by a Decoder only to the extent it produces such a bitstream.
+
+2.5. Final Deliverable.  "Final Deliverable" means the final version of a
+     deliverable approved by the Alliance for Open Media as a Final
+     Deliverable.
+
+2.6. Implementation.  "Implementation" means any implementation, including the
+     Reference Implementation, that is an Encoder and/or a Decoder. An
+     Implementation also includes components of an Implementation only to the
+     extent they are used as part of an Implementation.
+
+2.7. License. "License" means this license.
+
+2.8. Licensee. "Licensee" means any person or entity who exercises patent
+     rights granted under this License.
+
+2.9. Licensor.  "Licensor" means (i) any Licensee that makes, sells, offers
+     for sale, imports or distributes any Implementation, or (ii) a person
+     or entity that has a licensing obligation to the Implementation as a
+     result of its membership and/or participation in the Alliance for Open
+     Media working group that developed the Specification.
+
+2.10. Necessary Claims.  "Necessary Claims" means all claims of patents or
+      patent applications, (a) that currently or at any time in the future,
+      are owned or controlled by the Licensor, and (b) (i) would be an
+      Essential Claim as defined by the W3C Policy as of February 5, 2004
+      (https://www.w3.org/Consortium/Patent-Policy-20040205/#def-essential)
+      as if the Specification was a W3C Recommendation; or (ii) are infringed
+      by the Reference Implementation.
+
+2.11. Reference Implementation. "Reference Implementation" means an Encoder
+      and/or Decoder released by the Alliance for Open Media as a Final
+      Deliverable.
+
+2.12. Specification. "Specification" means the specification designated by
+      the Alliance for Open Media as a Final Deliverable for which this
+      License was issued.
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..01afccb
--- /dev/null
+++ b/README.md
@@ -0,0 +1,80 @@
+# AVIF-info
+
+**libavifinfo** is a standalone library that can be used to extract the width,
+height, bit depth and number of channels from an AVIF payload.
+
+See `avifinfo.h` for details on the API and `avifinfo.c` for the implementation.
+See `avifinfo_test.cc` for usage examples.
+
+## Contents
+
+1.  [How to use](#how-to-use)
+
+    1.  [Build](#build)
+    2.  [Test](#test)
+
+2.  [Development](#development)
+
+    1.  [Coding style](#coding-style)
+    2.  [Submitting patches](#submitting-patches)
+
+3.  [Bug reports](#bug-reports)
+
+## How to use {#how-to-use}
+
+**libavifinfo** can be used when only a few AVIF features are needed and when
+linking to or including [libavif](https://github.com/AOMediaCodec/libavif) is
+not an option. For decoding an image or extracting more features, please rely on
+[libavif](https://github.com/AOMediaCodec/libavif).
+
+```
+AvifInfoFeatures features;
+if (AvifInfoGet(bytes, number_of_available_bytes, &features) == kAvifInfoOk) {
+  // Use 'features.width' etc.
+}
+```
+
+Note: `AvifInfoGet()` is designed to return the same `avifImage` field values as
+[`avifDecoderRead()`](https://github.com/AOMediaCodec/libavif/blob/9d8f9f9eb24fcea36113c946fa72f9f92aa7b317/include/avif/avif.h#L894).
+However **libavifinfo** is more permissive and may return features of images
+considered invalid by **libavif**.
+
+### Build {#build}
+
+`avifinfo.c` is written in C. To build from this directory:
+
+```
+mkdir build && \
+cd build && \
+cmake .. && \
+cmake --build . --config Release
+```
+
+### Test {#test}
+
+Tests are written in C++. GoogleTest is required.
+
+```
+mkdir build && \
+cd build && \
+cmake .. -DAVIFINFO_BUILD_TESTS=ON && \
+cmake --build . --config Debug && \
+ctest .
+```
+
+## Development {#development}
+
+### Coding style {#coding-style}
+
+[Google C/C++ Style Guide](https://google.github.io/styleguide/cppguide.html) is
+used in this project.
+
+### Submitting patches {#submitting-patches}
+
+If you would like to contribute to **libavifinfo**, please follow the steps for
+**libaom** at https://aomedia.googlesource.com/aom/#submitting-patches.
+
+## Bug reports {#bug-reports}
+
+Bug reports can be filed in the Alliance for Open Media
+[issue tracker](https://bugs.chromium.org/p/aomedia/issues/list).
diff --git a/avifinfo.c b/avifinfo.c
new file mode 100644
index 0000000..f284924
--- /dev/null
+++ b/avifinfo.c
@@ -0,0 +1,710 @@
+// Copyright (c) 2021, Alliance for Open Media. All rights reserved
+//
+// This source code is subject to the terms of the BSD 2 Clause License and
+// the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
+// was not distributed with this source code in the LICENSE file, you can
+// obtain it at www.aomedia.org/license/software. If the Alliance for Open
+// Media Patent License 1.0 was not distributed with this source code in the
+// PATENTS file, you can obtain it at www.aomedia.org/license/patent.
+
+#include "avifinfo.h"
+
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+
+//------------------------------------------------------------------------------
+
+// Status returned when reading the content of a box (or file).
+typedef enum {
+  kFound,     // Input correctly parsed and information retrieved.
+  kNotFound,  // Input correctly parsed but information is missing or elsewhere.
+  kTruncated,  // Input correctly parsed until missing bytes to continue.
+  kAborted,  // Input correctly parsed until stopped to avoid timeout or crash.
+  kInvalid,  // Input incorrectly parsed.
+} AvifInfoInternalStatus;
+
+// uint32_t is used everywhere in this file. It is unlikely to be insufficient
+// to parse AVIF headers. Clamp any input to 2^32-1 for simplicity.
+static const uint32_t kAvifInfoInternalMaxSize = UINT32_MAX;
+
+// Reads an unsigned integer from 'input' with most significant bits first.
+// 'input' must be at least 'num_bytes'-long.
+static uint32_t AvifInfoInternalReadBigEndian(const uint8_t* input,
+                                              uint32_t num_bytes) {
+  uint32_t value = 0;
+  for (uint32_t i = 0; i < num_bytes; ++i) {
+    value = (value << 8) | input[i];
+  }
+  return value;
+}
+
+//------------------------------------------------------------------------------
+// Convenience macros.
+
+#if defined(AVIFINFO_LOG_ERROR)  // Toggle to log encountered issues.
+static void AvifInfoInternalLogError(const char* file, int line,
+                                     AvifInfoInternalStatus status) {
+  const char* kStr[] = {"Found", "NotFound", "Truncated", "Invalid", "Aborted"};
+  fprintf(stderr, "  %s:%d: %s\n", file, line, kStr[status]);
+  // Set a breakpoint here to catch the first detected issue.
+}
+#define AVIFINFO_RETURN(check_status)                               \
+  do {                                                              \
+    const AvifInfoInternalStatus status_checked = (check_status);   \
+    if (status_checked != kFound && status_checked != kNotFound) {  \
+      AvifInfoInternalLogError(__FILE__, __LINE__, status_checked); \
+    }                                                               \
+    return status_checked;                                          \
+  } while (0)
+#else
+#define AVIFINFO_RETURN(check_status) \
+  do {                                \
+    return (check_status);            \
+  } while (0)
+#endif
+
+#define AVIFINFO_CHECK(check_condition, check_status)      \
+  do {                                                     \
+    if (!(check_condition)) AVIFINFO_RETURN(check_status); \
+  } while (0)
+#define AVIFINFO_CHECK_STATUS_IS(check_status, expected_status)            \
+  do {                                                                     \
+    const AvifInfoInternalStatus status_returned = (check_status);         \
+    AVIFINFO_CHECK(status_returned == (expected_status), status_returned); \
+  } while (0)
+#define AVIFINFO_CHECK_FOUND(check_status) \
+  AVIFINFO_CHECK_STATUS_IS((check_status), kFound)
+#define AVIFINFO_CHECK_NOT_FOUND(check_status) \
+  AVIFINFO_CHECK_STATUS_IS((check_status), kNotFound)
+
+//------------------------------------------------------------------------------
+// Box header parsing and various size checks.
+
+typedef struct {
+  uint32_t size;              // In bytes.
+  const uint8_t* type;        // Points to four characters.
+  uint32_t version;           // 0 or actual version if this is a full box.
+  uint32_t flags;             // 0 or actual value if this is a full box.
+  uint32_t content_size;      // 'size' minus the header size.
+  uint32_t content_position;  // Position in bytes of the 'content' of this box
+                              // relative to its container.
+  const uint8_t* content;     // Content bytes of this box (after its header).
+} AvifInfoInternalBox;
+
+// Reads the header of a 'box' starting at 'bytes + position'.
+// 'num_bytes' is the number of available 'bytes'.
+// 'max_num_bytes' is the size of the container of the 'box' (either the file
+// itself or the content of the parent of the 'box').
+static AvifInfoInternalStatus AvifInfoInternalParseBox(
+    const uint8_t* bytes, uint32_t num_bytes, uint32_t max_num_bytes,
+    uint32_t position, uint32_t* num_parsed_boxes, AvifInfoInternalBox* box) {
+  // See ISO/IEC 14496-12:2012(E) 4.2
+  AVIFINFO_CHECK(position <= kAvifInfoInternalMaxSize - 8, kAborted);
+  AVIFINFO_CHECK(position + 8 <= max_num_bytes, kInvalid);  // box size+type
+  AVIFINFO_CHECK(position + 4 <= num_bytes, kTruncated);    // 32b size
+  box->size = AvifInfoInternalReadBigEndian(bytes + position, sizeof(uint32_t));
+  // Note: 'box->size==1' means 64b size should be read.
+  //       'box->size==0' means this box extends to all remaining bytes.
+  //       These two use cases are not handled here for simplicity.
+  AVIFINFO_CHECK(box->size >= 2, kAborted);
+  AVIFINFO_CHECK(box->size >= 8, kInvalid);  // box 32b size + 32b type
+  AVIFINFO_CHECK(box->size <= kAvifInfoInternalMaxSize - position, kAborted);
+  AVIFINFO_CHECK(position + box->size <= max_num_bytes, kInvalid);
+  AVIFINFO_CHECK(position + 8 <= num_bytes, kTruncated);
+  box->type = bytes + position + 4;
+
+  const int has_fullbox_header =
+      !memcmp(box->type, "meta", 4) || !memcmp(box->type, "pitm", 4) ||
+      !memcmp(box->type, "ipma", 4) || !memcmp(box->type, "ispe", 4) ||
+      !memcmp(box->type, "pixi", 4) || !memcmp(box->type, "iref", 4) ||
+      !memcmp(box->type, "auxC", 4);
+  const uint32_t box_header_size = (has_fullbox_header ? 12 : 8);
+  AVIFINFO_CHECK(box->size >= box_header_size, kInvalid);
+  box->content_position = position + box_header_size;
+  AVIFINFO_CHECK(box->content_position <= num_bytes, kTruncated);
+  box->content_size = box->size - box_header_size;
+  box->content = bytes + box->content_position;
+  // Avoid timeouts. The maximum number of parsed boxes is arbitrary.
+  ++*num_parsed_boxes;
+  AVIFINFO_CHECK(*num_parsed_boxes < 4096, kAborted);
+
+  box->version = 0;
+  box->flags = 0;
+  if (has_fullbox_header) {
+    box->version = AvifInfoInternalReadBigEndian(bytes + position + 8, 1);
+    box->flags = AvifInfoInternalReadBigEndian(bytes + position + 9, 3);
+    // See AV1 Image File Format (AVIF) 8.1
+    // at https://aomediacodec.github.io/av1-avif/#avif-boxes (available when
+    // https://github.com/AOMediaCodec/av1-avif/pull/170 is merged).
+    uint32_t is_parsable = 1;
+    if (!memcmp(box->type, "meta", 4)) is_parsable = (box->version <= 0);
+    if (!memcmp(box->type, "pitm", 4)) is_parsable = (box->version <= 1);
+    if (!memcmp(box->type, "ipma", 4)) is_parsable = (box->version <= 1);
+    if (!memcmp(box->type, "ispe", 4)) is_parsable = (box->version <= 0);
+    if (!memcmp(box->type, "pixi", 4)) is_parsable = (box->version <= 0);
+    if (!memcmp(box->type, "iref", 4)) is_parsable = (box->version <= 1);
+    if (!memcmp(box->type, "auxC", 4)) is_parsable = (box->version <= 0);
+    // Instead of considering this file as invalid, skip unparsable boxes.
+    if (!is_parsable) box->type = (const uint8_t*)"\0skip";
+  }
+  return kFound;
+}
+
+// Returns kFound if 'min_size' bytes can be read from the 'box.content' now.
+// 'num_bytes' is the number of available bytes of the parent of the 'box'.
+static AvifInfoInternalStatus AccessContent(AvifInfoInternalBox* box,
+                                            uint32_t num_bytes,
+                                            uint32_t min_size) {
+  AVIFINFO_CHECK(box->content_size >= min_size, kInvalid);
+  AVIFINFO_CHECK(box->content_position + min_size <= num_bytes, kTruncated);
+  return kFound;
+}
+
+//------------------------------------------------------------------------------
+// Search if the file identifies itself as AVIF through an "ftyp" box.
+
+static AvifInfoInternalStatus ParseFileForBrand(const uint8_t* bytes,
+                                                uint32_t num_bytes,
+                                                uint32_t file_size,
+                                                uint32_t* num_parsed_boxes) {
+  uint32_t position = 0;  // Within 'bytes' (that points to first byte of file).
+  do {
+    AvifInfoInternalBox box;
+    AVIFINFO_CHECK_FOUND(AvifInfoInternalParseBox(
+        bytes, num_bytes, file_size, position, num_parsed_boxes, &box));
+
+    if (!memcmp(box.type, "ftyp", 4)) {
+      // Iterate over brands. See ISO/IEC 14496-12:2012(E) 4.3.1
+      AVIFINFO_CHECK(box.content_size >= 8, kInvalid);  // major_brand + version
+      for (uint32_t i = 0; i < box.content_size; i += 4) {
+        AVIFINFO_CHECK_FOUND(AccessContent(&box, num_bytes, i + 4));
+        if (i == 4) continue;  // Skip minor_version.
+        if (!memcmp(box.content + i, "avif", 4) ||
+            !memcmp(box.content + i, "avis", 4)) {
+          return kFound;
+        }
+      }
+      AVIFINFO_RETURN(kInvalid);  // Only one "ftyp" allowed per file.
+    }
+    position += box.size;
+    // File is valid only if the end of at least one box is at the same position
+    // as the end of the container. Oddities are caught when parsing further.
+  } while (position != file_size);
+  AVIFINFO_RETURN(kInvalid);  // There should be one "ftyp" box.
+}
+
+//------------------------------------------------------------------------------
+// Search the primary item ID through "meta > pitm" boxes.
+
+static AvifInfoInternalStatus ParseMetaForPrimaryItemId(
+    const uint8_t* bytes, uint32_t num_bytes, uint32_t max_num_bytes,
+    uint32_t* num_parsed_boxes, uint32_t* primary_item_id) {
+  uint32_t position = 0;  // Within 'bytes' (first byte of "meta" box content).
+  do {
+    AvifInfoInternalBox box;
+    AVIFINFO_CHECK_FOUND(AvifInfoInternalParseBox(
+        bytes, num_bytes, max_num_bytes, position, num_parsed_boxes, &box));
+
+    if (!memcmp(box.type, "pitm", 4)) {
+      // See ISO/IEC 14496-12:2015(E) 8.11.4.2
+      const uint32_t num_bytes_per_id = (box.version == 0) ? 2 : 4;
+      AVIFINFO_CHECK_FOUND(AccessContent(&box, num_bytes, num_bytes_per_id));
+      *primary_item_id =
+          AvifInfoInternalReadBigEndian(box.content + 0, num_bytes_per_id);
+      return kFound;
+    }
+    position += box.size;
+  } while (position != max_num_bytes);
+
+  // According to ISO/IEC 14496-12:2012(E) 8.11.1.1, there is at most one "meta"
+  // per file. No "pitm" until now means never.
+  AVIFINFO_RETURN(kInvalid);
+}
+
+static AvifInfoInternalStatus ParseFileForPrimaryItemId(
+    const uint8_t* bytes, uint32_t num_bytes, uint32_t file_size,
+    uint32_t* num_parsed_boxes, uint32_t* primary_item_id) {
+  uint32_t position = 0;  // Within 'bytes' (that points to first byte of file).
+  do {
+    AvifInfoInternalBox box;
+    AVIFINFO_CHECK_FOUND(AvifInfoInternalParseBox(
+        bytes, num_bytes, file_size, position, num_parsed_boxes, &box));
+
+    if (!memcmp(box.type, "meta", 4)) {
+      return ParseMetaForPrimaryItemId(
+          box.content, num_bytes - box.content_position, box.content_size,
+          num_parsed_boxes, primary_item_id);
+    }
+    position += box.size;
+  } while (position != file_size);
+  AVIFINFO_RETURN(kInvalid);  // No "meta" is an issue.
+}
+
+//------------------------------------------------------------------------------
+// Search the features of an item given its ID through "meta > iprp" boxes.
+
+static AvifInfoInternalStatus ParseIpcoForFeaturesInProperty(
+    const uint8_t* bytes, uint32_t num_bytes, uint32_t max_num_bytes,
+    uint32_t target_property_index, uint32_t* num_parsed_boxes,
+    AvifInfoFeatures* features) {
+  uint32_t position = 0;
+  uint32_t box_index = 1;  // 1-based index. Used for iterating over properties.
+  do {
+    AvifInfoInternalBox box;
+    AVIFINFO_CHECK_FOUND(AvifInfoInternalParseBox(
+        bytes, num_bytes, max_num_bytes, position, num_parsed_boxes, &box));
+
+    if (box_index != target_property_index) {
+      // Skip.
+    } else if (features->width == 0 && !memcmp(box.type, "ispe", 4)) {
+      // See ISO/IEC 23008-12:2017(E) 6.5.3.2
+      AVIFINFO_CHECK_FOUND(AccessContent(&box, num_bytes, 4 + 4));
+      features->width = AvifInfoInternalReadBigEndian(box.content + 0, 4);
+      features->height = AvifInfoInternalReadBigEndian(box.content + 4, 4);
+      AVIFINFO_CHECK(features->width != 0 && features->height != 0, kInvalid);
+      return kFound;
+    } else if (features->num_channels == 0 && !memcmp(box.type, "pixi", 4)) {
+      // See ISO/IEC 23008-12:2017(E) 6.5.6.2
+      AVIFINFO_CHECK_FOUND(AccessContent(&box, num_bytes, 1));
+      features->num_channels =
+          AvifInfoInternalReadBigEndian(box.content + 0, 1);
+      AVIFINFO_CHECK(features->num_channels >= 1, kInvalid);
+      AVIFINFO_CHECK_FOUND(
+          AccessContent(&box, num_bytes, 1 + features->num_channels));
+      features->bit_depth = AvifInfoInternalReadBigEndian(box.content + 1, 1);
+      AVIFINFO_CHECK(features->bit_depth >= 1, kInvalid);
+      for (uint32_t i = 1; i < features->num_channels; ++i) {
+        const uint32_t bit_depth =
+            AvifInfoInternalReadBigEndian(box.content + 1 + i, 1);
+        // Bit depth should be the same for all channels.
+        AVIFINFO_CHECK(bit_depth == features->bit_depth, kInvalid);
+      }
+      return kFound;
+    } else if (features->num_channels == 0 && !memcmp(box.type, "av1C", 4)) {
+      // See AV1 Codec ISO Media File Format Binding 2.3.1
+      // at https://aomediacodec.github.io/av1-isobmff/#av1c
+      // Only parse the necessary third byte. Assume that the others are valid.
+      AVIFINFO_CHECK_FOUND(AccessContent(&box, num_bytes, 3));
+      const uint32_t fields = AvifInfoInternalReadBigEndian(box.content + 2, 1);
+      const int high_bitdepth = (fields & 0x40) != 0;
+      const int twelve_bit = (fields & 0x20) != 0;
+      const int monochrome = (fields & 0x10) != 0;
+      AVIFINFO_CHECK(twelve_bit || !high_bitdepth, kInvalid);
+      features->num_channels = monochrome ? 1 : 3;
+      features->bit_depth = high_bitdepth ? twelve_bit ? 12 : 10 : 8;
+      return kFound;
+    }
+    ++box_index;
+    position += box.size;
+  } while (position != max_num_bytes && box_index <= target_property_index);
+  AVIFINFO_RETURN(kNotFound);
+}
+
+static AvifInfoInternalStatus ParseIprpForFeaturesInProperty(
+    const uint8_t* bytes, uint32_t num_bytes, uint32_t max_num_bytes,
+    uint32_t target_property_index, uint32_t* num_parsed_boxes,
+    AvifInfoFeatures* features) {
+  uint32_t position = 0;
+  do {
+    AvifInfoInternalBox box;
+    AVIFINFO_CHECK_FOUND(AvifInfoInternalParseBox(
+        bytes, num_bytes, max_num_bytes, position, num_parsed_boxes, &box));
+
+    if (!memcmp(box.type, "ipco", 4)) {
+      return ParseIpcoForFeaturesInProperty(
+          box.content, num_bytes - box.content_position, box.content_size,
+          target_property_index, num_parsed_boxes, features);
+    }
+    position += box.size;
+  } while (position != max_num_bytes);
+  AVIFINFO_RETURN(kInvalid);  // No "ipco" in "iprp" is an issue.
+}
+
+static AvifInfoInternalStatus ParseIprpForFeatures(const uint8_t* bytes,
+                                                   uint32_t num_bytes,
+                                                   uint32_t max_num_bytes,
+                                                   uint32_t target_item_id,
+                                                   uint32_t* num_parsed_boxes,
+                                                   AvifInfoFeatures* features) {
+  uint32_t position = 0;
+  do {
+    AvifInfoInternalBox box;
+    AVIFINFO_CHECK_FOUND(AvifInfoInternalParseBox(
+        bytes, num_bytes, max_num_bytes, position, num_parsed_boxes, &box));
+
+    if (!memcmp(box.type, "ipma", 4)) {
+      // See ISO/IEC 23008-12:2017(E) 9.3.2
+      AVIFINFO_CHECK_FOUND(AccessContent(&box, num_bytes, 4));
+      const uint32_t entry_count =
+          AvifInfoInternalReadBigEndian(box.content + 0, 4);
+      uint32_t offset = 4;
+      const uint32_t id_num_bytes = (box.version < 1) ? 2 : 4;
+      const uint32_t index_num_bytes = (box.flags & 1) ? 2 : 1;
+      const uint32_t essential_bit_mask = (box.flags & 1) ? 0x8000 : 0x80;
+
+      for (uint32_t entry = 0; entry < entry_count; ++entry) {
+        AVIFINFO_CHECK_FOUND(
+            AccessContent(&box, num_bytes, offset + id_num_bytes + 1));
+        const uint32_t item_id =
+            AvifInfoInternalReadBigEndian(box.content + offset, id_num_bytes);
+
+        offset += id_num_bytes;
+        const uint32_t association_count =
+            AvifInfoInternalReadBigEndian(box.content + offset, 1);
+        offset += 1;
+
+        for (uint32_t property = 0; property < association_count; ++property) {
+          AVIFINFO_CHECK_FOUND(
+              AccessContent(&box, num_bytes, offset + index_num_bytes));
+          const uint32_t value = AvifInfoInternalReadBigEndian(
+              box.content + offset, index_num_bytes);
+          offset += index_num_bytes;
+
+          if (item_id == target_item_id) {
+            // const int essential = (value & essential_bit_mask);  // Unused.
+            const uint32_t property_index = (value & ~essential_bit_mask);
+
+            // Parse again at the same "iprp" level to find the associated
+            // "ipco" and the "ispe", "pixi" or "av1C" within.
+            const AvifInfoInternalStatus status =
+                ParseIprpForFeaturesInProperty(bytes, num_bytes, max_num_bytes,
+                                               property_index, num_parsed_boxes,
+                                               features);
+            if (status != kFound) {
+              // Stop in case of error, carry on if not found.
+              AVIFINFO_CHECK_NOT_FOUND(status);
+            } else if (features->width != 0 && features->height != 0 &&
+                       features->num_channels != 0 &&
+                       features->bit_depth != 0) {
+              return kFound;  // Found everything. Otherwise carry on.
+            }
+          }
+        }
+      }
+
+      // According to ISO/IEC 14496-12:2012(E) 8.11.1.1, there is at most one
+      // "meta" per file. According to ISO/IEC 23008-12:2017(E) 9.3.1, there is
+      // exactly one "ipma" per "iprp" and at most one "iprp" per "meta".
+      // The primary properties shall have been found now.
+      if (features->width != 0 && features->height != 0) {
+        // Exception: The bit depth and number of channels may be referenced
+        //            in a tile and not in the primary item of item type "grid".
+        return kNotFound;  // Continue the search at a higher level.
+      }
+      AVIFINFO_RETURN(kInvalid);
+    }
+    position += box.size;
+  } while (position != max_num_bytes);
+  AVIFINFO_RETURN(kInvalid);  // No "ipma" in "iprp" is an issue.
+}
+
+static AvifInfoInternalStatus ParseMetaForFeatures(const uint8_t* bytes,
+                                                   uint32_t num_bytes,
+                                                   uint32_t max_num_bytes,
+                                                   uint32_t target_item_id,
+                                                   uint32_t* num_parsed_boxes,
+                                                   AvifInfoFeatures* features) {
+  uint32_t position = 0;
+  do {
+    AvifInfoInternalBox box;
+    AVIFINFO_CHECK_FOUND(AvifInfoInternalParseBox(
+        bytes, num_bytes, max_num_bytes, position, num_parsed_boxes, &box));
+
+    if (!memcmp(box.type, "iprp", 4)) {
+      return ParseIprpForFeatures(box.content, num_bytes - box.content_position,
+                                  box.content_size, target_item_id,
+                                  num_parsed_boxes, features);
+    }
+    position += box.size;
+  } while (position != max_num_bytes);
+  AVIFINFO_RETURN(kInvalid);  // No "iprp" in "meta" is an issue.
+}
+
+static AvifInfoInternalStatus ParseFileForFeatures(const uint8_t* bytes,
+                                                   uint32_t num_bytes,
+                                                   uint32_t file_size,
+                                                   uint32_t target_item_id,
+                                                   uint32_t* num_parsed_boxes,
+                                                   AvifInfoFeatures* features) {
+  uint32_t position = 0;
+  do {
+    AvifInfoInternalBox box;
+    AVIFINFO_CHECK_FOUND(AvifInfoInternalParseBox(
+        bytes, num_bytes, file_size, position, num_parsed_boxes, &box));
+
+    if (!memcmp(box.type, "meta", 4)) {
+      return ParseMetaForFeatures(box.content, num_bytes - box.content_position,
+                                  box.content_size, target_item_id,
+                                  num_parsed_boxes, features);
+    }
+    position += box.size;
+  } while (position != file_size);
+  AVIFINFO_RETURN(kInvalid);  // No "meta" is an issue.
+}
+
+//------------------------------------------------------------------------------
+// Search if a tile contains features through "meta > iref > dimg" boxes.
+
+static AvifInfoInternalStatus ParseIrefForFeaturesInTiles(
+    const uint8_t* bytes, uint32_t num_bytes, uint32_t max_num_bytes,
+    const uint8_t* meta_bytes, uint32_t meta_num_bytes,
+    uint32_t meta_max_num_bytes, uint32_t primary_item_id,
+    uint32_t* num_parsed_boxes, AvifInfoFeatures* features) {
+  uint32_t position = 0;
+  do {
+    AvifInfoInternalBox box;
+    AVIFINFO_CHECK_FOUND(AvifInfoInternalParseBox(
+        bytes, num_bytes, max_num_bytes, position, num_parsed_boxes, &box));
+
+    if (!memcmp(box.type, "dimg", 4)) {
+      // See ISO/IEC 14496-12:2015(E) 8.11.12.2
+      const uint32_t num_bytes_per_id = (box.version == 0) ? 2 : 4;
+      uint32_t offset = 0;
+      AVIFINFO_CHECK_FOUND(
+          AccessContent(&box, num_bytes, num_bytes_per_id + 2));
+      const uint32_t from_item_id =
+          AvifInfoInternalReadBigEndian(box.content + offset, num_bytes_per_id);
+      offset += num_bytes_per_id;
+      if (from_item_id == primary_item_id) {
+        const uint32_t reference_count =
+            AvifInfoInternalReadBigEndian(box.content + offset, 2);
+        offset += 2;
+        for (uint32_t i = 0; i < reference_count; ++i) {
+          AVIFINFO_CHECK_FOUND(
+              AccessContent(&box, num_bytes, offset + num_bytes_per_id));
+          const uint32_t to_item_id = AvifInfoInternalReadBigEndian(
+              box.content + offset, num_bytes_per_id);
+          offset += num_bytes_per_id;
+          AVIFINFO_CHECK(meta_bytes != NULL && meta_bytes < bytes, kInvalid);
+          AVIFINFO_CHECK(meta_max_num_bytes > 0, kInvalid);
+          // Go up one level: from "dimg" among "iref" to boxes among "meta".
+          AVIFINFO_CHECK_NOT_FOUND(ParseMetaForFeatures(
+              meta_bytes, meta_num_bytes, meta_max_num_bytes, to_item_id,
+              num_parsed_boxes, features));
+          // Trying the first tile should be enough. Check others just in case.
+        }
+      }
+    }
+    position += box.size;
+  } while (position != max_num_bytes);
+  AVIFINFO_RETURN(kNotFound);  // No "dimg" in "iref" is not an issue.
+}
+
+static AvifInfoInternalStatus ParseMetaForFeaturesInTiles(
+    const uint8_t* bytes, uint32_t num_bytes, uint32_t max_num_bytes,
+    uint32_t primary_item_id, uint32_t* num_parsed_boxes,
+    AvifInfoFeatures* features) {
+  uint32_t position = 0;
+  do {
+    AvifInfoInternalBox box;
+    AVIFINFO_CHECK_FOUND(AvifInfoInternalParseBox(
+        bytes, num_bytes, max_num_bytes, position, num_parsed_boxes, &box));
+
+    if (!memcmp(box.type, "iref", 4)) {
+      return ParseIrefForFeaturesInTiles(
+          box.content, num_bytes - box.content_position, box.content_size,
+          bytes, num_bytes, max_num_bytes, primary_item_id, num_parsed_boxes,
+          features);
+    }
+    position += box.size;
+  } while (position != max_num_bytes);
+  AVIFINFO_RETURN(kNotFound);  // No "iref" in "meta" is not an issue.
+}
+
+static AvifInfoInternalStatus ParseFileForFeaturesInTiles(
+    const uint8_t* bytes, uint32_t num_bytes, uint32_t file_size,
+    uint32_t primary_item_id, uint32_t* num_parsed_boxes,
+    AvifInfoFeatures* features) {
+  uint32_t position = 0;
+  do {
+    AvifInfoInternalBox box;
+    AVIFINFO_CHECK_FOUND(AvifInfoInternalParseBox(
+        bytes, num_bytes, file_size, position, num_parsed_boxes, &box));
+
+    if (!memcmp(box.type, "meta", 4)) {
+      return ParseMetaForFeaturesInTiles(
+          box.content, num_bytes - box.content_position, box.content_size,
+          primary_item_id, num_parsed_boxes, features);
+    }
+    position += box.size;
+  } while (position != file_size);
+  AVIFINFO_RETURN(kInvalid);  // No "meta" is an issue.
+}
+
+//------------------------------------------------------------------------------
+// Search if there is an alpha layer through "meta > iprp > ipco > auxC" boxes.
+
+static AvifInfoInternalStatus ParseIpcoForAlpha(const uint8_t* bytes,
+                                                uint32_t num_bytes,
+                                                uint32_t max_num_bytes,
+                                                uint32_t* num_parsed_boxes) {
+  uint32_t position = 0;
+  do {
+    AvifInfoInternalBox box;
+    AVIFINFO_CHECK_FOUND(AvifInfoInternalParseBox(
+        bytes, num_bytes, max_num_bytes, position, num_parsed_boxes, &box));
+
+    if (!memcmp(box.type, "auxC", 4)) {
+      // See AV1 Image File Format (AVIF) 4
+      // at https://aomediacodec.github.io/av1-avif/#auxiliary-images
+      const char* kAlphaStr = "urn:mpeg:mpegB:cicp:systems:auxiliary:alpha";
+      const uint32_t kAlphaStrLength = 44;  // Includes terminating character.
+      if (box.content_size >= kAlphaStrLength) {
+        AVIFINFO_CHECK(box.content_position + kAlphaStrLength <= num_bytes,
+                       kTruncated);
+        const char* const aux_type = (const char*)box.content;
+        if (strcmp(aux_type, kAlphaStr) == 0) {
+          // Note: It is unlikely but it is possible that this alpha plane does
+          //       not belong to the primary item or a tile. Ignore this issue.
+          return kFound;
+        }
+      }
+    }
+    position += box.size;
+  } while (position != max_num_bytes);
+  AVIFINFO_RETURN(kNotFound);  // No "auxC" in "ipco" is not an issue.
+}
+
+static AvifInfoInternalStatus ParseIprpForAlpha(const uint8_t* bytes,
+                                                uint32_t num_bytes,
+                                                uint32_t max_num_bytes,
+                                                uint32_t* num_parsed_boxes) {
+  uint32_t position = 0;
+  do {
+    AvifInfoInternalBox box;
+    AVIFINFO_CHECK_FOUND(AvifInfoInternalParseBox(
+        bytes, num_bytes, max_num_bytes, position, num_parsed_boxes, &box));
+
+    if (!memcmp(box.type, "ipco", 4)) {
+      return ParseIpcoForAlpha(box.content, num_bytes - box.content_position,
+                               box.content_size, num_parsed_boxes);
+    }
+    position += box.size;
+  } while (position != max_num_bytes);
+  AVIFINFO_RETURN(kInvalid);  // No "ipco" in "iprp" is an issue.
+}
+
+static AvifInfoInternalStatus ParseMetaForAlpha(const uint8_t* bytes,
+                                                uint32_t num_bytes,
+                                                uint32_t max_num_bytes,
+                                                uint32_t* num_parsed_boxes) {
+  uint32_t position = 0;
+  do {
+    AvifInfoInternalBox box;
+    AVIFINFO_CHECK_FOUND(AvifInfoInternalParseBox(
+        bytes, num_bytes, max_num_bytes, position, num_parsed_boxes, &box));
+
+    if (!memcmp(box.type, "iprp", 4)) {
+      return ParseIprpForAlpha(box.content, num_bytes - box.content_position,
+                               box.content_size, num_parsed_boxes);
+    }
+    position += box.size;
+  } while (position != max_num_bytes);
+  AVIFINFO_RETURN(kInvalid);  // No "iprp" in "meta" is an issue.
+}
+
+static AvifInfoInternalStatus ParseFileForAlpha(const uint8_t* bytes,
+                                                uint32_t num_bytes,
+                                                uint32_t file_size,
+                                                uint32_t* num_parsed_boxes) {
+  uint32_t position = 0;
+  do {
+    AvifInfoInternalBox box;
+    AVIFINFO_CHECK_FOUND(AvifInfoInternalParseBox(
+        bytes, num_bytes, file_size, position, num_parsed_boxes, &box));
+
+    if (!memcmp(box.type, "meta", 4)) {
+      return ParseMetaForAlpha(box.content, num_bytes - box.content_position,
+                               box.content_size, num_parsed_boxes);
+    }
+    position += box.size;
+  } while (position != file_size);
+  AVIFINFO_RETURN(kInvalid);  // No "meta" is an issue.
+}
+
+//------------------------------------------------------------------------------
+// Parsing starting point.
+
+static AvifInfoInternalStatus AvifInfoInternalParseFile(
+    const uint8_t* bytes, uint32_t num_bytes, uint32_t file_size,
+    AvifInfoFeatures* features) {
+  uint32_t num_parsed_boxes = 0;
+  AVIFINFO_CHECK_FOUND(
+      ParseFileForBrand(bytes, num_bytes, file_size, &num_parsed_boxes));
+
+  // 'bytes' is an AVIF file. Next step is finding the ID of the primary item.
+  uint32_t primary_item_id;
+  AVIFINFO_CHECK_FOUND(ParseFileForPrimaryItemId(
+      bytes, num_bytes, file_size, &num_parsed_boxes, &primary_item_id));
+
+  // Now find the 'features' of the primary item.
+  AvifInfoInternalStatus status =
+      ParseFileForFeatures(bytes, num_bytes, file_size, primary_item_id,
+                           &num_parsed_boxes, features);
+  if (status == kNotFound) {
+    // It is possible that some of the 'features' are missing for the primary
+    // item. Try to look into tiles in case they are defined there.
+    status = ParseFileForFeaturesInTiles(bytes, num_bytes, file_size,
+                                         primary_item_id, &num_parsed_boxes,
+                                         features);
+  }
+  AVIFINFO_CHECK_FOUND(status);
+
+  // If there is an alpha plane, add 1 to the number of channels.
+  status = ParseFileForAlpha(bytes, num_bytes, file_size, &num_parsed_boxes);
+  if (status == kFound) {
+    ++features->num_channels;
+  } else {
+    AVIFINFO_CHECK_NOT_FOUND(status);
+  }
+  return kFound;
+}
+
+//------------------------------------------------------------------------------
+// Public API
+
+AvifInfoStatus AvifInfoGet(const uint8_t* data, size_t data_size,
+                           AvifInfoFeatures* features) {
+  // Consider the file to be of maximum size.
+  return AvifInfoGetWithSize(data, data_size, features,
+                             /*file_size=*/kAvifInfoInternalMaxSize);
+}
+
+AvifInfoStatus AvifInfoGetWithSize(const uint8_t* data, size_t data_size,
+                                   AvifInfoFeatures* features,
+                                   size_t file_size) {
+  if (features != NULL) memset(features, 0, sizeof(*features));
+  if (data == NULL) return kAvifInfoNotEnoughData;
+  if (data_size > file_size) data_size = file_size;
+
+  AvifInfoFeatures parsed_features;
+  memset(&parsed_features, 0, sizeof(parsed_features));
+  const AvifInfoInternalStatus status = AvifInfoInternalParseFile(
+      data,
+      (data_size >= kAvifInfoInternalMaxSize) ? kAvifInfoInternalMaxSize
+                                              : (uint32_t)data_size,
+      (file_size >= kAvifInfoInternalMaxSize) ? kAvifInfoInternalMaxSize
+                                              : (uint32_t)file_size,
+      &parsed_features);
+
+  if (status == kNotFound) {
+    return (data_size < file_size) ? kAvifInfoNotEnoughData
+                                   : kAvifInfoInvalidFile;
+  }
+  if (status == kTruncated) return kAvifInfoNotEnoughData;
+  if (status == kInvalid) return kAvifInfoInvalidFile;
+  if (status == kAborted) return kAvifInfoTooComplex;
+  if (features != NULL) {
+    memcpy(features, &parsed_features, sizeof(*features));
+  }
+  return kAvifInfoOk;
+}
+
+//------------------------------------------------------------------------------
+
+#undef AVIFINFO_RETURN
+#undef AVIFINFO_CHECK
+#undef AVIFINFO_CHECK_STATUS_IS
+#undef AVIFINFO_CHECK_FOUND
+#undef AVIFINFO_CHECK_NOT_FOUND
diff --git a/avifinfo.h b/avifinfo.h
new file mode 100644
index 0000000..ea4d9d7
--- /dev/null
+++ b/avifinfo.h
@@ -0,0 +1,70 @@
+// Copyright (c) 2021, Alliance for Open Media. All rights reserved
+//
+// This source code is subject to the terms of the BSD 2 Clause License and
+// the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
+// was not distributed with this source code in the LICENSE file, you can
+// obtain it at www.aomedia.org/license/software. If the Alliance for Open
+// Media Patent License 1.0 was not distributed with this source code in the
+// PATENTS file, you can obtain it at www.aomedia.org/license/patent.
+
+#ifndef AVIFINFO_H_
+#define AVIFINFO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+//------------------------------------------------------------------------------
+
+typedef enum {
+  kAvifInfoOk,             // The file was correctly parsed and the requested
+                           // information was extracted. It is not guaranteed
+                           // that the input bitstream is a valid complete
+                           // AVIF file.
+  kAvifInfoNotEnoughData,  // The input bitstream was correctly parsed until
+                           // now but bytes are missing. The request should be
+                           // repeated with more input bytes.
+  kAvifInfoTooComplex,     // The input bitstream was correctly parsed until
+                           // now but it is too complex. The parsing was
+                           // stopped to avoid any timeout or crash.
+  kAvifInfoInvalidFile,    // The input bitstream is not a valid AVIF file,
+                           // truncated or not.
+} AvifInfoStatus;
+
+typedef struct {
+  uint32_t width, height;  // In number of pixels. Ignores mirror and rotation.
+  uint32_t bit_depth;      // Likely 8, 10 or 12 bits per channel per pixel.
+  uint32_t num_channels;   // Likely 1, 2, 3 or 4 channels:
+                           //   (1 monochrome or 3 colors) + (0 or 1 alpha)
+} AvifInfoFeatures;
+
+// Parses the AVIF 'data' and extracts its 'features'.
+// 'data' can be partial but must point to the beginning of the AVIF file.
+// The 'features' can be parsed in the first 450 bytes of most AVIF files.
+// 'features' are set to 0 unless kAvifInfoOk is returned.
+AvifInfoStatus AvifInfoGet(const uint8_t* data, size_t data_size,
+                           AvifInfoFeatures* features);
+
+// Same as above with an extra argument 'file_size'. If the latter is known,
+// please use this version for extra bitstream validation.
+AvifInfoStatus AvifInfoGetWithSize(const uint8_t* data, size_t data_size,
+                                   AvifInfoFeatures* features,
+                                   size_t file_size);
+
+//------------------------------------------------------------------------------
+
+// If needed, avifinfo.h and avifinfo.c can be merged into a single file:
+//   1. Replace this block comment by the content of avifinfo.c
+//   2. Discard #include "./avifinfo.h" and move other includes to the top
+//   3. Mark AvifInfoGet*() declarations and definitions as static
+// This procedure can be useful when only one translation unit uses avifinfo,
+// whether it includes the merged .h or the merged code is inserted into a file.
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#endif  // AVIFINFO_H_
diff --git a/tests/avifinfo_test.cc b/tests/avifinfo_test.cc
new file mode 100644
index 0000000..de28ba8
--- /dev/null
+++ b/tests/avifinfo_test.cc
@@ -0,0 +1,181 @@
+// Copyright (c) 2021, Alliance for Open Media. All rights reserved
+//
+// This source code is subject to the terms of the BSD 2 Clause License and
+// the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
+// was not distributed with this source code in the LICENSE file, you can
+// obtain it at www.aomedia.org/license/software. If the Alliance for Open
+// Media Patent License 1.0 was not distributed with this source code in the
+// PATENTS file, you can obtain it at www.aomedia.org/license/patent.
+
+#include "avifinfo.h"
+
+#include <algorithm>
+#include <fstream>
+#include <vector>
+
+#include "gtest/gtest.h"
+
+namespace {
+
+using Data = std::vector<uint8_t>;
+
+Data LoadFile(const char file_name[]) {
+  std::ifstream file(file_name, std::ios::binary | std::ios::ate);
+  if (!file) return Data();
+  const auto file_size = file.tellg();
+  Data bytes(file_size * sizeof(char));
+  file.seekg(0);  // Rewind.
+  return file.read(reinterpret_cast<char*>(bytes.data()), file_size) ? bytes
+                                                                     : Data();
+}
+
+//------------------------------------------------------------------------------
+// Positive tests
+
+TEST(AvifInfoGetTest, WithoutFileSize) {
+  const Data input = LoadFile("avifinfo_test_1x1.avif");
+  ASSERT_FALSE(input.empty());
+
+  AvifInfoFeatures features;
+  EXPECT_EQ(AvifInfoGet(input.data(), input.size(), &features), kAvifInfoOk);
+  EXPECT_EQ(features.width, 1u);
+  EXPECT_EQ(features.height, 1u);
+  EXPECT_EQ(features.bit_depth, 8u);
+  EXPECT_EQ(features.num_channels, 3u);
+}
+
+TEST(AvifInfoGetTest, WithFileSize) {
+  const Data input = LoadFile("avifinfo_test_1x1.avif");
+  ASSERT_FALSE(input.empty());
+
+  AvifInfoFeatures features;
+  EXPECT_EQ(AvifInfoGetWithSize(input.data(), /*data_size=*/input.size(),
+                                &features, /*file_size=*/input.size()),
+            kAvifInfoOk);
+  EXPECT_EQ(features.width, 1u);
+  EXPECT_EQ(features.height, 1u);
+  EXPECT_EQ(features.bit_depth, 8u);
+  EXPECT_EQ(features.num_channels, 3u);
+}
+
+TEST(AvifInfoGetTest, WithShorterSize) {
+  const Data input = LoadFile("avifinfo_test_1x1.avif");
+  ASSERT_FALSE(input.empty());
+
+  AvifInfoFeatures features;
+  // No more than 'file_size' bytes should be read, even if more are passed.
+  EXPECT_EQ(AvifInfoGetWithSize(input.data(), /*data_size=*/input.size() * 10,
+                                &features,
+                                /*file_size=*/input.size()),
+            kAvifInfoOk);
+  EXPECT_EQ(features.width, 1u);
+  EXPECT_EQ(features.height, 1u);
+  EXPECT_EQ(features.bit_depth, 8u);
+  EXPECT_EQ(features.num_channels, 3u);
+}
+
+TEST(AvifInfoGetTest, EnoughBytes) {
+  Data input = LoadFile("avifinfo_test_1x1.avif");
+  ASSERT_FALSE(input.empty());
+  // Truncate 'input' just after the required information (discard AV1 box).
+  const uint8_t kMdatTag[] = {'m', 'd', 'a', 't'};
+  input.resize(std::search(input.begin(), input.end(), kMdatTag, kMdatTag + 4) -
+               input.begin());
+
+  AvifInfoFeatures features;
+  EXPECT_EQ(AvifInfoGet(input.data(), input.size(), &features), kAvifInfoOk);
+  EXPECT_EQ(features.width, 1u);
+  EXPECT_EQ(features.height, 1u);
+  EXPECT_EQ(features.bit_depth, 8u);
+  EXPECT_EQ(features.num_channels, 3u);
+}
+
+TEST(AvifInfoGetTest, Null) {
+  const Data input = LoadFile("avifinfo_test_1x1.avif");
+  ASSERT_FALSE(input.empty());
+
+  EXPECT_EQ(AvifInfoGet(input.data(), input.size(), nullptr), kAvifInfoOk);
+  EXPECT_EQ(
+      AvifInfoGetWithSize(input.data(), input.size(), nullptr, input.size()),
+      kAvifInfoOk);
+}
+
+//------------------------------------------------------------------------------
+// Negative tests
+
+TEST(AvifInfoGetTest, Empty) {
+  AvifInfoFeatures features;
+  EXPECT_EQ(AvifInfoGet(nullptr, 0, &features), kAvifInfoNotEnoughData);
+  EXPECT_EQ(features.width, 0u);
+  EXPECT_EQ(features.height, 0u);
+  EXPECT_EQ(features.bit_depth, 0u);
+  EXPECT_EQ(features.num_channels, 0u);
+}
+
+TEST(AvifInfoGetTest, NotEnoughBytes) {
+  Data input = LoadFile("avifinfo_test_1x1.avif");
+  ASSERT_FALSE(input.empty());
+  // Truncate 'input' before having all the required information.
+  const uint8_t kIpmaTag[] = {'i', 'p', 'm', 'a'};
+  input.resize(std::search(input.begin(), input.end(), kIpmaTag, kIpmaTag + 4) -
+               input.begin());
+
+  AvifInfoFeatures features;
+  EXPECT_EQ(AvifInfoGet(input.data(), input.size(), &features),
+            kAvifInfoNotEnoughData);
+}
+
+TEST(AvifInfoGetTest, Broken) {
+  Data input = LoadFile("avifinfo_test_1x1.avif");
+  ASSERT_FALSE(input.empty());
+  // Change "ispe" to "aspe".
+  const uint8_t kIspeTag[] = {'i', 's', 'p', 'e'};
+  std::search(input.begin(), input.end(), kIspeTag, kIspeTag + 4)[0] = 'a';
+
+  AvifInfoFeatures features;
+  EXPECT_EQ(AvifInfoGet(input.data(), input.size(), &features),
+            kAvifInfoInvalidFile);
+  EXPECT_EQ(features.width, 0u);
+  EXPECT_EQ(features.height, 0u);
+  EXPECT_EQ(features.bit_depth, 0u);
+  EXPECT_EQ(features.num_channels, 0u);
+}
+
+TEST(AvifInfoGetTest, MetaBoxIsTooBig) {
+  Data input = LoadFile("avifinfo_test_1x1.avif");
+  ASSERT_FALSE(input.empty());
+  // Change "meta" box size to the maximum size 2^32-1.
+  const uint8_t kMetaTag[] = {'m', 'e', 't', 'a'};
+  auto meta_tag =
+      std::search(input.begin(), input.end(), kMetaTag, kMetaTag + 4);
+  meta_tag[-4] = meta_tag[-3] = meta_tag[-2] = meta_tag[-1] = 255;
+
+  AvifInfoFeatures features;
+  EXPECT_EQ(AvifInfoGet(input.data(), input.size(), &features),
+            kAvifInfoTooComplex);
+  EXPECT_EQ(features.width, 0u);
+  EXPECT_EQ(features.height, 0u);
+  EXPECT_EQ(features.bit_depth, 0u);
+  EXPECT_EQ(features.num_channels, 0u);
+}
+
+TEST(AvifInfoGetTest, TooManyBoxes) {
+  // Create a valid-ish input with too many boxes to parse.
+  Data input = {0,   0,   0,   16,  'f', 't', 'y', 'p',
+                'a', 'v', 'i', 'f', 0,   0,   0,   0};
+  const uint32_t kNumBoxes = 12345;
+  input.reserve(input.size() + kNumBoxes * 8);
+  for (uint32_t i = 0; i < kNumBoxes; ++i) {
+    const uint8_t kBox[] = {0, 0, 0, 8, 'a', 'b', 'c', 'd'};
+    input.insert(input.end(), kBox, kBox + kBox[3]);
+  }
+
+  AvifInfoFeatures features;
+  EXPECT_EQ(AvifInfoGet(reinterpret_cast<uint8_t*>(input.data()),
+                        input.size() * 4, &features),
+            kAvifInfoTooComplex);
+}
+
+//------------------------------------------------------------------------------
+
+}  // namespace
diff --git a/tests/avifinfo_test_1x1.avif b/tests/avifinfo_test_1x1.avif
new file mode 100644
index 0000000..21707b2
--- /dev/null
+++ b/tests/avifinfo_test_1x1.avif
Binary files differ