PageRenderTime 354ms CodeModel.GetById 84ms app.highlight 173ms RepoModel.GetById 79ms app.codeStats 1ms

/htdocs/includes/tcpdf/tcpdf_filters.php

https://bitbucket.org/speedealing/speedealing
PHP | 477 lines | 235 code | 22 blank | 220 comment | 41 complexity | 602e2cd0d6a8e7560bc861254a1c6d86 MD5 | raw file
  1<?php
  2//============================================================+
  3// File name   : tcpdf_filters.php
  4// Version     : 1.0.000
  5// Begin       : 2011-05-23
  6// Last Update : 2012-01-28
  7// Author      : Nicola Asuni - Tecnick.com LTD - Manor Coach House, Church Hill, Aldershot, Hants, GU12 4RQ, UK - www.tecnick.com - info@tecnick.com
  8// License     : http://www.tecnick.com/pagefiles/tcpdf/LICENSE.TXT GNU-LGPLv3
  9// -------------------------------------------------------------------
 10// Copyright (C) 2011-2012  Nicola Asuni - Tecnick.com LTD
 11//
 12// This file is part of TCPDF software library.
 13//
 14// TCPDF is free software: you can redistribute it and/or modify it
 15// under the terms of the GNU Lesser General Public License as
 16// published by the Free Software Foundation, either version 3 of the
 17// License, or (at your option) any later version.
 18//
 19// TCPDF is distributed in the hope that it will be useful, but
 20// WITHOUT ANY WARRANTY; without even the implied warranty of
 21// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 22// See the GNU Lesser General Public License for more details.
 23//
 24// You should have received a copy of the License
 25// along with TCPDF. If not, see
 26// <http://www.tecnick.com/pagefiles/tcpdf/LICENSE.TXT>.
 27//
 28// See LICENSE.TXT file for more information.
 29// -------------------------------------------------------------------
 30//
 31// Description : This is a PHP class for decoding common PDF filters (PDF 32000-2008 - 7.4 Filters).
 32//
 33//============================================================+
 34
 35/**
 36 * @file
 37 * This is a PHP class for decoding common PDF filters (PDF 32000-2008 - 7.4 Filters).<br>
 38 * @package com.tecnick.tcpdf
 39 * @author Nicola Asuni
 40 * @version 1.0.000
 41 */
 42
 43/**
 44 * @class TCPDF_FILTERS
 45 * This is a PHP class for decoding common PDF filters (PDF 32000-2008 - 7.4 Filters).<br>
 46 * @package com.tecnick.tcpdf
 47 * @brief This is a PHP class for decoding common PDF filters.
 48 * @version 1.0.000
 49 * @author Nicola Asuni - info@tecnick.com
 50 */
 51class TCPDF_FILTERS {
 52
 53	/**
 54	 * Define a list of available filter decoders.
 55	 * @private
 56	 */
 57	private $available_filters = array('ASCIIHexDecode', 'ASCII85Decode', 'LZWDecode', 'FlateDecode', 'RunLengthDecode');
 58
 59// -----------------------------------------------------------------------------
 60
 61	/**
 62	 * Get a list of available decoding filters.
 63	 * @return (array) Array of available filter decoders.
 64	 * @public
 65	 * @since 1.0.000 (2011-05-23)
 66	 */
 67	public function getAvailableFilters() {
 68		return $this->available_filters;
 69	}
 70
 71	/**
 72	 * Decode data using the specified filter type.
 73	 * @param $filter (string) Filter name.
 74	 * @param $data (string) Data to decode.
 75	 * @return Decoded data string.
 76	 * @public
 77	 * @since 1.0.000 (2011-05-23)
 78	 */
 79	public function decodeFilter($filter, $data) {
 80		switch ($filter) {
 81			case 'ASCIIHexDecode': {
 82				return $this->decodeFilterASCIIHexDecode($data);
 83				break;
 84			}
 85			case 'ASCII85Decode': {
 86				return $this->decodeFilterASCII85Decode($data);
 87				break;
 88			}
 89			case 'LZWDecode': {
 90				return $this->decodeFilterLZWDecode($data);
 91				break;
 92			}
 93			case 'FlateDecode': {
 94				return $this->decodeFilterFlateDecode($data);
 95				break;
 96			}
 97			case 'RunLengthDecode': {
 98				return $this->decodeFilterRunLengthDecode($data);
 99				break;
100			}
101			case 'CCITTFaxDecode': {
102				return $this->decodeFilterCCITTFaxDecode($data);
103				break;
104			}
105			case 'JBIG2Decode': {
106				return $this->decodeFilterJBIG2Decode($data);
107				break;
108			}
109			case 'DCTDecode': {
110				return $this->decodeFilterDCTDecode($data);
111				break;
112			}
113			case 'JPXDecode': {
114				return $this->decodeFilterJPXDecode($data);
115				break;
116			}
117			case 'Crypt': {
118				return $this->decodeFilterCrypt($data);
119				break;
120			}
121			default: {
122				return decodeFilterStandard($data);
123				break;
124			}
125		}
126	}
127
128	// --- FILTERS (PDF 32000-2008 - 7.4 Filters) ------------------------------
129
130	/**
131	 * Standard
132	 * Default decoding filter (leaves data unchanged).
133	 * @param $data (string) Data to decode.
134	 * @return Decoded data string.
135	 * @public
136	 * @since 1.0.000 (2011-05-23)
137	 */
138	public function decodeFilterStandard($data) {
139		return $data;
140	}
141
142	/**
143	 * ASCIIHexDecode
144	 * Decodes data encoded in an ASCII hexadecimal representation, reproducing the original binary data.
145	 * @param $data (string) Data to decode.
146	 * @return Decoded data string.
147	 * @public
148	 * @since 1.0.000 (2011-05-23)
149	 */
150	public function decodeFilterASCIIHexDecode($data) {
151		// intialize string to return
152		$decoded = '';
153		// all white-space characters shall be ignored
154		$data = preg_replace('/[\s]/', '', $data);
155		// check for EOD character: GREATER-THAN SIGN (3Eh)
156		$eod = strpos($data, '>');
157		if ($eod !== false) {
158			// remove EOD and extra data (if any)
159			$data = substr($data, 0, $eod);
160			$eod = true;
161		}
162		// get data length
163		$data_length = strlen($data);
164		if (($data_length % 2) != 0) {
165			// odd number of hexadecimal digits
166			if ($eod) {
167				// EOD shall behave as if a 0 (zero) followed the last digit
168				$data = substr($data, 0, -1).'0'.substr($data, -1);
169			} else {
170				$this->Error('decodeASCIIHex: invalid code');
171			}
172		}
173		// check for invalid characters
174		if (preg_match('/[^a-fA-F\d]/', $data) > 0) {
175			$this->Error('decodeASCIIHex: invalid code');
176		}
177		// get one byte of binary data for each pair of ASCII hexadecimal digits
178		$decoded = pack('H*', $data);
179		return $decoded;
180	}
181
182	/**
183	 * ASCII85Decode
184	 * Decodes data encoded in an ASCII base-85 representation, reproducing the original binary data.
185	 * @param $data (string) Data to decode.
186	 * @return Decoded data string.
187	 * @public
188	 * @since 1.0.000 (2011-05-23)
189	 */
190	public function decodeFilterASCII85Decode($data) {
191		// intialize string to return
192		$decoded = '';
193		// all white-space characters shall be ignored
194		$data = preg_replace('/[\s]/', '', $data);
195		// remove start sequence 2-character sequence <~ (3Ch)(7Eh)
196		if (strpos($data, '<~') !== false) {
197			// remove EOD and extra data (if any)
198			$data = substr($data, 2);
199		}
200		// check for EOD: 2-character sequence ~> (7Eh)(3Eh)
201		$eod = strpos($data, '~>');
202		if ($eod !== false) {
203			// remove EOD and extra data (if any)
204			$data = substr($data, 0, $eod);
205		}
206		// data length
207		$data_length = strlen($data);
208		// check for invalid characters
209		if (preg_match('/[^\x21-\x75,\x74]/', $data) > 0) {
210			$this->Error('decodeASCII85: invalid code');
211		}
212		// z sequence
213		$zseq = chr(0).chr(0).chr(0).chr(0);
214		// position inside a group of 4 bytes (0-3)
215		$group_pos = 0;
216		$tuple = 0;
217		$pow85 = array((85*85*85*85), (85*85*85), (85*85), 85, 1);
218		$last_pos = ($data_length - 1);
219		// for each byte
220		for ($i = 0; $i < $data_length; ++$i) {
221			// get char value
222			$char = ord($data[$i]);
223			if ($char == 122) { // 'z'
224				if ($group_pos == 0) {
225					$decoded .= $zseq;
226				} else {
227					$this->Error('decodeASCII85: invalid code');
228				}
229			} else {
230				// the value represented by a group of 5 characters should never be greater than 2^32 - 1
231				$tuple += (($char - 33) * $pow85[$group_pos]);
232				if ($group_pos == 4) {
233					$decoded .= chr($tuple >> 24).chr($tuple >> 16).chr($tuple >> 8).chr($tuple);
234					$tuple = 0;
235					$group_pos = 0;
236				} else {
237					++$group_pos;
238				}
239			}
240		}
241		if ($group_pos > 1) {
242			$tuple += $pow85[($group_pos - 1)];
243		}
244		// last tuple (if any)
245		switch ($group_pos) {
246			case 4: {
247				$decoded .= chr($tuple >> 24).chr($tuple >> 16).chr($tuple >> 8);
248				break;
249			}
250			case 3: {
251				$decoded .= chr($tuple >> 24).chr($tuple >> 16);
252				break;
253			}
254			case 2: {
255				$decoded .= chr($tuple >> 24);
256				break;
257			}
258			case 1: {
259				$this->Error('decodeASCII85: invalid code');
260				break;
261			}
262		}
263		return $decoded;
264	}
265
266	/**
267	 * LZWDecode
268	 * Decompresses data encoded using the LZW (Lempel-Ziv-Welch) adaptive compression method, reproducing the original text or binary data.
269	 * @param $data (string) Data to decode.
270	 * @return Decoded data string.
271	 * @public
272	 * @since 1.0.000 (2011-05-23)
273	 */
274	public function decodeFilterLZWDecode($data) {
275		// intialize string to return
276		$decoded = '';
277		// data length
278		$data_length = strlen($data);
279		// convert string to binary string
280		$bitstring = '';
281		for ($i = 0; $i < $data_length; ++$i) {
282			$bitstring .= sprintf('%08b', ord($data{$i}));
283		}
284		// get the number of bits
285		$data_length = strlen($bitstring);
286		// initialize code length in bits
287		$bitlen = 9;
288		// initialize dictionary index
289		$dix = 258;
290		// initialize the dictionary (with the first 256 entries).
291		$dictionary = array();
292		for ($i = 0; $i < 256; ++$i) {
293			$dictionary[$i] = chr($i);
294		}
295		// previous val
296		$prev_index = 0;
297		// while we encounter EOD marker (257), read code_length bits
298		while (($data_length > 0) AND (($index = bindec(substr($bitstring, 0, $bitlen))) != 257)) {
299			// remove read bits from string
300			$bitstring = substr($bitstring, $bitlen);
301			// update number of bits
302			$data_length -= $bitlen;
303			if ($index == 256) { // clear-table marker
304				// reset code length in bits
305				$bitlen = 9;
306				// reset dictionary index
307				$dix = 258;
308				$prev_index = 256;
309				// reset the dictionary (with the first 256 entries).
310				$dictionary = array();
311				for ($i = 0; $i < 256; ++$i) {
312					$dictionary[$i] = chr($i);
313				}
314			} elseif ($prev_index == 256) {
315				// first entry
316				$decoded .= $dictionary[$index];
317				$prev_index = $index;
318			} else {
319				// check if index exist in the dictionary
320				if ($index < $dix) {
321					// index exist on dictionary
322					$decoded .= $dictionary[$index];
323					$dic_val = $dictionary[$prev_index].$dictionary[$index]{0};
324					// store current index
325					$prev_index = $index;
326				} else {
327					// index do not exist on dictionary
328					$dic_val = $dictionary[$prev_index].$dictionary[$prev_index]{0};
329					$decoded .= $dic_val;
330				}
331				// update dictionary
332				$dictionary[$dix] = $dic_val;
333				++$dix;
334				// change bit length by case
335				if ($dix == 2047) {
336					$bitlen = 12;
337				} elseif ($dix == 1023) {
338					$bitlen = 11;
339				} elseif ($dix == 511) {
340					$bitlen = 10;
341				}
342			}
343		}
344		return $decoded;
345	}
346
347	/**
348	 * FlateDecode
349	 * Decompresses data encoded using the zlib/deflate compression method, reproducing the original text or binary data.
350	 * @param $data (string) Data to decode.
351	 * @return Decoded data string.
352	 * @public
353	 * @since 1.0.000 (2011-05-23)
354	 */
355	public function decodeFilterFlateDecode($data) {
356		// intialize string to return
357		$decoded = gzuncompress($data);
358		if ($decoded === false) {
359			$this->Error('decodeFlate: invalid code');
360		}
361		return $decoded;
362	}
363
364	/**
365	 * RunLengthDecode
366	 * Decompresses data encoded using a byte-oriented run-length encoding algorithm.
367	 * @param $data (string) Data to decode.
368	 * @public
369	 * @since 1.0.000 (2011-05-23)
370	 */
371	public function decodeFilterRunLengthDecode($data) {
372		// intialize string to return
373		$decoded = '';
374		// data length
375		$data_length = strlen($data);
376		$i = 0;
377		while($i < $data_length) {
378			// get current byte value
379			$byte = ord($data{$i});
380			if ($byte == 128) {
381				// a length value of 128 denote EOD
382				break;
383			} elseif ($byte < 128) {
384				// if the length byte is in the range 0 to 127
385				// the following length + 1 (1 to 128) bytes shall be copied literally during decompression
386				$decoded .= substr($data, ($i + 1), ($byte + 1));
387				// move to next block
388				$i += ($byte + 2);
389			} else {
390				// if length is in the range 129 to 255,
391				// the following single byte shall be copied 257 - length (2 to 128) times during decompression
392				$decoded .= str_repeat($data{($i + 1)}, (257 - $byte));
393				// move to next block
394				$i += 2;
395			}
396		}
397		return $decoded;
398	}
399
400	/**
401	 * CCITTFaxDecode (NOT IMPLEMETED)
402	 * Decompresses data encoded using the CCITT facsimile standard, reproducing the original data (typically monochrome image data at 1 bit per pixel).
403	 * @param $data (string) Data to decode.
404	 * @return Decoded data string.
405	 * @public
406	 * @since 1.0.000 (2011-05-23)
407	 */
408	public function decodeFilterCCITTFaxDecode($data) {
409		return $data;
410	}
411
412	/**
413	 * JBIG2Decode (NOT IMPLEMETED)
414	 * Decompresses data encoded using the JBIG2 standard, reproducing the original monochrome (1 bit per pixel) image data (or an approximation of that data).
415	 * @param $data (string) Data to decode.
416	 * @return Decoded data string.
417	 * @public
418	 * @since 1.0.000 (2011-05-23)
419	 */
420	public function decodeFilterJBIG2Decode($data) {
421		return $data;
422	}
423
424	/**
425	 * DCTDecode (NOT IMPLEMETED)
426	 * Decompresses data encoded using a DCT (discrete cosine transform) technique based on the JPEG standard, reproducing image sample data that approximates the original data.
427	 * @param $data (string) Data to decode.
428	 * @return Decoded data string.
429	 * @public
430	 * @since 1.0.000 (2011-05-23)
431	 */
432	public function decodeFilterDCTDecode($data) {
433		return $data;
434	}
435
436	/**
437	 * JPXDecode (NOT IMPLEMETED)
438	 * Decompresses data encoded using the wavelet-based JPEG2000 standard, reproducing the original image data.
439	 * @param $data (string) Data to decode.
440	 * @return Decoded data string.
441	 * @public
442	 * @since 1.0.000 (2011-05-23)
443	 */
444	public function decodeFilterJPXDecode($data) {
445		return $data;
446	}
447
448	/**
449	 * Crypt (NOT IMPLEMETED)
450	 * Decrypts data encrypted by a security handler, reproducing the data as it was before encryption.
451	 * @param $data (string) Data to decode.
452	 * @return Decoded data string.
453	 * @public
454	 * @since 1.0.000 (2011-05-23)
455	 */
456	public function decodeFilterCrypt($data) {
457		return $data;
458	}
459
460	// --- END FILTERS SECTION -------------------------------------------------
461
462	/**
463	 * This method is automatically called in case of fatal error; it simply outputs the message and halts the execution.
464	 * @param $msg (string) The error message
465	 * @public
466	 * @since 1.0.000 (2011-05-23)
467	 */
468	public function Error($msg) {
469		// exit program and print error
470		die('<strong>TCPDF_FILTERS ERROR: </strong>'.$msg);
471	}
472
473} // END OF TCPDF_FILTERS CLASS
474
475//============================================================+
476// END OF FILE
477//============================================================+