<?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] << 16 ) | ( $bytes[2] << 8 ) | $bytes[3];

  } else { // $num_bytes is 4

    // This might fail to read unsigned values >= 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 && strlen( $data ) >= $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 <-> parent item id associations.

  public $tile_item_id;

  public $parent_item_id;

}

class Prop { // Property index <-> item id associations.

  public $property_index;

  public $item_id;

}

class Dim_Prop { // Property <-> features associations.

  public $property_index;

  public $width;

  public $height;

}

class Chan_Prop { // Property <-> features associations.

  public $property_index;

  public $bit_depth;

  public $num_channels;

}

class Features {

  public $has_primary_item = false; // True if "pitm" was parsed.

  public $has_alpha = false; // True if an alpha "auxC" was parsed.

  public $primary_item_id;

  public $primary_item_features = array( // Deduced from the data below.

    'width'        => UNDEFINED, // In number of pixels.

    'height'       => UNDEFINED, // Ignores mirror and rotation.

    'bit_depth'    => UNDEFINED, // Likely 8, 10 or 12 bits per channel per pixel.

    'num_channels' => 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->props as $prop ) {

      if ( $prop->item_id != $target_item_id ) {

        continue;

      }

      // Retrieve the width and height of the primary item if not already done.

      if ( $target_item_id == $this->primary_item_id &&

           ( $this->primary_item_features['width'] == UNDEFINED ||

             $this->primary_item_features['height'] == UNDEFINED ) ) {

        foreach ( $this->dim_props as $dim_prop ) {

          if ( $dim_prop->property_index != $prop->property_index ) {

            continue;

          }

          $this->primary_item_features['width']  = $dim_prop->width;

          $this->primary_item_features['height'] = $dim_prop->height;

          if ( $this->primary_item_features['bit_depth'] != UNDEFINED &&

               $this->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->primary_item_features['bit_depth'] == UNDEFINED ||

           $this->primary_item_features['num_channels'] == UNDEFINED ) {

        foreach ( $this->chan_props as $chan_prop ) {

          if ( $chan_prop->property_index != $prop->property_index ) {

            continue;

          }

          $this->primary_item_features['bit_depth']    = $chan_prop->bit_depth;

          $this->primary_item_features['num_channels'] = $chan_prop->num_channels;

          if ( $this->primary_item_features['width'] != UNDEFINED &&

              $this->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 < 3 ) {

      foreach ( $this->tiles as $tile ) {

        if ( $tile->parent_item_id != $target_item_id ) {

          continue;

        }

        $status = $this->get_item_features( $tile->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->has_primary_item ) {

      return NOT_FOUND;

    }

    // Early exit.

    if ( empty( $this->dim_props ) || empty( $this->chan_props ) ) {

      return NOT_FOUND;

    }

    $status = $this->get_item_features( $this->primary_item_id, /*tile_depth=*/ 0 );

    if ( $status != FOUND ) {

      return $status;

    }

    // "auxC" is parsed before the "ipma" properties so it is known now, if any.

    if ( $this->has_alpha ) {

      ++$this->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, &$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 > $num_remaining_bytes ) {

      return INVALID;

    }

    if ( !( $data = read( $handle, 8 ) ) ) {

      return TRUNCATED;

    }

    $this->size = read_big_endian( $data, 4 );

    $this->type = substr( $data, 4, 4 );

    // 'box->size==1' means 64-bit size should be read after the box type.

    // 'box->size==0' means this box extends to all remaining bytes.

    if ( $this->size == 1 ) {

      $header_size += 8;

      if ( $header_size > $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->size = read_big_endian( substr( $data, 4, 4 ), 4 );

    } else if ( $this->size == 0 ) {

      $this->size = $num_remaining_bytes;

    }

    if ( $this->size < $header_size ) {

      return INVALID;

    }

    if ( $this->size > $num_remaining_bytes ) {

      return INVALID;

    }

    $has_fullbox_header = $this->type == 'meta' || $this->type == 'pitm' ||

                          $this->type == 'ipma' || $this->type == 'ispe' ||

                          $this->type == 'pixi' || $this->type == 'iref' ||

                          $this->type == 'auxC';

    if ( $has_fullbox_header ) {

      $header_size += 4;

    }

    if ( $this->size < $header_size ) {

      return INVALID;

    }

    $this->content_size = $this->size - $header_size;

    // Avoid timeouts. The maximum number of parsed boxes is arbitrary.

    ++$num_parsed_boxes;

    if ( $num_parsed_boxes >= MAX_NUM_BOXES ) {

      return ABORTED;

    }

    $this->version = 0;

    $this->flags   = 0;

    if ( $has_fullbox_header ) {

      if ( !( $data = read( $handle, 4 ) ) ) {

        return TRUNCATED;

      }

      $this->version = read_big_endian( $data, 1 );

      $this->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->type == 'meta' && $this->version <= 0 ) ||

                     ( $this->type == 'pitm' && $this->version <= 1 ) ||

                     ( $this->type == 'ipma' && $this->version <= 1 ) ||

                     ( $this->type == 'ispe' && $this->version <= 0 ) ||

                     ( $this->type == 'pixi' && $this->version <= 0 ) ||

                     ( $this->type == 'iref' && $this->version <= 1 ) ||

                     ( $this->type == 'auxC' && $this->version <= 0 );

      // Instead of considering this file as invalid, skip unparsable boxes.

      if ( !$is_parsable ) {

        $this->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->handle   = $handle;

    $this->features = new Features();

  }

  /**

   * Parses an "ipco" box.

   *

   * "ispe" is used for width and height, "pixi" and "av1C" are used for bit depth

   * and number of channels, and "auxC" is used for alpha.

   *

   * @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->parse( $this->handle, $this->num_parsed_boxes, $num_remaining_bytes );

      if ( $status != FOUND ) {

        return $status;

      }

      if ( $box->type == 'ispe' ) {

        // See ISO/IEC 23008-12:2017(E) 6.5.3.2

        if ( $box->content_size < 8 ) {

          return INVALID;

        }

        if ( !( $data = read( $this->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->features->dim_props ) <= MAX_FEATURES &&

             $box_index <= MAX_VALUE ) {

          $dim_prop_count = count( $this->features->dim_props );

          $this->features->dim_props[$dim_prop_count]                 = new Dim_Prop();

          $this->features->dim_props[$dim_prop_count]->property_index = $box_index;

          $this->features->dim_props[$dim_prop_count]->width          = $width;

          $this->features->dim_props[$dim_prop_count]->height         = $height;

        } else {

          $this->data_was_skipped = true;

        }

        if ( !skip( $this->handle, $box->content_size - 8 ) ) {

          return TRUNCATED;

        }

      } else if ( $box->type == 'pixi' ) {

        // See ISO/IEC 23008-12:2017(E) 6.5.6.2

        if ( $box->content_size < 1 ) {

          return INVALID;

        }

        if ( !( $data = read( $this->handle, 1 ) ) ) {

          return TRUNCATED;

        }

        $num_channels = read_big_endian( $data, 1 );

        if ( $num_channels < 1 ) {

          return INVALID;

        }

        if ( $box->content_size < 1 + $num_channels ) {

          return INVALID;

        }

        if ( !( $data = read( $this->handle, 1 ) ) ) {

          return TRUNCATED;

        }

        $bit_depth = read_big_endian( $data, 1 );

        if ( $bit_depth < 1 ) {

          return INVALID;

        }

        for ( $i = 1; $i < $num_channels; ++$i ) {

          if ( !( $data = read( $this->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 > 32 ) {

            return ABORTED; // Be reasonable.

          }

        }

        if ( count( $this->features->chan_props ) <= MAX_FEATURES &&

             $box_index <= MAX_VALUE && $bit_depth <= MAX_VALUE &&

             $num_channels <= MAX_VALUE ) {

          $chan_prop_count = count( $this->features->chan_props );

          $this->features->chan_props[$chan_prop_count]                 = new Chan_Prop();