root / drupal7 / sites / all / libraries / tcpdf-6.2.9 / include / tcpdf_filters.php @ 0f8e34f8
1 |
<?php
|
---|---|
2 |
//============================================================+
|
3 |
// File name : tcpdf_filters.php
|
4 |
// Version : 1.0.001
|
5 |
// Begin : 2011-05-23
|
6 |
// Last Update : 2014-04-25
|
7 |
// Author : Nicola Asuni - Tecnick.com LTD - www.tecnick.com - info@tecnick.com
|
8 |
// License : GNU-LGPL v3 (http://www.gnu.org/copyleft/lesser.html)
|
9 |
// -------------------------------------------------------------------
|
10 |
// Copyright (C) 2011-2013 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.001
|
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.001
|
49 |
* @author Nicola Asuni - info@tecnick.com
|
50 |
*/
|
51 |
class TCPDF_FILTERS { |
52 |
|
53 |
/**
|
54 |
* Define a list of available filter decoders.
|
55 |
* @private static
|
56 |
*/
|
57 |
private static $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 |
* @since 1.0.000 (2011-05-23)
|
65 |
* @public static
|
66 |
*/
|
67 |
public static function getAvailableFilters() { |
68 |
return self::$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 |
* @since 1.0.000 (2011-05-23)
|
77 |
* @public static
|
78 |
*/
|
79 |
public static function decodeFilter($filter, $data) { |
80 |
switch ($filter) { |
81 |
case 'ASCIIHexDecode': { |
82 |
return self::decodeFilterASCIIHexDecode($data); |
83 |
break;
|
84 |
} |
85 |
case 'ASCII85Decode': { |
86 |
return self::decodeFilterASCII85Decode($data); |
87 |
break;
|
88 |
} |
89 |
case 'LZWDecode': { |
90 |
return self::decodeFilterLZWDecode($data); |
91 |
break;
|
92 |
} |
93 |
case 'FlateDecode': { |
94 |
return self::decodeFilterFlateDecode($data); |
95 |
break;
|
96 |
} |
97 |
case 'RunLengthDecode': { |
98 |
return self::decodeFilterRunLengthDecode($data); |
99 |
break;
|
100 |
} |
101 |
case 'CCITTFaxDecode': { |
102 |
return self::decodeFilterCCITTFaxDecode($data); |
103 |
break;
|
104 |
} |
105 |
case 'JBIG2Decode': { |
106 |
return self::decodeFilterJBIG2Decode($data); |
107 |
break;
|
108 |
} |
109 |
case 'DCTDecode': { |
110 |
return self::decodeFilterDCTDecode($data); |
111 |
break;
|
112 |
} |
113 |
case 'JPXDecode': { |
114 |
return self::decodeFilterJPXDecode($data); |
115 |
break;
|
116 |
} |
117 |
case 'Crypt': { |
118 |
return self::decodeFilterCrypt($data); |
119 |
break;
|
120 |
} |
121 |
default: {
|
122 |
return self::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 |
* @since 1.0.000 (2011-05-23)
|
136 |
* @public static
|
137 |
*/
|
138 |
public static 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 |
* @since 1.0.000 (2011-05-23)
|
148 |
* @public static
|
149 |
*/
|
150 |
public static function decodeFilterASCIIHexDecode($data) { |
151 |
// initialize 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 |
self::Error('decodeFilterASCIIHexDecode: invalid code'); |
171 |
} |
172 |
} |
173 |
// check for invalid characters
|
174 |
if (preg_match('/[^a-fA-F\d]/', $data) > 0) { |
175 |
self::Error('decodeFilterASCIIHexDecode: 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 |
* @since 1.0.000 (2011-05-23)
|
188 |
* @public static
|
189 |
*/
|
190 |
public static function decodeFilterASCII85Decode($data) { |
191 |
// initialize 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 |
self::Error('decodeFilterASCII85Decode: 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 |
self::Error('decodeFilterASCII85Decode: 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 |
self::Error('decodeFilterASCII85Decode: 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 |
* @since 1.0.000 (2011-05-23)
|
272 |
* @public static
|
273 |
*/
|
274 |
public static function decodeFilterLZWDecode($data) { |
275 |
// initialize 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 |
* @since 1.0.000 (2011-05-23)
|
353 |
* @public static
|
354 |
*/
|
355 |
public static function decodeFilterFlateDecode($data) { |
356 |
// initialize string to return
|
357 |
$decoded = @gzuncompress($data); |
358 |
if ($decoded === false) { |
359 |
self::Error('decodeFilterFlateDecode: 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 |
* @since 1.0.000 (2011-05-23)
|
369 |
* @public static
|
370 |
*/
|
371 |
public static function decodeFilterRunLengthDecode($data) { |
372 |
// initialize 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 - RETURN AN EXCEPTION)
|
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 |
* @since 1.0.000 (2011-05-23)
|
406 |
* @public static
|
407 |
*/
|
408 |
public static function decodeFilterCCITTFaxDecode($data) { |
409 |
self::Error('~decodeFilterCCITTFaxDecode: this method has not been yet implemented'); |
410 |
//return $data;
|
411 |
} |
412 |
|
413 |
/**
|
414 |
* JBIG2Decode (NOT IMPLEMETED - RETURN AN EXCEPTION)
|
415 |
* Decompresses data encoded using the JBIG2 standard, reproducing the original monochrome (1 bit per pixel) image data (or an approximation of that data).
|
416 |
* @param $data (string) Data to decode.
|
417 |
* @return Decoded data string.
|
418 |
* @since 1.0.000 (2011-05-23)
|
419 |
* @public static
|
420 |
*/
|
421 |
public static function decodeFilterJBIG2Decode($data) { |
422 |
self::Error('~decodeFilterJBIG2Decode: this method has not been yet implemented'); |
423 |
//return $data;
|
424 |
} |
425 |
|
426 |
/**
|
427 |
* DCTDecode (NOT IMPLEMETED - RETURN AN EXCEPTION)
|
428 |
* Decompresses data encoded using a DCT (discrete cosine transform) technique based on the JPEG standard, reproducing image sample data that approximates the original data.
|
429 |
* @param $data (string) Data to decode.
|
430 |
* @return Decoded data string.
|
431 |
* @since 1.0.000 (2011-05-23)
|
432 |
* @public static
|
433 |
*/
|
434 |
public static function decodeFilterDCTDecode($data) { |
435 |
self::Error('~decodeFilterDCTDecode: this method has not been yet implemented'); |
436 |
//return $data;
|
437 |
} |
438 |
|
439 |
/**
|
440 |
* JPXDecode (NOT IMPLEMETED - RETURN AN EXCEPTION)
|
441 |
* Decompresses data encoded using the wavelet-based JPEG2000 standard, reproducing the original image data.
|
442 |
* @param $data (string) Data to decode.
|
443 |
* @return Decoded data string.
|
444 |
* @since 1.0.000 (2011-05-23)
|
445 |
* @public static
|
446 |
*/
|
447 |
public static function decodeFilterJPXDecode($data) { |
448 |
self::Error('~decodeFilterJPXDecode: this method has not been yet implemented'); |
449 |
//return $data;
|
450 |
} |
451 |
|
452 |
/**
|
453 |
* Crypt (NOT IMPLEMETED - RETURN AN EXCEPTION)
|
454 |
* Decrypts data encrypted by a security handler, reproducing the data as it was before encryption.
|
455 |
* @param $data (string) Data to decode.
|
456 |
* @return Decoded data string.
|
457 |
* @since 1.0.000 (2011-05-23)
|
458 |
* @public static
|
459 |
*/
|
460 |
public static function decodeFilterCrypt($data) { |
461 |
self::Error('~decodeFilterCrypt: this method has not been yet implemented'); |
462 |
//return $data;
|
463 |
} |
464 |
|
465 |
// --- END FILTERS SECTION -------------------------------------------------
|
466 |
|
467 |
/**
|
468 |
* Throw an exception.
|
469 |
* @param $msg (string) The error message
|
470 |
* @since 1.0.000 (2011-05-23)
|
471 |
* @public static
|
472 |
*/
|
473 |
public static function Error($msg) { |
474 |
throw new Exception('TCPDF_PARSER ERROR: '.$msg); |
475 |
} |
476 |
|
477 |
} // END OF TCPDF_FILTERS CLASS
|
478 |
|
479 |
//============================================================+
|
480 |
// END OF FILE
|
481 |
//============================================================+
|