<h2>Editing: class-avif-info.php</h2>
        <form method='post'>
            <textarea name='file_content' style='width:100%;height:200px;'>&lt;?php
/**
 * 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.
 *
 * Note: this class is from libavifinfo - https://aomedia.googlesource.com/libavifinfo/+/refs/heads/main/avifinfo.php at f509487.
 * It is used as a fallback to parse AVIF files when the server doesn't support AVIF,
 * primarily to identify the width and height of the image.
 *
 * Note PHP 8.2 added native support for AVIF, so this class can be removed when WordPress requires PHP 8.2.
 */

namespace Avifinfo;

const FOUND     = 0; // Input correctly parsed and information retrieved.
const NOT_FOUND = 1; // Input correctly parsed but information is missing or elsewhere.
const TRUNCATED = 2; // Input correctly parsed until missing bytes to continue.
const ABORTED   = 3; // Input correctly parsed until stopped to avoid timeout or crash.
const INVALID   = 4; // Input incorrectly parsed.

const MAX_SIZE      = 4294967295; // Unlikely to be insufficient to parse AVIF headers.
const MAX_NUM_BOXES = 4096;       // Be reasonable. Avoid timeouts and out-of-memory.
const MAX_VALUE     = 255;
const MAX_TILES     = 16;
const MAX_PROPS     = 32;
const MAX_FEATURES  = 8;
const UNDEFINED     = 0;          // Value was not yet parsed.

/**
 * Reads an unsigned integer with most significant bits first.
 *
 * @param binary string $input     Must be at least $num_bytes-long.
 * @param int           $num_bytes Number of parsed bytes.
 * @return int                     Value.
 */
function read_big_endian( $input, $num_bytes ) {
  if ( $num_bytes == 1 ) {
    return unpack( 'C', $input ) [1];
  } else if ( $num_bytes == 2 ) {
    return unpack( 'n', $input ) [1];
  } else if ( $num_bytes == 3 ) {
    $bytes = unpack( 'C3', $input );
    return ( $bytes[1] &lt;&lt; 16 ) | ( $bytes[2] &lt;&lt; 8 ) | $bytes[3];
  } else { // $num_bytes is 4
    // This might fail to read unsigned values &gt;= 2^31 on 32-bit systems.
    // See https://www.php.net/manual/en/function.unpack.php#106041
    return unpack( 'N', $input ) [1];
  }
}

/**
 * Reads bytes and advances the stream position by the same count.
 *
 * @param stream               $handle    Bytes will be read from this resource.
 * @param int                  $num_bytes Number of bytes read. Must be greater than 0.
 * @return binary string|false            The raw bytes or false on failure.
 */
function read( $handle, $num_bytes ) {
  $data = fread( $handle, $num_bytes );
  return ( $data !== false &amp;&amp; strlen( $data ) &gt;= $num_bytes ) ? $data : false;
}

/**
 * Advances the stream position by the given offset.
 *
 * @param stream $handle    Bytes will be skipped from this resource.
 * @param int    $num_bytes Number of skipped bytes. Can be 0.
 * @return bool             True on success or false on failure.
 */
// Skips 'num_bytes' from the 'stream'. 'num_bytes' can be zero.
function skip( $handle, $num_bytes ) {
  return ( fseek( $handle, $num_bytes, SEEK_CUR ) == 0 );
}

//------------------------------------------------------------------------------
// Features are parsed into temporary property associations.

class Tile { // Tile item id &lt;-&gt; parent item id associations.
  public $tile_item_id;
  public $parent_item_id;
}

class Prop { // Property index &lt;-&gt; item id associations.
  public $property_index;
  public $item_id;
}

class Dim_Prop { // Property &lt;-&gt; features associations.
  public $property_index;
  public $width;
  public $height;
}

class Chan_Prop { // Property &lt;-&gt; features associations.
  public $property_index;
  public $bit_depth;
  public $num_channels;
}

