46f479e0b11b50441ed2ccc585168ac830838d3f
[pdfium.git] / core / src / fxcodec / codec / fx_codec.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 "../../../include/fxcodec/fx_codec.h"
8
9 #include <cmath>
10
11 #include "../../../../third_party/base/logging.h"
12 #include "../../../include/fxcrt/fx_safe_types.h"
13 #include "codec_int.h"
14
15 CCodec_ModuleMgr::CCodec_ModuleMgr()
16     : m_pBasicModule(new CCodec_BasicModule),
17       m_pFaxModule(new CCodec_FaxModule),
18       m_pJpegModule(new CCodec_JpegModule),
19       m_pJpxModule(new CCodec_JpxModule),
20       m_pJbig2Module(new CCodec_Jbig2Module),
21       m_pIccModule(new CCodec_IccModule),
22       m_pFlateModule(new CCodec_FlateModule) {}
23
24 CCodec_ScanlineDecoder::ImageDataCache::ImageDataCache(int width,
25                                                        int height,
26                                                        int pitch)
27     : m_Width(width), m_Height(height), m_Pitch(pitch), m_nCachedLines(0) {
28 }
29
30 CCodec_ScanlineDecoder::ImageDataCache::~ImageDataCache() {
31 }
32
33 bool CCodec_ScanlineDecoder::ImageDataCache::AllocateCache() {
34   if (m_Pitch <= 0 || m_Height < 0)
35     return false;
36
37   FX_SAFE_SIZE_T size = m_Pitch;
38   size *= m_Height;
39   if (!size.IsValid())
40     return false;
41
42   m_Data.reset(FX_TryAlloc(uint8_t, size.ValueOrDie()));
43   return IsValid();
44 }
45
46 void CCodec_ScanlineDecoder::ImageDataCache::AppendLine(const uint8_t* line) {
47   // If the callers adds more lines than there is room, fail.
48   if (m_Pitch <= 0 || m_nCachedLines >= m_Height) {
49     NOTREACHED();
50     return;
51   }
52
53   size_t offset = m_Pitch;
54   FXSYS_memcpy(m_Data.get() + offset * m_nCachedLines, line, m_Pitch);
55   ++m_nCachedLines;
56 }
57
58 const uint8_t* CCodec_ScanlineDecoder::ImageDataCache::GetLine(int line) const {
59   if (m_Pitch <= 0 || line < 0 || line >= m_nCachedLines)
60     return nullptr;
61
62   size_t offset = m_Pitch;
63   return m_Data.get() + offset * line;
64 }
65
66 CCodec_ScanlineDecoder::CCodec_ScanlineDecoder()
67     : m_NextLine(-1), m_pLastScanline(nullptr) {
68 }
69
70 CCodec_ScanlineDecoder::~CCodec_ScanlineDecoder() {
71 }
72
73 const uint8_t* CCodec_ScanlineDecoder::GetScanline(int line) {
74   if (m_pDataCache && line < m_pDataCache->NumLines())
75     return m_pDataCache->GetLine(line);
76
77   if (m_NextLine == line + 1)
78     return m_pLastScanline;
79
80   if (m_NextLine < 0 || m_NextLine > line) {
81     if (!v_Rewind())
82       return nullptr;
83     m_NextLine = 0;
84   }
85   while (m_NextLine < line) {
86     ReadNextLine();
87     m_NextLine++;
88   }
89   m_pLastScanline = ReadNextLine();
90   m_NextLine++;
91   return m_pLastScanline;
92 }
93
94 FX_BOOL CCodec_ScanlineDecoder::SkipToScanline(int line, IFX_Pause* pPause) {
95   if (m_pDataCache && line < m_pDataCache->NumLines())
96     return FALSE;
97
98   if (m_NextLine == line || m_NextLine == line + 1)
99     return FALSE;
100
101   if (m_NextLine < 0 || m_NextLine > line) {
102     v_Rewind();
103     m_NextLine = 0;
104   }
105   m_pLastScanline = nullptr;
106   while (m_NextLine < line) {
107     m_pLastScanline = ReadNextLine();
108     m_NextLine++;
109     if (pPause && pPause->NeedToPauseNow()) {
110       return TRUE;
111     }
112   }
113   return FALSE;
114 }
115
116 uint8_t* CCodec_ScanlineDecoder::ReadNextLine() {
117   uint8_t* pLine = v_GetNextLine();
118   if (!pLine)
119     return nullptr;
120
121   if (m_pDataCache && m_NextLine == m_pDataCache->NumLines())
122     m_pDataCache->AppendLine(pLine);
123   return pLine;
124 }
125
126 void CCodec_ScanlineDecoder::DownScale(int dest_width, int dest_height) {
127   dest_width = std::abs(dest_width);
128   dest_height = std::abs(dest_height);
129   v_DownScale(dest_width, dest_height);
130
131   if (m_pDataCache &&
132       m_pDataCache->IsSameDimensions(m_OutputWidth, m_OutputHeight)) {
133     return;
134   }
135
136   nonstd::unique_ptr<ImageDataCache> cache(
137       new ImageDataCache(m_OutputWidth, m_OutputHeight, m_Pitch));
138   if (!cache->AllocateCache())
139     return;
140
141   m_pDataCache = nonstd::move(cache);
142 }
143
144 FX_BOOL CCodec_BasicModule::RunLengthEncode(const uint8_t* src_buf,
145                                             FX_DWORD src_size,
146                                             uint8_t*& dest_buf,
147                                             FX_DWORD& dest_size) {
148   return FALSE;
149 }
150 extern "C" double FXstrtod(const char* nptr, char** endptr) {
151   double ret = 0.0;
152   const char* ptr = nptr;
153   const char* exp_ptr = NULL;
154   int e_number = 0, e_signal = 0, e_point = 0, is_negative = 0;
155   int exp_ret = 0, exp_sig = 1, fra_ret = 0, fra_count = 0, fra_base = 1;
156   if (nptr == NULL) {
157     return 0.0;
158   }
159   for (;; ptr++) {
160     if (!e_number && !e_point && (*ptr == '\t' || *ptr == ' ')) {
161       continue;
162     }
163     if (*ptr >= '0' && *ptr <= '9') {
164       if (!e_number) {
165         e_number = 1;
166       }
167       if (!e_point) {
168         ret *= 10;
169         ret += (*ptr - '0');
170       } else {
171         fra_count++;
172         fra_ret *= 10;
173         fra_ret += (*ptr - '0');
174       }
175       continue;
176     }
177     if (!e_point && *ptr == '.') {
178       e_point = 1;
179       continue;
180     }
181     if (!e_number && !e_point && !e_signal) {
182       switch (*ptr) {
183         case '-':
184           is_negative = 1;
185         case '+':
186           e_signal = 1;
187           continue;
188       }
189     }
190     if (e_number && (*ptr == 'e' || *ptr == 'E')) {
191 #define EXPONENT_DETECT(ptr)        \
192   for (;; ptr++) {                  \
193     if (*ptr < '0' || *ptr > '9') { \
194       if (endptr)                   \
195         *endptr = (char*)ptr;       \
196       break;                        \
197     } else {                        \
198       exp_ret *= 10;                \
199       exp_ret += (*ptr - '0');      \
200       continue;                     \
201     }                               \
202   }
203       exp_ptr = ptr++;
204       if (*ptr == '+' || *ptr == '-') {
205         exp_sig = (*ptr++ == '+') ? 1 : -1;
206         if (*ptr < '0' || *ptr > '9') {
207           if (endptr) {
208             *endptr = (char*)exp_ptr;
209           }
210           break;
211         }
212         EXPONENT_DETECT(ptr);
213       } else if (*ptr >= '0' && *ptr <= '9') {
214         EXPONENT_DETECT(ptr);
215       } else {
216         if (endptr) {
217           *endptr = (char*)exp_ptr;
218         }
219         break;
220       }
221 #undef EXPONENT_DETECT
222       break;
223     }
224     if (ptr != nptr && !e_number) {
225       if (endptr) {
226         *endptr = (char*)nptr;
227       }
228       break;
229     }
230     if (endptr) {
231       *endptr = (char*)ptr;
232     }
233     break;
234   }
235   while (fra_count--) {
236     fra_base *= 10;
237   }
238   ret += (double)fra_ret / (double)fra_base;
239   if (exp_sig == 1) {
240     while (exp_ret--) {
241       ret *= 10.0;
242     }
243   } else {
244     while (exp_ret--) {
245       ret /= 10.0;
246     }
247   }
248   return is_negative ? -ret : ret;
249 }
250 FX_BOOL CCodec_BasicModule::A85Encode(const uint8_t* src_buf,
251                                       FX_DWORD src_size,
252                                       uint8_t*& dest_buf,
253                                       FX_DWORD& dest_size) {
254   return FALSE;
255 }
256 class CCodec_RLScanlineDecoder : public CCodec_ScanlineDecoder {
257  public:
258   CCodec_RLScanlineDecoder();
259   ~CCodec_RLScanlineDecoder() override;
260
261   FX_BOOL Create(const uint8_t* src_buf,
262                  FX_DWORD src_size,
263                  int width,
264                  int height,
265                  int nComps,
266                  int bpc);
267
268   // CCodec_ScanlineDecoder
269   void v_DownScale(int dest_width, int dest_height) override {}
270   FX_BOOL v_Rewind() override;
271   uint8_t* v_GetNextLine() override;
272   FX_DWORD GetSrcOffset() override { return m_SrcOffset; }
273
274  protected:
275   FX_BOOL CheckDestSize();
276   void GetNextOperator();
277   void UpdateOperator(uint8_t used_bytes);
278
279   uint8_t* m_pScanline;
280   const uint8_t* m_pSrcBuf;
281   FX_DWORD m_SrcSize;
282   FX_DWORD m_dwLineBytes;
283   FX_DWORD m_SrcOffset;
284   FX_BOOL m_bEOD;
285   uint8_t m_Operator;
286 };
287 CCodec_RLScanlineDecoder::CCodec_RLScanlineDecoder()
288     : m_pScanline(NULL),
289       m_pSrcBuf(NULL),
290       m_SrcSize(0),
291       m_dwLineBytes(0),
292       m_SrcOffset(0),
293       m_bEOD(FALSE),
294       m_Operator(0) {}
295 CCodec_RLScanlineDecoder::~CCodec_RLScanlineDecoder() {
296   FX_Free(m_pScanline);
297 }
298 FX_BOOL CCodec_RLScanlineDecoder::CheckDestSize() {
299   FX_DWORD i = 0;
300   FX_DWORD old_size = 0;
301   FX_DWORD dest_size = 0;
302   while (i < m_SrcSize) {
303     if (m_pSrcBuf[i] < 128) {
304       old_size = dest_size;
305       dest_size += m_pSrcBuf[i] + 1;
306       if (dest_size < old_size) {
307         return FALSE;
308       }
309       i += m_pSrcBuf[i] + 2;
310     } else if (m_pSrcBuf[i] > 128) {
311       old_size = dest_size;
312       dest_size += 257 - m_pSrcBuf[i];
313       if (dest_size < old_size) {
314         return FALSE;
315       }
316       i += 2;
317     } else {
318       break;
319     }
320   }
321   if (((FX_DWORD)m_OrigWidth * m_nComps * m_bpc * m_OrigHeight + 7) / 8 >
322       dest_size) {
323     return FALSE;
324   }
325   return TRUE;
326 }
327 FX_BOOL CCodec_RLScanlineDecoder::Create(const uint8_t* src_buf,
328                                          FX_DWORD src_size,
329                                          int width,
330                                          int height,
331                                          int nComps,
332                                          int bpc) {
333   m_pSrcBuf = src_buf;
334   m_SrcSize = src_size;
335   m_OutputWidth = m_OrigWidth = width;
336   m_OutputHeight = m_OrigHeight = height;
337   m_nComps = nComps;
338   m_bpc = bpc;
339   m_bColorTransformed = FALSE;
340   m_DownScale = 1;
341   m_Pitch = (width * nComps * bpc + 31) / 32 * 4;
342   m_dwLineBytes = (width * nComps * bpc + 7) / 8;
343   m_pScanline = FX_Alloc(uint8_t, m_Pitch);
344   return CheckDestSize();
345 }
346 FX_BOOL CCodec_RLScanlineDecoder::v_Rewind() {
347   FXSYS_memset(m_pScanline, 0, m_Pitch);
348   m_SrcOffset = 0;
349   m_bEOD = FALSE;
350   m_Operator = 0;
351   return TRUE;
352 }
353 uint8_t* CCodec_RLScanlineDecoder::v_GetNextLine() {
354   if (m_SrcOffset == 0) {
355     GetNextOperator();
356   } else {
357     if (m_bEOD) {
358       return NULL;
359     }
360   }
361   FXSYS_memset(m_pScanline, 0, m_Pitch);
362   FX_DWORD col_pos = 0;
363   FX_BOOL eol = FALSE;
364   while (m_SrcOffset < m_SrcSize && !eol) {
365     if (m_Operator < 128) {
366       FX_DWORD copy_len = m_Operator + 1;
367       if (col_pos + copy_len >= m_dwLineBytes) {
368         copy_len = m_dwLineBytes - col_pos;
369         eol = TRUE;
370       }
371       if (copy_len >= m_SrcSize - m_SrcOffset) {
372         copy_len = m_SrcSize - m_SrcOffset;
373         m_bEOD = TRUE;
374       }
375       FXSYS_memcpy(m_pScanline + col_pos, m_pSrcBuf + m_SrcOffset, copy_len);
376       col_pos += copy_len;
377       UpdateOperator((uint8_t)copy_len);
378     } else if (m_Operator > 128) {
379       int fill = 0;
380       if (m_SrcOffset - 1 < m_SrcSize - 1) {
381         fill = m_pSrcBuf[m_SrcOffset];
382       }
383       FX_DWORD duplicate_len = 257 - m_Operator;
384       if (col_pos + duplicate_len >= m_dwLineBytes) {
385         duplicate_len = m_dwLineBytes - col_pos;
386         eol = TRUE;
387       }
388       FXSYS_memset(m_pScanline + col_pos, fill, duplicate_len);
389       col_pos += duplicate_len;
390       UpdateOperator((uint8_t)duplicate_len);
391     } else {
392       m_bEOD = TRUE;
393       break;
394     }
395   }
396   return m_pScanline;
397 }
398 void CCodec_RLScanlineDecoder::GetNextOperator() {
399   if (m_SrcOffset >= m_SrcSize) {
400     m_Operator = 128;
401     return;
402   }
403   m_Operator = m_pSrcBuf[m_SrcOffset];
404   m_SrcOffset++;
405 }
406 void CCodec_RLScanlineDecoder::UpdateOperator(uint8_t used_bytes) {
407   if (used_bytes == 0) {
408     return;
409   }
410   if (m_Operator < 128) {
411     FXSYS_assert((FX_DWORD)m_Operator + 1 >= used_bytes);
412     if (used_bytes == m_Operator + 1) {
413       m_SrcOffset += used_bytes;
414       GetNextOperator();
415       return;
416     }
417     m_Operator -= used_bytes;
418     m_SrcOffset += used_bytes;
419     if (m_SrcOffset >= m_SrcSize) {
420       m_Operator = 128;
421     }
422     return;
423   }
424   uint8_t count = 257 - m_Operator;
425   FXSYS_assert((FX_DWORD)count >= used_bytes);
426   if (used_bytes == count) {
427     m_SrcOffset++;
428     GetNextOperator();
429     return;
430   }
431   count -= used_bytes;
432   m_Operator = 257 - count;
433 }
434 ICodec_ScanlineDecoder* CCodec_BasicModule::CreateRunLengthDecoder(
435     const uint8_t* src_buf,
436     FX_DWORD src_size,
437     int width,
438     int height,
439     int nComps,
440     int bpc) {
441   CCodec_RLScanlineDecoder* pRLScanlineDecoder = new CCodec_RLScanlineDecoder;
442   if (!pRLScanlineDecoder->Create(src_buf, src_size, width, height, nComps,
443                                   bpc)) {
444     delete pRLScanlineDecoder;
445     return NULL;
446   }
447   return pRLScanlineDecoder;
448 }