Revert "Cleanup some numeric code."
[pdfium.git] / core / src / fxcodec / codec / fx_codec_flate.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 "../../../../third_party/base/nonstd_unique_ptr.h"
8 #include "../../../../third_party/zlib_v128/zlib.h"
9 #include "../../../include/fxcodec/fx_codec.h"
10 #include "../../../include/fxcodec/fx_codec_flate.h"
11 #include "codec_int.h"
12
13 extern "C" {
14 static void* my_alloc_func(void* opaque,
15                            unsigned int items,
16                            unsigned int size) {
17   return FX_Alloc2D(uint8_t, items, size);
18 }
19 static void my_free_func(void* opaque, void* address) {
20   FX_Free(address);
21 }
22 static int FPDFAPI_FlateGetTotalOut(void* context) {
23   return ((z_stream*)context)->total_out;
24 }
25 static int FPDFAPI_FlateGetTotalIn(void* context) {
26   return ((z_stream*)context)->total_in;
27 }
28 static void FPDFAPI_FlateCompress(unsigned char* dest_buf,
29                                   unsigned long* dest_size,
30                                   const unsigned char* src_buf,
31                                   unsigned long src_size) {
32   compress(dest_buf, dest_size, src_buf, src_size);
33 }
34 void* FPDFAPI_FlateInit(void* (*alloc_func)(void*, unsigned int, unsigned int),
35                         void (*free_func)(void*, void*)) {
36   z_stream* p = (z_stream*)alloc_func(0, 1, sizeof(z_stream));
37   if (p == NULL) {
38     return NULL;
39   }
40   FXSYS_memset(p, 0, sizeof(z_stream));
41   p->zalloc = alloc_func;
42   p->zfree = free_func;
43   inflateInit(p);
44   return p;
45 }
46 void FPDFAPI_FlateInput(void* context,
47                         const unsigned char* src_buf,
48                         unsigned int src_size) {
49   ((z_stream*)context)->next_in = (unsigned char*)src_buf;
50   ((z_stream*)context)->avail_in = src_size;
51 }
52 int FPDFAPI_FlateOutput(void* context,
53                         unsigned char* dest_buf,
54                         unsigned int dest_size) {
55   ((z_stream*)context)->next_out = dest_buf;
56   ((z_stream*)context)->avail_out = dest_size;
57   unsigned int pre_pos = (unsigned int)FPDFAPI_FlateGetTotalOut(context);
58   int ret = inflate((z_stream*)context, Z_SYNC_FLUSH);
59   unsigned int post_pos = (unsigned int)FPDFAPI_FlateGetTotalOut(context);
60   unsigned int written = post_pos - pre_pos;
61   if (written < dest_size) {
62     FXSYS_memset(dest_buf + written, '\0', dest_size - written);
63   }
64   return ret;
65 }
66 int FPDFAPI_FlateGetAvailIn(void* context) {
67   return ((z_stream*)context)->avail_in;
68 }
69 int FPDFAPI_FlateGetAvailOut(void* context) {
70   return ((z_stream*)context)->avail_out;
71 }
72 void FPDFAPI_FlateEnd(void* context) {
73   inflateEnd((z_stream*)context);
74   ((z_stream*)context)->zfree(0, context);
75 }
76 }  // extern "C"
77
78 namespace {
79
80 class CLZWDecoder {
81  public:
82   int Decode(uint8_t* output,
83              FX_DWORD& outlen,
84              const uint8_t* input,
85              FX_DWORD& size,
86              FX_BOOL bEarlyChange);
87
88  private:
89   void AddCode(FX_DWORD prefix_code, uint8_t append_char);
90   void DecodeString(FX_DWORD code);
91
92   FX_DWORD m_InPos;
93   FX_DWORD m_OutPos;
94   uint8_t* m_pOutput;
95   const uint8_t* m_pInput;
96   FX_BOOL m_Early;
97   FX_DWORD m_CodeArray[5021];
98   FX_DWORD m_nCodes;
99   uint8_t m_DecodeStack[4000];
100   FX_DWORD m_StackLen;
101   int m_CodeLen;
102 };
103 void CLZWDecoder::AddCode(FX_DWORD prefix_code, uint8_t append_char) {
104   if (m_nCodes + m_Early == 4094) {
105     return;
106   }
107   m_CodeArray[m_nCodes++] = (prefix_code << 16) | append_char;
108   if (m_nCodes + m_Early == 512 - 258) {
109     m_CodeLen = 10;
110   } else if (m_nCodes + m_Early == 1024 - 258) {
111     m_CodeLen = 11;
112   } else if (m_nCodes + m_Early == 2048 - 258) {
113     m_CodeLen = 12;
114   }
115 }
116 void CLZWDecoder::DecodeString(FX_DWORD code) {
117   while (1) {
118     int index = code - 258;
119     if (index < 0 || index >= (int)m_nCodes) {
120       break;
121     }
122     FX_DWORD data = m_CodeArray[index];
123     if (m_StackLen >= sizeof(m_DecodeStack)) {
124       return;
125     }
126     m_DecodeStack[m_StackLen++] = (uint8_t)data;
127     code = data >> 16;
128   }
129   if (m_StackLen >= sizeof(m_DecodeStack)) {
130     return;
131   }
132   m_DecodeStack[m_StackLen++] = (uint8_t)code;
133 }
134 int CLZWDecoder::Decode(uint8_t* dest_buf,
135                         FX_DWORD& dest_size,
136                         const uint8_t* src_buf,
137                         FX_DWORD& src_size,
138                         FX_BOOL bEarlyChange) {
139   m_CodeLen = 9;
140   m_InPos = 0;
141   m_OutPos = 0;
142   m_pInput = src_buf;
143   m_pOutput = dest_buf;
144   m_Early = bEarlyChange ? 1 : 0;
145   m_nCodes = 0;
146   FX_DWORD old_code = (FX_DWORD)-1;
147   uint8_t last_char;
148   while (1) {
149     if (m_InPos + m_CodeLen > src_size * 8) {
150       break;
151     }
152     int byte_pos = m_InPos / 8;
153     int bit_pos = m_InPos % 8, bit_left = m_CodeLen;
154     FX_DWORD code = 0;
155     if (bit_pos) {
156       bit_left -= 8 - bit_pos;
157       code = (m_pInput[byte_pos++] & ((1 << (8 - bit_pos)) - 1)) << bit_left;
158     }
159     if (bit_left < 8) {
160       code |= m_pInput[byte_pos] >> (8 - bit_left);
161     } else {
162       bit_left -= 8;
163       code |= m_pInput[byte_pos++] << bit_left;
164       if (bit_left) {
165         code |= m_pInput[byte_pos] >> (8 - bit_left);
166       }
167     }
168     m_InPos += m_CodeLen;
169     if (code < 256) {
170       if (m_OutPos == dest_size) {
171         return -5;
172       }
173       if (m_pOutput) {
174         m_pOutput[m_OutPos] = (uint8_t)code;
175       }
176       m_OutPos++;
177       last_char = (uint8_t)code;
178       if (old_code != (FX_DWORD)-1) {
179         AddCode(old_code, last_char);
180       }
181       old_code = code;
182     } else if (code == 256) {
183       m_CodeLen = 9;
184       m_nCodes = 0;
185       old_code = (FX_DWORD)-1;
186     } else if (code == 257) {
187       break;
188     } else {
189       if (old_code == (FX_DWORD)-1) {
190         return 2;
191       }
192       m_StackLen = 0;
193       if (code >= m_nCodes + 258) {
194         if (m_StackLen < sizeof(m_DecodeStack)) {
195           m_DecodeStack[m_StackLen++] = last_char;
196         }
197         DecodeString(old_code);
198       } else {
199         DecodeString(code);
200       }
201       if (m_OutPos + m_StackLen > dest_size) {
202         return -5;
203       }
204       if (m_pOutput) {
205         for (FX_DWORD i = 0; i < m_StackLen; i++) {
206           m_pOutput[m_OutPos + i] = m_DecodeStack[m_StackLen - i - 1];
207         }
208       }
209       m_OutPos += m_StackLen;
210       last_char = m_DecodeStack[m_StackLen - 1];
211       if (old_code < 256) {
212         AddCode(old_code, last_char);
213       } else if (old_code - 258 >= m_nCodes) {
214         dest_size = m_OutPos;
215         src_size = (m_InPos + 7) / 8;
216         return 0;
217       } else {
218         AddCode(old_code, last_char);
219       }
220       old_code = code;
221     }
222   }
223   dest_size = m_OutPos;
224   src_size = (m_InPos + 7) / 8;
225   return 0;
226 }
227
228 uint8_t PaethPredictor(int a, int b, int c) {
229   int p = a + b - c;
230   int pa = FXSYS_abs(p - a);
231   int pb = FXSYS_abs(p - b);
232   int pc = FXSYS_abs(p - c);
233   if (pa <= pb && pa <= pc) {
234     return (uint8_t)a;
235   }
236   if (pb <= pc) {
237     return (uint8_t)b;
238   }
239   return (uint8_t)c;
240 }
241
242 FX_BOOL PNG_PredictorEncode(uint8_t*& data_buf,
243                             FX_DWORD& data_size,
244                             int predictor,
245                             int Colors,
246                             int BitsPerComponent,
247                             int Columns) {
248   const int BytesPerPixel = (Colors * BitsPerComponent + 7) / 8;
249   const int row_size = (Colors * BitsPerComponent * Columns + 7) / 8;
250   if (row_size <= 0)
251     return FALSE;
252   const int row_count = (data_size + row_size - 1) / row_size;
253   const int last_row_size = data_size % row_size;
254   uint8_t* dest_buf = FX_Alloc2D(uint8_t, row_size + 1, row_count);
255   int byte_cnt = 0;
256   uint8_t* pSrcData = data_buf;
257   uint8_t* pDestData = dest_buf;
258   for (int row = 0; row < row_count; row++) {
259     if (predictor == 10) {
260       pDestData[0] = 0;
261       int move_size = row_size;
262       if (move_size * (row + 1) > (int)data_size) {
263         move_size = data_size - (move_size * row);
264       }
265       FXSYS_memmove(pDestData + 1, pSrcData, move_size);
266       pDestData += (move_size + 1);
267       pSrcData += move_size;
268       byte_cnt += move_size;
269       continue;
270     }
271     for (int byte = 0; byte < row_size && byte_cnt < (int)data_size; byte++) {
272       switch (predictor) {
273         case 11: {
274           pDestData[0] = 1;
275           uint8_t left = 0;
276           if (byte >= BytesPerPixel) {
277             left = pSrcData[byte - BytesPerPixel];
278           }
279           pDestData[byte + 1] = pSrcData[byte] - left;
280         } break;
281         case 12: {
282           pDestData[0] = 2;
283           uint8_t up = 0;
284           if (row) {
285             up = pSrcData[byte - row_size];
286           }
287           pDestData[byte + 1] = pSrcData[byte] - up;
288         } break;
289         case 13: {
290           pDestData[0] = 3;
291           uint8_t left = 0;
292           if (byte >= BytesPerPixel) {
293             left = pSrcData[byte - BytesPerPixel];
294           }
295           uint8_t up = 0;
296           if (row) {
297             up = pSrcData[byte - row_size];
298           }
299           pDestData[byte + 1] = pSrcData[byte] - (left + up) / 2;
300         } break;
301         case 14: {
302           pDestData[0] = 4;
303           uint8_t left = 0;
304           if (byte >= BytesPerPixel) {
305             left = pSrcData[byte - BytesPerPixel];
306           }
307           uint8_t up = 0;
308           if (row) {
309             up = pSrcData[byte - row_size];
310           }
311           uint8_t upper_left = 0;
312           if (byte >= BytesPerPixel && row) {
313             upper_left = pSrcData[byte - row_size - BytesPerPixel];
314           }
315           pDestData[byte + 1] =
316               pSrcData[byte] - PaethPredictor(left, up, upper_left);
317         } break;
318         default: { pDestData[byte + 1] = pSrcData[byte]; } break;
319       }
320       byte_cnt++;
321     }
322     pDestData += (row_size + 1);
323     pSrcData += row_size;
324   }
325   FX_Free(data_buf);
326   data_buf = dest_buf;
327   data_size = (row_size + 1) * row_count -
328               (last_row_size > 0 ? (row_size - last_row_size) : 0);
329   return TRUE;
330 }
331
332 void PNG_PredictLine(uint8_t* pDestData,
333                      const uint8_t* pSrcData,
334                      const uint8_t* pLastLine,
335                      int bpc,
336                      int nColors,
337                      int nPixels) {
338   int row_size = (nPixels * bpc * nColors + 7) / 8;
339   int BytesPerPixel = (bpc * nColors + 7) / 8;
340   uint8_t tag = pSrcData[0];
341   if (tag == 0) {
342     FXSYS_memmove(pDestData, pSrcData + 1, row_size);
343     return;
344   }
345   for (int byte = 0; byte < row_size; byte++) {
346     uint8_t raw_byte = pSrcData[byte + 1];
347     switch (tag) {
348       case 1: {
349         uint8_t left = 0;
350         if (byte >= BytesPerPixel) {
351           left = pDestData[byte - BytesPerPixel];
352         }
353         pDestData[byte] = raw_byte + left;
354         break;
355       }
356       case 2: {
357         uint8_t up = 0;
358         if (pLastLine) {
359           up = pLastLine[byte];
360         }
361         pDestData[byte] = raw_byte + up;
362         break;
363       }
364       case 3: {
365         uint8_t left = 0;
366         if (byte >= BytesPerPixel) {
367           left = pDestData[byte - BytesPerPixel];
368         }
369         uint8_t up = 0;
370         if (pLastLine) {
371           up = pLastLine[byte];
372         }
373         pDestData[byte] = raw_byte + (up + left) / 2;
374         break;
375       }
376       case 4: {
377         uint8_t left = 0;
378         if (byte >= BytesPerPixel) {
379           left = pDestData[byte - BytesPerPixel];
380         }
381         uint8_t up = 0;
382         if (pLastLine) {
383           up = pLastLine[byte];
384         }
385         uint8_t upper_left = 0;
386         if (byte >= BytesPerPixel && pLastLine) {
387           upper_left = pLastLine[byte - BytesPerPixel];
388         }
389         pDestData[byte] = raw_byte + PaethPredictor(left, up, upper_left);
390         break;
391       }
392       default:
393         pDestData[byte] = raw_byte;
394         break;
395     }
396   }
397 }
398
399 FX_BOOL PNG_Predictor(uint8_t*& data_buf,
400                       FX_DWORD& data_size,
401                       int Colors,
402                       int BitsPerComponent,
403                       int Columns) {
404   const int BytesPerPixel = (Colors * BitsPerComponent + 7) / 8;
405   const int row_size = (Colors * BitsPerComponent * Columns + 7) / 8;
406   if (row_size <= 0)
407     return FALSE;
408   const int row_count = (data_size + row_size) / (row_size + 1);
409   if (row_count <= 0)
410     return FALSE;
411   const int last_row_size = data_size % (row_size + 1);
412   uint8_t* dest_buf = FX_Alloc2D(uint8_t, row_size, row_count);
413   int byte_cnt = 0;
414   uint8_t* pSrcData = data_buf;
415   uint8_t* pDestData = dest_buf;
416   for (int row = 0; row < row_count; row++) {
417     uint8_t tag = pSrcData[0];
418     byte_cnt++;
419     if (tag == 0) {
420       int move_size = row_size;
421       if ((row + 1) * (move_size + 1) > (int)data_size) {
422         move_size = last_row_size - 1;
423       }
424       FXSYS_memmove(pDestData, pSrcData + 1, move_size);
425       pSrcData += move_size + 1;
426       pDestData += move_size;
427       byte_cnt += move_size;
428       continue;
429     }
430     for (int byte = 0; byte < row_size && byte_cnt < (int)data_size; byte++) {
431       uint8_t raw_byte = pSrcData[byte + 1];
432       switch (tag) {
433         case 1: {
434           uint8_t left = 0;
435           if (byte >= BytesPerPixel) {
436             left = pDestData[byte - BytesPerPixel];
437           }
438           pDestData[byte] = raw_byte + left;
439           break;
440         }
441         case 2: {
442           uint8_t up = 0;
443           if (row) {
444             up = pDestData[byte - row_size];
445           }
446           pDestData[byte] = raw_byte + up;
447           break;
448         }
449         case 3: {
450           uint8_t left = 0;
451           if (byte >= BytesPerPixel) {
452             left = pDestData[byte - BytesPerPixel];
453           }
454           uint8_t up = 0;
455           if (row) {
456             up = pDestData[byte - row_size];
457           }
458           pDestData[byte] = raw_byte + (up + left) / 2;
459           break;
460         }
461         case 4: {
462           uint8_t left = 0;
463           if (byte >= BytesPerPixel) {
464             left = pDestData[byte - BytesPerPixel];
465           }
466           uint8_t up = 0;
467           if (row) {
468             up = pDestData[byte - row_size];
469           }
470           uint8_t upper_left = 0;
471           if (byte >= BytesPerPixel && row) {
472             upper_left = pDestData[byte - row_size - BytesPerPixel];
473           }
474           pDestData[byte] = raw_byte + PaethPredictor(left, up, upper_left);
475           break;
476         }
477         default:
478           pDestData[byte] = raw_byte;
479           break;
480       }
481       byte_cnt++;
482     }
483     pSrcData += row_size + 1;
484     pDestData += row_size;
485   }
486   FX_Free(data_buf);
487   data_buf = dest_buf;
488   data_size = row_size * row_count -
489               (last_row_size > 0 ? (row_size + 1 - last_row_size) : 0);
490   return TRUE;
491 }
492
493 void TIFF_PredictorEncodeLine(uint8_t* dest_buf,
494                               int row_size,
495                               int BitsPerComponent,
496                               int Colors,
497                               int Columns) {
498   int BytesPerPixel = BitsPerComponent * Colors / 8;
499   if (BitsPerComponent < 8) {
500     uint8_t mask = 0x01;
501     if (BitsPerComponent == 2) {
502       mask = 0x03;
503     } else if (BitsPerComponent == 4) {
504       mask = 0x0F;
505     }
506     int row_bits = Colors * BitsPerComponent * Columns;
507     for (int i = row_bits - BitsPerComponent; i >= BitsPerComponent;
508          i -= BitsPerComponent) {
509       int col = i % 8;
510       int index = i / 8;
511       int col_pre =
512           (col == 0) ? (8 - BitsPerComponent) : (col - BitsPerComponent);
513       int index_pre = (col == 0) ? (index - 1) : index;
514       uint8_t cur = (dest_buf[index] >> (8 - col - BitsPerComponent)) & mask;
515       uint8_t left =
516           (dest_buf[index_pre] >> (8 - col_pre - BitsPerComponent)) & mask;
517       cur -= left;
518       cur &= mask;
519       cur <<= (8 - col - BitsPerComponent);
520       dest_buf[index] &= ~(mask << ((8 - col - BitsPerComponent)));
521       dest_buf[index] |= cur;
522     }
523   } else if (BitsPerComponent == 8) {
524     for (int i = row_size - 1; i >= BytesPerPixel; i--) {
525       dest_buf[i] -= dest_buf[i - BytesPerPixel];
526     }
527   } else {
528     for (int i = row_size - BytesPerPixel; i >= BytesPerPixel;
529          i -= BytesPerPixel) {
530       FX_WORD pixel = (dest_buf[i] << 8) | dest_buf[i + 1];
531       pixel -=
532           (dest_buf[i - BytesPerPixel] << 8) | dest_buf[i - BytesPerPixel + 1];
533       dest_buf[i] = pixel >> 8;
534       dest_buf[i + 1] = (uint8_t)pixel;
535     }
536   }
537 }
538
539 FX_BOOL TIFF_PredictorEncode(uint8_t*& data_buf,
540                              FX_DWORD& data_size,
541                              int Colors,
542                              int BitsPerComponent,
543                              int Columns) {
544   int row_size = (Colors * BitsPerComponent * Columns + 7) / 8;
545   if (row_size == 0)
546     return FALSE;
547   const int row_count = (data_size + row_size - 1) / row_size;
548   const int last_row_size = data_size % row_size;
549   for (int row = 0; row < row_count; row++) {
550     uint8_t* scan_line = data_buf + row * row_size;
551     if ((row + 1) * row_size > (int)data_size) {
552       row_size = last_row_size;
553     }
554     TIFF_PredictorEncodeLine(scan_line, row_size, BitsPerComponent, Colors,
555                              Columns);
556   }
557   return TRUE;
558 }
559
560 void TIFF_PredictLine(uint8_t* dest_buf,
561                       int row_size,
562                       int BitsPerComponent,
563                       int Colors,
564                       int Columns) {
565   if (BitsPerComponent == 1) {
566     int row_bits = FX_MIN(BitsPerComponent * Colors * Columns, row_size * 8);
567     int index_pre = 0;
568     int col_pre = 0;
569     for (int i = 1; i < row_bits; i++) {
570       int col = i % 8;
571       int index = i / 8;
572       if (((dest_buf[index] >> (7 - col)) & 1) ^
573           ((dest_buf[index_pre] >> (7 - col_pre)) & 1)) {
574         dest_buf[index] |= 1 << (7 - col);
575       } else {
576         dest_buf[index] &= ~(1 << (7 - col));
577       }
578       index_pre = index;
579       col_pre = col;
580     }
581     return;
582   }
583   int BytesPerPixel = BitsPerComponent * Colors / 8;
584   if (BitsPerComponent == 16) {
585     for (int i = BytesPerPixel; i < row_size; i += 2) {
586       FX_WORD pixel =
587           (dest_buf[i - BytesPerPixel] << 8) | dest_buf[i - BytesPerPixel + 1];
588       pixel += (dest_buf[i] << 8) | dest_buf[i + 1];
589       dest_buf[i] = pixel >> 8;
590       dest_buf[i + 1] = (uint8_t)pixel;
591     }
592   } else {
593     for (int i = BytesPerPixel; i < row_size; i++) {
594       dest_buf[i] += dest_buf[i - BytesPerPixel];
595     }
596   }
597 }
598
599 FX_BOOL TIFF_Predictor(uint8_t*& data_buf,
600                        FX_DWORD& data_size,
601                        int Colors,
602                        int BitsPerComponent,
603                        int Columns) {
604   int row_size = (Colors * BitsPerComponent * Columns + 7) / 8;
605   if (row_size == 0)
606     return FALSE;
607   const int row_count = (data_size + row_size - 1) / row_size;
608   const int last_row_size = data_size % row_size;
609   for (int row = 0; row < row_count; row++) {
610     uint8_t* scan_line = data_buf + row * row_size;
611     if ((row + 1) * row_size > (int)data_size) {
612       row_size = last_row_size;
613     }
614     TIFF_PredictLine(scan_line, row_size, BitsPerComponent, Colors, Columns);
615   }
616   return TRUE;
617 }
618
619 void FlateUncompress(const uint8_t* src_buf,
620                      FX_DWORD src_size,
621                      FX_DWORD orig_size,
622                      uint8_t*& dest_buf,
623                      FX_DWORD& dest_size,
624                      FX_DWORD& offset) {
625   FX_DWORD guess_size = orig_size ? orig_size : src_size * 2;
626   const FX_DWORD kStepSize = 10240;
627   FX_DWORD alloc_step = orig_size ? kStepSize : std::min(src_size, kStepSize);
628   static const FX_DWORD kMaxInitialAllocSize = 10000000;
629   if (guess_size > kMaxInitialAllocSize) {
630     guess_size = kMaxInitialAllocSize;
631     alloc_step = kMaxInitialAllocSize;
632   }
633   FX_DWORD buf_size = guess_size;
634   FX_DWORD last_buf_size = buf_size;
635
636   dest_buf = nullptr;
637   dest_size = 0;
638   void* context = FPDFAPI_FlateInit(my_alloc_func, my_free_func);
639   if (!context)
640     return;
641
642   nonstd::unique_ptr<uint8_t, FxFreeDeleter> guess_buf(
643       FX_Alloc(uint8_t, guess_size + 1));
644   guess_buf.get()[guess_size] = '\0';
645
646   FPDFAPI_FlateInput(context, src_buf, src_size);
647
648   if (src_size < kStepSize) {
649     // This is the old implementation.
650     uint8_t* cur_buf = guess_buf.get();
651     while (1) {
652       int32_t ret = FPDFAPI_FlateOutput(context, cur_buf, buf_size);
653       if (ret != Z_OK)
654         break;
655       int32_t avail_buf_size = FPDFAPI_FlateGetAvailOut(context);
656       if (avail_buf_size != 0)
657         break;
658
659       FX_DWORD old_size = guess_size;
660       guess_size += alloc_step;
661       if (guess_size < old_size || guess_size + 1 < guess_size) {
662         FPDFAPI_FlateEnd(context);
663         return;
664       }
665
666       {
667         uint8_t* new_buf =
668             FX_Realloc(uint8_t, guess_buf.release(), guess_size + 1);
669         guess_buf.reset(new_buf);
670       }
671       guess_buf.get()[guess_size] = '\0';
672       cur_buf = guess_buf.get() + old_size;
673       buf_size = guess_size - old_size;
674     }
675     dest_size = FPDFAPI_FlateGetTotalOut(context);
676     offset = FPDFAPI_FlateGetTotalIn(context);
677     if (guess_size / 2 > dest_size) {
678       {
679         uint8_t* new_buf =
680             FX_Realloc(uint8_t, guess_buf.release(), dest_size + 1);
681         guess_buf.reset(new_buf);
682       }
683       guess_size = dest_size;
684       guess_buf.get()[guess_size] = '\0';
685     }
686     dest_buf = guess_buf.release();
687   } else {
688     CFX_ArrayTemplate<uint8_t*> result_tmp_bufs;
689     uint8_t* cur_buf = guess_buf.release();
690     while (1) {
691       int32_t ret = FPDFAPI_FlateOutput(context, cur_buf, buf_size);
692       int32_t avail_buf_size = FPDFAPI_FlateGetAvailOut(context);
693       if (ret != Z_OK) {
694         last_buf_size = buf_size - avail_buf_size;
695         result_tmp_bufs.Add(cur_buf);
696         break;
697       }
698       if (avail_buf_size != 0) {
699         last_buf_size = buf_size - avail_buf_size;
700         result_tmp_bufs.Add(cur_buf);
701         break;
702       }
703
704       result_tmp_bufs.Add(cur_buf);
705       cur_buf = FX_Alloc(uint8_t, buf_size + 1);
706       cur_buf[buf_size] = '\0';
707     }
708     dest_size = FPDFAPI_FlateGetTotalOut(context);
709     offset = FPDFAPI_FlateGetTotalIn(context);
710     if (result_tmp_bufs.GetSize() == 1) {
711       dest_buf = result_tmp_bufs[0];
712     } else {
713       uint8_t* result_buf = FX_Alloc(uint8_t, dest_size);
714       FX_DWORD result_pos = 0;
715       for (int32_t i = 0; i < result_tmp_bufs.GetSize(); i++) {
716         uint8_t* tmp_buf = result_tmp_bufs[i];
717         FX_DWORD tmp_buf_size = buf_size;
718         if (i == result_tmp_bufs.GetSize() - 1) {
719           tmp_buf_size = last_buf_size;
720         }
721         FXSYS_memcpy(result_buf + result_pos, tmp_buf, tmp_buf_size);
722         result_pos += tmp_buf_size;
723         FX_Free(result_tmp_bufs[i]);
724       }
725       dest_buf = result_buf;
726     }
727   }
728   FPDFAPI_FlateEnd(context);
729 }
730
731 }  // namespace
732
733 class CCodec_FlateScanlineDecoder : public CCodec_ScanlineDecoder {
734  public:
735   CCodec_FlateScanlineDecoder();
736   ~CCodec_FlateScanlineDecoder() override;
737
738   void Create(const uint8_t* src_buf,
739               FX_DWORD src_size,
740               int width,
741               int height,
742               int nComps,
743               int bpc,
744               int predictor,
745               int Colors,
746               int BitsPerComponent,
747               int Columns);
748   void Destroy() { delete this; }
749
750   // CCodec_ScanlineDecoder
751   void v_DownScale(int dest_width, int dest_height) override {}
752   FX_BOOL v_Rewind() override;
753   uint8_t* v_GetNextLine() override;
754   FX_DWORD GetSrcOffset() override;
755
756   void* m_pFlate;
757   const uint8_t* m_SrcBuf;
758   FX_DWORD m_SrcSize;
759   uint8_t* m_pScanline;
760   uint8_t* m_pLastLine;
761   uint8_t* m_pPredictBuffer;
762   uint8_t* m_pPredictRaw;
763   int m_Predictor;
764   int m_Colors, m_BitsPerComponent, m_Columns, m_PredictPitch, m_LeftOver;
765 };
766
767 CCodec_FlateScanlineDecoder::CCodec_FlateScanlineDecoder() {
768   m_pFlate = NULL;
769   m_pScanline = NULL;
770   m_pLastLine = NULL;
771   m_pPredictBuffer = NULL;
772   m_pPredictRaw = NULL;
773   m_LeftOver = 0;
774 }
775 CCodec_FlateScanlineDecoder::~CCodec_FlateScanlineDecoder() {
776   FX_Free(m_pScanline);
777   FX_Free(m_pLastLine);
778   FX_Free(m_pPredictBuffer);
779   FX_Free(m_pPredictRaw);
780   if (m_pFlate) {
781     FPDFAPI_FlateEnd(m_pFlate);
782   }
783 }
784 void CCodec_FlateScanlineDecoder::Create(const uint8_t* src_buf,
785                                          FX_DWORD src_size,
786                                          int width,
787                                          int height,
788                                          int nComps,
789                                          int bpc,
790                                          int predictor,
791                                          int Colors,
792                                          int BitsPerComponent,
793                                          int Columns) {
794   m_SrcBuf = src_buf;
795   m_SrcSize = src_size;
796   m_OutputWidth = m_OrigWidth = width;
797   m_OutputHeight = m_OrigHeight = height;
798   m_nComps = nComps;
799   m_bpc = bpc;
800   m_bColorTransformed = FALSE;
801   m_Pitch = (width * nComps * bpc + 7) / 8;
802   m_pScanline = FX_Alloc(uint8_t, m_Pitch);
803   m_Predictor = 0;
804   if (predictor) {
805     if (predictor >= 10) {
806       m_Predictor = 2;
807     } else if (predictor == 2) {
808       m_Predictor = 1;
809     }
810     if (m_Predictor) {
811       if (BitsPerComponent * Colors * Columns == 0) {
812         BitsPerComponent = m_bpc;
813         Colors = m_nComps;
814         Columns = m_OrigWidth;
815       }
816       m_Colors = Colors;
817       m_BitsPerComponent = BitsPerComponent;
818       m_Columns = Columns;
819       m_PredictPitch = (m_BitsPerComponent * m_Colors * m_Columns + 7) / 8;
820       m_pLastLine = FX_Alloc(uint8_t, m_PredictPitch);
821       m_pPredictRaw = FX_Alloc(uint8_t, m_PredictPitch + 1);
822       m_pPredictBuffer = FX_Alloc(uint8_t, m_PredictPitch);
823     }
824   }
825 }
826 FX_BOOL CCodec_FlateScanlineDecoder::v_Rewind() {
827   if (m_pFlate) {
828     FPDFAPI_FlateEnd(m_pFlate);
829   }
830   m_pFlate = FPDFAPI_FlateInit(my_alloc_func, my_free_func);
831   if (m_pFlate == NULL) {
832     return FALSE;
833   }
834   FPDFAPI_FlateInput(m_pFlate, m_SrcBuf, m_SrcSize);
835   m_LeftOver = 0;
836   return TRUE;
837 }
838 uint8_t* CCodec_FlateScanlineDecoder::v_GetNextLine() {
839   if (m_Predictor) {
840     if (m_Pitch == m_PredictPitch) {
841       if (m_Predictor == 2) {
842         FPDFAPI_FlateOutput(m_pFlate, m_pPredictRaw, m_PredictPitch + 1);
843         PNG_PredictLine(m_pScanline, m_pPredictRaw, m_pLastLine,
844                         m_BitsPerComponent, m_Colors, m_Columns);
845         FXSYS_memcpy(m_pLastLine, m_pScanline, m_PredictPitch);
846       } else {
847         FPDFAPI_FlateOutput(m_pFlate, m_pScanline, m_Pitch);
848         TIFF_PredictLine(m_pScanline, m_PredictPitch, m_bpc, m_nComps,
849                          m_OutputWidth);
850       }
851     } else {
852       int bytes_to_go = m_Pitch;
853       int read_leftover = m_LeftOver > bytes_to_go ? bytes_to_go : m_LeftOver;
854       if (read_leftover) {
855         FXSYS_memcpy(m_pScanline,
856                      m_pPredictBuffer + m_PredictPitch - m_LeftOver,
857                      read_leftover);
858         m_LeftOver -= read_leftover;
859         bytes_to_go -= read_leftover;
860       }
861       while (bytes_to_go) {
862         if (m_Predictor == 2) {
863           FPDFAPI_FlateOutput(m_pFlate, m_pPredictRaw, m_PredictPitch + 1);
864           PNG_PredictLine(m_pPredictBuffer, m_pPredictRaw, m_pLastLine,
865                           m_BitsPerComponent, m_Colors, m_Columns);
866           FXSYS_memcpy(m_pLastLine, m_pPredictBuffer, m_PredictPitch);
867         } else {
868           FPDFAPI_FlateOutput(m_pFlate, m_pPredictBuffer, m_PredictPitch);
869           TIFF_PredictLine(m_pPredictBuffer, m_PredictPitch, m_BitsPerComponent,
870                            m_Colors, m_Columns);
871         }
872         int read_bytes =
873             m_PredictPitch > bytes_to_go ? bytes_to_go : m_PredictPitch;
874         FXSYS_memcpy(m_pScanline + m_Pitch - bytes_to_go, m_pPredictBuffer,
875                      read_bytes);
876         m_LeftOver += m_PredictPitch - read_bytes;
877         bytes_to_go -= read_bytes;
878       }
879     }
880   } else {
881     FPDFAPI_FlateOutput(m_pFlate, m_pScanline, m_Pitch);
882   }
883   return m_pScanline;
884 }
885 FX_DWORD CCodec_FlateScanlineDecoder::GetSrcOffset() {
886   return FPDFAPI_FlateGetTotalIn(m_pFlate);
887 }
888
889 ICodec_ScanlineDecoder* CCodec_FlateModule::CreateDecoder(
890     const uint8_t* src_buf,
891     FX_DWORD src_size,
892     int width,
893     int height,
894     int nComps,
895     int bpc,
896     int predictor,
897     int Colors,
898     int BitsPerComponent,
899     int Columns) {
900   CCodec_FlateScanlineDecoder* pDecoder = new CCodec_FlateScanlineDecoder;
901   pDecoder->Create(src_buf, src_size, width, height, nComps, bpc, predictor,
902                    Colors, BitsPerComponent, Columns);
903   return pDecoder;
904 }
905 FX_DWORD CCodec_FlateModule::FlateOrLZWDecode(FX_BOOL bLZW,
906                                               const uint8_t* src_buf,
907                                               FX_DWORD src_size,
908                                               FX_BOOL bEarlyChange,
909                                               int predictor,
910                                               int Colors,
911                                               int BitsPerComponent,
912                                               int Columns,
913                                               FX_DWORD estimated_size,
914                                               uint8_t*& dest_buf,
915                                               FX_DWORD& dest_size) {
916   dest_buf = NULL;
917   FX_DWORD offset = 0;
918   int predictor_type = 0;
919   if (predictor) {
920     if (predictor >= 10) {
921       predictor_type = 2;
922     } else if (predictor == 2) {
923       predictor_type = 1;
924     }
925   }
926   if (bLZW) {
927     {
928       nonstd::unique_ptr<CLZWDecoder> decoder(new CLZWDecoder);
929       dest_size = (FX_DWORD)-1;
930       offset = src_size;
931       int err = decoder->Decode(NULL, dest_size, src_buf, offset, bEarlyChange);
932       if (err || dest_size == 0 || dest_size + 1 < dest_size) {
933         return -1;
934       }
935     }
936     {
937       nonstd::unique_ptr<CLZWDecoder> decoder(new CLZWDecoder);
938       dest_buf = FX_Alloc(uint8_t, dest_size + 1);
939       dest_buf[dest_size] = '\0';
940       decoder->Decode(dest_buf, dest_size, src_buf, offset, bEarlyChange);
941     }
942   } else {
943     FlateUncompress(src_buf, src_size, estimated_size, dest_buf, dest_size,
944                     offset);
945   }
946   if (predictor_type == 0) {
947     return offset;
948   }
949   FX_BOOL ret = TRUE;
950   if (predictor_type == 2) {
951     ret = PNG_Predictor(dest_buf, dest_size, Colors, BitsPerComponent, Columns);
952   } else if (predictor_type == 1) {
953     ret =
954         TIFF_Predictor(dest_buf, dest_size, Colors, BitsPerComponent, Columns);
955   }
956   return ret ? offset : -1;
957 }
958 FX_BOOL CCodec_FlateModule::Encode(const uint8_t* src_buf,
959                                    FX_DWORD src_size,
960                                    int predictor,
961                                    int Colors,
962                                    int BitsPerComponent,
963                                    int Columns,
964                                    uint8_t*& dest_buf,
965                                    FX_DWORD& dest_size) {
966   if (predictor != 2 && predictor < 10) {
967     return Encode(src_buf, src_size, dest_buf, dest_size);
968   }
969   uint8_t* pSrcBuf = NULL;
970   pSrcBuf = FX_Alloc(uint8_t, src_size);
971   FXSYS_memcpy(pSrcBuf, src_buf, src_size);
972   FX_BOOL ret = TRUE;
973   if (predictor == 2) {
974     ret = TIFF_PredictorEncode(pSrcBuf, src_size, Colors, BitsPerComponent,
975                                Columns);
976   } else if (predictor >= 10) {
977     ret = PNG_PredictorEncode(pSrcBuf, src_size, predictor, Colors,
978                               BitsPerComponent, Columns);
979   }
980   if (ret)
981     ret = Encode(pSrcBuf, src_size, dest_buf, dest_size);
982   FX_Free(pSrcBuf);
983   return ret;
984 }
985 FX_BOOL CCodec_FlateModule::Encode(const uint8_t* src_buf,
986                                    FX_DWORD src_size,
987                                    uint8_t*& dest_buf,
988                                    FX_DWORD& dest_size) {
989   dest_size = src_size + src_size / 1000 + 12;
990   dest_buf = FX_Alloc(uint8_t, dest_size);
991   unsigned long temp_size = dest_size;
992   FPDFAPI_FlateCompress(dest_buf, &temp_size, src_buf, src_size);
993   dest_size = (FX_DWORD)temp_size;
994   return TRUE;
995 }