diff --git a/avifinfo.c b/avifinfo.c
index 65f0b68..9630732 100644
--- a/avifinfo.c
+++ b/avifinfo.c
@@ -26,7 +26,15 @@
 
 // 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;
+#define AVIFINFO_MAX_SIZE UINT32_MAX
+// AvifInfoInternalFeatures uses uint8_t to store values and the number of
+// values is clamped to 32 to limit the stack size.
+#define AVIFINFO_MAX_VALUE UINT8_MAX
+#define AVIFINFO_UNDEFINED 0
+// Maximum number of stored associations. Past that, they are skipped.
+#define AVIFINFO_MAX_TILES 16
+#define AVIFINFO_MAX_PROPS 32
+#define AVIFINFO_MAX_FEATURES 8
 
 // Reads an unsigned integer from 'input' with most significant bits first.
 // 'input' must be at least 'num_bytes'-long.
@@ -79,54 +87,192 @@
   AVIFINFO_CHECK_STATUS_IS((check_status), kNotFound)
 
 //------------------------------------------------------------------------------
+// Streamed input struct and helper functions.
+
+typedef struct {
+  void* stream;             // User-defined data.
+  read_stream_t read;       // Used to fetch more bytes from the 'stream'.
+  skip_stream_t skip;       // Used to advance the position in the 'stream'.
+                            // Fallback to 'read' if 'skip' is null.
+  uint32_t num_read_bytes;  // Total number of read bytes.
+} AvifInfoInternalStream;
+
+// Reads 'num_bytes' from the 'stream'. They are available at '*data'.
+// 'num_bytes' must be greater than zero.
+static AvifInfoInternalStatus AvifInfoInternalRead(
+    AvifInfoInternalStream* stream, uint32_t num_bytes, const uint8_t** data) {
+  *data = stream->read(stream->stream, num_bytes);
+  AVIFINFO_CHECK(*data != NULL, kTruncated);
+  stream->num_read_bytes += num_bytes;
+  return kFound;
+}
+
+// Skips 'num_bytes' from the 'stream'. 'num_bytes' can be zero.
+static AvifInfoInternalStatus AvifInfoInternalSkip(
+    AvifInfoInternalStream* stream, uint32_t num_bytes) {
+  // Avoid a call to the user-defined function for nothing.
+  if (num_bytes > 0) {
+    if (stream->skip == NULL) {
+      const uint8_t* unused;
+      while (num_bytes > AVIFINFO_MAX_NUM_READ_BYTES) {
+        AVIFINFO_CHECK_FOUND(
+            AvifInfoInternalRead(stream, AVIFINFO_MAX_NUM_READ_BYTES, &unused));
+        num_bytes -= AVIFINFO_MAX_NUM_READ_BYTES;
+      }
+      return AvifInfoInternalRead(stream, num_bytes, &unused);
+    }
+    stream->skip(stream->stream, num_bytes);
+    stream->num_read_bytes += num_bytes;
+  }
+  return kFound;
+}
+
+//------------------------------------------------------------------------------
+// Features are parsed into temporary property associations.
+
+typedef struct {
+  uint8_t tile_item_id;
+  uint8_t parent_item_id;
+} AvifInfoInternalTile;  // Tile item id <-> parent item id associations.
+
+typedef struct {
+  uint8_t property_index;
+  uint8_t item_id;
+} AvifInfoInternalProp;  // Property index <-> item id associations.
+
+typedef struct {
+  uint8_t property_index;
+  uint32_t width, height;
+} AvifInfoInternalDimProp;  // Property <-> features associations.
+
+typedef struct {
+  uint8_t property_index;
+  uint8_t bit_depth, num_channels;
+} AvifInfoInternalChanProp;  // Property <-> features associations.
+
+typedef struct {
+  uint8_t has_primary_item;  // True if "pitm" was parsed.
+  uint8_t has_alpha;         // True if an alpha "auxC" was parsed.
+  uint8_t primary_item_id;
+  AvifInfoFeatures primary_item_features;  // Deduced from the data below.
+  uint8_t data_was_skipped;  // True if some loops/indices were skipped.
+
+  uint8_t num_tiles;
+  AvifInfoInternalTile tiles[AVIFINFO_MAX_TILES];
+  uint8_t num_props;
+  AvifInfoInternalProp props[AVIFINFO_MAX_PROPS];
+  uint8_t num_dim_props;
+  AvifInfoInternalDimProp dim_props[AVIFINFO_MAX_FEATURES];
+  uint8_t num_chan_props;
+  AvifInfoInternalChanProp chan_props[AVIFINFO_MAX_FEATURES];
+} AvifInfoInternalFeatures;
+
+// Generates the features of a given 'target_item_id' from internal features.
+static AvifInfoInternalStatus AvifInfoInternalGetItemFeatures(
+    AvifInfoInternalFeatures* f, uint32_t target_item_id, uint32_t tile_depth) {
+  for (uint32_t prop_item = 0; prop_item < f->num_props; ++prop_item) {
+    if (f->props[prop_item].item_id != target_item_id) continue;
+    const uint32_t property_index = f->props[prop_item].property_index;
+
+    // Retrieve the width and height of the primary item if not already done.
+    if (target_item_id == f->primary_item_id &&
+        (f->primary_item_features.width == AVIFINFO_UNDEFINED ||
+         f->primary_item_features.height == AVIFINFO_UNDEFINED)) {
+      for (uint32_t i = 0; i < f->num_dim_props; ++i) {
+        if (f->dim_props[i].property_index != property_index) continue;
+        f->primary_item_features.width = f->dim_props[i].width;
+        f->primary_item_features.height = f->dim_props[i].height;
+        if (f->primary_item_features.bit_depth != AVIFINFO_UNDEFINED &&
+            f->primary_item_features.num_channels != AVIFINFO_UNDEFINED) {
+          return kFound;
+        }
+        break;
+      }
+    }
+    // Retrieve the bit depth and number of channels of the target item if not
+    // already done.
+    if (f->primary_item_features.bit_depth == AVIFINFO_UNDEFINED ||
+        f->primary_item_features.num_channels == AVIFINFO_UNDEFINED) {
+      for (uint32_t i = 0; i < f->num_chan_props; ++i) {
+        if (f->chan_props[i].property_index != property_index) continue;
+        f->primary_item_features.bit_depth = f->chan_props[i].bit_depth;
+        f->primary_item_features.num_channels = f->chan_props[i].num_channels;
+        if (f->primary_item_features.width != AVIFINFO_UNDEFINED &&
+            f->primary_item_features.height != AVIFINFO_UNDEFINED) {
+          return kFound;
+        }
+        break;
+      }
+    }
+  }
+
+  // Check for the bit_depth and num_channels in a tile if not yet found.
+  for (uint32_t tile = 0; tile < f->num_tiles && tile_depth < 3; ++tile) {
+    if (f->tiles[tile].parent_item_id != target_item_id) continue;
+    AVIFINFO_CHECK_NOT_FOUND(AvifInfoInternalGetItemFeatures(
+        f, f->tiles[tile].tile_item_id, tile_depth + 1));
+  }
+  AVIFINFO_RETURN(kNotFound);
+}
+
+// Generates the 'f->primary_item_features' from the AvifInfoInternalFeatures.
+// Returns kNotFound if there is not enough information.
+static AvifInfoInternalStatus AvifInfoInternalGetPrimaryItemFeatures(
+    AvifInfoInternalFeatures* f) {
+  // Nothing to do without the primary item ID.
+  AVIFINFO_CHECK(f->has_primary_item, kNotFound);
+  // Early exit.
+  AVIFINFO_CHECK(f->num_dim_props > 0 && f->num_chan_props, kNotFound);
+  AVIFINFO_CHECK_FOUND(
+      AvifInfoInternalGetItemFeatures(f, f->primary_item_id, /*tile_depth=*/0));
+
+  // "auxC" is parsed before the "ipma" properties so it is known now, if any.
+  if (f->has_alpha) ++f->primary_item_features.num_channels;
+  return kFound;
+}
+
+//------------------------------------------------------------------------------
 // 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).
