OLD | NEW |
| (Empty) |
1 // Copyright 2014 PDFium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com | |
6 | |
7 #include "core/fpdfapi/fpdf_parser/fpdf_parser_decode.h" | |
8 | |
9 #include <limits.h> | |
10 | |
11 #include <algorithm> | |
12 #include <utility> | |
13 #include <vector> | |
14 | |
15 #include "core/fpdfapi/cpdf_modulemgr.h" | |
16 #include "core/fpdfapi/fpdf_parser/cpdf_array.h" | |
17 #include "core/fpdfapi/fpdf_parser/cpdf_dictionary.h" | |
18 #include "core/fpdfapi/fpdf_parser/fpdf_parser_utility.h" | |
19 #include "core/fxcodec/fx_codec.h" | |
20 #include "core/fxcrt/fx_ext.h" | |
21 #include "third_party/base/stl_util.h" | |
22 | |
23 namespace { | |
24 | |
25 const uint32_t kMaxStreamSize = 20 * 1024 * 1024; | |
26 | |
27 bool CheckFlateDecodeParams(int Colors, int BitsPerComponent, int Columns) { | |
28 if (Colors < 0 || BitsPerComponent < 0 || Columns < 0) | |
29 return false; | |
30 | |
31 int check = Columns; | |
32 if (check > 0 && Colors > INT_MAX / check) | |
33 return false; | |
34 | |
35 check *= Colors; | |
36 if (check > 0 && BitsPerComponent > INT_MAX / check) | |
37 return false; | |
38 | |
39 return check * BitsPerComponent <= INT_MAX - 7; | |
40 } | |
41 | |
42 } // namespace | |
43 | |
44 const uint16_t PDFDocEncoding[256] = { | |
45 0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008, | |
46 0x0009, 0x000a, 0x000b, 0x000c, 0x000d, 0x000e, 0x000f, 0x0010, 0x0011, | |
47 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017, 0x02d8, 0x02c7, 0x02c6, | |
48 0x02d9, 0x02dd, 0x02db, 0x02da, 0x02dc, 0x0020, 0x0021, 0x0022, 0x0023, | |
49 0x0024, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029, 0x002a, 0x002b, 0x002c, | |
50 0x002d, 0x002e, 0x002f, 0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, | |
51 0x0036, 0x0037, 0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, | |
52 0x003f, 0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, | |
53 0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f, 0x0050, | |
54 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, | |
55 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f, 0x0060, 0x0061, 0x0062, | |
56 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006a, 0x006b, | |
57 0x006c, 0x006d, 0x006e, 0x006f, 0x0070, 0x0071, 0x0072, 0x0073, 0x0074, | |
58 0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007a, 0x007b, 0x007c, 0x007d, | |
59 0x007e, 0x0000, 0x2022, 0x2020, 0x2021, 0x2026, 0x2014, 0x2013, 0x0192, | |
60 0x2044, 0x2039, 0x203a, 0x2212, 0x2030, 0x201e, 0x201c, 0x201d, 0x2018, | |
61 0x2019, 0x201a, 0x2122, 0xfb01, 0xfb02, 0x0141, 0x0152, 0x0160, 0x0178, | |
62 0x017d, 0x0131, 0x0142, 0x0153, 0x0161, 0x017e, 0x0000, 0x20ac, 0x00a1, | |
63 0x00a2, 0x00a3, 0x00a4, 0x00a5, 0x00a6, 0x00a7, 0x00a8, 0x00a9, 0x00aa, | |
64 0x00ab, 0x00ac, 0x0000, 0x00ae, 0x00af, 0x00b0, 0x00b1, 0x00b2, 0x00b3, | |
65 0x00b4, 0x00b5, 0x00b6, 0x00b7, 0x00b8, 0x00b9, 0x00ba, 0x00bb, 0x00bc, | |
66 0x00bd, 0x00be, 0x00bf, 0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, | |
67 0x00c6, 0x00c7, 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce, | |
68 0x00cf, 0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7, | |
69 0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df, 0x00e0, | |
70 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x00e7, 0x00e8, 0x00e9, | |
71 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef, 0x00f0, 0x00f1, 0x00f2, | |
72 0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x00f7, 0x00f8, 0x00f9, 0x00fa, 0x00fb, | |
73 0x00fc, 0x00fd, 0x00fe, 0x00ff}; | |
74 | |
75 uint32_t A85Decode(const uint8_t* src_buf, | |
76 uint32_t src_size, | |
77 uint8_t*& dest_buf, | |
78 uint32_t& dest_size) { | |
79 dest_size = 0; | |
80 dest_buf = nullptr; | |
81 if (src_size == 0) | |
82 return 0; | |
83 | |
84 // Count legal characters and zeros. | |
85 uint32_t zcount = 0; | |
86 uint32_t pos = 0; | |
87 while (pos < src_size) { | |
88 uint8_t ch = src_buf[pos]; | |
89 if (ch == 'z') { | |
90 zcount++; | |
91 } else if ((ch < '!' || ch > 'u') && !PDFCharIsLineEnding(ch) && | |
92 ch != ' ' && ch != '\t') { | |
93 break; | |
94 } | |
95 pos++; | |
96 } | |
97 // No content to decode. | |
98 if (pos == 0) | |
99 return 0; | |
100 | |
101 // Count the space needed to contain non-zero characters. The encoding ratio | |
102 // of Ascii85 is 4:5. | |
103 uint32_t space_for_non_zeroes = (pos - zcount) / 5 * 4 + 4; | |
104 if (zcount > (UINT_MAX - space_for_non_zeroes) / 4) { | |
105 return (uint32_t)-1; | |
106 } | |
107 dest_buf = FX_Alloc(uint8_t, zcount * 4 + space_for_non_zeroes); | |
108 size_t state = 0; | |
109 uint32_t res = 0; | |
110 pos = dest_size = 0; | |
111 while (pos < src_size) { | |
112 uint8_t ch = src_buf[pos++]; | |
113 if (PDFCharIsLineEnding(ch) || ch == ' ' || ch == '\t') | |
114 continue; | |
115 | |
116 if (ch == 'z') { | |
117 FXSYS_memset(dest_buf + dest_size, 0, 4); | |
118 state = 0; | |
119 res = 0; | |
120 dest_size += 4; | |
121 } else if (ch >= '!' && ch <= 'u') { | |
122 res = res * 85 + ch - 33; | |
123 state++; | |
124 if (state == 5) { | |
125 for (size_t i = 0; i < 4; i++) { | |
126 dest_buf[dest_size++] = (uint8_t)(res >> (3 - i) * 8); | |
127 } | |
128 state = 0; | |
129 res = 0; | |
130 } | |
131 } else { | |
132 // The end or illegal character. | |
133 break; | |
134 } | |
135 } | |
136 // Handle partial group. | |
137 if (state) { | |
138 for (size_t i = state; i < 5; i++) | |
139 res = res * 85 + 84; | |
140 for (size_t i = 0; i < state - 1; i++) | |
141 dest_buf[dest_size++] = (uint8_t)(res >> (3 - i) * 8); | |
142 } | |
143 if (pos < src_size && src_buf[pos] == '>') | |
144 pos++; | |
145 return pos; | |
146 } | |
147 | |
148 uint32_t HexDecode(const uint8_t* src_buf, | |
149 uint32_t src_size, | |
150 uint8_t*& dest_buf, | |
151 uint32_t& dest_size) { | |
152 dest_size = 0; | |
153 if (src_size == 0) { | |
154 dest_buf = nullptr; | |
155 return 0; | |
156 } | |
157 | |
158 uint32_t i = 0; | |
159 // Find the end of data. | |
160 while (i < src_size && src_buf[i] != '>') | |
161 i++; | |
162 | |
163 dest_buf = FX_Alloc(uint8_t, i / 2 + 1); | |
164 bool bFirst = true; | |
165 for (i = 0; i < src_size; i++) { | |
166 uint8_t ch = src_buf[i]; | |
167 if (PDFCharIsLineEnding(ch) || ch == ' ' || ch == '\t') | |
168 continue; | |
169 | |
170 if (ch == '>') { | |
171 ++i; | |
172 break; | |
173 } | |
174 if (!std::isxdigit(ch)) | |
175 continue; | |
176 | |
177 int digit = FXSYS_toHexDigit(ch); | |
178 if (bFirst) | |
179 dest_buf[dest_size] = digit * 16; | |
180 else | |
181 dest_buf[dest_size++] += digit; | |
182 | |
183 bFirst = !bFirst; | |
184 } | |
185 if (!bFirst) | |
186 dest_size++; | |
187 return i; | |
188 } | |
189 | |
190 uint32_t RunLengthDecode(const uint8_t* src_buf, | |
191 uint32_t src_size, | |
192 uint8_t*& dest_buf, | |
193 uint32_t& dest_size) { | |
194 uint32_t i = 0; | |
195 dest_size = 0; | |
196 while (i < src_size) { | |
197 if (src_buf[i] == 128) | |
198 break; | |
199 | |
200 uint32_t old = dest_size; | |
201 if (src_buf[i] < 128) { | |
202 dest_size += src_buf[i] + 1; | |
203 if (dest_size < old) | |
204 return FX_INVALID_OFFSET; | |
205 i += src_buf[i] + 2; | |
206 } else { | |
207 dest_size += 257 - src_buf[i]; | |
208 if (dest_size < old) | |
209 return FX_INVALID_OFFSET; | |
210 i += 2; | |
211 } | |
212 } | |
213 if (dest_size >= kMaxStreamSize) | |
214 return FX_INVALID_OFFSET; | |
215 | |
216 dest_buf = FX_Alloc(uint8_t, dest_size); | |
217 i = 0; | |
218 int dest_count = 0; | |
219 while (i < src_size) { | |
220 if (src_buf[i] == 128) | |
221 break; | |
222 | |
223 if (src_buf[i] < 128) { | |
224 uint32_t copy_len = src_buf[i] + 1; | |
225 uint32_t buf_left = src_size - i - 1; | |
226 if (buf_left < copy_len) { | |
227 uint32_t delta = copy_len - buf_left; | |
228 copy_len = buf_left; | |
229 FXSYS_memset(dest_buf + dest_count + copy_len, '\0', delta); | |
230 } | |
231 FXSYS_memcpy(dest_buf + dest_count, src_buf + i + 1, copy_len); | |
232 dest_count += src_buf[i] + 1; | |
233 i += src_buf[i] + 2; | |
234 } else { | |
235 int fill = 0; | |
236 if (i < src_size - 1) { | |
237 fill = src_buf[i + 1]; | |
238 } | |
239 FXSYS_memset(dest_buf + dest_count, fill, 257 - src_buf[i]); | |
240 dest_count += 257 - src_buf[i]; | |
241 i += 2; | |
242 } | |
243 } | |
244 | |
245 return std::min(i + 1, src_size); | |
246 } | |
247 | |
248 CCodec_ScanlineDecoder* FPDFAPI_CreateFaxDecoder( | |
249 const uint8_t* src_buf, | |
250 uint32_t src_size, | |
251 int width, | |
252 int height, | |
253 const CPDF_Dictionary* pParams) { | |
254 int K = 0; | |
255 bool EndOfLine = false; | |
256 bool ByteAlign = false; | |
257 bool BlackIs1 = false; | |
258 int Columns = 1728; | |
259 int Rows = 0; | |
260 if (pParams) { | |
261 K = pParams->GetIntegerFor("K"); | |
262 EndOfLine = !!pParams->GetIntegerFor("EndOfLine"); | |
263 ByteAlign = !!pParams->GetIntegerFor("EncodedByteAlign"); | |
264 BlackIs1 = !!pParams->GetIntegerFor("BlackIs1"); | |
265 Columns = pParams->GetIntegerFor("Columns", 1728); | |
266 Rows = pParams->GetIntegerFor("Rows"); | |
267 if (Rows > USHRT_MAX) { | |
268 Rows = 0; | |
269 } | |
270 } | |
271 return CPDF_ModuleMgr::Get()->GetFaxModule()->CreateDecoder( | |
272 src_buf, src_size, width, height, K, EndOfLine, ByteAlign, BlackIs1, | |
273 Columns, Rows); | |
274 } | |
275 | |
276 CCodec_ScanlineDecoder* FPDFAPI_CreateFlateDecoder( | |
277 const uint8_t* src_buf, | |
278 uint32_t src_size, | |
279 int width, | |
280 int height, | |
281 int nComps, | |
282 int bpc, | |
283 const CPDF_Dictionary* pParams) { | |
284 int predictor = 0; | |
285 int Colors = 0, BitsPerComponent = 0, Columns = 0; | |
286 if (pParams) { | |
287 predictor = pParams->GetIntegerFor("Predictor"); | |
288 Colors = pParams->GetIntegerFor("Colors", 1); | |
289 BitsPerComponent = pParams->GetIntegerFor("BitsPerComponent", 8); | |
290 Columns = pParams->GetIntegerFor("Columns", 1); | |
291 if (!CheckFlateDecodeParams(Colors, BitsPerComponent, Columns)) { | |
292 return nullptr; | |
293 } | |
294 } | |
295 return CPDF_ModuleMgr::Get()->GetFlateModule()->CreateDecoder( | |
296 src_buf, src_size, width, height, nComps, bpc, predictor, Colors, | |
297 BitsPerComponent, Columns); | |
298 } | |
299 | |
300 uint32_t FPDFAPI_FlateOrLZWDecode(FX_BOOL bLZW, | |
301 const uint8_t* src_buf, | |
302 uint32_t src_size, | |
303 CPDF_Dictionary* pParams, | |
304 uint32_t estimated_size, | |
305 uint8_t*& dest_buf, | |
306 uint32_t& dest_size) { | |
307 int predictor = 0; | |
308 FX_BOOL bEarlyChange = TRUE; | |
309 int Colors = 0, BitsPerComponent = 0, Columns = 0; | |
310 if (pParams) { | |
311 predictor = pParams->GetIntegerFor("Predictor"); | |
312 bEarlyChange = pParams->GetIntegerFor("EarlyChange", 1); | |
313 Colors = pParams->GetIntegerFor("Colors", 1); | |
314 BitsPerComponent = pParams->GetIntegerFor("BitsPerComponent", 8); | |
315 Columns = pParams->GetIntegerFor("Columns", 1); | |
316 if (!CheckFlateDecodeParams(Colors, BitsPerComponent, Columns)) { | |
317 return (uint32_t)-1; | |
318 } | |
319 } | |
320 return CPDF_ModuleMgr::Get()->GetFlateModule()->FlateOrLZWDecode( | |
321 bLZW, src_buf, src_size, bEarlyChange, predictor, Colors, | |
322 BitsPerComponent, Columns, estimated_size, dest_buf, dest_size); | |
323 } | |
324 | |
325 FX_BOOL PDF_DataDecode(const uint8_t* src_buf, | |
326 uint32_t src_size, | |
327 const CPDF_Dictionary* pDict, | |
328 uint8_t*& dest_buf, | |
329 uint32_t& dest_size, | |
330 CFX_ByteString& ImageEncoding, | |
331 CPDF_Dictionary*& pImageParms, | |
332 uint32_t last_estimated_size, | |
333 FX_BOOL bImageAcc) { | |
334 CPDF_Object* pDecoder = pDict ? pDict->GetDirectObjectFor("Filter") : nullptr; | |
335 if (!pDecoder || (!pDecoder->IsArray() && !pDecoder->IsName())) | |
336 return FALSE; | |
337 | |
338 CPDF_Object* pParams = | |
339 pDict ? pDict->GetDirectObjectFor("DecodeParms") : nullptr; | |
340 | |
341 std::vector<std::pair<CFX_ByteString, CPDF_Object*>> DecoderArray; | |
342 if (CPDF_Array* pDecoders = pDecoder->AsArray()) { | |
343 CPDF_Array* pParamsArray = ToArray(pParams); | |
344 for (size_t i = 0; i < pDecoders->GetCount(); i++) { | |
345 DecoderArray.push_back( | |
346 {pDecoders->GetStringAt(i), | |
347 pParamsArray ? pParamsArray->GetDictAt(i) : nullptr}); | |
348 } | |
349 } else { | |
350 DecoderArray.push_back( | |
351 {pDecoder->GetString(), pParams ? pParams->GetDict() : nullptr}); | |
352 } | |
353 uint8_t* last_buf = const_cast<uint8_t*>(src_buf); | |
354 uint32_t last_size = src_size; | |
355 int nSize = pdfium::CollectionSize<int>(DecoderArray); | |
356 for (int i = 0; i < nSize; i++) { | |
357 int estimated_size = i == nSize - 1 ? last_estimated_size : 0; | |
358 CFX_ByteString decoder = DecoderArray[i].first; | |
359 CPDF_Dictionary* pParam = ToDictionary(DecoderArray[i].second); | |
360 uint8_t* new_buf = nullptr; | |
361 uint32_t new_size = (uint32_t)-1; | |
362 int offset = -1; | |
363 if (decoder == "FlateDecode" || decoder == "Fl") { | |
364 if (bImageAcc && i == nSize - 1) { | |
365 ImageEncoding = "FlateDecode"; | |
366 dest_buf = (uint8_t*)last_buf; | |
367 dest_size = last_size; | |
368 pImageParms = pParam; | |
369 return TRUE; | |
370 } | |
371 offset = FPDFAPI_FlateOrLZWDecode(FALSE, last_buf, last_size, pParam, | |
372 estimated_size, new_buf, new_size); | |
373 } else if (decoder == "LZWDecode" || decoder == "LZW") { | |
374 offset = FPDFAPI_FlateOrLZWDecode(TRUE, last_buf, last_size, pParam, | |
375 estimated_size, new_buf, new_size); | |
376 } else if (decoder == "ASCII85Decode" || decoder == "A85") { | |
377 offset = A85Decode(last_buf, last_size, new_buf, new_size); | |
378 } else if (decoder == "ASCIIHexDecode" || decoder == "AHx") { | |
379 offset = HexDecode(last_buf, last_size, new_buf, new_size); | |
380 } else if (decoder == "RunLengthDecode" || decoder == "RL") { | |
381 if (bImageAcc && i == nSize - 1) { | |
382 ImageEncoding = "RunLengthDecode"; | |
383 dest_buf = (uint8_t*)last_buf; | |
384 dest_size = last_size; | |
385 pImageParms = pParam; | |
386 return TRUE; | |
387 } | |
388 offset = RunLengthDecode(last_buf, last_size, new_buf, new_size); | |
389 } else if (decoder == "Crypt") { | |
390 continue; | |
391 } else { | |
392 // If we get here, assume it's an image decoder. | |
393 if (decoder == "DCT") { | |
394 decoder = "DCTDecode"; | |
395 } else if (decoder == "CCF") { | |
396 decoder = "CCITTFaxDecode"; | |
397 } | |
398 ImageEncoding = decoder; | |
399 pImageParms = pParam; | |
400 dest_buf = (uint8_t*)last_buf; | |
401 dest_size = last_size; | |
402 if (CPDF_Array* pDecoders = pDecoder->AsArray()) | |
403 pDecoders->RemoveAt(i + 1, pDecoders->GetCount() - i - 1); | |
404 return TRUE; | |
405 } | |
406 if (last_buf != src_buf) { | |
407 FX_Free(last_buf); | |
408 } | |
409 if (offset == -1) { | |
410 FX_Free(new_buf); | |
411 return FALSE; | |
412 } | |
413 last_buf = new_buf; | |
414 last_size = new_size; | |
415 } | |
416 ImageEncoding = ""; | |
417 pImageParms = nullptr; | |
418 dest_buf = last_buf; | |
419 dest_size = last_size; | |
420 return TRUE; | |
421 } | |
422 | |
423 CFX_WideString PDF_DecodeText(const uint8_t* src_data, uint32_t src_len) { | |
424 CFX_WideString result; | |
425 if (src_len >= 2 && ((src_data[0] == 0xfe && src_data[1] == 0xff) || | |
426 (src_data[0] == 0xff && src_data[1] == 0xfe))) { | |
427 bool bBE = src_data[0] == 0xfe; | |
428 uint32_t max_chars = (src_len - 2) / 2; | |
429 if (!max_chars) { | |
430 return result; | |
431 } | |
432 if (src_data[0] == 0xff) { | |
433 bBE = !src_data[2]; | |
434 } | |
435 FX_WCHAR* dest_buf = result.GetBuffer(max_chars); | |
436 const uint8_t* uni_str = src_data + 2; | |
437 int dest_pos = 0; | |
438 for (uint32_t i = 0; i < max_chars * 2; i += 2) { | |
439 uint16_t unicode = bBE ? (uni_str[i] << 8 | uni_str[i + 1]) | |
440 : (uni_str[i + 1] << 8 | uni_str[i]); | |
441 if (unicode == 0x1b) { | |
442 i += 2; | |
443 while (i < max_chars * 2) { | |
444 uint16_t unicode2 = bBE ? (uni_str[i] << 8 | uni_str[i + 1]) | |
445 : (uni_str[i + 1] << 8 | uni_str[i]); | |
446 i += 2; | |
447 if (unicode2 == 0x1b) | |
448 break; | |
449 } | |
450 } else { | |
451 dest_buf[dest_pos++] = unicode; | |
452 } | |
453 } | |
454 result.ReleaseBuffer(dest_pos); | |
455 } else { | |
456 FX_WCHAR* dest_buf = result.GetBuffer(src_len); | |
457 for (uint32_t i = 0; i < src_len; i++) | |
458 dest_buf[i] = PDFDocEncoding[src_data[i]]; | |
459 result.ReleaseBuffer(src_len); | |
460 } | |
461 return result; | |
462 } | |
463 | |
464 CFX_WideString PDF_DecodeText(const CFX_ByteString& bstr) { | |
465 return PDF_DecodeText((const uint8_t*)bstr.c_str(), bstr.GetLength()); | |
466 } | |
467 | |
468 CFX_ByteString PDF_EncodeText(const FX_WCHAR* pString, int len) { | |
469 if (len == -1) { | |
470 len = FXSYS_wcslen(pString); | |
471 } | |
472 CFX_ByteString result; | |
473 FX_CHAR* dest_buf1 = result.GetBuffer(len); | |
474 int i; | |
475 for (i = 0; i < len; i++) { | |
476 int code; | |
477 for (code = 0; code < 256; code++) | |
478 if (PDFDocEncoding[code] == pString[i]) { | |
479 break; | |
480 } | |
481 if (code == 256) { | |
482 break; | |
483 } | |
484 dest_buf1[i] = code; | |
485 } | |
486 result.ReleaseBuffer(i); | |
487 if (i == len) { | |
488 return result; | |
489 } | |
490 | |
491 if (len > INT_MAX / 2 - 1) { | |
492 result.ReleaseBuffer(0); | |
493 return result; | |
494 } | |
495 | |
496 int encLen = len * 2 + 2; | |
497 | |
498 uint8_t* dest_buf2 = (uint8_t*)result.GetBuffer(encLen); | |
499 dest_buf2[0] = 0xfe; | |
500 dest_buf2[1] = 0xff; | |
501 dest_buf2 += 2; | |
502 for (int j = 0; j < len; j++) { | |
503 *dest_buf2++ = pString[i] >> 8; | |
504 *dest_buf2++ = (uint8_t)pString[j]; | |
505 } | |
506 result.ReleaseBuffer(encLen); | |
507 return result; | |
508 } | |
509 | |
510 CFX_ByteString PDF_EncodeText(const CFX_WideString& str) { | |
511 return PDF_EncodeText(str.c_str(), str.GetLength()); | |
512 } | |
513 | |
514 CFX_ByteString PDF_EncodeString(const CFX_ByteString& src, FX_BOOL bHex) { | |
515 CFX_ByteTextBuf result; | |
516 int srclen = src.GetLength(); | |
517 if (bHex) { | |
518 result.AppendChar('<'); | |
519 for (int i = 0; i < srclen; i++) { | |
520 result.AppendChar("0123456789ABCDEF"[src[i] / 16]); | |
521 result.AppendChar("0123456789ABCDEF"[src[i] % 16]); | |
522 } | |
523 result.AppendChar('>'); | |
524 return result.MakeString(); | |
525 } | |
526 result.AppendChar('('); | |
527 for (int i = 0; i < srclen; i++) { | |
528 uint8_t ch = src[i]; | |
529 if (ch == 0x0a) { | |
530 result << "\\n"; | |
531 continue; | |
532 } | |
533 if (ch == 0x0d) { | |
534 result << "\\r"; | |
535 continue; | |
536 } | |
537 if (ch == ')' || ch == '\\' || ch == '(') | |
538 result.AppendChar('\\'); | |
539 result.AppendChar(ch); | |
540 } | |
541 result.AppendChar(')'); | |
542 return result.MakeString(); | |
543 } | |
544 | |
545 bool FlateEncode(const uint8_t* src_buf, | |
546 uint32_t src_size, | |
547 uint8_t** dest_buf, | |
548 uint32_t* dest_size) { | |
549 CCodec_ModuleMgr* pEncoders = CPDF_ModuleMgr::Get()->GetCodecModule(); | |
550 return pEncoders && | |
551 pEncoders->GetFlateModule()->Encode(src_buf, src_size, dest_buf, | |
552 dest_size); | |
553 } | |
554 | |
555 bool PngEncode(const uint8_t* src_buf, | |
556 uint32_t src_size, | |
557 uint8_t** dest_buf, | |
558 uint32_t* dest_size) { | |
559 CCodec_ModuleMgr* pEncoders = CPDF_ModuleMgr::Get()->GetCodecModule(); | |
560 return pEncoders && | |
561 pEncoders->GetFlateModule()->PngEncode(src_buf, src_size, dest_buf, | |
562 dest_size); | |
563 } | |
564 | |
565 uint32_t FlateDecode(const uint8_t* src_buf, | |
566 uint32_t src_size, | |
567 uint8_t*& dest_buf, | |
568 uint32_t& dest_size) { | |
569 CCodec_ModuleMgr* pEncoders = CPDF_ModuleMgr::Get()->GetCodecModule(); | |
570 if (pEncoders) { | |
571 return pEncoders->GetFlateModule()->FlateOrLZWDecode( | |
572 FALSE, src_buf, src_size, FALSE, 0, 0, 0, 0, 0, dest_buf, dest_size); | |
573 } | |
574 return 0; | |
575 } | |
OLD | NEW |