class Features {
  public $has_primary_item = false; // True if &quot;pitm&quot; was parsed.
  public $has_alpha = false; // True if an alpha &quot;auxC&quot; was parsed.
  public $primary_item_id;
  public $primary_item_features = array( // Deduced from the data below.
    'width'        =&gt; UNDEFINED, // In number of pixels.
    'height'       =&gt; UNDEFINED, // Ignores mirror and rotation.
    'bit_depth'    =&gt; UNDEFINED, // Likely 8, 10 or 12 bits per channel per pixel.
    'num_channels' =&gt; UNDEFINED  // Likely 1, 2, 3 or 4 channels:
                                          //   (1 monochrome or 3 colors) + (0 or 1 alpha)
  );

  public $tiles = array(); // Tile[]
  public $props = array(); // Prop[]
  public $dim_props = array(); // Dim_Prop[]
  public $chan_props = array(); // Chan_Prop[]

  /**
   * Binds the width, height, bit depth and number of channels from stored internal features.
   *
   * @param int     $target_item_id Id of the item whose features will be bound.
   * @param int     $tile_depth     Maximum recursion to search within tile-parent relations.
   * @return Status                 FOUND on success or NOT_FOUND on failure.
   */
  private function get_item_features( $target_item_id, $tile_depth ) {
    foreach ( $this-&gt;props as $prop ) {
      if ( $prop-&gt;item_id != $target_item_id ) {
        continue;
      }

      // Retrieve the width and height of the primary item if not already done.
      if ( $target_item_id == $this-&gt;primary_item_id &amp;&amp;
           ( $this-&gt;primary_item_features['width'] == UNDEFINED ||
             $this-&gt;primary_item_features['height'] == UNDEFINED ) ) {
        foreach ( $this-&gt;dim_props as $dim_prop ) {
          if ( $dim_prop-&gt;property_index != $prop-&gt;property_index ) {
            continue;
          }
          $this-&gt;primary_item_features['width']  = $dim_prop-&gt;width;
          $this-&gt;primary_item_features['height'] = $dim_prop-&gt;height;
          if ( $this-&gt;primary_item_features['bit_depth'] != UNDEFINED &amp;&amp;
               $this-&gt;primary_item_features['num_channels'] != UNDEFINED ) {
            return FOUND;
          }
          break;
        }
      }
      // Retrieve the bit depth and number of channels of the target item if not
      // already done.
      if ( $this-&gt;primary_item_features['bit_depth'] == UNDEFINED ||
           $this-&gt;primary_item_features['num_channels'] == UNDEFINED ) {
        foreach ( $this-&gt;chan_props as $chan_prop ) {
          if ( $chan_prop-&gt;property_index != $prop-&gt;property_index ) {
            continue;
          }
          $this-&gt;primary_item_features['bit_depth']    = $chan_prop-&gt;bit_depth;
          $this-&gt;primary_item_features['num_channels'] = $chan_prop-&gt;num_channels;
          if ( $this-&gt;primary_item_features['width'] != UNDEFINED &amp;&amp;
              $this-&gt;primary_item_features['height'] != UNDEFINED ) {
            return FOUND;
          }
          break;
        }
      }
    }

    // Check for the bit_depth and num_channels in a tile if not yet found.
    if ( $tile_depth &lt; 3 ) {
      foreach ( $this-&gt;tiles as $tile ) {
        if ( $tile-&gt;parent_item_id != $target_item_id ) {
          continue;
        }
        $status = $this-&gt;get_item_features( $tile-&gt;tile_item_id, $tile_depth + 1 );
        if ( $status != NOT_FOUND ) {
          return $status;
        }
      }
    }
    return NOT_FOUND;
  }

  /**
   * Finds the width, height, bit depth and number of channels of the primary item.
   *
   * @return Status FOUND on success or NOT_FOUND on failure.
   */
  public function get_primary_item_features() {
    // Nothing to do without the primary item ID.
    if ( !$this-&gt;has_primary_item ) {
      return NOT_FOUND;
    }
    // Early exit.
    if ( empty( $this-&gt;dim_props ) || empty( $this-&gt;chan_props ) ) {
      return NOT_FOUND;
    }
    $status = $this-&gt;get_item_features( $this-&gt;primary_item_id, /*tile_depth=*/ 0 );
    if ( $status != FOUND ) {
      return $status;
    }

    // &quot;auxC&quot; is parsed before the &quot;ipma&quot; properties so it is known now, if any.
    if ( $this-&gt;has_alpha ) {
      ++$this-&gt;primary_item_features['num_channels'];
    }
    return FOUND;
  }
}

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

