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 FX_BOOL     RunLengthEncode(const uint8_t* src_buf, FX_DWORD src_size, uint8_t*& dest_buf,
  21                                     FX_DWORD& dest_size);
  22     virtual FX_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     FX_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     FX_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     FX_BOOL                             m_bColorTransformed;
 102
 103     uint8_t*                    ReadNextLine();
 104
 105     virtual FX_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, FX_BOOL EndOfLine, FX_BOOL EncodedByteAlign, FX_BOOL BlackIs1, int Columns, int Rows);
 122     FX_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(FX_BOOL bLZW, const uint8_t* src_buf, FX_DWORD src_size, FX_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 FX_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 FX_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, FX_BOOL ColorTransform);
 147     FX_BOOL             LoadInfo(const uint8_t* src_buf, FX_DWORD src_size, int& width, int& height,
 148                          int& num_components, int& bits_per_components, FX_BOOL& color_transform,
 149                          uint8_t** icc_buf_ptr, FX_DWORD* icc_length);
 150     FX_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 FX_BOOL             StartScanline(void* pContext, int down_scale);
 156     virtual FX_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, FX_BOOL useColorSpace = FALSE);
 203     void                GetImageInfo(void* ctx, FX_DWORD& width, FX_DWORD& height,
 204                              FX_DWORD& codestream_nComps, FX_DWORD& output_nComps);
 205     FX_BOOL             Decode(void* ctx, uint8_t* dest_data, int pitch, FX_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     IFX_FileRead* m_file_ptr;
 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     FX_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     FX_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     FX_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_