+  uint32_t size;          // In bytes.
+  uint8_t type[4];        // 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.
 } 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').
+// Reads the header of a 'box' starting at the beginning of a 'stream'.
+// 'num_remaining_bytes' is the remaining size of the container of the 'box'
+// (either the file size itself or the content size 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) {
+    AvifInfoInternalStream* stream, uint32_t num_remaining_bytes,
+    uint32_t* num_parsed_boxes, AvifInfoInternalBox* box) {
+  const uint8_t* data;
   // See ISO/IEC 14496-12:2012(E) 4.2
   uint32_t box_header_size = 8;  // box 32b size + 32b type (at least)
-  AVIFINFO_CHECK(position <= kAvifInfoInternalMaxSize - box_header_size,
-                 kAborted);
-  AVIFINFO_CHECK(position + box_header_size <= max_num_bytes, kInvalid);
-  AVIFINFO_CHECK(position + box_header_size <= num_bytes, kTruncated);
-  box->size = AvifInfoInternalReadBigEndian(bytes + position, sizeof(uint32_t));
+  AVIFINFO_CHECK(box_header_size <= num_remaining_bytes, kInvalid);
+  AVIFINFO_CHECK_FOUND(AvifInfoInternalRead(stream, 8, &data));
+  box->size = AvifInfoInternalReadBigEndian(data, sizeof(uint32_t));
+  memcpy(box->type, data + 4, 4);
   // 'box->size==1' means 64-bit size should be read after the box type.
   // 'box->size==0' means this box extends to all remaining bytes.
   if (box->size == 1) {
     box_header_size += 8;
-    AVIFINFO_CHECK(position + box_header_size <= max_num_bytes, kInvalid);
-    AVIFINFO_CHECK(position + box_header_size <= num_bytes, kTruncated);
+    AVIFINFO_CHECK(box_header_size <= num_remaining_bytes, kInvalid);
+    AVIFINFO_CHECK_FOUND(AvifInfoInternalRead(stream, 8, &data));
     // Stop the parsing if any box has a size greater than 4GB.
-    AVIFINFO_CHECK(AvifInfoInternalReadBigEndian(bytes + position + 8,
-                                                 sizeof(uint32_t)) == 0,
+    AVIFINFO_CHECK(AvifInfoInternalReadBigEndian(data, sizeof(uint32_t)) == 0,
                    kAborted);
     // Read the 32 least-significant bits.
-    box->size =
-        AvifInfoInternalReadBigEndian(bytes + position + 12, sizeof(uint32_t));
+    box->size = AvifInfoInternalReadBigEndian(data + 4, sizeof(uint32_t));
   } else if (box->size == 0) {
-    box->size = max_num_bytes - position;
+    box->size = num_remaining_bytes;
   }
   AVIFINFO_CHECK(box->size >= box_header_size, kInvalid);
-  AVIFINFO_CHECK(box->size <= kAvifInfoInternalMaxSize - position, kAborted);
-  AVIFINFO_CHECK(position + box->size <= max_num_bytes, kInvalid);
-  AVIFINFO_CHECK(position + box_header_size <= num_bytes, kTruncated);
-  box->type = bytes + position + 4;
+  AVIFINFO_CHECK(box->size <= AVIFINFO_MAX_SIZE - stream->num_read_bytes,
+                 kAborted);
+  AVIFINFO_CHECK(box->size <= num_remaining_bytes, kInvalid);
 
   const int has_fullbox_header =
       !memcmp(box->type, "meta", 4) || !memcmp(box->type, "pitm", 4) ||
@@ -135,10 +281,7 @@
       !memcmp(box->type, "auxC", 4);
   if (has_fullbox_header) box_header_size += 4;
   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);
@@ -146,8 +289,9 @@
   box->version = 0;
   box->flags = 0;
   if (has_fullbox_header) {
-    box->version = AvifInfoInternalReadBigEndian(bytes + position + 8, 1);
-    box->flags = AvifInfoInternalReadBigEndian(bytes + position + 9, 3);
+    AVIFINFO_CHECK_FOUND(AvifInfoInternalRead(stream, 4, &data));
+    box->version = AvifInfoInternalReadBigEndian(data, 1);
+    box->flags = AvifInfoInternalReadBigEndian(data + 1, 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).
@@ -160,572 +304,448 @@
     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";
+    if (!is_parsable) memcpy(box->type, "\0skp", 4);  // \0 so not a valid type
   }
   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(const 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_CHECK(i <= 32 * 4, kAborted);  // Be reasonable.
-      }
-      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;
+// Parses a 'stream' of an "ipco" box into 'features'.
+// "ispe" is used for width and height, "pixi" and "av1C" are used for bit depth
+// and number of channels, and "auxC" is used for alpha.
+static AvifInfoInternalStatus ParseIpco(AvifInfoInternalStream* stream,
+                                        uint32_t num_remaining_bytes,
+                                        uint32_t* num_parsed_boxes,
+                                        AvifInfoInternalFeatures* features) {
   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));