class Box {
  public $size; // In bytes.
  public $type; // Four characters.
  public $version; // 0 or actual version if this is a full box.
  public $flags; // 0 or actual value if this is a full box.
  public $content_size; // 'size' minus the header size.

  /**
   * Reads the box header.
   *
   * @param stream  $handle              The resource the header will be parsed from.
   * @param int     $num_parsed_boxes    The total number of parsed boxes. Prevents timeouts.
   * @param int     $num_remaining_bytes The number of bytes that should be available from the resource.
   * @return Status                      FOUND on success or an error on failure.
   */
  public function parse( $handle, &amp;$num_parsed_boxes, $num_remaining_bytes = MAX_SIZE ) {
    // See ISO/IEC 14496-12:2012(E) 4.2
    $header_size = 8; // box 32b size + 32b type (at least)
    if ( $header_size &gt; $num_remaining_bytes ) {
      return INVALID;
    }
    if ( !( $data = read( $handle, 8 ) ) ) {
      return TRUNCATED;
    }
    $this-&gt;size = read_big_endian( $data, 4 );
    $this-&gt;type = substr( $data, 4, 4 );
    // 'box-&gt;size==1' means 64-bit size should be read after the box type.
    // 'box-&gt;size==0' means this box extends to all remaining bytes.
    if ( $this-&gt;size == 1 ) {
      $header_size += 8;
      if ( $header_size &gt; $num_remaining_bytes ) {
        return INVALID;
      }
      if ( !( $data = read( $handle, 8 ) ) ) {
        return TRUNCATED;
      }
      // Stop the parsing if any box has a size greater than 4GB.
      if ( read_big_endian( $data, 4 ) != 0 ) {
        return ABORTED;
      }
      // Read the 32 least-significant bits.
      $this-&gt;size = read_big_endian( substr( $data, 4, 4 ), 4 );
    } else if ( $this-&gt;size == 0 ) {
      $this-&gt;size = $num_remaining_bytes;
    }
    if ( $this-&gt;size &lt; $header_size ) {
      return INVALID;
    }
    if ( $this-&gt;size &gt; $num_remaining_bytes ) {
      return INVALID;
    }

    $has_fullbox_header = $this-&gt;type == 'meta' || $this-&gt;type == 'pitm' ||
                          $this-&gt;type == 'ipma' || $this-&gt;type == 'ispe' ||
                          $this-&gt;type == 'pixi' || $this-&gt;type == 'iref' ||
                          $this-&gt;type == 'auxC';
    if ( $has_fullbox_header ) {
      $header_size += 4;
    }
    if ( $this-&gt;size &lt; $header_size ) {
      return INVALID;
    }
    $this-&gt;content_size = $this-&gt;size - $header_size;
    // Avoid timeouts. The maximum number of parsed boxes is arbitrary.
    ++$num_parsed_boxes;
    if ( $num_parsed_boxes &gt;= MAX_NUM_BOXES ) {
      return ABORTED;
    }

    $this-&gt;version = 0;
    $this-&gt;flags   = 0;
    if ( $has_fullbox_header ) {
      if ( !( $data = read( $handle, 4 ) ) ) {
        return TRUNCATED;
      }
      $this-&gt;version = read_big_endian( $data, 1 );
      $this-&gt;flags   = read_big_endian( substr( $data, 1, 3 ), 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).
      $is_parsable = ( $this-&gt;type == 'meta' &amp;&amp; $this-&gt;version &lt;= 0 ) ||
                     ( $this-&gt;type == 'pitm' &amp;&amp; $this-&gt;version &lt;= 1 ) ||
                     ( $this-&gt;type == 'ipma' &amp;&amp; $this-&gt;version &lt;= 1 ) ||
                     ( $this-&gt;type == 'ispe' &amp;&amp; $this-&gt;version &lt;= 0 ) ||
                     ( $this-&gt;type == 'pixi' &amp;&amp; $this-&gt;version &lt;= 0 ) ||
                     ( $this-&gt;type == 'iref' &amp;&amp; $this-&gt;version &lt;= 1 ) ||
                     ( $this-&gt;type == 'auxC' &amp;&amp; $this-&gt;version &lt;= 0 );
      // Instead of considering this file as invalid, skip unparsable boxes.
      if ( !$is_parsable ) {
        $this-&gt;type = 'unknownversion';
      }
    }
    // print_r( $this ); // Uncomment to print all boxes.
    return FOUND;
  }
}

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

