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