e9449693dd386c87a73bac992b5f41d863678349
[pdfium.git] / core / src / fxcodec / codec / codec_int.h
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 #ifndef CORE_SRC_FXCODEC_CODEC_CODEC_INT_H_
8 #define CORE_SRC_FXCODEC_CODEC_CODEC_INT_H_
9
10 #include <limits.h>
11 #include <list>
12
13 #include "../../../../third_party/libopenjpeg20/openjpeg.h"  // For OPJ_SIZE_T.
14 #include "../../../include/fxcodec/fx_codec.h"
15 #include "../jbig2/JBig2_Context.h"
16
17 class CCodec_BasicModule : public ICodec_BasicModule {
18  public:
19   virtual FX_BOOL RunLengthEncode(const uint8_t* src_buf,
20                                   FX_DWORD src_size,
21                                   uint8_t*& dest_buf,
22                                   FX_DWORD& dest_size);
23   virtual FX_BOOL A85Encode(const uint8_t* src_buf,
24                             FX_DWORD src_size,
25                             uint8_t*& dest_buf,
26                             FX_DWORD& dest_size);
27   virtual ICodec_ScanlineDecoder* CreateRunLengthDecoder(const uint8_t* src_buf,
28                                                          FX_DWORD src_size,
29                                                          int width,
30                                                          int height,
31                                                          int nComps,
32                                                          int bpc);
33 };
34 struct CCodec_ImageDataCache {
35   int m_Width, m_Height;
36   int m_nCachedLines;
37   uint8_t m_Data;
38 };
39 class CCodec_ScanlineDecoder : public ICodec_ScanlineDecoder {
40  public:
41   CCodec_ScanlineDecoder();
42
43   virtual ~CCodec_ScanlineDecoder();
44
45   virtual FX_DWORD GetSrcOffset() { return -1; }
46
47   virtual void DownScale(int dest_width, int dest_height);
48
49   uint8_t* GetScanline(int line);
50
51   FX_BOOL SkipToScanline(int line, IFX_Pause* pPause);
52
53   int GetWidth() { return m_OutputWidth; }
54
55   int GetHeight() { return m_OutputHeight; }
56
57   int CountComps() { return m_nComps; }
58
59   int GetBPC() { return m_bpc; }
60
61   FX_BOOL IsColorTransformed() { return m_bColorTransformed; }
62
63   void ClearImageData() {
64     if (m_pDataCache) {
65       FX_Free(m_pDataCache);
66     }
67     m_pDataCache = NULL;
68   }
69
70  protected:
71   int m_OrigWidth;
72
73   int m_OrigHeight;
74
75   int m_DownScale;
76
77   int m_OutputWidth;
78
79   int m_OutputHeight;
80
81   int m_nComps;
82
83   int m_bpc;
84
85   int m_Pitch;
86
87   FX_BOOL m_bColorTransformed;
88
89   uint8_t* ReadNextLine();
90
91   virtual FX_BOOL v_Rewind() = 0;
92
93   virtual uint8_t* v_GetNextLine() = 0;
94
95   virtual void v_DownScale(int dest_width, int dest_height) = 0;
96
97   int m_NextLine;
98
99   uint8_t* m_pLastScanline;
100
101   CCodec_ImageDataCache* m_pDataCache;
102 };
103 class CCodec_FaxModule : public ICodec_FaxModule {
104  public:
105   virtual ICodec_ScanlineDecoder* CreateDecoder(const uint8_t* src_buf,
106                                                 FX_DWORD src_size,
107                                                 int width,
108                                                 int height,
109                                                 int K,
110                                                 FX_BOOL EndOfLine,
111                                                 FX_BOOL EncodedByteAlign,
112                                                 FX_BOOL BlackIs1,
113                                                 int Columns,
114                                                 int Rows);
115   FX_BOOL Encode(const uint8_t* src_buf,
116                  int width,
117                  int height,
118                  int pitch,
119                  uint8_t*& dest_buf,
120                  FX_DWORD& dest_size);
121 };
122 class CCodec_FlateModule : public ICodec_FlateModule {
123  public:
124   virtual ICodec_ScanlineDecoder* CreateDecoder(const uint8_t* src_buf,
125                                                 FX_DWORD src_size,
126                                                 int width,
127                                                 int height,
128                                                 int nComps,
129                                                 int bpc,
130                                                 int predictor,
131                                                 int Colors,
132                                                 int BitsPerComponent,
133                                                 int Columns);
134   virtual FX_DWORD FlateOrLZWDecode(FX_BOOL bLZW,
135                                     const uint8_t* src_buf,
136                                     FX_DWORD src_size,
137                                     FX_BOOL bEarlyChange,
138                                     int predictor,
139                                     int Colors,
140                                     int BitsPerComponent,
141                                     int Columns,
142                                     FX_DWORD estimated_size,
143                                     uint8_t*& dest_buf,
144                                     FX_DWORD& dest_size);
145   virtual FX_BOOL Encode(const uint8_t* src_buf,
146                          FX_DWORD src_size,
147                          int predictor,
148                          int Colors,
149                          int BitsPerComponent,
150                          int Columns,
151                          uint8_t*& dest_buf,
152                          FX_DWORD& dest_size);
153   virtual FX_BOOL Encode(const uint8_t* src_buf,
154                          FX_DWORD src_size,
155                          uint8_t*& dest_buf,
156                          FX_DWORD& dest_size);
157 };
158 class CCodec_JpegModule : public ICodec_JpegModule {
159  public:
160   CCodec_JpegModule() : m_pExtProvider(NULL) {}
161   void SetPovider(IFX_JpegProvider* pJP) { m_pExtProvider = pJP; }
162   ICodec_ScanlineDecoder* CreateDecoder(const uint8_t* src_buf,
163                                         FX_DWORD src_size,
164                                         int width,
165                                         int height,
166                                         int nComps,
167                                         FX_BOOL ColorTransform);
168   FX_BOOL LoadInfo(const uint8_t* src_buf,
169                    FX_DWORD src_size,
170                    int& width,
171                    int& height,
172                    int& num_components,
173                    int& bits_per_components,
174                    FX_BOOL& color_transform,
175                    uint8_t** icc_buf_ptr,
176                    FX_DWORD* icc_length);
177   FX_BOOL Encode(const CFX_DIBSource* pSource,
178                  uint8_t*& dest_buf,
179                  FX_STRSIZE& dest_size,
180                  int quality,
181                  const uint8_t* icc_buf,
182                  FX_DWORD icc_length);
183   virtual void* Start();
184   virtual void Finish(void* pContext);
185   virtual void Input(void* pContext, const uint8_t* src_buf, FX_DWORD src_size);
186   virtual int ReadHeader(void* pContext, int* width, int* height, int* nComps);
187   virtual int StartScanline(void* pContext, int down_scale);
188   virtual FX_BOOL ReadScanline(void* pContext, uint8_t* dest_buf);
189   virtual FX_DWORD GetAvailInput(void* pContext, uint8_t** avail_buf_ptr);
190
191  protected:
192   IFX_JpegProvider* m_pExtProvider;
193 };
194 class CCodec_IccModule : public ICodec_IccModule {
195  public:
196   virtual IccCS GetProfileCS(const uint8_t* pProfileData,
197                              unsigned int dwProfileSize);
198   virtual IccCS GetProfileCS(IFX_FileRead* pFile);
199   virtual void* CreateTransform(
200       ICodec_IccModule::IccParam* pInputParam,
201       ICodec_IccModule::IccParam* pOutputParam,
202       ICodec_IccModule::IccParam* pProofParam = NULL,
203       FX_DWORD dwIntent = Icc_INTENT_PERCEPTUAL,
204       FX_DWORD dwFlag = Icc_FLAGS_DEFAULT,
205       FX_DWORD dwPrfIntent = Icc_INTENT_ABSOLUTE_COLORIMETRIC,
206       FX_DWORD dwPrfFlag = Icc_FLAGS_SOFTPROOFING);
207   virtual void* CreateTransform_sRGB(const uint8_t* pProfileData,
208                                      FX_DWORD dwProfileSize,
209                                      int32_t& nComponents,
210                                      int32_t intent = 0,
211                                      FX_DWORD dwSrcFormat = Icc_FORMAT_DEFAULT);
212   virtual void* CreateTransform_CMYK(const uint8_t* pSrcProfileData,
213                                      FX_DWORD dwSrcProfileSize,
214                                      int32_t& nSrcComponents,
215                                      const uint8_t* pDstProfileData,
216                                      FX_DWORD dwDstProfileSize,
217                                      int32_t intent = 0,
218                                      FX_DWORD dwSrcFormat = Icc_FORMAT_DEFAULT,
219                                      FX_DWORD dwDstFormat = Icc_FORMAT_DEFAULT);
220   virtual void DestroyTransform(void* pTransform);
221   virtual void Translate(void* pTransform,
222                          FX_FLOAT* pSrcValues,
223                          FX_FLOAT* pDestValues);
224   virtual void TranslateScanline(void* pTransform,
225                                  uint8_t* pDest,
226                                  const uint8_t* pSrc,
227                                  int pixels);
228   virtual void SetComponents(FX_DWORD nComponents) {
229     m_nComponents = nComponents;
230   }
231   virtual ~CCodec_IccModule();
232
233  protected:
234   CFX_MapByteStringToPtr m_MapTranform;
235   CFX_MapByteStringToPtr m_MapProfile;
236   FX_DWORD m_nComponents;
237   typedef enum {
238     Icc_CLASS_INPUT = 0,
239     Icc_CLASS_OUTPUT,
240     Icc_CLASS_PROOF,
241     Icc_CLASS_MAX
242   } Icc_CLASS;
243   void* CreateProfile(ICodec_IccModule::IccParam* pIccParam,
244                       Icc_CLASS ic,
245                       CFX_BinaryBuf* pTransformKey);
246 };
247 class CCodec_JpxModule : public ICodec_JpxModule {
248  public:
249   CCodec_JpxModule();
250   void* CreateDecoder(const uint8_t* src_buf,
251                       FX_DWORD src_size,
252                       FX_BOOL useColorSpace = FALSE);
253   void GetImageInfo(void* ctx,
254                     FX_DWORD& width,
255                     FX_DWORD& height,
256                     FX_DWORD& codestream_nComps,
257                     FX_DWORD& output_nComps);
258   FX_BOOL Decode(void* ctx,
259                  uint8_t* dest_data,
260                  int pitch,
261                  FX_BOOL bTranslateColor,
262                  uint8_t* offsets);
263   void DestroyDecoder(void* ctx);
264 };
265 class CPDF_Jbig2Interface : public CJBig2_Module {
266  public:
267   virtual void* JBig2_Malloc(FX_DWORD dwSize) {
268     return FX_Alloc(uint8_t, dwSize);
269   }
270   virtual void* JBig2_Malloc2(FX_DWORD num, FX_DWORD dwSize) {
271     if (dwSize && num >= UINT_MAX / dwSize) {
272       return NULL;
273     }
274     return FX_Alloc(uint8_t, num * dwSize);
275   }
276   virtual void* JBig2_Malloc3(FX_DWORD num, FX_DWORD dwSize, FX_DWORD dwSize2) {
277     if (dwSize2 && dwSize >= UINT_MAX / dwSize2) {
278       return NULL;
279     }
280     FX_DWORD size = dwSize2 * dwSize;
281     if (size && num >= UINT_MAX / size) {
282       return NULL;
283     }
284     return FX_Alloc(uint8_t, num * size);
285   }
286   virtual void* JBig2_Realloc(void* pMem, FX_DWORD dwSize) {
287     return FX_Realloc(uint8_t, pMem, dwSize);
288   }
289   virtual void JBig2_Free(void* pMem) { FX_Free(pMem); }
290 };
291 class CCodec_Jbig2Context {
292  public:
293   CCodec_Jbig2Context();
294   ~CCodec_Jbig2Context(){};
295
296   FX_DWORD m_width;
297   FX_DWORD m_height;
298   uint8_t* m_src_buf;
299   FX_DWORD m_src_size;
300   const uint8_t* m_global_data;
301   FX_DWORD m_global_size;
302   uint8_t* m_dest_buf;
303   FX_DWORD m_dest_pitch;
304   FX_BOOL m_bFileReader;
305   IFX_Pause* m_pPause;
306   CJBig2_Context* m_pContext;
307   CJBig2_Image* m_dest_image;
308 };
309 class CCodec_Jbig2Module : public ICodec_Jbig2Module {
310  public:
311   CCodec_Jbig2Module(){};
312   ~CCodec_Jbig2Module();
313   FX_BOOL Decode(FX_DWORD width,
314                  FX_DWORD height,
315                  const uint8_t* src_buf,
316                  FX_DWORD src_size,
317                  const uint8_t* global_data,
318                  FX_DWORD global_size,
319                  uint8_t* dest_buf,
320                  FX_DWORD dest_pitch);
321   FX_BOOL Decode(IFX_FileRead* file_ptr,
322                  FX_DWORD& width,
323                  FX_DWORD& height,
324                  FX_DWORD& pitch,
325                  uint8_t*& dest_buf);
326   void* CreateJbig2Context();
327   FXCODEC_STATUS StartDecode(void* pJbig2Context,
328                              FX_DWORD width,
329                              FX_DWORD height,
330                              const uint8_t* src_buf,
331                              FX_DWORD src_size,
332                              const uint8_t* global_data,
333                              FX_DWORD global_size,
334                              uint8_t* dest_buf,
335                              FX_DWORD dest_pitch,
336                              IFX_Pause* pPause);
337
338   FXCODEC_STATUS StartDecode(void* pJbig2Context,
339                              IFX_FileRead* file_ptr,
340                              FX_DWORD& width,
341                              FX_DWORD& height,
342                              FX_DWORD& pitch,
343                              uint8_t*& dest_buf,
344                              IFX_Pause* pPause);
345   FXCODEC_STATUS ContinueDecode(void* pJbig2Context, IFX_Pause* pPause);
346   void DestroyJbig2Context(void* pJbig2Context);
347   CPDF_Jbig2Interface m_Module;
348   std::list<CJBig2_CachePair> m_SymbolDictCache;
349
350  private:
351 };
352
353 struct DecodeData {
354  public:
355   DecodeData(unsigned char* src_data, OPJ_SIZE_T src_size)
356       : src_data(src_data), src_size(src_size), offset(0) {}
357   unsigned char* src_data;
358   OPJ_SIZE_T src_size;
359   OPJ_SIZE_T offset;
360 };
361
362 /* Wrappers for C-style callbacks. */
363 OPJ_SIZE_T opj_read_from_memory(void* p_buffer,
364                                 OPJ_SIZE_T nb_bytes,
365                                 void* p_user_data);
366 OPJ_SIZE_T opj_write_from_memory(void* p_buffer,
367                                  OPJ_SIZE_T nb_bytes,
368                                  void* p_user_data);
369 OPJ_OFF_T opj_skip_from_memory(OPJ_OFF_T nb_bytes, void* p_user_data);
370 OPJ_BOOL opj_seek_from_memory(OPJ_OFF_T nb_bytes, void* p_user_data);
371
372 #endif  // CORE_SRC_FXCODEC_CODEC_CODEC_INT_H_