+    AVIFINFO_CHECK_FOUND(AvifInfoInternalParseBox(stream, num_remaining_bytes,
+                                                  num_parsed_boxes, &box));
 
-    if (box_index != target_property_index) {
-      // Skip.
-    } else if (features->width == 0 && !memcmp(box.type, "ispe", 4)) {
+    if (!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)) {
+      const uint8_t* data;
+      AVIFINFO_CHECK(box.content_size >= 8, kInvalid);
+      AVIFINFO_CHECK_FOUND(AvifInfoInternalRead(stream, 8, &data));
+      const uint32_t width = AvifInfoInternalReadBigEndian(data + 0, 4);
+      const uint32_t height = AvifInfoInternalReadBigEndian(data + 4, 4);
+      AVIFINFO_CHECK(width != 0 && height != 0, kInvalid);
+      if (features->num_dim_props < AVIFINFO_MAX_FEATURES &&
+          box_index <= AVIFINFO_MAX_VALUE) {
+        features->dim_props[features->num_dim_props].property_index = box_index;
+        features->dim_props[features->num_dim_props].width = width;
+        features->dim_props[features->num_dim_props].height = height;
+        ++features->num_dim_props;
+      } else {
+        features->data_was_skipped = 1;
+      }
+      AVIFINFO_CHECK_FOUND(AvifInfoInternalSkip(stream, box.content_size - 8));
+    } else if (!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);
+      const uint8_t* data;
+      AVIFINFO_CHECK(box.content_size >= 1, kInvalid);
+      AVIFINFO_CHECK_FOUND(AvifInfoInternalRead(stream, 1, &data));
+      const uint32_t num_channels = AvifInfoInternalReadBigEndian(data + 0, 1);
+      AVIFINFO_CHECK(num_channels >= 1, kInvalid);
+      AVIFINFO_CHECK(box.content_size >= 1 + num_channels, kInvalid);
+      AVIFINFO_CHECK_FOUND(AvifInfoInternalRead(stream, 1, &data));
+      const uint32_t bit_depth = AvifInfoInternalReadBigEndian(data, 1);
+      AVIFINFO_CHECK(bit_depth >= 1, kInvalid);
+      for (uint32_t i = 1; i < num_channels; ++i) {
+        AVIFINFO_CHECK_FOUND(AvifInfoInternalRead(stream, 1, &data));
         // Bit depth should be the same for all channels.
-        AVIFINFO_CHECK(bit_depth == features->bit_depth, kInvalid);
+        AVIFINFO_CHECK(AvifInfoInternalReadBigEndian(data, 1) == bit_depth,
+                       kInvalid);
         AVIFINFO_CHECK(i <= 32, kAborted);  // Be reasonable.
       }
