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