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