// 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
  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));
  // '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);
    // Stop the parsing if any box has a size greater than 4GB.
    AVIFINFO_CHECK(AvifInfoInternalReadBigEndian(bytes + position + 8,
                                                 sizeof(uint32_t)) == 0,
                   kAborted);
    // Read the 32 least-significant bits.
    box->size =
        AvifInfoInternalReadBigEndian(bytes + position + 12, sizeof(uint32_t));
  } else if (box->size == 0) {
    box->size = max_num_bytes - position;
  }
  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;

  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);
  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);

  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(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;
  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);
        AVIFINFO_CHECK(i <= 32, kAborted);  // Be reasonable.
      }
      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;
      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.
      }

      // 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)) {
      // 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