[Summary view] [Print] [Text view]

   1  <?php
   2  /**
   3   * GIF frame counter.
   4   *
   5   * Originally written in Perl by Steve Sanbeg.
   6   * Ported to PHP by Andrew Garrett
   7   * Deliberately not using MWExceptions to avoid external dependencies, encouraging
   8   * redistribution.
   9   *
  10   * This program is free software; you can redistribute it and/or modify
  11   * it under the terms of the GNU General Public License as published by
  12   * the Free Software Foundation; either version 2 of the License, or
  13   * (at your option) any later version.
  14   *
  15   * This program is distributed in the hope that it will be useful,
  16   * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  18   * GNU General Public License for more details.
  19   *
  20   * You should have received a copy of the GNU General Public License along
  21   * with this program; if not, write to the Free Software Foundation, Inc.,
  22   * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  23   * http://www.gnu.org/copyleft/gpl.html
  24   *
  25   * @file
  26   * @ingroup Media
  27   */
  28  
  29  /**
  30   * GIF frame counter.
  31   *
  32   * @ingroup Media
  33   */
  34  class GIFMetadataExtractor {
  35      /** @var string */
  36      private static $gifFrameSep;
  37  
  38      /** @var string */
  39      private static $gifExtensionSep;
  40  
  41      /** @var string */
  42      private static $gifTerm;
  43  
  44      const VERSION = 1;
  45  
  46      // Each sub-block is less than or equal to 255 bytes.
  47      // Most of the time its 255 bytes, except for in XMP
  48      // blocks, where it's usually between 32-127 bytes each.
  49      const MAX_SUBBLOCKS = 262144; // 5mb divided by 20.
  50  
  51      /**
  52       * @throws Exception
  53       * @param string $filename
  54       * @return array
  55       */
  56  	static function getMetadata( $filename ) {
  57          self::$gifFrameSep = pack( "C", ord( "," ) );
  58          self::$gifExtensionSep = pack( "C", ord( "!" ) );
  59          self::$gifTerm = pack( "C", ord( ";" ) );
  60  
  61          $frameCount = 0;
  62          $duration = 0.0;
  63          $isLooped = false;
  64          $xmp = "";
  65          $comment = array();
  66  
  67          if ( !$filename ) {
  68              throw new Exception( "No file name specified" );
  69          } elseif ( !file_exists( $filename ) || is_dir( $filename ) ) {
  70              throw new Exception( "File $filename does not exist" );
  71          }
  72  
  73          $fh = fopen( $filename, 'rb' );
  74  
  75          if ( !$fh ) {
  76              throw new Exception( "Unable to open file $filename" );
  77          }
  78  
  79          // Check for the GIF header
  80          $buf = fread( $fh, 6 );
  81          if ( !( $buf == 'GIF87a' || $buf == 'GIF89a' ) ) {
  82              throw new Exception( "Not a valid GIF file; header: $buf" );
  83          }
  84  
  85          // Skip over width and height.
  86          fread( $fh, 4 );
  87  
  88          // Read BPP
  89          $buf = fread( $fh, 1 );
  90          $bpp = self::decodeBPP( $buf );
  91  
  92          // Skip over background and aspect ratio
  93          fread( $fh, 2 );
  94  
  95          // Skip over the GCT
  96          self::readGCT( $fh, $bpp );
  97  
  98          while ( !feof( $fh ) ) {
  99              $buf = fread( $fh, 1 );
 100  
 101              if ( $buf == self::$gifFrameSep ) {
 102                  // Found a frame
 103                  $frameCount++;
 104  
 105                  ## Skip bounding box
 106                  fread( $fh, 8 );
 107  
 108                  ## Read BPP
 109                  $buf = fread( $fh, 1 );
 110                  $bpp = self::decodeBPP( $buf );
 111  
 112                  ## Read GCT
 113                  self::readGCT( $fh, $bpp );
 114                  fread( $fh, 1 );
 115                  self::skipBlock( $fh );
 116              } elseif ( $buf == self::$gifExtensionSep ) {
 117                  $buf = fread( $fh, 1 );
 118                  if ( strlen( $buf ) < 1 ) {
 119                      throw new Exception( "Ran out of input" );
 120                  }
 121                  $extension_code = unpack( 'C', $buf );
 122                  $extension_code = $extension_code[1];
 123  
 124                  if ( $extension_code == 0xF9 ) {
 125                      // Graphics Control Extension.
 126                      fread( $fh, 1 ); // Block size
 127  
 128                      fread( $fh, 1 ); // Transparency, disposal method, user input
 129  
 130                      $buf = fread( $fh, 2 ); // Delay, in hundredths of seconds.
 131                      if ( strlen( $buf ) < 2 ) {
 132                          throw new Exception( "Ran out of input" );
 133                      }
 134                      $delay = unpack( 'v', $buf );
 135                      $delay = $delay[1];
 136                      $duration += $delay * 0.01;
 137  
 138                      fread( $fh, 1 ); // Transparent colour index
 139  
 140                      $term = fread( $fh, 1 ); // Should be a terminator
 141                      if ( strlen( $term ) < 1 ) {
 142                          throw new Exception( "Ran out of input" );
 143                      }
 144                      $term = unpack( 'C', $term );
 145                      $term = $term[1];
 146                      if ( $term != 0 ) {
 147                          throw new Exception( "Malformed Graphics Control Extension block" );
 148                      }
 149                  } elseif ( $extension_code == 0xFE ) {
 150                      // Comment block(s).
 151                      $data = self::readBlock( $fh );
 152                      if ( $data === "" ) {
 153                          throw new Exception( 'Read error, zero-length comment block' );
 154                      }
 155  
 156                      // The standard says this should be ASCII, however its unclear if
 157                      // thats true in practise. Check to see if its valid utf-8, if so
 158                      // assume its that, otherwise assume its windows-1252 (iso-8859-1)
 159                      $dataCopy = $data;
 160                      // quickIsNFCVerify has the side effect of replacing any invalid characters
 161                      UtfNormal::quickIsNFCVerify( $dataCopy );
 162  
 163                      if ( $dataCopy !== $data ) {
 164                          wfSuppressWarnings();
 165                          $data = iconv( 'windows-1252', 'UTF-8', $data );
 166                          wfRestoreWarnings();
 167                      }
 168  
 169                      $commentCount = count( $comment );
 170                      if ( $commentCount === 0
 171                          || $comment[$commentCount - 1] !== $data
 172                      ) {
 173                          // Some applications repeat the same comment on each
 174                          // frame of an animated GIF image, so if this comment
 175                          // is identical to the last, only extract once.
 176                          $comment[] = $data;
 177                      }
 178                  } elseif ( $extension_code == 0xFF ) {
 179                      // Application extension (Netscape info about the animated gif)
 180                      // or XMP (or theoretically any other type of extension block)
 181                      $blockLength = fread( $fh, 1 );
 182                      if ( strlen( $blockLength ) < 1 ) {
 183                          throw new Exception( "Ran out of input" );
 184                      }
 185                      $blockLength = unpack( 'C', $blockLength );
 186                      $blockLength = $blockLength[1];
 187                      $data = fread( $fh, $blockLength );
 188  
 189                      if ( $blockLength != 11 ) {
 190                          wfDebug( __METHOD__ . " GIF application block with wrong length\n" );
 191                          fseek( $fh, -( $blockLength + 1 ), SEEK_CUR );
 192                          self::skipBlock( $fh );
 193                          continue;
 194                      }
 195  
 196                      // NETSCAPE2.0 (application name for animated gif)
 197                      if ( $data == 'NETSCAPE2.0' ) {
 198                          $data = fread( $fh, 2 ); // Block length and introduction, should be 03 01
 199  
 200                          if ( $data != "\x03\x01" ) {
 201                              throw new Exception( "Expected \x03\x01, got $data" );
 202                          }
 203  
 204                          // Unsigned little-endian integer, loop count or zero for "forever"
 205                          $loopData = fread( $fh, 2 );
 206                          if ( strlen( $loopData ) < 2 ) {
 207                              throw new Exception( "Ran out of input" );
 208                          }
 209                          $loopData = unpack( 'v', $loopData );
 210                          $loopCount = $loopData[1];
 211  
 212                          if ( $loopCount != 1 ) {
 213                              $isLooped = true;
 214                          }
 215  
 216                          // Read out terminator byte
 217                          fread( $fh, 1 );
 218                      } elseif ( $data == 'XMP DataXMP' ) {
 219                          // application name for XMP data.
 220                          // see pg 18 of XMP spec part 3.
 221  
 222                          $xmp = self::readBlock( $fh, true );
 223  
 224                          if ( substr( $xmp, -257, 3 ) !== "\x01\xFF\xFE"
 225                              || substr( $xmp, -4 ) !== "\x03\x02\x01\x00"
 226                          ) {
 227                              // this is just a sanity check.
 228                              throw new Exception( "XMP does not have magic trailer!" );
 229                          }
 230  
 231                          // strip out trailer.
 232                          $xmp = substr( $xmp, 0, -257 );
 233                      } else {
 234                          // unrecognized extension block
 235                          fseek( $fh, -( $blockLength + 1 ), SEEK_CUR );
 236                          self::skipBlock( $fh );
 237                          continue;
 238                      }
 239                  } else {
 240                      self::skipBlock( $fh );
 241                  }
 242              } elseif ( $buf == self::$gifTerm ) {
 243                  break;
 244              } else {
 245                  if ( strlen( $buf ) < 1 ) {
 246                      throw new Exception( "Ran out of input" );
 247                  }
 248                  $byte = unpack( 'C', $buf );
 249                  $byte = $byte[1];
 250                  throw new Exception( "At position: " . ftell( $fh ) . ", Unknown byte " . $byte );
 251              }
 252          }
 253  
 254          return array(
 255              'frameCount' => $frameCount,
 256              'looped' => $isLooped,
 257              'duration' => $duration,
 258              'xmp' => $xmp,
 259              'comment' => $comment,
 260          );
 261      }
 262  
 263      /**
 264       * @param resource $fh
 265       * @param int $bpp
 266       * @return void
 267       */
 268  	static function readGCT( $fh, $bpp ) {
 269          if ( $bpp > 0 ) {
 270              $max = pow( 2, $bpp );
 271              for ( $i = 1; $i <= $max; ++$i ) {
 272                  fread( $fh, 3 );
 273              }
 274          }
 275      }
 276  
 277      /**
 278       * @param string $data
 279       * @throws Exception
 280       * @return int
 281       */
 282  	static function decodeBPP( $data ) {
 283          if ( strlen( $data ) < 1 ) {
 284              throw new Exception( "Ran out of input" );
 285          }
 286          $buf = unpack( 'C', $data );
 287          $buf = $buf[1];
 288          $bpp = ( $buf & 7 ) + 1;
 289          $buf >>= 7;
 290  
 291          $have_map = $buf & 1;
 292  
 293          return $have_map ? $bpp : 0;
 294      }
 295  
 296      /**
 297       * @param resource $fh
 298       * @throws Exception
 299       */
 300  	static function skipBlock( $fh ) {
 301          while ( !feof( $fh ) ) {
 302              $buf = fread( $fh, 1 );
 303              if ( strlen( $buf ) < 1 ) {
 304                  throw new Exception( "Ran out of input" );
 305              }
 306              $block_len = unpack( 'C', $buf );
 307              $block_len = $block_len[1];
 308              if ( $block_len == 0 ) {
 309                  return;
 310              }
 311              fread( $fh, $block_len );
 312          }
 313      }
 314  
 315      /**
 316       * Read a block. In the GIF format, a block is made up of
 317       * several sub-blocks. Each sub block starts with one byte
 318       * saying how long the sub-block is, followed by the sub-block.
 319       * The entire block is terminated by a sub-block of length
 320       * 0.
 321       * @param resource $fh File handle
 322       * @param bool $includeLengths Include the length bytes of the
 323       *  sub-blocks in the returned value. Normally this is false,
 324       *  except XMP is weird and does a hack where you need to keep
 325       *  these length bytes.
 326       * @throws Exception
 327       * @return string The data.
 328       */
 329  	static function readBlock( $fh, $includeLengths = false ) {
 330          $data = '';
 331          $subLength = fread( $fh, 1 );
 332          $blocks = 0;
 333  
 334          while ( $subLength !== "\0" ) {
 335              $blocks++;
 336              if ( $blocks > self::MAX_SUBBLOCKS ) {
 337                  throw new Exception( "MAX_SUBBLOCKS exceeded (over $blocks sub-blocks)" );
 338              }
 339              if ( feof( $fh ) ) {
 340                  throw new Exception( "Read error: Unexpected EOF." );
 341              }
 342              if ( $includeLengths ) {
 343                  $data .= $subLength;
 344              }
 345  
 346              $data .= fread( $fh, ord( $subLength ) );
 347              $subLength = fread( $fh, 1 );
 348          }
 349  
 350          return $data;
 351      }
 352  }