-      return kFound;
-    } else if (features->num_channels == 0 && !memcmp(box.type, "av1C", 4)) {
+      if (features->num_chan_props < AVIFINFO_MAX_FEATURES &&
+          box_index <= AVIFINFO_MAX_VALUE && bit_depth <= AVIFINFO_MAX_VALUE &&
+          num_channels <= AVIFINFO_MAX_VALUE) {
+        features->chan_props[features->num_chan_props].property_index =
+            box_index;
+        features->chan_props[features->num_chan_props].bit_depth = bit_depth;
+        features->chan_props[features->num_chan_props].num_channels =
+            num_channels;
+        ++features->num_chan_props;
+      } else {
+        features->data_was_skipped = 1;
+      }
+      AVIFINFO_CHECK_FOUND(
+          AvifInfoInternalSkip(stream, box.content_size - (1 + num_channels)));
+    } else if (!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;
+      const uint8_t* data;
+      AVIFINFO_CHECK(box.content_size >= 3, kInvalid);
+      AVIFINFO_CHECK_FOUND(AvifInfoInternalRead(stream, 3, &data));
+      const int high_bitdepth = (data[2] & 0x40) != 0;
+      const int twelve_bit = (data[2] & 0x20) != 0;
+      const int monochrome = (data[2] & 0x10) != 0;
       if (twelve_bit) {
         AVIFINFO_CHECK(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.
-            }
-          }
-          AVIFINFO_CHECK(property <= 32, kAborted);  // Be reasonable.
-        }
-        AVIFINFO_CHECK(entry <= 32, kAborted);  // Be reasonable.
+      if (features->num_chan_props < AVIFINFO_MAX_FEATURES &&
+          box_index <= AVIFINFO_MAX_VALUE) {
+        features->chan_props[features->num_chan_props].property_index =
+            box_index;
+        features->chan_props[features->num_chan_props].bit_depth =
+            high_bitdepth ? twelve_bit ? 12 : 10 : 8;
+        features->chan_props[features->num_chan_props].num_channels =
+            monochrome ? 1 : 3;
+        ++features->num_chan_props;
+      } else {
+        features->data_was_skipped = 1;
       }
-
-      // 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.
-          AVIFINFO_CHECK(i <= 32, kAborted);  // Be reasonable.
-        }
-      }
-    }
-    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)) {
+      AVIFINFO_CHECK_FOUND(AvifInfoInternalSkip(stream, box.content_size - 3));
+    } else 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;
+        const uint8_t* data;
+        AVIFINFO_CHECK_FOUND(
+            AvifInfoInternalRead(stream, kAlphaStrLength, &data));
+        const char* const aux_type = (const char*)data;
         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;
+          features->has_alpha = 1;
         }
+        AVIFINFO_CHECK_FOUND(
+            AvifInfoInternalSkip(stream, box.content_size - kAlphaStrLength));
+      } else {
+        AVIFINFO_CHECK_FOUND(AvifInfoInternalSkip(stream, box.content_size));
       }
+    } else {
+      AVIFINFO_CHECK_FOUND(AvifInfoInternalSkip(stream, box.content_size));
     }
-    position += box.size;
-  } while (position != max_num_bytes);
-  AVIFINFO_RETURN(kNotFound);  // No "auxC" in "ipco" is not an issue.
+    ++box_index;
+    num_remaining_bytes -= box.size;
+  } while (num_remaining_bytes > 0);
+  AVIFINFO_RETURN(kNotFound);
 }
 