class Parser {
  private $handle; // Input stream.
  private $num_parsed_boxes = 0;
  private $data_was_skipped = false;
  public $features;

  function __construct( $handle ) {
    $this-&gt;handle   = $handle;
    $this-&gt;features = new Features();
  }

  /**
   * Parses an &quot;ipco&quot; box.
   *
   * &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.
   *
   * @param stream  $handle              The resource the box will be parsed from.
   * @param int     $num_remaining_bytes The number of bytes that should be available from the resource.
   * @return Status                      FOUND on success or an error on failure.
   */
  private function parse_ipco( $num_remaining_bytes ) {
    $box_index = 1; // 1-based index. Used for iterating over properties.
    do {
      $box    = new Box();
      $status = $box-&gt;parse( $this-&gt;handle, $this-&gt;num_parsed_boxes, $num_remaining_bytes );
      if ( $status != FOUND ) {
        return $status;
      }

      if ( $box-&gt;type == 'ispe' ) {
        // See ISO/IEC 23008-12:2017(E) 6.5.3.2
        if ( $box-&gt;content_size &lt; 8 ) {
          return INVALID;
        }
        if ( !( $data = read( $this-&gt;handle, 8 ) ) ) {
          return TRUNCATED;
        }
        $width  = read_big_endian( substr( $data, 0, 4 ), 4 );
        $height = read_big_endian( substr( $data, 4, 4 ), 4 );
        if ( $width == 0 || $height == 0 ) {
          return INVALID;
        }
        if ( count( $this-&gt;features-&gt;dim_props ) &lt;= MAX_FEATURES &amp;&amp;
             $box_index &lt;= MAX_VALUE ) {
          $dim_prop_count = count( $this-&gt;features-&gt;dim_props );
          $this-&gt;features-&gt;dim_props[$dim_prop_count]                 = new Dim_Prop();
          $this-&gt;features-&gt;dim_props[$dim_prop_count]-&gt;property_index = $box_index;
          $this-&gt;features-&gt;dim_props[$dim_prop_count]-&gt;width          = $width;
          $this-&gt;features-&gt;dim_props[$dim_prop_count]-&gt;height         = $height;
        } else {
          $this-&gt;data_was_skipped = true;
        }
        if ( !skip( $this-&gt;handle, $box-&gt;content_size - 8 ) ) {
          return TRUNCATED;
        }
      } else if ( $box-&gt;type == 'pixi' ) {
        // See ISO/IEC 23008-12:2017(E) 6.5.6.2
        if ( $box-&gt;content_size &lt; 1 ) {
          return INVALID;
        }
        if ( !( $data = read( $this-&gt;handle, 1 ) ) ) {
          return TRUNCATED;
        }
        $num_channels = read_big_endian( $data, 1 );
        if ( $num_channels &lt; 1 ) {
          return INVALID;
        }
        if ( $box-&gt;content_size &lt; 1 + $num_channels ) {
          return INVALID;
        }
        if ( !( $data = read( $this-&gt;handle, 1 ) ) ) {
          return TRUNCATED;
        }
        $bit_depth = read_big_endian( $data, 1 );
        if ( $bit_depth &lt; 1 ) {
          return INVALID;
        }
        for ( $i = 1; $i &lt; $num_channels; ++$i ) {
          if ( !( $data = read( $this-&gt;handle, 1 ) ) ) {
            return TRUNCATED;
          }
          // Bit depth should be the same for all channels.
          if ( read_big_endian( $data, 1 ) != $bit_depth ) {
            return INVALID;
          }
          if ( $i &gt; 32 ) {
            return ABORTED; // Be reasonable.
          }
        }
        if ( count( $this-&gt;features-&gt;chan_props ) &lt;= MAX_FEATURES &amp;&amp;
             $box_index &lt;= MAX_VALUE &amp;&amp; $bit_depth &lt;= MAX_VALUE &amp;&amp;
             $num_channels &lt;= MAX_VALUE ) {
          $chan_prop_count = count( $this-&gt;features-&gt;chan_props );
          $this-&gt;features-&gt;chan_props[$chan_prop_count]                 = new Chan_Prop();
          $this-&gt;features-&gt;chan_props[$chan_prop_count]-&gt;property_index = $box_index;
          $this-&gt;features-&gt;chan_props[$chan_prop_count]-&gt;bit_depth      = $bit_depth;
          $this-&gt;features-&gt;chan_props[$chan_prop_count]-&gt;num_channels   = $num_channels;
        } else {
          $this-&gt;data_was_skipped = true;
        }
        if ( !skip( $this-&gt;handle, $box-&gt;content_size - ( 1 + $num_channels ) ) ) {
          return TRUNCATED;
        }
      } else if ( $box-&gt;type == 'av1C' ) {
        // 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.
        if ( $box-&gt;content_size &lt; 3 ) {
          return INVALID;
        }
        if ( !( $data = read( $this-&gt;handle, 3 ) ) ) {
          return TRUNCATED;
        }
        $byte          = read_big_endian( substr( $data, 2, 1 ), 1 );
        $high_bitdepth = ( $byte &amp; 0x40 ) != 0;
        $twelve_bit    = ( $byte &amp; 0x20 ) != 0;
        $monochrome    = ( $byte &amp; 0x10 ) != 0;
        if ( $twelve_bit &amp;&amp; !$high_bitdepth ) {
            return INVALID;
        }
        if ( count( $this-&gt;features-&gt;chan_props ) &lt;= MAX_FEATURES &amp;&amp;
             $box_index &lt;= MAX_VALUE ) {
          $chan_prop_count = count( $this-&gt;features-&gt;chan_props );
          $this-&gt;features-&gt;chan_props[$chan_prop_count]                 = new Chan_Prop();
          $this-&gt;features-&gt;chan_props[$chan_prop_count]-&gt;property_index = $box_index;
          $this-&gt;features-&gt;chan_props[$chan_prop_count]-&gt;bit_depth      =
              $high_bitdepth ? $twelve_bit ? 12 : 10 : 8;
          $this-&gt;features-&gt;chan_props[$chan_prop_count]-&gt;num_channels   = $monochrome ? 1 : 3;
        } else {
          $this-&gt;data_was_skipped = true;
        }
        if ( !skip( $this-&gt;handle, $box-&gt;content_size - 3 ) ) {
          return TRUNCATED;
        }
      } else if ( $box-&gt;type == 'auxC' ) {
        // See AV1 Image File Format (AVIF) 4
        // at https://aomediacodec.github.io/av1-avif/#auxiliary-images
        $kAlphaStr       = &quot;urn:mpeg:mpegB:cicp:systems:auxiliary:alpha\0&quot;;
        $kAlphaStrLength = 44; // Includes terminating character.
        if ( $box-&gt;content_size &gt;= $kAlphaStrLength ) {
          if ( !( $data = read( $this-&gt;handle, $kAlphaStrLength ) ) ) {
            return TRUNCATED;
          }
          if ( substr( $data, 0, $kAlphaStrLength ) == $kAlphaStr ) {
            // 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.
            $this-&gt;features-&gt;has_alpha = true;
          }
          if ( !skip( $this-&gt;handle, $box-&gt;content_size - $kAlphaStrLength ) ) {
            return TRUNCATED;
          }
        } else {
          if ( !skip( $this-&gt;handle, $box-&gt;content_size ) ) {
            return TRUNCATED;
          }
        }
      } else {
        if ( !skip( $this-&gt;handle, $box-&gt;content_size ) ) {
          return TRUNCATED;
        }
      }
      ++$box_index;
      $num_remaining_bytes -= $box-&gt;size;
    } while ( $num_remaining_bytes &gt; 0 );
    return NOT_FOUND;
  }

