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