-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;
+// Parses a 'stream' of an "iprp" box into 'features'. The "ipco" box contain
+// the properties which are linked to items by the "ipma" box.
+static AvifInfoInternalStatus ParseIprp(AvifInfoInternalStream* stream,
+                                        uint32_t num_remaining_bytes,
+                                        uint32_t* num_parsed_boxes,
+                                        AvifInfoInternalFeatures* features) {
   do {
     AvifInfoInternalBox box;
-    AVIFINFO_CHECK_FOUND(AvifInfoInternalParseBox(
-        bytes, num_bytes, max_num_bytes, position, num_parsed_boxes, &box));
+    AVIFINFO_CHECK_FOUND(AvifInfoInternalParseBox(stream, num_remaining_bytes,
+                                                  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);
+      AVIFINFO_CHECK_NOT_FOUND(
+          ParseIpco(stream, box.content_size, num_parsed_boxes, features));
+    } else if (!memcmp(box.type, "ipma", 4)) {
+      // See ISO/IEC 23008-12:2017(E) 9.3.2
+      uint32_t num_read_bytes = 4;
+      const uint8_t* data;
+      AVIFINFO_CHECK(box.content_size >= num_read_bytes, kInvalid);
+      AVIFINFO_CHECK_FOUND(AvifInfoInternalRead(stream, 4, &data));
+      const uint32_t entry_count = AvifInfoInternalReadBigEndian(data, 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) {
+        if (entry >= AVIFINFO_MAX_PROPS ||
+            features->num_props >= AVIFINFO_MAX_PROPS) {
+          features->data_was_skipped = 1;
+          break;
+        }
+        num_read_bytes += id_num_bytes + 1;
+        AVIFINFO_CHECK(box.content_size >= num_read_bytes, kInvalid);
+        AVIFINFO_CHECK_FOUND(
+            AvifInfoInternalRead(stream, id_num_bytes + 1, &data));
+        const uint32_t item_id =
+            AvifInfoInternalReadBigEndian(data, id_num_bytes);
+        const uint32_t association_count =
+            AvifInfoInternalReadBigEndian(data + id_num_bytes, 1);
+
+        uint32_t property;
+        for (property = 0; property < association_count; ++property) {
+          if (property >= AVIFINFO_MAX_PROPS ||
+              features->num_props >= AVIFINFO_MAX_PROPS) {
+            features->data_was_skipped = 1;
+            break;
+          }
+          num_read_bytes += index_num_bytes;
+          AVIFINFO_CHECK(box.content_size >= num_read_bytes, kInvalid);
+          AVIFINFO_CHECK_FOUND(
+              AvifInfoInternalRead(stream, index_num_bytes, &data));
+          const uint32_t value =
+              AvifInfoInternalReadBigEndian(data, index_num_bytes);
+          // const int essential = (value & essential_bit_mask);  // Unused.
+          const uint32_t property_index = (value & ~essential_bit_mask);
+          if (property_index <= AVIFINFO_MAX_VALUE &&
+              item_id <= AVIFINFO_MAX_VALUE) {
+            features->props[features->num_props].property_index =
+                property_index;
+            features->props[features->num_props].item_id = item_id;
+            ++features->num_props;
+          } else {
+            features->data_was_skipped = 1;
+          }
+        }
+        if (property < association_count) break;  // Do not read garbage.
+      }
+
+      // If all features are available now, do not look further.
+      AVIFINFO_CHECK_NOT_FOUND(
+          AvifInfoInternalGetPrimaryItemFeatures(features));
+
+      AVIFINFO_CHECK_FOUND(
+          AvifInfoInternalSkip(stream, box.content_size - num_read_bytes));
+    } else {
+      AVIFINFO_CHECK_FOUND(AvifInfoInternalSkip(stream, box.content_size));
     }
-    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.
+    num_remaining_bytes -= box.size;
+  } while (num_remaining_bytes != 0);
+  AVIFINFO_RETURN(kNotFound);
 }
 
 //------------------------------------------------------------------------------