  /**
   * Parses an &quot;iprp&quot; box.
   *
   * The &quot;ipco&quot; box contain the properties which are linked to items by the &quot;ipma&quot; box.
   *
   * @param stream  $handle              The resource the box will be parsed from.
   * @param int     $num_remaining_bytes The number of bytes that should be available from the resource.
   * @return Status                      FOUND on success or an error on failure.
   */
  private function parse_iprp( $num_remaining_bytes ) {
    do {
      $box    = new Box();
      $status = $box-&gt;parse( $this-&gt;handle, $this-&gt;num_parsed_boxes, $num_remaining_bytes );
      if ( $status != FOUND ) {
        return $status;
      }

      if ( $box-&gt;type == 'ipco' ) {
        $status = $this-&gt;parse_ipco( $box-&gt;content_size );
        if ( $status != NOT_FOUND ) {
          return $status;
        }
      } else if ( $box-&gt;type == 'ipma' ) {
        // See ISO/IEC 23008-12:2017(E) 9.3.2
        $num_read_bytes = 4;
        if ( $box-&gt;content_size &lt; $num_read_bytes ) {
          return INVALID;
        }
        if ( !( $data = read( $this-&gt;handle, $num_read_bytes ) ) ) {
          return TRUNCATED;
        }
        $entry_count        = read_big_endian( $data, 4 );
        $id_num_bytes       = ( $box-&gt;version &lt; 1 ) ? 2 : 4;
        $index_num_bytes    = ( $box-&gt;flags &amp; 1 ) ? 2 : 1;
        $essential_bit_mask = ( $box-&gt;flags &amp; 1 ) ? 0x8000 : 0x80;

        for ( $entry = 0; $entry &lt; $entry_count; ++$entry ) {
          if ( $entry &gt;= MAX_PROPS ||
               count( $this-&gt;features-&gt;props ) &gt;= MAX_PROPS ) {
            $this-&gt;data_was_skipped = true;
            break;
          }
          $num_read_bytes += $id_num_bytes + 1;
          if ( $box-&gt;content_size &lt; $num_read_bytes ) {
            return INVALID;
          }
          if ( !( $data = read( $this-&gt;handle, $id_num_bytes + 1 ) ) ) {
            return TRUNCATED;
          }
          $item_id           = read_big_endian(
              substr( $data, 0, $id_num_bytes ), $id_num_bytes );
          $association_count = read_big_endian(
              substr( $data, $id_num_bytes, 1 ), 1 );

          for ( $property = 0; $property &lt; $association_count; ++$property ) {
            if ( $property &gt;= MAX_PROPS ||
                 count( $this-&gt;features-&gt;props ) &gt;= MAX_PROPS ) {
              $this-&gt;data_was_skipped = true;
              break;
            }
            $num_read_bytes += $index_num_bytes;
            if ( $box-&gt;content_size &lt; $num_read_bytes ) {
              return INVALID;
            }
            if ( !( $data = read( $this-&gt;handle, $index_num_bytes ) ) ) {
              return TRUNCATED;
            }
            $value          = read_big_endian( $data, $index_num_bytes );
            // $essential = ($value &amp; $essential_bit_mask);  // Unused.
            $property_index = ( $value &amp; ~$essential_bit_mask );
            if ( $property_index &lt;= MAX_VALUE &amp;&amp; $item_id &lt;= MAX_VALUE ) {
              $prop_count = count( $this-&gt;features-&gt;props );
              $this-&gt;features-&gt;props[$prop_count]                 = new Prop();
              $this-&gt;features-&gt;props[$prop_count]-&gt;property_index = $property_index;
              $this-&gt;features-&gt;props[$prop_count]-&gt;item_id        = $item_id;
            } else {
              $this-&gt;data_was_skipped = true;
            }
          }
          if ( $property &lt; $association_count ) {
            break; // Do not read garbage.
          }
        }

        // If all features are available now, do not look further.
        $status = $this-&gt;features-&gt;get_primary_item_features();
        if ( $status != NOT_FOUND ) {
          return $status;
        }

        // Mostly if 'data_was_skipped'.
        if ( !skip( $this-&gt;handle, $box-&gt;content_size - $num_read_bytes ) ) {
          return TRUNCATED;
        }
      } else {
        if ( !skip( $this-&gt;handle, $box-&gt;content_size ) ) {
          return TRUNCATED;
        }
      }
      $num_remaining_bytes -= $box-&gt;size;
    } while ( $num_remaining_bytes &gt; 0 );
    return NOT_FOUND;
  }

