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