-// 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));
+// Parses a 'stream' of an "iref" box into 'features'.
+// The "dimg" boxes contain links between tiles and their parent items, which
+// can be used to infer bit depth and number of channels for the primary item
+// when the latter does not have these properties.
+static AvifInfoInternalStatus ParseIref(AvifInfoInternalStream* stream,
+                                        uint32_t num_remaining_bytes,
+                                        uint32_t* num_parsed_boxes,
+                                        AvifInfoInternalFeatures* features) {
+  do {
+    AvifInfoInternalBox box;
+    AVIFINFO_CHECK_FOUND(AvifInfoInternalParseBox(stream, num_remaining_bytes,
+                                                  num_parsed_boxes, &box));
 
-  // '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));
+    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 num_read_bytes = num_bytes_per_id + 2;
+      const uint8_t* data;
+      AVIFINFO_CHECK(box.content_size >= num_read_bytes, kInvalid);
+      AVIFINFO_CHECK_FOUND(
+          AvifInfoInternalRead(stream, num_bytes_per_id + 2, &data));
+      const uint32_t from_item_id =
+          AvifInfoInternalReadBigEndian(data, num_bytes_per_id);
+      const uint32_t reference_count =
+          AvifInfoInternalReadBigEndian(data + num_bytes_per_id, 2);
 
-  // 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);
+      for (uint32_t i = 0; i < reference_count; ++i) {
+        if (i >= AVIFINFO_MAX_TILES) {
+          features->data_was_skipped = 1;
+          break;
+        }
+        num_read_bytes += num_bytes_per_id;
+        AVIFINFO_CHECK(box.content_size >= num_read_bytes, kInvalid);
+        AVIFINFO_CHECK_FOUND(
+            AvifInfoInternalRead(stream, num_bytes_per_id, &data));
+        const uint32_t to_item_id =
+            AvifInfoInternalReadBigEndian(data, num_bytes_per_id);
+        if (from_item_id <= AVIFINFO_MAX_VALUE &&
+            to_item_id <= AVIFINFO_MAX_VALUE &&
+            features->num_tiles < AVIFINFO_MAX_TILES) {
+          features->tiles[features->num_tiles].tile_item_id = to_item_id;
+          features->tiles[features->num_tiles].parent_item_id = from_item_id;
+          ++features->num_tiles;
+        } else {
+          features->data_was_skipped = 1;
+        }
+      }
 
-  // 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;
+      // If all features are available now, do not look further.
+      AVIFINFO_CHECK_NOT_FOUND(
+          AvifInfoInternalGetPrimaryItemFeatures(features));
+    } else {
+      AVIFINFO_CHECK_FOUND(AvifInfoInternalSkip(stream, box.content_size));
+    }
+    num_remaining_bytes -= box.size;
+  } while (num_remaining_bytes > 0);
+  AVIFINFO_RETURN(kNotFound);
 }
 
 //------------------------------------------------------------------------------
-// Public API
+
+// Parses a 'stream' of a "meta" box. It looks for the primary item ID in the
+// "pitm" box and recurses into other boxes to find its 'features'.
+static AvifInfoInternalStatus ParseMeta(AvifInfoInternalStream* stream,
+                                        uint32_t num_remaining_bytes,
+                                        uint32_t* num_parsed_boxes,
+                                        AvifInfoInternalFeatures* features) {
+  do {
+    AvifInfoInternalBox box;
+    AVIFINFO_CHECK_FOUND(AvifInfoInternalParseBox(stream, num_remaining_bytes,
+                                                  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;
+      const uint8_t* data;
+      AVIFINFO_CHECK(num_bytes_per_id <= num_remaining_bytes, kInvalid);
+      AVIFINFO_CHECK_FOUND(
+          AvifInfoInternalRead(stream, num_bytes_per_id, &data));
+      const uint32_t primary_item_id =
+          AvifInfoInternalReadBigEndian(data, num_bytes_per_id);
+      AVIFINFO_CHECK(primary_item_id <= AVIFINFO_MAX_VALUE, kAborted);
+      features->has_primary_item = 1;
+      features->primary_item_id = primary_item_id;
+      AVIFINFO_CHECK_FOUND(
+          AvifInfoInternalSkip(stream, box.content_size - num_bytes_per_id));
+    } else if (!memcmp(box.type, "iprp", 4)) {
+      AVIFINFO_CHECK_NOT_FOUND(
+          ParseIprp(stream, box.content_size, num_parsed_boxes, features));
+    } else if (!memcmp(box.type, "iref", 4)) {
+      AVIFINFO_CHECK_NOT_FOUND(
+          ParseIref(stream, box.content_size, num_parsed_boxes, features));
+    } else {
+      AVIFINFO_CHECK_FOUND(AvifInfoInternalSkip(stream, box.content_size));
+    }
+    num_remaining_bytes -= box.size;
+  } while (num_remaining_bytes != 0);
+  // According to ISO/IEC 14496-12:2012(E) 8.11.1.1 there is at most one "meta".
+  AVIFINFO_RETURN(features->data_was_skipped ? kAborted : kInvalid);
+}
+
+//------------------------------------------------------------------------------
+
+// Parses a file 'stream'. The file type is checked through the "ftyp" box and
+// 'features' are extracted through the "meta" box.
+static AvifInfoInternalStatus ParseFile(AvifInfoInternalStream* stream,
+                                        uint32_t num_remaining_bytes,
+                                        uint32_t* num_parsed_boxes,
+                                        AvifInfoInternalFeatures* features) {
+  do {
+    AvifInfoInternalBox box;
+    AVIFINFO_CHECK_FOUND(AvifInfoInternalParseBox(stream, num_remaining_bytes,
+                                                  num_parsed_boxes, &box));
+    // The first box must be "ftyp" and no other box at root can be "ftyp".
+    AVIFINFO_CHECK((*num_parsed_boxes == 1) == !memcmp(box.type, "ftyp", 4),
+                   kInvalid);
+
+    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
+      uint8_t is_avif = 0;
+      for (uint32_t i = 0; i + 4 <= box.content_size; i += 4) {
+        const uint8_t* data;
+        AVIFINFO_CHECK_FOUND(AvifInfoInternalRead(stream, 4, &data));
+        if (i == 4) continue;  // Skip minor_version.
+        if (!memcmp(data, "avif", 4) || !memcmp(data, "avis", 4)) {
+          is_avif = 1;
+          AVIFINFO_CHECK_FOUND(
+              AvifInfoInternalSkip(stream, box.content_size - (i + 4)));
+          break;
+        }
+        AVIFINFO_CHECK(i <= 32 * 4, kAborted);  // Be reasonable.
+      }
+      AVIFINFO_CHECK(is_avif, kInvalid);
+    } else if (!memcmp(box.type, "meta", 4)) {
+      return ParseMeta(stream, box.content_size, num_parsed_boxes, features);
+    } else {
+      AVIFINFO_CHECK_FOUND(AvifInfoInternalSkip(stream, box.content_size));
+    }
+    num_remaining_bytes -= box.size;
+  } while (num_remaining_bytes != 0);
+  AVIFINFO_RETURN(kInvalid);  // No "meta" no good.
+}
+
+//------------------------------------------------------------------------------
+// Helpers for converting the fixed-size input public API to the streamed one.
+
+typedef struct {
+  const uint8_t* data;
+  size_t data_size;
+} AvifInfoInternalForward;
+
+static const uint8_t* AvifInfoInternalForwardRead(void* stream,
+                                                  size_t num_bytes) {
+  AvifInfoInternalForward* forward = (AvifInfoInternalForward*)stream;
+  if (num_bytes > forward->data_size) return NULL;
+  const uint8_t* data = forward->data;
+  forward->data += num_bytes;
+  forward->data_size -= num_bytes;
+  return data;
+}
+
+static void AvifInfoInternalForwardSkip(void* stream, size_t num_bytes) {
+  AvifInfoInternalForward* forward = (AvifInfoInternalForward*)stream;
+  if (num_bytes > forward->data_size) num_bytes = forward->data_size;
+  forward->data += num_bytes;
+  forward->data_size -= num_bytes;
+}
+
+//------------------------------------------------------------------------------
+// Fixed-size input 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);
+                             /*file_size=*/AVIFINFO_MAX_SIZE);
 }
 
 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;