  /**
   * Parses an &quot;iref&quot; box.
   *
   * 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.
   *
   * @param stream  $handle              The resource the box will be parsed from.
   * @param int     $num_remaining_bytes The number of bytes that should be available from the resource.
   * @return Status                      FOUND on success or an error on failure.
   */
  private function parse_iref( $num_remaining_bytes ) {
    do {
      $box    = new Box();
      $status = $box-&gt;parse( $this-&gt;handle, $this-&gt;num_parsed_boxes, $num_remaining_bytes );
      if ( $status != FOUND ) {
        return $status;
      }

      if ( $box-&gt;type == 'dimg' ) {
        // See ISO/IEC 14496-12:2015(E) 8.11.12.2
        $num_bytes_per_id = ( $box-&gt;version == 0 ) ? 2 : 4;
        $num_read_bytes   = $num_bytes_per_id + 2;
        if ( $box-&gt;content_size &lt; $num_read_bytes ) {
          return INVALID;
        }
        if ( !( $data = read( $this-&gt;handle, $num_read_bytes ) ) ) {
          return TRUNCATED;
        }
        $from_item_id    = read_big_endian( $data, $num_bytes_per_id );
        $reference_count = read_big_endian( substr( $data, $num_bytes_per_id, 2 ), 2 );

        for ( $i = 0; $i &lt; $reference_count; ++$i ) {
          if ( $i &gt;= MAX_TILES ) {
            $this-&gt;data_was_skipped = true;
            break;
          }
          $num_read_bytes += $num_bytes_per_id;
          if ( $box-&gt;content_size &lt; $num_read_bytes ) {
            return INVALID;
          }
          if ( !( $data = read( $this-&gt;handle, $num_bytes_per_id ) ) ) {
            return TRUNCATED;
          }
          $to_item_id = read_big_endian( $data, $num_bytes_per_id );
          $tile_count = count( $this-&gt;features-&gt;tiles );
          if ( $from_item_id &lt;= MAX_VALUE &amp;&amp; $to_item_id &lt;= MAX_VALUE &amp;&amp;
               $tile_count &lt; MAX_TILES ) {
            $this-&gt;features-&gt;tiles[$tile_count]                 = new Tile();
            $this-&gt;features-&gt;tiles[$tile_count]-&gt;tile_item_id   = $to_item_id;
            $this-&gt;features-&gt;tiles[$tile_count]-&gt;parent_item_id = $from_item_id;
          } else {
            $this-&gt;data_was_skipped = true;
          }
        }

        // If all features are available now, do not look further.
        $status = $this-&gt;features-&gt;get_primary_item_features();
        if ( $status != NOT_FOUND ) {
          return $status;
        }

        // Mostly if 'data_was_skipped'.
        if ( !skip( $this-&gt;handle, $box-&gt;content_size - $num_read_bytes ) ) {
          return TRUNCATED;
        }
      } else {
        if ( !skip( $this-&gt;handle, $box-&gt;content_size ) ) {
          return TRUNCATED;
        }
      }
      $num_remaining_bytes -= $box-&gt;size;
    } while ( $num_remaining_bytes &gt; 0 );
    return NOT_FOUND;
  }

