�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FSRC%2F'>SRC</a>/<a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2F'>php-8.4.5</a>/<a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2Fext%2F'>ext</a>/<a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2Fext%2Fstandard%2F'>standard</a>/<a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2Fext%2Fstandard%2Flibavifinfo%2F'>libavifinfo</a>/</p><hr><h3>✏️ Editing: avifinfo.c</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>// 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 &quot;avifinfo.h&quot;

#include &lt;stdint.h&gt;
#include &lt;stdio.h&gt;
#include &lt;string.h&gt;

//------------------------------------------------------------------------------

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

static AvifInfoStatus AvifInfoInternalConvertStatus(AvifInfoInternalStatus s) {
  return (s == kFound)                         ? kAvifInfoOk
         : (s == kNotFound || s == kTruncated) ? kAvifInfoNotEnoughData
         : (s == kAborted)                     ? kAvifInfoTooComplex
                                               : kAvifInfoInvalidFile;
}

// uint32_t is used everywhere in this file. It is unlikely to be insufficient
// to parse AVIF headers.
#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 &#039;input&#039; with most significant bits first.
// &#039;input&#039; must be at least &#039;num_bytes&#039;-long.
static uint32_t AvifInfoInternalReadBigEndian(const uint8_t* input,
                                              uint32_t num_bytes) {
  uint32_t value = 0;
  for (uint32_t i = 0; i &lt; num_bytes; ++i) {
    value = (value &lt;&lt; 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[] = {&quot;Found&quot;, &quot;NotFound&quot;, &quot;Truncated&quot;, &quot;Invalid&quot;, &quot;Aborted&quot;};
  fprintf(stderr, &quot;  %s:%d: %s\n&quot;, 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 &amp;&amp; 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)

//------------------------------------------------------------------------------
// Streamed input struct and helper functions.

typedef struct {
  void* stream;             // User-defined data.
  read_stream_t read;       // Used to fetch more bytes from the &#039;stream&#039;.
  skip_stream_t skip;       // Used to advance the position in the &#039;stream&#039;.
                            // Fallback to &#039;read&#039; if &#039;skip&#039; is null.
} AvifInfoInternalStream;

// Reads &#039;num_bytes&#039; from the &#039;stream&#039;. They are available at &#039;*data&#039;.
// &#039;num_bytes&#039; must be greater than zero.
static AvifInfoInternalStatus AvifInfoInternalRead(
    AvifInfoInternalStream* stream, uint32_t num_bytes, const uint8_t** data) {
  *data = stream-&gt;read(stream-&gt;stream, num_bytes);
  AVIFINFO_CHECK(*data != NULL, kTruncated);
  return kFound;
}

// Skips &#039;num_bytes&#039; from the &#039;stream&#039;. &#039;num_bytes&#039; 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 &gt; 0) {
    if (stream-&gt;skip == NULL) {
      const uint8_t* unused;
      while (num_bytes &gt; AVIFINFO_MAX_NUM_READ_BYTES) {
        AVIFINFO_CHECK_FOUND(
            AvifInfoInternalRead(stream, AVIFINFO_MAX_NUM_READ_BYTES, &amp;unused));
        num_bytes -= AVIFINFO_MAX_NUM_READ_BYTES;
      }
      return AvifInfoInternalRead(stream, num_bytes, &amp;unused);
    }
    stream-&gt;skip(stream-&gt;stream, 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 &lt;-&gt; parent item id associations.

typedef struct {
  uint8_t property_index;
  uint8_t item_id;
} AvifInfoInternalProp;  // Property index &lt;-&gt; item id associations.

typedef struct {
  uint8_t property_index;
  uint32_t width, height;
} AvifInfoInternalDimProp;  // Property &lt;-&gt; features associations.

typedef struct {
  uint8_t property_index;
  uint8_t bit_depth, num_channels;
} AvifInfoInternalChanProp;  // Property &lt;-&gt; features associations.

typedef struct {
  uint8_t has_primary_item;  // True if &quot;pitm&quot; was parsed.
  uint8_t has_alpha;         // True if an alpha &quot;auxC&quot; 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 &#039;target_item_id&#039; 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 &lt; f-&gt;num_props; ++prop_item) {
    if (f-&gt;props[prop_item].item_id != target_item_id) continue;
    const uint32_t property_index = f-&gt;props[prop_item].property_index;

    // Retrieve the width and height of the primary item if not already done.
    if (target_item_id == f-&gt;primary_item_id &amp;&amp;
        (f-&gt;primary_item_features.width == AVIFINFO_UNDEFINED ||
         f-&gt;primary_item_features.height == AVIFINFO_UNDEFINED)) {
      for (uint32_t i = 0; i &lt; f-&gt;num_dim_props; ++i) {
        if (f-&gt;dim_props[i].property_index != property_index) continue;
        f-&gt;primary_item_features.width = f-&gt;dim_props[i].width;
        f-&gt;primary_item_features.height = f-&gt;dim_props[i].height;
        if (f-&gt;primary_item_features.bit_depth != AVIFINFO_UNDEFINED &amp;&amp;
            f-&gt;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-&gt;primary_item_features.bit_depth == AVIFINFO_UNDEFINED ||
        f-&gt;primary_item_features.num_channels == AVIFINFO_UNDEFINED) {
      for (uint32_t i = 0; i &lt; f-&gt;num_chan_props; ++i) {
        if (f-&gt;chan_props[i].property_index != property_index) continue;
        f-&gt;primary_item_features.bit_depth = f-&gt;chan_props[i].bit_depth;
        f-&gt;primary_item_features.num_channels = f-&gt;chan_props[i].num_channels;
        if (f-&gt;primary_item_features.width != AVIFINFO_UNDEFINED &amp;&amp;
            f-&gt;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 &lt; f-&gt;num_tiles &amp;&amp; tile_depth &lt; 3; ++tile) {
    if (f-&gt;tiles[tile].parent_item_id != target_item_id) continue;
    AVIFINFO_CHECK_NOT_FOUND(AvifInfoInternalGetItemFeatures(
        f, f-&gt;tiles[tile].tile_item_id, tile_depth + 1));
  }
  AVIFINFO_RETURN(kNotFound);
}

// Generates the &#039;f-&gt;primary_item_features&#039; 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-&gt;has_primary_item, kNotFound);
  // Early exit.
  AVIFINFO_CHECK(f-&gt;num_dim_props &gt; 0 &amp;&amp; f-&gt;num_chan_props, kNotFound);
  AVIFINFO_CHECK_FOUND(
      AvifInfoInternalGetItemFeatures(f, f-&gt;primary_item_id, /*tile_depth=*/0));

  // &quot;auxC&quot; is parsed before the &quot;ipma&quot; properties so it is known now, if any.
  if (f-&gt;has_alpha) ++f-&gt;primary_item_features.num_channels;
  return kFound;
}

//------------------------------------------------------------------------------
// Box header parsing and various size checks.

typedef struct {
  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;  // &#039;size&#039; minus the header size.
} AvifInfoInternalBox;

// Reads the header of a &#039;box&#039; starting at the beginning of a &#039;stream&#039;.
// &#039;num_remaining_bytes&#039; is the remaining size of the container of the &#039;box&#039;
// (either the file size itself or the content size of the parent of the &#039;box&#039;).
static AvifInfoInternalStatus AvifInfoInternalParseBox(
    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(box_header_size &lt;= num_remaining_bytes, kInvalid);
  AVIFINFO_CHECK_FOUND(AvifInfoInternalRead(stream, 8, &amp;data));
  box-&gt;size = AvifInfoInternalReadBigEndian(data, sizeof(uint32_t));
  memcpy(box-&gt;type, data + 4, 4);
  // &#039;box-&gt;size==1&#039; means 64-bit size should be read after the box type.
  // &#039;box-&gt;size==0&#039; means this box extends to all remaining bytes.
  if (box-&gt;size == 1) {
    box_header_size += 8;
    AVIFINFO_CHECK(box_header_size &lt;= num_remaining_bytes, kInvalid);
    AVIFINFO_CHECK_FOUND(AvifInfoInternalRead(stream, 8, &amp;data));
    // Stop the parsing if any box has a size greater than 4GB.
    AVIFINFO_CHECK(AvifInfoInternalReadBigEndian(data, sizeof(uint32_t)) == 0,
                   kAborted);
    // Read the 32 least-significant bits.
    box-&gt;size = AvifInfoInternalReadBigEndian(data + 4, sizeof(uint32_t));
  } else if (box-&gt;size == 0) {
    box-&gt;size = num_remaining_bytes;
  }
  AVIFINFO_CHECK(box-&gt;size &gt;= box_header_size, kInvalid);
  AVIFINFO_CHECK(box-&gt;size &lt;= num_remaining_bytes, kInvalid);

  const int has_fullbox_header =
      !memcmp(box-&gt;type, &quot;meta&quot;, 4) || !memcmp(box-&gt;type, &quot;pitm&quot;, 4) ||
      !memcmp(box-&gt;type, &quot;ipma&quot;, 4) || !memcmp(box-&gt;type, &quot;ispe&quot;, 4) ||
      !memcmp(box-&gt;type, &quot;pixi&quot;, 4) || !memcmp(box-&gt;type, &quot;iref&quot;, 4) ||
      !memcmp(box-&gt;type, &quot;auxC&quot;, 4);
  if (has_fullbox_header) box_header_size += 4;
  AVIFINFO_CHECK(box-&gt;size &gt;= box_header_size, kInvalid);
  box-&gt;content_size = box-&gt;size - box_header_size;
  // Avoid timeouts. The maximum number of parsed boxes is arbitrary.
  ++*num_parsed_boxes;
  AVIFINFO_CHECK(*num_parsed_boxes &lt; 4096, kAborted);

  box-&gt;version = 0;
  box-&gt;flags = 0;
  if (has_fullbox_header) {
    AVIFINFO_CHECK_FOUND(AvifInfoInternalRead(stream, 4, &amp;data));
    box-&gt;version = AvifInfoInternalReadBigEndian(data, 1);
    box-&gt;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).
    uint32_t is_parsable = 1;
    if (!memcmp(box-&gt;type, &quot;meta&quot;, 4)) is_parsable = (box-&gt;version &lt;= 0);
    if (!memcmp(box-&gt;type, &quot;pitm&quot;, 4)) is_parsable = (box-&gt;version &lt;= 1);
    if (!memcmp(box-&gt;type, &quot;ipma&quot;, 4)) is_parsable = (box-&gt;version &lt;= 1);
    if (!memcmp(box-&gt;type, &quot;ispe&quot;, 4)) is_parsable = (box-&gt;version &lt;= 0);
    if (!memcmp(box-&gt;type, &quot;pixi&quot;, 4)) is_parsable = (box-&gt;version &lt;= 0);
    if (!memcmp(box-&gt;type, &quot;iref&quot;, 4)) is_parsable = (box-&gt;version &lt;= 1);
    if (!memcmp(box-&gt;type, &quot;auxC&quot;, 4)) is_parsable = (box-&gt;version &lt;= 0);
    // Instead of considering this file as invalid, skip unparsable boxes.
    if (!is_parsable) memcpy(box-&gt;type, &quot;\0skp&quot;, 4);  // \0 so not a valid type
  }
  return kFound;
}

//------------------------------------------------------------------------------

// Parses a &#039;stream&#039; of an &quot;ipco&quot; box into &#039;features&#039;.
// &quot;ispe&quot; is used for width and height, &quot;pixi&quot; and &quot;av1C&quot; are used for bit depth
// and number of channels, and &quot;auxC&quot; 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(stream, num_remaining_bytes,
                                                  num_parsed_boxes, &amp;box));

    if (!memcmp(box.type, &quot;ispe&quot;, 4)) {
      // See ISO/IEC 23008-12:2017(E) 6.5.3.2
      const uint8_t* data;
      AVIFINFO_CHECK(box.content_size &gt;= 8, kInvalid);
      AVIFINFO_CHECK_FOUND(AvifInfoInternalRead(stream, 8, &amp;data));
      const uint32_t width = AvifInfoInternalReadBigEndian(data + 0, 4);
      const uint32_t height = AvifInfoInternalReadBigEndian(data + 4, 4);
      AVIFINFO_CHECK(width != 0 &amp;&amp; height != 0, kInvalid);
      if (features-&gt;num_dim_props &lt; AVIFINFO_MAX_FEATURES &amp;&amp;
          box_index &lt;= AVIFINFO_MAX_VALUE) {
        features-&gt;dim_props[features-&gt;num_dim_props].property_index = box_index;
        features-&gt;dim_props[features-&gt;num_dim_props].width = width;
        features-&gt;dim_props[features-&gt;num_dim_props].height = height;
        ++features-&gt;num_dim_props;
      } else {
        features-&gt;data_was_skipped = 1;
      }
      AVIFINFO_CHECK_FOUND(AvifInfoInternalSkip(stream, box.content_size - 8));
    } else if (!memcmp(box.type, &quot;pixi&quot;, 4)) {
      // See ISO/IEC 23008-12:2017(E) 6.5.6.2
      const uint8_t* data;
      AVIFINFO_CHECK(box.content_size &gt;= 1, kInvalid);
      AVIFINFO_CHECK_FOUND(AvifInfoInternalRead(stream, 1, &amp;data));
      const uint32_t num_channels = AvifInfoInternalReadBigEndian(data + 0, 1);
      AVIFINFO_CHECK(num_channels &gt;= 1, kInvalid);
      AVIFINFO_CHECK(box.content_size &gt;= 1 + num_channels, kInvalid);
      AVIFINFO_CHECK_FOUND(AvifInfoInternalRead(stream, 1, &amp;data));
      const uint32_t bit_depth = AvifInfoInternalReadBigEndian(data, 1);
      AVIFINFO_CHECK(bit_depth &gt;= 1, kInvalid);
      for (uint32_t i = 1; i &lt; num_channels; ++i) {
        AVIFINFO_CHECK_FOUND(AvifInfoInternalRead(stream, 1, &amp;data));
        // Bit depth should be the same for all channels.
        AVIFINFO_CHECK(AvifInfoInternalReadBigEndian(data, 1) == bit_depth,
                       kInvalid);
        AVIFINFO_CHECK(i &lt;= 32, kAborted);  // Be reasonable.
      }
      if (features-&gt;num_chan_props &lt; AVIFINFO_MAX_FEATURES &amp;&amp;
          box_index &lt;= AVIFINFO_MAX_VALUE &amp;&amp; bit_depth &lt;= AVIFINFO_MAX_VALUE &amp;&amp;
          num_channels &lt;= AVIFINFO_MAX_VALUE) {
        features-&gt;chan_props[features-&gt;num_chan_props].property_index =
            box_index;
        features-&gt;chan_props[features-&gt;num_chan_props].bit_depth = bit_depth;
        features-&gt;chan_props[features-&gt;num_chan_props].num_channels =
            num_channels;
        ++features-&gt;num_chan_props;
      } else {
        features-&gt;data_was_skipped = 1;
      }
      AVIFINFO_CHECK_FOUND(
          AvifInfoInternalSkip(stream, box.content_size - (1 + num_channels)));
    } else if (!memcmp(box.type, &quot;av1C&quot;, 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.
      const uint8_t* data;
      AVIFINFO_CHECK(box.content_size &gt;= 3, kInvalid);
      AVIFINFO_CHECK_FOUND(AvifInfoInternalRead(stream, 3, &amp;data));
      const int high_bitdepth = (data[2] &amp; 0x40) != 0;
      const int twelve_bit = (data[2] &amp; 0x20) != 0;
      const int monochrome = (data[2] &amp; 0x10) != 0;
      if (twelve_bit) {
        AVIFINFO_CHECK(high_bitdepth, kInvalid);
      }
      if (features-&gt;num_chan_props &lt; AVIFINFO_MAX_FEATURES &amp;&amp;
          box_index &lt;= AVIFINFO_MAX_VALUE) {
        features-&gt;chan_props[features-&gt;num_chan_props].property_index =
            box_index;
        features-&gt;chan_props[features-&gt;num_chan_props].bit_depth =
            high_bitdepth ? twelve_bit ? 12 : 10 : 8;
        features-&gt;chan_props[features-&gt;num_chan_props].num_channels =
            monochrome ? 1 : 3;
        ++features-&gt;num_chan_props;
      } else {
        features-&gt;data_was_skipped = 1;
      }
      AVIFINFO_CHECK_FOUND(AvifInfoInternalSkip(stream, box.content_size - 3));
    } else if (!memcmp(box.type, &quot;auxC&quot;, 4)) {
      // See AV1 Image File Format (AVIF) 4
      // at https://aomediacodec.github.io/av1-avif/#auxiliary-images
      const char* kAlphaStr = &quot;urn:mpeg:mpegB:cicp:systems:auxiliary:alpha&quot;;
      const uint32_t kAlphaStrLength = 44;  // Includes terminating character.
      if (box.content_size &gt;= kAlphaStrLength) {
        const uint8_t* data;
        AVIFINFO_CHECK_FOUND(
            AvifInfoInternalRead(stream, kAlphaStrLength, &amp;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.
          features-&gt;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));
    }
    ++box_index;
    num_remaining_bytes -= box.size;
  } while (num_remaining_bytes &gt; 0);
  AVIFINFO_RETURN(kNotFound);
}

// Parses a &#039;stream&#039; of an &quot;iprp&quot; box into &#039;features&#039;. The &quot;ipco&quot; box contain
// the properties which are linked to items by the &quot;ipma&quot; 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(stream, num_remaining_bytes,
                                                  num_parsed_boxes, &amp;box));

    if (!memcmp(box.type, &quot;ipco&quot;, 4)) {
      AVIFINFO_CHECK_NOT_FOUND(
          ParseIpco(stream, box.content_size, num_parsed_boxes, features));
    } else if (!memcmp(box.type, &quot;ipma&quot;, 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 &gt;= num_read_bytes, kInvalid);
      AVIFINFO_CHECK_FOUND(AvifInfoInternalRead(stream, 4, &amp;data));
      const uint32_t entry_count = AvifInfoInternalReadBigEndian(data, 4);
      const uint32_t id_num_bytes = (box.version &lt; 1) ? 2 : 4;
      const uint32_t index_num_bytes = (box.flags &amp; 1) ? 2 : 1;
      const uint32_t essential_bit_mask = (box.flags &amp; 1) ? 0x8000 : 0x80;

      for (uint32_t entry = 0; entry &lt; entry_count; ++entry) {
        if (entry &gt;= AVIFINFO_MAX_PROPS ||
            features-&gt;num_props &gt;= AVIFINFO_MAX_PROPS) {
          features-&gt;data_was_skipped = 1;
          break;
        }
        num_read_bytes += id_num_bytes + 1;
        AVIFINFO_CHECK(box.content_size &gt;= num_read_bytes, kInvalid);
        AVIFINFO_CHECK_FOUND(
            AvifInfoInternalRead(stream, id_num_bytes + 1, &amp;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 &lt; association_count; ++property) {
          if (property &gt;= AVIFINFO_MAX_PROPS ||
              features-&gt;num_props &gt;= AVIFINFO_MAX_PROPS) {
            features-&gt;data_was_skipped = 1;
            break;
          }
          num_read_bytes += index_num_bytes;
          AVIFINFO_CHECK(box.content_size &gt;= num_read_bytes, kInvalid);
          AVIFINFO_CHECK_FOUND(
              AvifInfoInternalRead(stream, index_num_bytes, &amp;data));
          const uint32_t value =
              AvifInfoInternalReadBigEndian(data, index_num_bytes);
          // const int essential = (value &amp; essential_bit_mask);  // Unused.
          const uint32_t property_index = (value &amp; ~essential_bit_mask);
          if (property_index &lt;= AVIFINFO_MAX_VALUE &amp;&amp;
              item_id &lt;= AVIFINFO_MAX_VALUE) {
            features-&gt;props[features-&gt;num_props].property_index =
                property_index;
            features-&gt;props[features-&gt;num_props].item_id = item_id;
            ++features-&gt;num_props;
          } else {
            features-&gt;data_was_skipped = 1;
          }
        }
        if (property &lt; 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));
    }
    num_remaining_bytes -= box.size;
  } while (num_remaining_bytes != 0);
  AVIFINFO_RETURN(kNotFound);
}

//------------------------------------------------------------------------------

// Parses a &#039;stream&#039; of an &quot;iref&quot; box into &#039;features&#039;.
// The &quot;dimg&quot; 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, &amp;box));

    if (!memcmp(box.type, &quot;dimg&quot;, 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 &gt;= num_read_bytes, kInvalid);
      AVIFINFO_CHECK_FOUND(
          AvifInfoInternalRead(stream, num_bytes_per_id + 2, &amp;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);

      for (uint32_t i = 0; i &lt; reference_count; ++i) {
        if (i &gt;= AVIFINFO_MAX_TILES) {
          features-&gt;data_was_skipped = 1;
          break;
        }
        num_read_bytes += num_bytes_per_id;
        AVIFINFO_CHECK(box.content_size &gt;= num_read_bytes, kInvalid);
        AVIFINFO_CHECK_FOUND(
            AvifInfoInternalRead(stream, num_bytes_per_id, &amp;data));
        const uint32_t to_item_id =
            AvifInfoInternalReadBigEndian(data, num_bytes_per_id);
        if (from_item_id &lt;= AVIFINFO_MAX_VALUE &amp;&amp;
            to_item_id &lt;= AVIFINFO_MAX_VALUE &amp;&amp;
            features-&gt;num_tiles &lt; AVIFINFO_MAX_TILES) {
          features-&gt;tiles[features-&gt;num_tiles].tile_item_id = to_item_id;
          features-&gt;tiles[features-&gt;num_tiles].parent_item_id = from_item_id;
          ++features-&gt;num_tiles;
        } else {
          features-&gt;data_was_skipped = 1;
        }
      }

      // 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 &gt; 0);
  AVIFINFO_RETURN(kNotFound);
}

//------------------------------------------------------------------------------

// Parses a &#039;stream&#039; of a &quot;meta&quot; box. It looks for the primary item ID in the
// &quot;pitm&quot; box and recurses into other boxes to find its &#039;features&#039;.
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, &amp;box));

    if (!memcmp(box.type, &quot;pitm&quot;, 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 &lt;= num_remaining_bytes, kInvalid);
      AVIFINFO_CHECK_FOUND(
          AvifInfoInternalRead(stream, num_bytes_per_id, &amp;data));
      const uint32_t primary_item_id =
          AvifInfoInternalReadBigEndian(data, num_bytes_per_id);
      AVIFINFO_CHECK(primary_item_id &lt;= AVIFINFO_MAX_VALUE, kAborted);
      features-&gt;has_primary_item = 1;
      features-&gt;primary_item_id = primary_item_id;
      AVIFINFO_CHECK_FOUND(
          AvifInfoInternalSkip(stream, box.content_size - num_bytes_per_id));
    } else if (!memcmp(box.type, &quot;iprp&quot;, 4)) {
      AVIFINFO_CHECK_NOT_FOUND(
          ParseIprp(stream, box.content_size, num_parsed_boxes, features));
    } else if (!memcmp(box.type, &quot;iref&quot;, 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 &quot;meta&quot;.
  AVIFINFO_RETURN(features-&gt;data_was_skipped ? kAborted : kInvalid);
}

//------------------------------------------------------------------------------

// Parses a file &#039;stream&#039;. The file type is checked through the &quot;ftyp&quot; box.
static AvifInfoInternalStatus ParseFtyp(AvifInfoInternalStream* stream) {
  AvifInfoInternalBox box;
  uint32_t num_parsed_boxes = 0;
  AVIFINFO_CHECK_FOUND(AvifInfoInternalParseBox(stream, AVIFINFO_MAX_SIZE,
                                                &amp;num_parsed_boxes, &amp;box));
  AVIFINFO_CHECK(!memcmp(box.type, &quot;ftyp&quot;, 4), kInvalid);
  // Iterate over brands. See ISO/IEC 14496-12:2012(E) 4.3.1
  AVIFINFO_CHECK(box.content_size &gt;= 8, kInvalid);  // major_brand,minor_version
  for (uint32_t i = 0; i + 4 &lt;= box.content_size; i += 4) {
    const uint8_t* data;
    AVIFINFO_CHECK_FOUND(AvifInfoInternalRead(stream, 4, &amp;data));
    if (i == 4) continue;  // Skip minor_version.
    if (!memcmp(data, &quot;avif&quot;, 4) || !memcmp(data, &quot;avis&quot;, 4)) {
      AVIFINFO_CHECK_FOUND(
          AvifInfoInternalSkip(stream, box.content_size - (i + 4)));
      return kFound;
    }
    AVIFINFO_CHECK(i &lt;= 32 * 4, kAborted);  // Be reasonable.
  }
  AVIFINFO_RETURN(kInvalid);  // No AVIF brand no good.
}

// Parses a file &#039;stream&#039;. &#039;features&#039; are extracted from the &quot;meta&quot; box.
static AvifInfoInternalStatus ParseFile(AvifInfoInternalStream* stream,
                                        uint32_t* num_parsed_boxes,
                                        AvifInfoInternalFeatures* features) {
  while (1) {
    AvifInfoInternalBox box;
    AVIFINFO_CHECK_FOUND(AvifInfoInternalParseBox(stream, AVIFINFO_MAX_SIZE,
                                                  num_parsed_boxes, &amp;box));
    if (!memcmp(box.type, &quot;meta&quot;, 4)) {
      return ParseMeta(stream, box.content_size, num_parsed_boxes, features);
    } else {
      AVIFINFO_CHECK_FOUND(AvifInfoInternalSkip(stream, box.content_size));
    }
  }
  AVIFINFO_RETURN(kInvalid);  // No &quot;meta&quot; 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 &gt; forward-&gt;data_size) return NULL;
  const uint8_t* data = forward-&gt;data;
  forward-&gt;data += num_bytes;
  forward-&gt;data_size -= num_bytes;
  return data;
}

static void AvifInfoInternalForwardSkip(void* stream, size_t num_bytes) {
  AvifInfoInternalForward* forward = (AvifInfoInternalForward*)stream;
  if (num_bytes &gt; forward-&gt;data_size) num_bytes = forward-&gt;data_size;
  forward-&gt;data += num_bytes;
  forward-&gt;data_size -= num_bytes;
}

//------------------------------------------------------------------------------
// Fixed-size input public API

AvifInfoStatus AvifInfoIdentify(const uint8_t* data, size_t data_size) {
  AvifInfoInternalForward stream;
  stream.data = data;
  stream.data_size = data_size;
  // Forward null &#039;data&#039; as a null &#039;stream&#039; to handle it the same way.
  return AvifInfoIdentifyStream(
      (void*)&amp;stream, (data == NULL) ? NULL : AvifInfoInternalForwardRead,
      AvifInfoInternalForwardSkip);
}

AvifInfoStatus AvifInfoGetFeatures(const uint8_t* data, size_t data_size,
                                   AvifInfoFeatures* features) {
  AvifInfoInternalForward stream;
  stream.data = data;
  stream.data_size = data_size;
  return AvifInfoGetFeaturesStream(
      (void*)&amp;stream, (data == NULL) ? NULL : AvifInfoInternalForwardRead,
      AvifInfoInternalForwardSkip, features);
}

//------------------------------------------------------------------------------
// Streamed input API

AvifInfoStatus AvifInfoIdentifyStream(void* stream, read_stream_t read,
                                    skip_stream_t skip) {
  if (read == NULL) return kAvifInfoNotEnoughData;

  AvifInfoInternalStream internal_stream;
  internal_stream.stream = stream;
  internal_stream.read = read;
  internal_stream.skip = skip;  // Fallbacks to &#039;read&#039; if null.
  return AvifInfoInternalConvertStatus(ParseFtyp(&amp;internal_stream));
}

AvifInfoStatus AvifInfoGetFeaturesStream(void* stream, read_stream_t read,
                                    skip_stream_t skip,
                                    AvifInfoFeatures* features) {
  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 &#039;read&#039; if null.
  uint32_t num_parsed_boxes = 0;
  AvifInfoInternalFeatures internal_features;
  memset(&amp;internal_features, AVIFINFO_UNDEFINED, sizeof(internal_features));

  // Go through all relevant boxes sequentially.
  const AvifInfoInternalStatus status =
      ParseFile(&amp;internal_stream, &amp;num_parsed_boxes, &amp;internal_features);
  if (status == kFound &amp;&amp; features != NULL) {
    memcpy(features, &amp;internal_features.primary_item_features,
           sizeof(*features));
  }
  return AvifInfoInternalConvertStatus(status);
}
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2Fext%2Fstandard%2Flibavifinfo'>🔙 Back</a></p>