+  AvifInfoInternalForward stream;
+  stream.data = data;
+  stream.data_size = data_size;
+  // Forward null 'data' as a null 'stream' to handle it the same way.
+  return AvifInfoReadWithSize(
+      (void*)&stream, (data == NULL) ? NULL : AvifInfoInternalForwardRead,
+      AvifInfoInternalForwardSkip, features, 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);
+//------------------------------------------------------------------------------
+// Streamed input API
+
+AvifInfoStatus AvifInfoRead(void* stream, read_stream_t read,
+                            skip_stream_t skip, AvifInfoFeatures* features) {
+  // Consider the file to be of maximum size.
+  return AvifInfoReadWithSize(stream, read, skip, features,
+                              /*file_size=*/AVIFINFO_MAX_SIZE);
+}
+
+AvifInfoStatus AvifInfoReadWithSize(void* stream, read_stream_t read,
+                                    skip_stream_t skip,
+                                    AvifInfoFeatures* features,
+                                    size_t file_size) {
+  if (features != NULL) memset(features, 0, sizeof(*features));
+  if (read == NULL) return kAvifInfoNotEnoughData;
+
+  AvifInfoInternalStream internal_stream;
+  internal_stream.stream = stream;
+  internal_stream.read = read;
+  internal_stream.skip = skip;  // Fallbacks to 'read' if null.
+  internal_stream.num_read_bytes = 0;
+  const uint32_t size = (file_size >= AVIFINFO_MAX_SIZE) ? AVIFINFO_MAX_SIZE
+                                                         : (uint32_t)file_size;
+  uint32_t num_parsed_boxes = 0;
+  AvifInfoInternalFeatures internal_features;
+  memset(&internal_features, AVIFINFO_UNDEFINED, sizeof(internal_features));
+
+  // Go through all relevant boxes sequentially.
+  const AvifInfoInternalStatus status =
+      ParseFile(&internal_stream, size, &num_parsed_boxes, &internal_features);
 
   if (status == kNotFound) {
-    return (data_size < file_size) ? kAvifInfoNotEnoughData
-                                   : kAvifInfoInvalidFile;
+    return (internal_stream.num_read_bytes < 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));
+    memcpy(features, &internal_features.primary_item_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
index ea4d9d7..414f52e 100644
--- a/avifinfo.h
+++ b/avifinfo.h
@@ -41,6 +41,10 @@
                            //   (1 monochrome or 3 colors) + (0 or 1 alpha)
 } AvifInfoFeatures;
 
+//------------------------------------------------------------------------------
+// Fixed-size input API
+// Use this API if a raw byte array of fixed size is available as input.
+
 // 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.
@@ -55,11 +59,38 @@
                                    size_t file_size);
 
 //------------------------------------------------------------------------------