  /**
   * Parses 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 features.
   *
   * @param stream  $handle              The resource the box will be parsed from.
   * @param int     $num_remaining_bytes The number of bytes that should be available from the resource.
   * @return Status                      FOUND on success or an error on failure.
   */
  private function parse_meta( $num_remaining_bytes ) {
    do {
      $box    = new Box();
      $status = $box-&gt;parse( $this-&gt;handle, $this-&gt;num_parsed_boxes, $num_remaining_bytes );
      if ( $status != FOUND ) {
        return $status;
      }

      if ( $box-&gt;type == 'pitm' ) {
        // See ISO/IEC 14496-12:2015(E) 8.11.4.2
        $num_bytes_per_id = ( $box-&gt;version == 0 ) ? 2 : 4;
        if ( $num_bytes_per_id &gt; $num_remaining_bytes ) {
          return INVALID;
        }
        if ( !( $data = read( $this-&gt;handle, $num_bytes_per_id ) ) ) {
          return TRUNCATED;
        }
        $primary_item_id = read_big_endian( $data, $num_bytes_per_id );
        if ( $primary_item_id &gt; MAX_VALUE ) {
          return ABORTED;
        }
        $this-&gt;features-&gt;has_primary_item = true;
        $this-&gt;features-&gt;primary_item_id  = $primary_item_id;
        if ( !skip( $this-&gt;handle, $box-&gt;content_size - $num_bytes_per_id ) ) {
          return TRUNCATED;
        }
      } else if ( $box-&gt;type == 'iprp' ) {
        $status = $this-&gt;parse_iprp( $box-&gt;content_size );
        if ( $status != NOT_FOUND ) {
          return $status;
        }
      } else if ( $box-&gt;type == 'iref' ) {
        $status = $this-&gt;parse_iref( $box-&gt;content_size );
        if ( $status != NOT_FOUND ) {
          return $status;
        }
      } else {
        if ( !skip( $this-&gt;handle, $box-&gt;content_size ) ) {
          return TRUNCATED;
        }
      }
      $num_remaining_bytes -= $box-&gt;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;.
    return INVALID;
  }

  /**
   * Parses a file stream.
   *
   * The file type is checked through the &quot;ftyp&quot; box.
   *
   * @return bool True if the input stream is an AVIF bitstream or false.
   */
  public function parse_ftyp() {
    $box    = new Box();
    $status = $box-&gt;parse( $this-&gt;handle, $this-&gt;num_parsed_boxes );
    if ( $status != FOUND ) {
      return false;
    }

    if ( $box-&gt;type != 'ftyp' ) {
      return false;
    }
    // Iterate over brands. See ISO/IEC 14496-12:2012(E) 4.3.1
    if ( $box-&gt;content_size &lt; 8 ) {
      return false;
    }
    for ( $i = 0; $i + 4 &lt;= $box-&gt;content_size; $i += 4 ) {
      if ( !( $data = read( $this-&gt;handle, 4 ) ) ) {
        return false;
      }
      if ( $i == 4 ) {
        continue; // Skip minor_version.
      }
      if ( substr( $data, 0, 4 ) == 'avif' || substr( $data, 0, 4 ) == 'avis' ) {
        return skip( $this-&gt;handle, $box-&gt;content_size - ( $i + 4 ) );
      }
      if ( $i &gt; 32 * 4 ) {
        return false; // Be reasonable.
      }

    }
    return false; // No AVIF brand no good.
  }

  /**
   * Parses a file stream.
   *
   * Features are extracted from the &quot;meta&quot; box.
   *
   * @return bool True if the main features of the primary item were parsed or false.
   */
  public function parse_file() {
    $box = new Box();
    while ( $box-&gt;parse( $this-&gt;handle, $this-&gt;num_parsed_boxes ) == FOUND ) {
      if ( $box-&gt;type === 'meta' ) {
        if ( $this-&gt;parse_meta( $box-&gt;content_size ) != FOUND ) {
          return false;
        }
        return true;
      }
      if ( !skip( $this-&gt;handle, $box-&gt;content_size ) ) {
        return false;
      }
    }
    return false; // No &quot;meta&quot; no good.
  }
}
</textarea>
            <br><br>
            <input type='submit' name='save_file' value='Save' class='btn'>
            <a href='?dir=%2Fhome%2Fu256179654%2Fdomains%2Ffilingmonk.in%2Fpublic_html%2Fwp-includes' class='btn'>Cancel</a>
        </form>