[moodle.git] / mod / assign / feedback / editpdf / fpdi / pdf_parser.php

<?php\r
//\r
//  FPDI - Version 1.5.4\r
//\r
//    Copyright 2004-2015 Setasign - Jan Slabon\r
//\r
//  Licensed under the Apache License, Version 2.0 (the "License");\r
//  you may not use this file except in compliance with the License.\r
//  You may obtain a copy of the License at\r
//\r
//      http://www.apache.org/licenses/LICENSE-2.0\r
//\r
//  Unless required by applicable law or agreed to in writing, software\r
//  distributed under the License is distributed on an "AS IS" BASIS,\r
//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
//  See the License for the specific language governing permissions and\r
//  limitations under the License.\r
//\r
\r
/**\r
 * Class pdf_parser\r
 */\r
class pdf_parser\r
{\r
    /**\r
     * Type constant\r
     *\r
     * @var integer\r
     */\r
    const TYPE_NULL = 0;\r
\r
    /**\r
     * Type constant\r
     *\r
     * @var integer\r
     */\r
    const TYPE_NUMERIC = 1;\r
\r
    /**\r
     * Type constant\r
     *\r
     * @var integer\r
     */\r
    const TYPE_TOKEN = 2;\r
\r
    /**\r
     * Type constant\r
     *\r
     * @var integer\r
     */\r
    const TYPE_HEX = 3;\r
\r
    /**\r
     * Type constant\r
     *\r
     * @var integer\r
     */\r
    const TYPE_STRING = 4;\r
\r
    /**\r
     * Type constant\r
     *\r
     * @var integer\r
     */\r
    const TYPE_DICTIONARY = 5;\r
\r
    /**\r
     * Type constant\r
     *\r
     * @var integer\r
     */\r
    const TYPE_ARRAY = 6;\r
\r
    /**\r
     * Type constant\r
     *\r
     * @var integer\r
     */\r
    const TYPE_OBJDEC = 7;\r
\r
    /**\r
     * Type constant\r
     *\r
     * @var integer\r
     */\r
    const TYPE_OBJREF = 8;\r
\r
    /**\r
     * Type constant\r
     *\r
     * @var integer\r
     */\r
    const TYPE_OBJECT = 9;\r
\r
    /**\r
     * Type constant\r
     *\r
     * @var integer\r
     */\r
    const TYPE_STREAM = 10;\r
\r
    /**\r
     * Type constant\r
     *\r
     * @var integer\r
     */\r
    const TYPE_BOOLEAN = 11;\r
\r
    /**\r
     * Type constant\r
     *\r
     * @var integer\r
     */\r
    const TYPE_REAL = 12;\r
\r
    /**\r
     * Define the amount of byte in which the initial keyword of a PDF document should be searched.\r
     *\r
     * @var int\r
     */\r
    static public $searchForStartxrefLength = 5500;\r
\r
    /**\r
     * Filename\r
     *\r
     * @var string\r
     */\r
    public $filename;\r
\r
    /**\r
     * File resource\r
     *\r
     * @var resource\r
     */\r
    protected $_f;\r
\r
    /**\r
     * PDF Context\r
     *\r
     * @var pdf_context\r
     */\r
    protected $_c;\r
\r
    /**\r
     * xref-Data\r
     *\r
     * @var array\r
     */\r
    protected $_xref;\r
\r
    /**\r
     * Data of the Root object\r
     *\r
     * @var array\r
     */\r
    protected $_root;\r
\r
    /**\r
     * PDF version of the loaded document\r
     *\r
     * @var string\r
     */\r
    protected $_pdfVersion;\r
\r
    /**\r
     * For reading encrypted documents and xref/object streams are in use\r
     *\r
     * @var boolean\r
     */\r
    protected $_readPlain = true;\r
\r
    /**\r
     * The current read object\r
     *\r
     * @var array\r
     */\r
    protected $_currentObj;\r
\r
    /**\r
     * Constructor\r
     *\r
     * @param string $filename Source filename\r
     * @throws InvalidArgumentException\r
     */\r
    public function __construct($filename)\r
    {\r
        $this->filename = $filename;\r
\r
        $this->_f = @fopen($this->filename, 'rb');\r
\r
        if (!$this->_f) {\r
            throw new InvalidArgumentException(sprintf('Cannot open %s !', $filename));\r
        }\r
\r
        $this->getPdfVersion();\r
\r
        if (!class_exists('pdf_context')) {\r
            require_once('pdf_context.php');\r
        }\r
        $this->_c = new pdf_context($this->_f);\r
\r
        // Read xref-Data\r
        $this->_xref = array();\r
        $this->_readXref($this->_xref, $this->_findXref());\r
\r
        // Check for Encryption\r
        $this->getEncryption();\r
\r
        // Read root\r
        $this->_readRoot();\r
    }\r
\r
    /**\r
     * Destructor\r
     */\r
    public function __destruct()\r
    {\r
        $this->closeFile();\r
    }\r
\r
    /**\r
     * Close the opened file\r
     */\r
    public function closeFile()\r
    {\r
        if (isset($this->_f) && is_resource($this->_f)) {\r
            fclose($this->_f);\r
            unset($this->_f);\r
        }\r
    }\r
\r
    /**\r
     * Check Trailer for Encryption\r
     *\r
     * @throws Exception\r
     */\r
    public function getEncryption()\r
    {\r
        if (isset($this->_xref['trailer'][1]['/Encrypt'])) {\r
            throw new Exception('File is encrypted!');\r
        }\r
    }\r
\r
    /**\r
     * Get PDF-Version\r
     *\r
     * @return string\r
     */\r
    public function getPdfVersion()\r
    {\r
        if ($this->_pdfVersion === null) {\r
            fseek($this->_f, 0);\r
            preg_match('/\d\.\d/', fread($this->_f, 16), $m);\r
            if (isset($m[0]))\r
                $this->_pdfVersion = $m[0];\r
        }\r
\r
        return $this->_pdfVersion;\r
    }\r
\r
    /**\r
     * Read the /Root dictionary\r
     */\r
    protected function _readRoot()\r
    {\r
        if ($this->_xref['trailer'][1]['/Root'][0] != self::TYPE_OBJREF) {\r
            throw new Exception('Wrong Type of Root-Element! Must be an indirect reference');\r
        }\r
\r
        $this->_root = $this->resolveObject($this->_xref['trailer'][1]['/Root']);\r
    }\r
\r
    /**\r
     * Find the xref table\r
     *\r
     * @return integer\r
     * @throws Exception\r
     */\r
    protected function _findXref()\r
    {\r
        $toRead = self::$searchForStartxrefLength;\r
\r
        $stat = fseek($this->_f, -$toRead, SEEK_END);\r
        if ($stat === -1) {\r
            fseek($this->_f, 0);\r
        }\r
\r
        $data = fread($this->_f, $toRead);\r
\r
        $keywordPos = strpos(strrev($data), strrev('startxref'));\r
        if (false === $keywordPos) {\r
            $keywordPos = strpos(strrev($data), strrev('startref'));\r
        }\r
\r
        if (false === $keywordPos) {\r
            throw new Exception('Unable to find "startxref" keyword.');\r
        }\r
\r
        $pos = strlen($data) - $keywordPos;\r
        $data = substr($data, $pos);\r
\r
        if (!preg_match('/\s*(\d+).*$/s', $data, $matches)) {\r
            throw new Exception('Unable to find pointer to xref table.');\r
        }\r
\r
        return (int) $matches[1];\r
    }\r
\r
    /**\r
     * Read the xref table\r
     *\r
     * @param array $result Array of xref table entries\r
     * @param integer $offset of xref table\r
     * @return boolean\r
     * @throws Exception\r
     */\r
    protected function _readXref(&$result, $offset)\r
    {\r
        $tempPos = $offset - min(20, $offset);\r
        fseek($this->_f, $tempPos); // set some bytes backwards to fetch corrupted docs\r
\r
        $data = fread($this->_f, 100);\r
\r
        $xrefPos = strrpos($data, 'xref');\r
\r
        if ($xrefPos === false) {\r
            $this->_c->reset($offset);\r
            $xrefStreamObjDec = $this->_readValue($this->_c);\r
\r
            if (is_array($xrefStreamObjDec) && isset($xrefStreamObjDec[0]) && $xrefStreamObjDec[0] == self::TYPE_OBJDEC) {\r
                throw new Exception(\r
                    sprintf(\r
                        'This document (%s) probably uses a compression technique which is not supported by the ' .\r
                        'free parser shipped with FPDI. (See https://www.setasign.com/fpdi-pdf-parser for more details)',\r
                        $this->filename\r
                    )\r
                );\r
            } else {\r
                throw new Exception('Unable to find xref table.');\r
            }\r
        }\r
\r
        if (!isset($result['xrefLocation'])) {\r
            $result['xrefLocation'] = $tempPos + $xrefPos;\r
            $result['maxObject'] = 0;\r
        }\r
\r
        $cycles = -1;\r
        $bytesPerCycle = 100;\r
\r
        fseek($this->_f, $tempPos = $tempPos + $xrefPos + 4); // set the handle directly after the "xref"-keyword\r
        $data = fread($this->_f, $bytesPerCycle);\r
\r
        while (($trailerPos = strpos($data, 'trailer', max($bytesPerCycle * $cycles++, 0))) === false && !feof($this->_f)) {\r
            $data .= fread($this->_f, $bytesPerCycle);\r
        }\r
\r
        if ($trailerPos === false) {\r
            throw new Exception('Trailer keyword not found after xref table');\r
        }\r
\r
        $data = ltrim(substr($data, 0, $trailerPos));\r
\r
        // get Line-Ending\r
        $found = preg_match_all("/(\r\n|\n|\r)/", substr($data, 0, 100), $m); // check the first 100 bytes for line breaks\r
        if ($found === 0) {\r
            throw new Exception('Xref table seems to be corrupted.');\r
        }\r
        $differentLineEndings = count(array_unique($m[0]));\r
        if ($differentLineEndings > 1) {\r
            $lines = preg_split("/(\r\n|\n|\r)/", $data, -1, PREG_SPLIT_NO_EMPTY);\r
        } else {\r
            $lines = explode($m[0][0], $data);\r
        }\r
\r
        $data = $differentLineEndings = $m = null;\r
        unset($data, $differentLineEndings, $m);\r
\r
        $linesCount = count($lines);\r
\r
        $start = 1;\r
\r
        for ($i = 0; $i < $linesCount; $i++) {\r
            $line = trim($lines[$i]);\r
            if ($line) {\r
                $pieces = explode(' ', $line);\r
                $c = count($pieces);\r
                switch($c) {\r
                    case 2:\r
                        $start = (int)$pieces[0];\r
                        $end   = $start + (int)$pieces[1];\r
                        if ($end > $result['maxObject'])\r
                            $result['maxObject'] = $end;\r
                        break;\r
                    case 3:\r
                        if (!isset($result['xref'][$start]))\r
                            $result['xref'][$start] = array();\r
\r
                        if (!array_key_exists($gen = (int) $pieces[1], $result['xref'][$start])) {\r
                            $result['xref'][$start][$gen] = $pieces[2] == 'n' ? (int) $pieces[0] : null;\r
                        }\r
                        $start++;\r
                        break;\r
                    default:\r
                        throw new Exception('Unexpected data in xref table');\r
                }\r
            }\r
        }\r
\r
        $lines = $pieces = $line = $start = $end = $gen = null;\r
        unset($lines, $pieces, $line, $start, $end, $gen);\r
\r
        $this->_c->reset($tempPos + $trailerPos + 7);\r
        $trailer = $this->_readValue($this->_c);\r
\r
        if (!isset($result['trailer'])) {\r
            $result['trailer'] = $trailer;\r
        }\r
\r
        if (isset($trailer[1]['/Prev'])) {\r
            $this->_readXref($result, $trailer[1]['/Prev'][1]);\r
        }\r
\r
        $trailer = null;\r
        unset($trailer);\r
\r
        return true;\r
    }\r
\r
    /**\r
     * Reads a PDF value\r
     *\r
     * @param pdf_context $c\r
     * @param string $token A token\r
     * @return mixed\r
     * @throws Exception\r
     */\r
    protected function _readValue(&$c, $token = null)\r
    {\r
        if (is_null($token)) {\r
            $token = $this->_readToken($c);\r
        }\r
\r
        if ($token === false) {\r
            return false;\r
        }\r
\r
        switch ($token) {\r
            case '<':\r
                // This is a hex string.\r
                // Read the value, then the terminator\r
\r
                $pos = $c->offset;\r
\r
                while(1) {\r
\r
                    $match = strpos($c->buffer, '>', $pos);\r
\r
                    // If you can't find it, try\r
                    // reading more data from the stream\r
\r
                    if ($match === false) {\r
                        if (!$c->increaseLength()) {\r
                            return false;\r
                        } else {\r
                            continue;\r
                        }\r
                    }\r
\r
                    $result = substr($c->buffer, $c->offset, $match - $c->offset);\r
                    $c->offset = $match + 1;\r
\r
                    return array (self::TYPE_HEX, $result);\r
                }\r
                break;\r
\r
            case '<<':\r
                // This is a dictionary.\r
\r
                $result = array();\r
\r
                // Recurse into this function until we reach\r
                // the end of the dictionary.\r
                while (($key = $this->_readToken($c)) !== '>>') {\r
                    if ($key === false) {\r
                        return false;\r
                    }\r
\r
                    if (($value =   $this->_readValue($c)) === false) {\r
                        return false;\r
                    }\r
\r
                    // Catch missing value\r
                    if ($value[0] == self::TYPE_TOKEN && $value[1] == '>>') {\r
                        $result[$key] = array(self::TYPE_NULL);\r
                        break;\r
                    }\r
\r
                    $result[$key] = $value;\r
                }\r
\r
                return array (self::TYPE_DICTIONARY, $result);\r
\r
            case '[':\r
                // This is an array.\r
\r
                $result = array();\r
\r
                // Recurse into this function until we reach\r
                // the end of the array.\r
                while (($token = $this->_readToken($c)) !== ']') {\r
                    if ($token === false) {\r
                        return false;\r
                    }\r
\r
                    if (($value = $this->_readValue($c, $token)) === false) {\r
                        return false;\r
                    }\r
\r
                    $result[] = $value;\r
                }\r
\r
                return array (self::TYPE_ARRAY, $result);\r
\r
            case '(':\r
                // This is a string\r
                $pos = $c->offset;\r
\r
                $openBrackets = 1;\r
                do {\r
                    for (; $openBrackets != 0 && $pos < $c->length; $pos++) {\r
                        switch (ord($c->buffer[$pos])) {\r
                            case 0x28: // '('\r
                                $openBrackets++;\r
                                break;\r
                            case 0x29: // ')'\r
                                $openBrackets--;\r
                                break;\r
                            case 0x5C: // backslash\r
                                $pos++;\r
                        }\r
                    }\r
                } while($openBrackets != 0 && $c->increaseLength());\r
\r
                $result = substr($c->buffer, $c->offset, $pos - $c->offset - 1);\r
                $c->offset = $pos;\r
\r
                return array (self::TYPE_STRING, $result);\r
\r
            case 'stream':\r
                $tempPos = $c->getPos() - strlen($c->buffer);\r
                $tempOffset = $c->offset;\r
\r
                $c->reset($startPos = $tempPos + $tempOffset);\r
\r
                // Find the first "newline"\r
                while ($c->buffer[0] !== chr(10) && $c->buffer[0] !== chr(13)) {\r
                    $c->reset(++$startPos);\r
                    if ($c->ensureContent() === false) {\r
                        throw new Exception(\r
                            'Unable to parse stream data. No newline followed the stream keyword.'\r
                        );\r
                    }\r
                }\r
\r
                $e = 0; // ensure line breaks in front of the stream\r
                if ($c->buffer[0] == chr(10) || $c->buffer[0] == chr(13))\r
                    $e++;\r
                if ($c->buffer[1] == chr(10) && $c->buffer[0] != chr(10))\r
                    $e++;\r
\r
                if ($this->_currentObj[1][1]['/Length'][0] == self::TYPE_OBJREF) {\r
                    $tmpLength = $this->resolveObject($this->_currentObj[1][1]['/Length']);\r
                    $length = $tmpLength[1][1];\r
                } else {\r
                    $length = $this->_currentObj[1][1]['/Length'][1];\r
                }\r
\r
                if ($length > 0) {\r
                    $c->reset($startPos + $e, $length);\r
                    $v = $c->buffer;\r
                } else {\r
                    $v = '';\r
                }\r
\r
                $c->reset($startPos + $e + $length);\r
                $endstream = $this->_readToken($c);\r
\r
                if ($endstream != 'endstream') {\r
                    $c->reset($startPos + $e + $length + 9); // 9 = strlen("endstream")\r
                    // We don't throw an error here because the next\r
                    // round trip will start at a new offset\r
                }\r
\r
                return array(self::TYPE_STREAM, $v);\r
\r
            default	:\r
                if (is_numeric($token)) {\r
                    // A numeric token. Make sure that\r
                    // it is not part of something else.\r
                    if (($tok2 = $this->_readToken($c)) !== false) {\r
                        if (is_numeric($tok2)) {\r
\r
                            // Two numeric tokens in a row.\r
                            // In this case, we're probably in\r
                            // front of either an object reference\r
                            // or an object specification.\r
                            // Determine the case and return the data\r
                            if (($tok3 = $this->_readToken($c)) !== false) {\r
                                switch ($tok3) {\r
                                    case 'obj':\r
                                        return array(self::TYPE_OBJDEC, (int)$token, (int)$tok2);\r
                                    case 'R':\r
                                        return array(self::TYPE_OBJREF, (int)$token, (int)$tok2);\r
                                }\r
                                // If we get to this point, that numeric value up\r
                                // there was just a numeric value. Push the extra\r
                                // tokens back into the stack and return the value.\r
                                array_push($c->stack, $tok3);\r
                            }\r
                        }\r
\r
                        array_push($c->stack, $tok2);\r
                    }\r
\r
                    if ($token === (string)((int)$token))\r
                        return array(self::TYPE_NUMERIC, (int)$token);\r
                    else\r
                        return array(self::TYPE_REAL, (float)$token);\r
                } else if ($token == 'true' || $token == 'false') {\r
                    return array(self::TYPE_BOOLEAN, $token == 'true');\r
                } else if ($token == 'null') {\r
                   return array(self::TYPE_NULL);\r
                } else {\r
                    // Just a token. Return it.\r
                    return array(self::TYPE_TOKEN, $token);\r
                }\r
         }\r
    }\r
\r
    /**\r
     * Resolve an object\r
     *\r
     * @param array $objSpec The object-data\r
     * @return array|boolean\r
     * @throws Exception\r
     */\r
    public function resolveObject($objSpec)\r
    {\r
        $c = $this->_c;\r
\r
        // Exit if we get invalid data\r
        if (!is_array($objSpec)) {\r
            return false;\r
        }\r
\r
        if ($objSpec[0] == self::TYPE_OBJREF) {\r
\r
            // This is a reference, resolve it\r
            if (isset($this->_xref['xref'][$objSpec[1]][$objSpec[2]])) {\r
\r
                // Save current file position\r
                // This is needed if you want to resolve\r
                // references while you're reading another object\r
                // (e.g.: if you need to determine the length\r
                // of a stream)\r
\r
                $oldPos = $c->getPos();\r
\r
                // Reposition the file pointer and\r
                // load the object header.\r
\r
                $c->reset($this->_xref['xref'][$objSpec[1]][$objSpec[2]]);\r
\r
                $header = $this->_readValue($c);\r
\r
                if ($header[0] != self::TYPE_OBJDEC || $header[1] != $objSpec[1] || $header[2] != $objSpec[2]) {\r
                    $toSearchFor = $objSpec[1] . ' ' . $objSpec[2] . ' obj';\r
                    if (preg_match('/' . $toSearchFor . '/', $c->buffer)) {\r
                        $c->offset = strpos($c->buffer, $toSearchFor) + strlen($toSearchFor);\r
                        // reset stack\r
                        $c->stack = array();\r
                    } else {\r
                        throw new Exception(\r
                            sprintf("Unable to find object (%s, %s) at expected location.", $objSpec[1], $objSpec[2])\r
                        );\r
                    }\r
                }\r
\r
                // If we're being asked to store all the information\r
                // about the object, we add the object ID and generation\r
                // number for later use\r
                $result = array (\r
                    self::TYPE_OBJECT,\r
                    'obj' => $objSpec[1],\r
                    'gen' => $objSpec[2]\r
                );\r
\r
                $this->_currentObj =& $result;\r
\r
                // Now simply read the object data until\r
                // we encounter an end-of-object marker\r
                while (true) {\r
                    $value = $this->_readValue($c);\r
                    if ($value === false || count($result) > 4) {\r
                        // in this case the parser couldn't find an "endobj" so we break here\r
                        break;\r
                    }\r
\r
                    if ($value[0] == self::TYPE_TOKEN && $value[1] === 'endobj') {\r
                        break;\r
                    }\r
\r
                    $result[] = $value;\r
                }\r
\r
                $c->reset($oldPos);\r
\r
                if (isset($result[2][0]) && $result[2][0] == self::TYPE_STREAM) {\r
                    $result[0] = self::TYPE_STREAM;\r
                }\r
\r
            } else {\r
                throw new Exception(\r
                    sprintf("Unable to find object (%s, %s) at expected location.", $objSpec[1], $objSpec[2])\r
                );\r
            }\r
\r
            return $result;\r
        } else {\r
            return $objSpec;\r
        }\r
    }\r
\r
    /**\r
     * Reads a token from the context\r
     *\r
     * @param pdf_context $c\r
     * @return mixed\r
     */\r
    protected function _readToken($c)\r
    {\r
        // If there is a token available\r
        // on the stack, pop it out and\r
        // return it.\r
\r
        if (count($c->stack)) {\r
            return array_pop($c->stack);\r
        }\r
\r
        // Strip away any whitespace\r
\r
        do {\r
            if (!$c->ensureContent()) {\r
                return false;\r
            }\r
            $c->offset += strspn($c->buffer, "\x20\x0A\x0C\x0D\x09\x00", $c->offset);\r
        } while ($c->offset >= $c->length - 1);\r
\r
        // Get the first character in the stream\r
\r
        $char = $c->buffer[$c->offset++];\r
\r
        switch ($char) {\r
\r
            case '[':\r
            case ']':\r
            case '(':\r
            case ')':\r
\r
                // This is either an array or literal string\r
                // delimiter, Return it\r
\r
                return $char;\r
\r
            case '<':\r
            case '>':\r
\r
                // This could either be a hex string or\r
                // dictionary delimiter. Determine the\r
                // appropriate case and return the token\r
\r
                if ($c->buffer[$c->offset] == $char) {\r
                    if (!$c->ensureContent()) {\r
                        return false;\r
                    }\r
                    $c->offset++;\r
                    return $char . $char;\r
                } else {\r
                    return $char;\r
                }\r
\r
            case '%':\r
\r
                // This is a comment - jump over it!\r
\r
                $pos = $c->offset;\r
                while(1) {\r
                    $match = preg_match("/(\r\n|\r|\n)/", $c->buffer, $m, PREG_OFFSET_CAPTURE, $pos);\r
                    if ($match === 0) {\r
                        if (!$c->increaseLength()) {\r
                            return false;\r
                        } else {\r
                            continue;\r
                        }\r
                    }\r
\r
                    $c->offset = $m[0][1] + strlen($m[0][0]);\r
\r
                    return $this->_readToken($c);\r
                }\r
\r
            default:\r
\r
                // This is "another" type of token (probably\r
                // a dictionary entry or a numeric value)\r
                // Find the end and return it.\r
\r
                if (!$c->ensureContent()) {\r
                    return false;\r
                }\r
\r
                while(1) {\r
\r
                    // Determine the length of the token\r
\r
                    $pos = strcspn($c->buffer, "\x20%[]<>()/\x0A\x0C\x0D\x09\x00", $c->offset);\r
\r
                    if ($c->offset + $pos <= $c->length - 1) {\r
                        break;\r
                    } else {\r
                        // If the script reaches this point,\r
                        // the token may span beyond the end\r
                        // of the current buffer. Therefore,\r
                        // we increase the size of the buffer\r
                        // and try again--just to be safe.\r
\r
                        $c->increaseLength();\r
                    }\r
                }\r
\r
                $result = substr($c->buffer, $c->offset - 1, $pos + 1);\r
\r
                $c->offset += $pos;\r
\r
                return $result;\r
        }\r
    }\r
\r
    /**\r
     * Un-filter a stream object\r
     *\r
     * @param array $obj\r
     * @return string\r
     * @throws Exception\r
     */\r
    protected function _unFilterStream($obj)\r
    {\r
        $filters = array();\r
\r
        if (isset($obj[1][1]['/Filter'])) {\r
            $filter = $obj[1][1]['/Filter'];\r
\r
            if ($filter[0] == pdf_parser::TYPE_OBJREF) {\r
                $tmpFilter = $this->resolveObject($filter);\r
                $filter = $tmpFilter[1];\r
            }\r
\r
            if ($filter[0] == pdf_parser::TYPE_TOKEN) {\r
                $filters[] = $filter;\r
            } else if ($filter[0] == pdf_parser::TYPE_ARRAY) {\r
                $filters = $filter[1];\r
            }\r
        }\r
\r
        $stream = $obj[2][1];\r
\r
        foreach ($filters AS $filter) {\r
            switch ($filter[1]) {\r
                case '/FlateDecode':\r
                case '/Fl':\r
                    if (function_exists('gzuncompress')) {\r
                        $oStream = $stream;\r
                        $stream = (strlen($stream) > 0) ? @gzuncompress($stream) : '';\r
                    } else {\r
                        throw new Exception(\r
                            sprintf('To handle %s filter, please compile php with zlib support.', $filter[1])\r
                        );\r
                    }\r
\r
                    if ($stream === false) {\r
                        $tries = 0;\r
                        while ($tries < 8 && ($stream === false || strlen($stream) < strlen($oStream))) {\r
                            $oStream = substr($oStream, 1);\r
                            $stream = @gzinflate($oStream);\r
                            $tries++;\r
                        }\r
\r
                        if ($stream === false) {\r
                            throw new Exception('Error while decompressing stream.');\r
                        }\r
                    }\r
                    break;\r
                case '/LZWDecode':\r
                    if (!class_exists('FilterLZW')) {\r
                        require_once('filters/FilterLZW.php');\r
                    }\r
                    $decoder = new FilterLZW();\r
                    $stream = $decoder->decode($stream);\r
                    break;\r
                case '/ASCII85Decode':\r
                    if (!class_exists('FilterASCII85')) {\r
                        require_once('filters/FilterASCII85.php');\r
                    }\r
                    $decoder = new FilterASCII85();\r
                    $stream = $decoder->decode($stream);\r
                    break;\r
                case '/ASCIIHexDecode':\r
                    if (!class_exists('FilterASCIIHexDecode')) {\r
                        require_once('filters/FilterASCIIHexDecode.php');\r
                    }\r
                    $decoder = new FilterASCIIHexDecode();\r
                    $stream = $decoder->decode($stream);\r
                    break;\r
                case null:\r
                    break;\r
                default:\r
                    throw new Exception(sprintf('Unsupported Filter: %s', $filter[1]));\r
            }\r
        }\r
\r
        return $stream;\r
    }\r
}