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