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