vendor/setasign/fpdi/pdf_parser.php

   1 <?php
   2 /**
   3  * This file is part of FPDI
   4  *
   5  * @package   FPDI
   6  * @copyright Copyright (c) 2017 Setasign - Jan Slabon (https://www.setasign.com)
   7  * @license   http://opensource.org/licenses/mit-license The MIT License
   8  * @version   1.6.2
   9  */
  10
  11 /**
  12  * Class pdf_parser
  13  */
  14 class pdf_parser
  15 {
  16     /**
  17      * Type constant
  18      *
  19      * @var integer
  20      */
  21     const TYPE_NULL = 0;
  22
  23     /**
  24      * Type constant
  25      *
  26      * @var integer
  27      */
  28     const TYPE_NUMERIC = 1;
  29
  30     /**
  31      * Type constant
  32      *
  33      * @var integer
  34      */
  35     const TYPE_TOKEN = 2;
  36
  37     /**
  38      * Type constant
  39      *
  40      * @var integer
  41      */
  42     const TYPE_HEX = 3;
  43
  44     /**
  45      * Type constant
  46      *
  47      * @var integer
  48      */
  49     const TYPE_STRING = 4;
  50
  51     /**
  52      * Type constant
  53      *
  54      * @var integer
  55      */
  56     const TYPE_DICTIONARY = 5;
  57
  58     /**
  59      * Type constant
  60      *
  61      * @var integer
  62      */
  63     const TYPE_ARRAY = 6;
  64
  65     /**
  66      * Type constant
  67      *
  68      * @var integer
  69      */
  70     const TYPE_OBJDEC = 7;
  71
  72     /**
  73      * Type constant
  74      *
  75      * @var integer
  76      */
  77     const TYPE_OBJREF = 8;
  78
  79     /**
  80      * Type constant
  81      *
  82      * @var integer
  83      */
  84     const TYPE_OBJECT = 9;
  85
  86     /**
  87      * Type constant
  88      *
  89      * @var integer
  90      */
  91     const TYPE_STREAM = 10;
  92
  93     /**
  94      * Type constant
  95      *
  96      * @var integer
  97      */
  98     const TYPE_BOOLEAN = 11;
  99
 100     /**
 101      * Type constant
 102      *
 103      * @var integer
 104      */
 105     const TYPE_REAL = 12;
 106
 107     /**
 108      * Define the amount of byte in which the initial keyword of a PDF document should be searched.
 109      *
 110      * @var int
 111      */
 112     static public $searchForStartxrefLength = 5500;
 113
 114     /**
 115      * Filename
 116      *
 117      * @var string
 118      */
 119     public $filename;
 120
 121     /**
 122      * File resource
 123      *
 124      * @var resource
 125      */
 126     protected $_f;
 127
 128     /**
 129      * PDF Context
 130      *
 131      * @var pdf_context
 132      */
 133     protected $_c;
 134
 135     /**
 136      * xref-Data
 137      *
 138      * @var array
 139      */
 140     protected $_xref;
 141
 142     /**
 143      * Data of the Root object
 144      *
 145      * @var array
 146      */
 147     protected $_root;
 148
 149     /**
 150      * PDF version of the loaded document
 151      *
 152      * @var string
 153      */
 154     protected $_pdfVersion;
 155
 156     /**
 157      * For reading encrypted documents and xref/object streams are in use
 158      *
 159      * @var boolean
 160      */
 161     protected $_readPlain = true;
 162
 163     /**
 164      * The current read object
 165      *
 166      * @var array
 167      */
 168     protected $_currentObj;
 169
 170     /**
 171      * Constructor
 172      *
 173      * @param string $filename Source filename
 174      * @throws InvalidArgumentException
 175      */
 176     public function __construct($filename)
 177     {
 178         $this->filename = $filename;
 179
 180         $this->_f = @fopen($this->filename, 'rb');
 181
 182         if (!$this->_f) {
 183             throw new InvalidArgumentException(sprintf('Cannot open %s !', $filename));
 184         }
 185
 186         $this->getPdfVersion();
 187
 188         if (!class_exists('pdf_context')) {
 189             require_once('pdf_context.php');
 190         }
 191         $this->_c = new pdf_context($this->_f);
 192
 193         // Read xref-Data
 194         $this->_xref = array();
 195         $this->_readXref($this->_xref, $this->_findXref());
 196
 197         // Check for Encryption
 198         $this->getEncryption();
 199
 200         // Read root
 201         $this->_readRoot();
 202     }
 203
 204     /**
 205      * Destructor
 206      */
 207     public function __destruct()
 208     {
 209         $this->closeFile();
 210     }
 211
 212     /**
 213      * Close the opened file
 214      */
 215     public function closeFile()
 216     {
 217         if (isset($this->_f) && is_resource($this->_f)) {
 218             fclose($this->_f);
 219             unset($this->_f);
 220         }
 221     }
 222
 223     /**
 224      * Check Trailer for Encryption
 225      *
 226      * @throws Exception
 227      */
 228     public function getEncryption()
 229     {
 230         if (isset($this->_xref['trailer'][1]['/Encrypt'])) {
 231             throw new Exception('File is encrypted!');
 232         }
 233     }
 234
 235     /**
 236      * Get PDF-Version
 237      *
 238      * @return string
 239      */
 240     public function getPdfVersion()
 241     {
 242         if ($this->_pdfVersion === null) {
 243             fseek($this->_f, 0);
 244             preg_match('/\d\.\d/', fread($this->_f, 16), $m);
 245             if (isset($m[0]))
 246                 $this->_pdfVersion = $m[0];
 247         }
 248
 249         return $this->_pdfVersion;
 250     }
 251
 252     /**
 253      * Read the /Root dictionary
 254      */
 255     protected function _readRoot()
 256     {
 257         if ($this->_xref['trailer'][1]['/Root'][0] != self::TYPE_OBJREF) {
 258             throw new Exception('Wrong Type of Root-Element! Must be an indirect reference');
 259         }
 260
 261         $this->_root = $this->resolveObject($this->_xref['trailer'][1]['/Root']);
 262     }
 263
 264     /**
 265      * Find the xref table
 266      *
 267      * @return integer
 268      * @throws Exception
 269      */
 270     protected function _findXref()
 271     {
 272         $toRead = self::$searchForStartxrefLength;
 273
 274         $stat = fseek($this->_f, -$toRead, SEEK_END);
 275         if ($stat === -1) {
 276             fseek($this->_f, 0);
 277         }
 278
 279         $data = fread($this->_f, $toRead);
 280
 281         $keywordPos = strpos(strrev($data), strrev('startxref'));
 282         if (false === $keywordPos) {
 283             $keywordPos = strpos(strrev($data), strrev('startref'));
 284         }
 285
 286         if (false === $keywordPos) {
 287             throw new Exception('Unable to find "startxref" keyword.');
 288         }
 289
 290         $pos = strlen($data) - $keywordPos;
 291         $data = substr($data, $pos);
 292
 293         if (!preg_match('/\s*(\d+).*$/s', $data, $matches)) {
 294             throw new Exception('Unable to find pointer to xref table.');
 295         }
 296
 297         return (int) $matches[1];
 298     }
 299
 300     /**
 301      * Read the xref table
 302      *
 303      * @param array $result Array of xref table entries
 304      * @param integer $offset of xref table
 305      * @return boolean
 306      * @throws Exception
 307      */
 308     protected function _readXref(&$result, $offset)
 309     {
 310         $tempPos = $offset - min(20, $offset);
 311         fseek($this->_f, $tempPos); // set some bytes backwards to fetch corrupted docs
 312
 313         $data = fread($this->_f, 100);
 314
 315         $xrefPos = strrpos($data, 'xref');
 316
 317         if ($xrefPos === false) {
 318             $this->_c->reset($offset);
 319             $xrefStreamObjDec = $this->_readValue($this->_c);
 320
 321             if (is_array($xrefStreamObjDec) && isset($xrefStreamObjDec[0]) && $xrefStreamObjDec[0] == self::TYPE_OBJDEC) {
 322                 throw new Exception(
 323                     sprintf(
 324                         'This document (%s) probably uses a compression technique which is not supported by the ' .
 325                         'free parser shipped with FPDI. (See https://www.setasign.com/fpdi-pdf-parser for more details)',
 326                         $this->filename
 327                     )
 328                 );
 329             } else {
 330                 throw new Exception('Unable to find xref table.');
 331             }
 332         }
 333
 334         if (!isset($result['xrefLocation'])) {
 335             $result['xrefLocation'] = $tempPos + $xrefPos;
 336             $result['maxObject'] = 0;
 337         }
 338
 339         $cycles = -1;
 340         $bytesPerCycle = 100;
 341
 342         fseek($this->_f, $tempPos = $tempPos + $xrefPos + 4); // set the handle directly after the "xref"-keyword
 343         $data = fread($this->_f, $bytesPerCycle);
 344
 345         while (($trailerPos = strpos($data, 'trailer', max($bytesPerCycle * $cycles++, 0))) === false && !feof($this->_f)) {
 346             $data .= fread($this->_f, $bytesPerCycle);
 347         }
 348
 349         if ($trailerPos === false) {
 350             throw new Exception('Trailer keyword not found after xref table');
 351         }
 352
 353         $data = ltrim(substr($data, 0, $trailerPos));
 354
 355         // get Line-Ending
 356         $found = preg_match_all("/(\r\n|\n|\r)/", substr($data, 0, 100), $m); // check the first 100 bytes for line breaks
 357         if ($found === 0) {
 358             throw new Exception('Xref table seems to be corrupted.');
 359         }
 360         $differentLineEndings = count(array_unique($m[0]));
 361         if ($differentLineEndings > 1) {
 362             $lines = preg_split("/(\r\n|\n|\r)/", $data, -1, PREG_SPLIT_NO_EMPTY);
 363         } else {
 364             $lines = explode($m[0][0], $data);
 365         }
 366
 367         $data = $differentLineEndings = $m = null;
 368         unset($data, $differentLineEndings, $m);
 369
 370         $linesCount = count($lines);
 371
 372         $start = 1;
 373
 374         for ($i = 0; $i < $linesCount; $i++) {
 375             $line = trim($lines[$i]);
 376             if ($line) {
 377                 $pieces = explode(' ', $line);
 378                 $c = count($pieces);
 379                 switch($c) {
 380                     case 2:
 381                         $start = (int)$pieces[0];
 382                         $end   = $start + (int)$pieces[1];
 383                         if ($end > $result['maxObject'])
 384                             $result['maxObject'] = $end;
 385                         break;
 386                     case 3:
 387                         if (!isset($result['xref'][$start]))
 388                             $result['xref'][$start] = array();
 389
 390                         if (!array_key_exists($gen = (int) $pieces[1], $result['xref'][$start])) {
 391                             $result['xref'][$start][$gen] = $pieces[2] == 'n' ? (int) $pieces[0] : null;
 392                         }
 393                         $start++;
 394                         break;
 395                     default:
 396                         throw new Exception('Unexpected data in xref table');
 397                 }
 398             }
 399         }
 400
 401         $lines = $pieces = $line = $start = $end = $gen = null;
 402         unset($lines, $pieces, $line, $start, $end, $gen);
 403
 404         $this->_c->reset($tempPos + $trailerPos + 7);
 405         $trailer = $this->_readValue($this->_c);
 406
 407         if (!isset($result['trailer'])) {
 408             $result['trailer'] = $trailer;
 409         }
 410
 411         if (isset($trailer[1]['/Prev'])) {
 412             $this->_readXref($result, $trailer[1]['/Prev'][1]);
 413         }
 414
 415         $trailer = null;
 416         unset($trailer);
 417
 418         return true;
 419     }
 420
 421     /**
 422      * Reads a PDF value
 423      *
 424      * @param pdf_context $c
 425      * @param string $token A token
 426      * @return mixed
 427      * @throws Exception
 428      */
 429     protected function _readValue(&$c, $token = null)
 430     {
 431         if (is_null($token)) {
 432             $token = $this->_readToken($c);
 433         }
 434
 435         if ($token === false) {
 436             return false;
 437         }
 438
 439         switch ($token) {
 440             case '<':
 441                 // This is a hex string.
 442                 // Read the value, then the terminator
 443
 444                 $pos = $c->offset;
 445
 446                 while(1) {
 447
 448                     $match = strpos($c->buffer, '>', $pos);
 449
 450                     // If you can't find it, try
 451                     // reading more data from the stream
 452
 453                     if ($match === false) {
 454                         if (!$c->increaseLength()) {
 455                             return false;
 456                         } else {
 457                             continue;
 458                         }
 459                     }
 460
 461                     $result = substr($c->buffer, $c->offset, $match - $c->offset);
 462                     $c->offset = $match + 1;
 463
 464                     return array (self::TYPE_HEX, $result);
 465                 }
 466                 break;
 467
 468             case '<<':
 469                 // This is a dictionary.
 470
 471                 $result = array();
 472
 473                 // Recurse into this function until we reach
 474                 // the end of the dictionary.
 475                 while (($key = $this->_readToken($c)) !== '>>') {
 476                     if ($key === false) {
 477                         return false;
 478                     }
 479
 480                     if (($value =   $this->_readValue($c)) === false) {
 481                         return false;
 482                     }
 483
 484                     // Catch missing value
 485                     if ($value[0] == self::TYPE_TOKEN && $value[1] == '>>') {
 486                         $result[$key] = array(self::TYPE_NULL);
 487                         break;
 488                     }
 489
 490                     $result[$key] = $value;
 491                 }
 492
 493                 return array (self::TYPE_DICTIONARY, $result);
 494
 495             case '[':
 496                 // This is an array.
 497
 498                 $result = array();
 499
 500                 // Recurse into this function until we reach
 501                 // the end of the array.
 502                 while (($token = $this->_readToken($c)) !== ']') {
 503                     if ($token === false) {
 504                         return false;
 505                     }
 506
 507                     if (($value = $this->_readValue($c, $token)) === false) {
 508                         return false;
 509                     }
 510
 511                     $result[] = $value;
 512                 }
 513
 514                 return array (self::TYPE_ARRAY, $result);
 515
 516             case '(':
 517                 // This is a string
 518                 $pos = $c->offset;
 519
 520                 $openBrackets = 1;
 521                 do {
 522                     for (; $openBrackets != 0 && $pos < $c->length; $pos++) {
 523                         switch (ord($c->buffer[$pos])) {
 524                             case 0x28: // '('
 525                                 $openBrackets++;
 526                                 break;
 527                             case 0x29: // ')'
 528                                 $openBrackets--;
 529                                 break;
 530                             case 0x5C: // backslash
 531                                 $pos++;
 532                         }
 533                     }
 534                 } while($openBrackets != 0 && $c->increaseLength());
 535
 536                 $result = substr($c->buffer, $c->offset, $pos - $c->offset - 1);
 537                 $c->offset = $pos;
 538
 539                 return array (self::TYPE_STRING, $result);
 540
 541             case 'stream':
 542                 $tempPos = $c->getPos() - strlen($c->buffer);
 543                 $tempOffset = $c->offset;
 544
 545                 $c->reset($startPos = $tempPos + $tempOffset);
 546
 547                 // Find the first "newline"
 548                 while ($c->buffer[0] !== chr(10) && $c->buffer[0] !== chr(13)) {
 549                     $c->reset(++$startPos);
 550                     if ($c->ensureContent() === false) {
 551                         throw new Exception(
 552                             'Unable to parse stream data. No newline followed the stream keyword.'
 553                         );
 554                     }
 555                 }
 556
 557                 $e = 0; // ensure line breaks in front of the stream
 558                 if ($c->buffer[0] == chr(10) || $c->buffer[0] == chr(13))
 559                     $e++;
 560                 if ($c->buffer[1] == chr(10) && $c->buffer[0] != chr(10))
 561                     $e++;
 562
 563                 if ($this->_currentObj[1][1]['/Length'][0] == self::TYPE_OBJREF) {
 564                     $tmpLength = $this->resolveObject($this->_currentObj[1][1]['/Length']);
 565                     $length = $tmpLength[1][1];
 566                 } else {
 567                     $length = $this->_currentObj[1][1]['/Length'][1];
 568                 }
 569
 570                 if ($length > 0) {
 571                     $c->reset($startPos + $e, $length);
 572                     $v = $c->buffer;
 573                 } else {
 574                     $v = '';
 575                 }
 576
 577                 $c->reset($startPos + $e + $length);
 578                 $endstream = $this->_readToken($c);
 579
 580                 if ($endstream != 'endstream') {
 581                     $c->reset($startPos + $e + $length + 9); // 9 = strlen("endstream")
 582                     // We don't throw an error here because the next
 583                     // round trip will start at a new offset
 584                 }
 585
 586                 return array(self::TYPE_STREAM, $v);
 587
 588             default:
 589                 if (is_numeric($token)) {
 590                     // A numeric token. Make sure that
 591                     // it is not part of something else.
 592                     if (($tok2 = $this->_readToken($c)) !== false) {
 593                         if (is_numeric($tok2)) {
 594
 595                             // Two numeric tokens in a row.
 596                             // In this case, we're probably in
 597                             // front of either an object reference
 598                             // or an object specification.
 599                             // Determine the case and return the data
 600                             if (($tok3 = $this->_readToken($c)) !== false) {
 601                                 switch ($tok3) {
 602                                     case 'obj':
 603                                         return array(self::TYPE_OBJDEC, (int)$token, (int)$tok2);
 604                                     case 'R':
 605                                         return array(self::TYPE_OBJREF, (int)$token, (int)$tok2);
 606                                 }
 607                                 // If we get to this point, that numeric value up
 608                                 // there was just a numeric value. Push the extra
 609                                 // tokens back into the stack and return the value.
 610                                 array_push($c->stack, $tok3);
 611                             }
 612                         }
 613
 614                         array_push($c->stack, $tok2);
 615                     }
 616
 617                     if ($token === (string)((int)$token))
 618                         return array(self::TYPE_NUMERIC, (int)$token);
 619                     else
 620                         return array(self::TYPE_REAL, (float)$token);
 621                 } else if ($token == 'true' || $token == 'false') {
 622                     return array(self::TYPE_BOOLEAN, $token == 'true');
 623                 } else if ($token == 'null') {
 624                    return array(self::TYPE_NULL);
 625                 } else {
 626                     // Just a token. Return it.
 627                     return array(self::TYPE_TOKEN, $token);
 628                 }
 629          }
 630     }
 631
 632     /**
 633      * Resolve an object
 634      *
 635      * @param array $objSpec The object-data
 636      * @return array|boolean
 637      * @throws Exception
 638      */
 639     public function resolveObject($objSpec)
 640     {
 641         $c = $this->_c;
 642
 643         // Exit if we get invalid data
 644         if (!is_array($objSpec)) {
 645             return false;
 646         }
 647
 648         if ($objSpec[0] == self::TYPE_OBJREF) {
 649
 650             // This is a reference, resolve it
 651             if (isset($this->_xref['xref'][$objSpec[1]][$objSpec[2]])) {
 652
 653                 // Save current file position
 654                 // This is needed if you want to resolve
 655                 // references while you're reading another object
 656                 // (e.g.: if you need to determine the length
 657                 // of a stream)
 658
 659                 $oldPos = $c->getPos();
 660
 661                 // Reposition the file pointer and
 662                 // load the object header.
 663
 664                 $c->reset($this->_xref['xref'][$objSpec[1]][$objSpec[2]]);
 665
 666                 $header = $this->_readValue($c);
 667
 668                 if ($header[0] != self::TYPE_OBJDEC || $header[1] != $objSpec[1] || $header[2] != $objSpec[2]) {
 669                     $toSearchFor = $objSpec[1] . ' ' . $objSpec[2] . ' obj';
 670                     if (preg_match('/' . $toSearchFor . '/', $c->buffer)) {
 671                         $c->offset = strpos($c->buffer, $toSearchFor) + strlen($toSearchFor);
 672                         // reset stack
 673                         $c->stack = array();
 674                     } else {
 675                         throw new Exception(
 676                             sprintf("Unable to find object (%s, %s) at expected location.", $objSpec[1], $objSpec[2])
 677                         );
 678                     }
 679                 }
 680
 681                 // If we're being asked to store all the information
 682                 // about the object, we add the object ID and generation
 683                 // number for later use
 684                 $result = array (
 685                     self::TYPE_OBJECT,
 686                     'obj' => $objSpec[1],
 687                     'gen' => $objSpec[2]
 688                 );
 689
 690                 $this->_currentObj =& $result;
 691
 692                 // Now simply read the object data until
 693                 // we encounter an end-of-object marker
 694                 while (true) {
 695                     $value = $this->_readValue($c);
 696                     if ($value === false || count($result) > 4) {
 697                         // in this case the parser couldn't find an "endobj" so we break here
 698                         break;
 699                     }
 700
 701                     if ($value[0] == self::TYPE_TOKEN && $value[1] === 'endobj') {
 702                         break;
 703                     }
 704
 705                     $result[] = $value;
 706                 }
 707
 708                 $c->reset($oldPos);
 709
 710                 if (isset($result[2][0]) && $result[2][0] == self::TYPE_STREAM) {
 711                     $result[0] = self::TYPE_STREAM;
 712                 }
 713
 714             } else {
 715                 throw new Exception(
 716                     sprintf("Unable to find object (%s, %s) at expected location.", $objSpec[1], $objSpec[2])
 717                 );
 718             }
 719
 720             return $result;
 721         } else {
 722             return $objSpec;
 723         }
 724     }
 725
 726     /**
 727      * Reads a token from the context
 728      *
 729      * @param pdf_context $c
 730      * @return mixed
 731      */
 732     protected function _readToken($c)
 733     {
 734         // If there is a token available
 735         // on the stack, pop it out and
 736         // return it.
 737
 738         if (count($c->stack)) {
 739             return array_pop($c->stack);
 740         }
 741
 742         // Strip away any whitespace
 743
 744         do {
 745             if (!$c->ensureContent()) {
 746                 return false;
 747             }
 748             $c->offset += strspn($c->buffer, "\x20\x0A\x0C\x0D\x09\x00", $c->offset);
 749         } while ($c->offset >= $c->length - 1);
 750
 751         // Get the first character in the stream
 752
 753         $char = $c->buffer[$c->offset++];
 754
 755         switch ($char) {
 756
 757             case '[':
 758             case ']':
 759             case '(':
 760             case ')':
 761
 762                 // This is either an array or literal string
 763                 // delimiter, Return it
 764
 765                 return $char;
 766
 767             case '<':
 768             case '>':
 769
 770                 // This could either be a hex string or
 771                 // dictionary delimiter. Determine the
 772                 // appropriate case and return the token
 773
 774                 if ($c->buffer[$c->offset] == $char) {
 775                     if (!$c->ensureContent()) {
 776                         return false;
 777                     }
 778                     $c->offset++;
 779                     return $char . $char;
 780                 } else {
 781                     return $char;
 782                 }
 783
 784             case '%':
 785
 786                 // This is a comment - jump over it!
 787
 788                 $pos = $c->offset;
 789                 while(1) {
 790                     $match = preg_match("/(\r\n|\r|\n)/", $c->buffer, $m, PREG_OFFSET_CAPTURE, $pos);
 791                     if ($match === 0) {
 792                         if (!$c->increaseLength()) {
 793                             return false;
 794                         } else {
 795                             continue;
 796                         }
 797                     }
 798
 799                     $c->offset = $m[0][1] + strlen($m[0][0]);
 800
 801                     return $this->_readToken($c);
 802                 }
 803
 804             default:
 805
 806                 // This is "another" type of token (probably
 807                 // a dictionary entry or a numeric value)
 808                 // Find the end and return it.
 809
 810                 if (!$c->ensureContent()) {
 811                     return false;
 812                 }
 813
 814                 while(1) {
 815
 816                     // Determine the length of the token
 817
 818                     $pos = strcspn($c->buffer, "\x20%[]<>()/\x0A\x0C\x0D\x09\x00", $c->offset);
 819
 820                     if ($c->offset + $pos <= $c->length - 1) {
 821                         break;
 822                     } else {
 823                         // If the script reaches this point,
 824                         // the token may span beyond the end
 825                         // of the current buffer. Therefore,
 826                         // we increase the size of the buffer
 827                         // and try again--just to be safe.
 828
 829                         $c->increaseLength();
 830                     }
 831                 }
 832
 833                 $result = substr($c->buffer, $c->offset - 1, $pos + 1);
 834
 835                 $c->offset += $pos;
 836
 837                 return $result;
 838         }
 839     }
 840
 841     /**
 842      * Un-filter a stream object
 843      *
 844      * @param array $obj
 845      * @return string
 846      * @throws Exception
 847      */
 848     protected function _unFilterStream($obj)
 849     {
 850         $filters = array();
 851
 852         if (isset($obj[1][1]['/Filter'])) {
 853             $filter = $obj[1][1]['/Filter'];
 854
 855             if ($filter[0] == pdf_parser::TYPE_OBJREF) {
 856                 $tmpFilter = $this->resolveObject($filter);
 857                 $filter = $tmpFilter[1];
 858             }
 859
 860             if ($filter[0] == pdf_parser::TYPE_TOKEN) {
 861                 $filters[] = $filter;
 862             } else if ($filter[0] == pdf_parser::TYPE_ARRAY) {
 863                 $filters = $filter[1];
 864             }
 865         }
 866
 867         $stream = $obj[2][1];
 868
 869         foreach ($filters AS $filter) {
 870             switch ($filter[1]) {
 871                 case '/FlateDecode':
 872                 case '/Fl':
 873                     if (function_exists('gzuncompress')) {
 874                         $oStream = $stream;
 875                         $stream = (strlen($stream) > 0) ? @gzuncompress($stream) : '';
 876                     } else {
 877                         throw new Exception(
 878                             sprintf('To handle %s filter, please compile php with zlib support.', $filter[1])
 879                         );
 880                     }
 881
 882                     if ($stream === false) {
 883                         $tries = 0;
 884                         while ($tries < 8 && ($stream === false || strlen($stream) < strlen($oStream))) {
 885                             $oStream = substr($oStream, 1);
 886                             $stream = @gzinflate($oStream);
 887                             $tries++;
 888                         }
 889
 890                         if ($stream === false) {
 891                             throw new Exception('Error while decompressing stream.');
 892                         }
 893                     }
 894                     break;
 895                 case '/LZWDecode':
 896                     if (!class_exists('FilterLZW')) {
 897                         require_once('filters/FilterLZW.php');
 898                     }
 899                     $decoder = new FilterLZW();
 900                     $stream = $decoder->decode($stream);
 901                     break;
 902                 case '/ASCII85Decode':
 903                     if (!class_exists('FilterASCII85')) {
 904                         require_once('filters/FilterASCII85.php');
 905                     }
 906                     $decoder = new FilterASCII85();
 907                     $stream = $decoder->decode($stream);
 908                     break;
 909                 case '/ASCIIHexDecode':
 910                     if (!class_exists('FilterASCIIHexDecode')) {
 911                         require_once('filters/FilterASCIIHexDecode.php');
 912                     }
 913                     $decoder = new FilterASCIIHexDecode();
 914                     $stream = $decoder->decode($stream);
 915                     break;
 916                 case null:
 917                     break;
 918                 default:
 919                     throw new Exception(sprintf('Unsupported Filter: %s', $filter[1]));
 920             }
 921         }
 922
 923         return $stream;
 924     }
 925 }