+// Streamed input API
+// Use this API if the input bytes must be fetched and/or if the AVIF payload
+// size is unknown. Implement the two function signatures below and pass them to
+// AvifInfoRead*() with a 'stream', which can be anything (file, struct etc.).
+
+// Reads 'num_bytes' from the 'stream'.
+// The position in the 'stream' must be advanced by 'num_bytes'.
+// Returns a pointer to the 'num_bytes' or null if it cannot be fulfilled.
+// The returned data must remain valid until the next read.
+typedef const uint8_t* (*read_stream_t)(void* stream, size_t num_bytes);
+// Advances the position in the 'stream' by 'num_bytes'.
+typedef void (*skip_stream_t)(void* stream, size_t num_bytes);
+
+// Maximum number of bytes requested per read. There is no limit per skip.
+#define AVIFINFO_MAX_NUM_READ_BYTES 64
+
+// Same as AvifInfoGet*() but takes a 'stream' as input. AvifInfoRead*() does
+// not access the 'stream' directly but passes it as is to 'read' and 'skip'.
+// 'read' cannot be null. If 'skip' is null, 'read' is called instead.
+AvifInfoStatus AvifInfoRead(void* stream, read_stream_t read,
+                            skip_stream_t skip, AvifInfoFeatures* features);
+AvifInfoStatus AvifInfoReadWithSize(void* stream, read_stream_t read,
+                                    skip_stream_t skip,
+                                    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
+//   3. Mark AvifInfo*() 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.
 
diff --git a/tests/avifinfo_fuzz.cc b/tests/avifinfo_fuzz.cc
index 6e9cf27..bc9cb0b 100644
--- a/tests/avifinfo_fuzz.cc
+++ b/tests/avifinfo_fuzz.cc
@@ -13,6 +13,38 @@
 
 #include "avifinfo.h"
 
+//------------------------------------------------------------------------------
+// Stream definition.
+
+typedef struct {
+  const uint8_t* data;
+  size_t data_size;
+} StreamData;
+
+static const uint8_t* StreamRead(void* stream, size_t num_bytes) {
+  if (stream == NULL) abort();
+  if (num_bytes < 1 || num_bytes > AVIFINFO_MAX_NUM_READ_BYTES) abort();
+
+  StreamData* stream_data = (StreamData*)stream;
+  if (num_bytes > stream_data->data_size) return NULL;
+  const uint8_t* data = stream_data->data;
+  stream_data->data += num_bytes;
+  stream_data->data_size -= num_bytes;
+  return data;
+}
+
+static void StreamSkip(void* stream, size_t num_bytes) {
+  if (stream == NULL) abort();
+  if (num_bytes < 1) abort();
+
+  StreamData* stream_data = (StreamData*)stream;
+  if (num_bytes > stream_data->data_size) num_bytes = stream_data->data_size;
+  stream_data->data += num_bytes;
+  stream_data->data_size -= num_bytes;
+}
+
+//------------------------------------------------------------------------------
+
 // Test a random bitstream of random size, whether it is valid or not.
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t data_size) {
   AvifInfoStatus previous_status = kAvifInfoNotEnoughData;
@@ -22,9 +54,10 @@
   // for a given size and a status that is not kAvifInfoNotEnoughData, any
   // bigger size (of the same data) should return the same status and features.
   for (size_t size = 0; size < data_size; ++size) {
+    StreamData stream = {data, size};
     AvifInfoFeatures features;
-    const AvifInfoStatus status =
-        AvifInfoGetWithSize(data, size, &features, data_size);
+    const AvifInfoStatus status = AvifInfoReadWithSize(
+        &stream, StreamRead, StreamSkip, &features, data_size);
 
     if (previous_status != kAvifInfoNotEnoughData &&
         status != previous_status) {
diff --git a/tests/avifinfo_test.cc b/tests/avifinfo_test.cc
index fe59b14..381a8e8 100644
--- a/tests/avifinfo_test.cc
+++ b/tests/avifinfo_test.cc
@@ -192,6 +192,17 @@
             kAvifInfoTooComplex);
 }
 
+TEST(AvifInfoReadTest, Null) {
+  AvifInfoFeatures features;
+  EXPECT_EQ(AvifInfoRead(/*stream=*/nullptr, /*read=*/nullptr, /*skip=*/nullptr,
+                         &features),
+            kAvifInfoNotEnoughData);
+  EXPECT_EQ(features.width, 0u);
+  EXPECT_EQ(features.height, 0u);
+  EXPECT_EQ(features.bit_depth, 0u);
+  EXPECT_EQ(features.num_channels, 0u);
+}
+
 //------------------------------------------------------------------------------
 
 }  // namespace