ddc47d3db5900068fed14088d0725ec2e8aaf597
[pdfium.git] / core / include / fxge / fx_dib.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_INCLUDE_FXGE_FX_DIB_H_
8 #define CORE_INCLUDE_FXGE_FX_DIB_H_
9
10 #include "../fxcrt/fx_basic.h"
11 #include "../fxcrt/fx_coordinates.h"
12
13 enum FXDIB_Format {
14   FXDIB_Invalid = 0,
15   FXDIB_1bppMask = 0x101,
16   FXDIB_1bppRgb = 0x001,
17   FXDIB_1bppCmyk = 0x401,
18   FXDIB_8bppMask = 0x108,
19   FXDIB_8bppRgb = 0x008,
20   FXDIB_8bppRgba = 0x208,
21   FXDIB_8bppCmyk = 0x408,
22   FXDIB_8bppCmyka = 0x608,
23   FXDIB_Rgb = 0x018,
24   FXDIB_Rgba = 0x218,
25   FXDIB_Rgb32 = 0x020,
26   FXDIB_Argb = 0x220,
27   FXDIB_Cmyk = 0x420,
28   FXDIB_Cmyka = 0x620,
29 };
30 enum FXDIB_Channel {
31   FXDIB_Red = 1,
32   FXDIB_Green,
33   FXDIB_Blue,
34   FXDIB_Cyan,
35   FXDIB_Magenta,
36   FXDIB_Yellow,
37   FXDIB_Black,
38   FXDIB_Alpha
39 };
40 #define FXDIB_DOWNSAMPLE 0x04
41 #define FXDIB_INTERPOL 0x20
42 #define FXDIB_BICUBIC_INTERPOL 0x80
43 #define FXDIB_NOSMOOTH 0x100
44 #define FXDIB_PALETTE_LOC 0x01
45 #define FXDIB_PALETTE_WIN 0x02
46 #define FXDIB_PALETTE_MAC 0x04
47 #define FXDIB_BLEND_NORMAL 0
48 #define FXDIB_BLEND_MULTIPLY 1
49 #define FXDIB_BLEND_SCREEN 2
50 #define FXDIB_BLEND_OVERLAY 3
51 #define FXDIB_BLEND_DARKEN 4
52 #define FXDIB_BLEND_LIGHTEN 5
53
54 #define FXDIB_BLEND_COLORDODGE 6
55 #define FXDIB_BLEND_COLORBURN 7
56 #define FXDIB_BLEND_HARDLIGHT 8
57 #define FXDIB_BLEND_SOFTLIGHT 9
58 #define FXDIB_BLEND_DIFFERENCE 10
59 #define FXDIB_BLEND_EXCLUSION 11
60 #define FXDIB_BLEND_NONSEPARABLE 21
61 #define FXDIB_BLEND_HUE 21
62 #define FXDIB_BLEND_SATURATION 22
63 #define FXDIB_BLEND_COLOR 23
64 #define FXDIB_BLEND_LUMINOSITY 24
65 #define FXDIB_BLEND_UNSUPPORTED -1
66 typedef FX_DWORD FX_ARGB;
67 typedef FX_DWORD FX_COLORREF;
68 typedef FX_DWORD FX_CMYK;
69 class CFX_ClipRgn;
70 class CFX_DIBSource;
71 class CFX_DIBitmap;
72 #define FXSYS_RGB(r, g, b) ((r) | ((g) << 8) | ((b) << 16))
73 #define FXSYS_GetRValue(rgb) ((rgb)&0xff)
74 #define FXSYS_GetGValue(rgb) (((rgb) >> 8) & 0xff)
75 #define FXSYS_GetBValue(rgb) (((rgb) >> 16) & 0xff)
76 #define FX_CCOLOR(val) (255 - (val))
77 #define FXSYS_CMYK(c, m, y, k) (((c) << 24) | ((m) << 16) | ((y) << 8) | (k))
78 #define FXSYS_GetCValue(cmyk) ((uint8_t)((cmyk) >> 24) & 0xff)
79 #define FXSYS_GetMValue(cmyk) ((uint8_t)((cmyk) >> 16) & 0xff)
80 #define FXSYS_GetYValue(cmyk) ((uint8_t)((cmyk) >> 8) & 0xff)
81 #define FXSYS_GetKValue(cmyk) ((uint8_t)(cmyk)&0xff)
82 void CmykDecode(FX_CMYK cmyk, int& c, int& m, int& y, int& k);
83 inline FX_CMYK CmykEncode(int c, int m, int y, int k) {
84   return (c << 24) | (m << 16) | (y << 8) | k;
85 }
86 void ArgbDecode(FX_ARGB argb, int& a, int& r, int& g, int& b);
87 void ArgbDecode(FX_ARGB argb, int& a, FX_COLORREF& rgb);
88 inline FX_ARGB ArgbEncode(int a, int r, int g, int b) {
89   return (a << 24) | (r << 16) | (g << 8) | b;
90 }
91 FX_ARGB ArgbEncode(int a, FX_COLORREF rgb);
92 #define FXARGB_A(argb) ((uint8_t)((argb) >> 24))
93 #define FXARGB_R(argb) ((uint8_t)((argb) >> 16))
94 #define FXARGB_G(argb) ((uint8_t)((argb) >> 8))
95 #define FXARGB_B(argb) ((uint8_t)(argb))
96 #define FXARGB_MAKE(a, r, g, b) \
97   (((FX_DWORD)(a) << 24) | ((r) << 16) | ((g) << 8) | (b))
98 #define FXARGB_MUL_ALPHA(argb, alpha) \
99   (((((argb) >> 24) * (alpha) / 255) << 24) | ((argb)&0xffffff))
100 #define FXRGB2GRAY(r, g, b) (((b)*11 + (g)*59 + (r)*30) / 100)
101 #define FXCMYK2GRAY(c, m, y, k)                                       \
102   (((255 - (c)) * (255 - (k)) * 30 + (255 - (m)) * (255 - (k)) * 59 + \
103     (255 - (y)) * (255 - (k)) * 11) /                                 \
104    25500)
105 #define FXDIB_ALPHA_MERGE(backdrop, source, source_alpha) \
106   (((backdrop) * (255 - (source_alpha)) + (source) * (source_alpha)) / 255)
107 #define FXDIB_ALPHA_UNION(dest, src) ((dest) + (src) - (dest) * (src) / 255)
108 #define FXCMYK_GETDIB(p)                                    \
109   ((((uint8_t*)(p))[0] << 24 | (((uint8_t*)(p))[1] << 16) | \
110     (((uint8_t*)(p))[2] << 8) | ((uint8_t*)(p))[3]))
111 #define FXCMYK_SETDIB(p, cmyk)  ((uint8_t*)(p))[0] = (uint8_t)((cmyk) >> 24), \
112         ((uint8_t*)(p))[1] = (uint8_t)((cmyk) >> 16), \
113                               ((uint8_t*)(p))[2] = (uint8_t)((cmyk) >> 8), \
114                                       ((uint8_t*)(p))[3] = (uint8_t)(cmyk))
115 #define FXARGB_GETDIB(p)                              \
116   ((((uint8_t*)(p))[0]) | (((uint8_t*)(p))[1] << 8) | \
117    (((uint8_t*)(p))[2] << 16) | (((uint8_t*)(p))[3] << 24))
118 #define FXARGB_SETDIB(p, argb)                  \
119   ((uint8_t*)(p))[0] = (uint8_t)(argb),         \
120   ((uint8_t*)(p))[1] = (uint8_t)((argb) >> 8),  \
121   ((uint8_t*)(p))[2] = (uint8_t)((argb) >> 16), \
122   ((uint8_t*)(p))[3] = (uint8_t)((argb) >> 24)
123 #define FXARGB_COPY(dest, src)                      \
124   *(uint8_t*)(dest) = *(uint8_t*)(src),             \
125   *((uint8_t*)(dest) + 1) = *((uint8_t*)(src) + 1), \
126   *((uint8_t*)(dest) + 2) = *((uint8_t*)(src) + 2), \
127   *((uint8_t*)(dest) + 3) = *((uint8_t*)(src) + 3)
128 #define FXCMYK_COPY(dest, src)                      \
129   *(uint8_t*)(dest) = *(uint8_t*)(src),             \
130   *((uint8_t*)(dest) + 1) = *((uint8_t*)(src) + 1), \
131   *((uint8_t*)(dest) + 2) = *((uint8_t*)(src) + 2), \
132   *((uint8_t*)(dest) + 3) = *((uint8_t*)(src) + 3)
133 #define FXARGB_SETRGBORDERDIB(p, argb)          \
134   ((uint8_t*)(p))[3] = (uint8_t)(argb >> 24),   \
135   ((uint8_t*)(p))[0] = (uint8_t)((argb) >> 16), \
136   ((uint8_t*)(p))[1] = (uint8_t)((argb) >> 8),  \
137   ((uint8_t*)(p))[2] = (uint8_t)(argb)
138 #define FXARGB_GETRGBORDERDIB(p)                     \
139   (((uint8_t*)(p))[2]) | (((uint8_t*)(p))[1] << 8) | \
140       (((uint8_t*)(p))[0] << 16) | (((uint8_t*)(p))[3] << 24)
141 #define FXARGB_RGBORDERCOPY(dest, src)                                   \
142   *((uint8_t*)(dest) + 3) = *((uint8_t*)(src) + 3),                      \
143                        *(uint8_t*)(dest) = *((uint8_t*)(src) + 2),       \
144                        *((uint8_t*)(dest) + 1) = *((uint8_t*)(src) + 1), \
145                        *((uint8_t*)(dest) + 2) = *((uint8_t*)(src))
146 #define FXARGB_TODIB(argb) (argb)
147 #define FXCMYK_TODIB(cmyk)                                    \
148   ((uint8_t)((cmyk) >> 24) | ((uint8_t)((cmyk) >> 16)) << 8 | \
149    ((uint8_t)((cmyk) >> 8)) << 16 | ((uint8_t)(cmyk) << 24))
150 #define FXARGB_TOBGRORDERDIB(argb)                       \
151   ((uint8_t)(argb >> 16) | ((uint8_t)(argb >> 8)) << 8 | \
152    ((uint8_t)(argb)) << 16 | ((uint8_t)(argb >> 24) << 24))
153 #define FXGETFLAG_COLORTYPE(flag) (uint8_t)((flag) >> 8)
154 #define FXGETFLAG_ALPHA_FILL(flag) (uint8_t)(flag)
155 #define FXGETFLAG_ALPHA_STROKE(flag) (uint8_t)((flag) >> 16)
156 #define FXSETFLAG_COLORTYPE(flag, val) \
157   flag = (((val) << 8) | (flag & 0xffff00ff))
158 #define FXSETFLAG_ALPHA_FILL(flag, val) flag = ((val) | (flag & 0xffffff00))
159 #define FXSETFLAG_ALPHA_STROKE(flag, val) \
160   flag = (((val) << 16) | (flag & 0xff00ffff))
161 class CFX_DIBSource {
162  public:
163   virtual ~CFX_DIBSource();
164
165   int GetWidth() const { return m_Width; }
166
167   int GetHeight() const { return m_Height; }
168
169   FXDIB_Format GetFormat() const {
170     return (FXDIB_Format)(m_AlphaFlag * 0x100 + m_bpp);
171   }
172
173   FX_DWORD GetPitch() const { return m_Pitch; }
174
175   FX_DWORD* GetPalette() const { return m_pPalette; }
176
177   virtual uint8_t* GetBuffer() const { return NULL; }
178
179   virtual const uint8_t* GetScanline(int line) const = 0;
180
181   virtual FX_BOOL SkipToScanline(int line, IFX_Pause* pPause) const {
182     return FALSE;
183   }
184
185   virtual void DownSampleScanline(int line,
186                                   uint8_t* dest_scan,
187                                   int dest_bpp,
188                                   int dest_width,
189                                   FX_BOOL bFlipX,
190                                   int clip_left,
191                                   int clip_width) const = 0;
192
193   virtual void SetDownSampleSize(int width, int height) const {}
194
195   int GetBPP() const { return m_bpp; }
196
197   FX_BOOL IsAlphaMask() const { return m_AlphaFlag == 1; }
198
199   FX_BOOL HasAlpha() const { return m_AlphaFlag & 2 ? TRUE : FALSE; }
200
201   FX_BOOL IsOpaqueImage() const { return !(m_AlphaFlag & 3); }
202
203   FX_BOOL IsCmykImage() const { return m_AlphaFlag & 4 ? TRUE : FALSE; }
204
205   int GetPaletteSize() const {
206     return IsAlphaMask() ? 0 : (m_bpp == 1 ? 2 : (m_bpp == 8 ? 256 : 0));
207   }
208
209   FX_DWORD GetPaletteEntry(int index) const;
210
211   void SetPaletteEntry(int index, FX_DWORD color);
212   FX_DWORD GetPaletteArgb(int index) const { return GetPaletteEntry(index); }
213   void SetPaletteArgb(int index, FX_DWORD color) {
214     SetPaletteEntry(index, color);
215   }
216
217   void CopyPalette(const FX_DWORD* pSrcPal, FX_DWORD size = 256);
218
219   CFX_DIBitmap* Clone(const FX_RECT* pClip = NULL) const;
220
221   CFX_DIBitmap* CloneConvert(FXDIB_Format format,
222                              const FX_RECT* pClip = NULL,
223                              void* pIccTransform = NULL) const;
224
225   CFX_DIBitmap* StretchTo(int dest_width,
226                           int dest_height,
227                           FX_DWORD flags = 0,
228                           const FX_RECT* pClip = NULL) const;
229
230   CFX_DIBitmap* TransformTo(const CFX_AffineMatrix* pMatrix,
231                             int& left,
232                             int& top,
233                             FX_DWORD flags = 0,
234                             const FX_RECT* pClip = NULL) const;
235
236   CFX_DIBitmap* GetAlphaMask(const FX_RECT* pClip = NULL) const;
237
238   FX_BOOL CopyAlphaMask(const CFX_DIBSource* pAlphaMask,
239                         const FX_RECT* pClip = NULL);
240
241   CFX_DIBitmap* SwapXY(FX_BOOL bXFlip,
242                        FX_BOOL bYFlip,
243                        const FX_RECT* pClip = NULL) const;
244
245   CFX_DIBitmap* FlipImage(FX_BOOL bXFlip, FX_BOOL bYFlip) const;
246
247   void GetOverlapRect(int& dest_left,
248                       int& dest_top,
249                       int& width,
250                       int& height,
251                       int src_width,
252                       int src_height,
253                       int& src_left,
254                       int& src_top,
255                       const CFX_ClipRgn* pClipRgn);
256
257   CFX_DIBitmap* m_pAlphaMask;
258
259  protected:
260   CFX_DIBSource();
261
262   int m_Width;
263
264   int m_Height;
265
266   int m_bpp;
267
268   FX_DWORD m_AlphaFlag;
269
270   FX_DWORD m_Pitch;
271
272   FX_DWORD* m_pPalette;
273
274   void BuildPalette();
275
276   FX_BOOL BuildAlphaMask();
277
278   int FindPalette(FX_DWORD color) const;
279
280   void GetPalette(FX_DWORD* pal, int alpha) const;
281 };
282 class CFX_DIBitmap : public CFX_DIBSource {
283  public:
284   virtual ~CFX_DIBitmap();
285
286   CFX_DIBitmap();
287
288   CFX_DIBitmap(const CFX_DIBitmap& src);
289
290   FX_BOOL Create(int width,
291                  int height,
292                  FXDIB_Format format,
293                  uint8_t* pBuffer = NULL,
294                  int pitch = 0);
295
296   FX_BOOL Copy(const CFX_DIBSource* pSrc);
297
298   virtual uint8_t* GetBuffer() const { return m_pBuffer; }
299
300   virtual const uint8_t* GetScanline(int line) const {
301     return m_pBuffer ? m_pBuffer + line * m_Pitch : NULL;
302   }
303
304   virtual void DownSampleScanline(int line,
305                                   uint8_t* dest_scan,
306                                   int dest_bpp,
307                                   int dest_width,
308                                   FX_BOOL bFlipX,
309                                   int clip_left,
310                                   int clip_width) const;
311
312   void TakeOver(CFX_DIBitmap* pSrcBitmap);
313
314   FX_BOOL ConvertFormat(FXDIB_Format format, void* pIccTransform = NULL);
315
316   void Clear(FX_DWORD color);
317
318   FX_DWORD GetPixel(int x, int y) const;
319
320   void SetPixel(int x, int y, FX_DWORD color);
321
322   FX_BOOL LoadChannel(FXDIB_Channel destChannel,
323                       const CFX_DIBSource* pSrcBitmap,
324                       FXDIB_Channel srcChannel);
325
326   FX_BOOL LoadChannel(FXDIB_Channel destChannel, int value);
327
328   FX_BOOL MultiplyAlpha(int alpha);
329
330   FX_BOOL MultiplyAlpha(const CFX_DIBSource* pAlphaMask);
331
332   FX_BOOL TransferBitmap(int dest_left,
333                          int dest_top,
334                          int width,
335                          int height,
336                          const CFX_DIBSource* pSrcBitmap,
337                          int src_left,
338                          int src_top,
339                          void* pIccTransform = NULL);
340
341   FX_BOOL CompositeBitmap(int dest_left,
342                           int dest_top,
343                           int width,
344                           int height,
345                           const CFX_DIBSource* pSrcBitmap,
346                           int src_left,
347                           int src_top,
348                           int blend_type = FXDIB_BLEND_NORMAL,
349                           const CFX_ClipRgn* pClipRgn = NULL,
350                           FX_BOOL bRgbByteOrder = FALSE,
351                           void* pIccTransform = NULL);
352
353   FX_BOOL TransferMask(int dest_left,
354                        int dest_top,
355                        int width,
356                        int height,
357                        const CFX_DIBSource* pMask,
358                        FX_DWORD color,
359                        int src_left,
360                        int src_top,
361                        int alpha_flag = 0,
362                        void* pIccTransform = NULL);
363
364   FX_BOOL CompositeMask(int dest_left,
365                         int dest_top,
366                         int width,
367                         int height,
368                         const CFX_DIBSource* pMask,
369                         FX_DWORD color,
370                         int src_left,
371                         int src_top,
372                         int blend_type = FXDIB_BLEND_NORMAL,
373                         const CFX_ClipRgn* pClipRgn = NULL,
374                         FX_BOOL bRgbByteOrder = FALSE,
375                         int alpha_flag = 0,
376                         void* pIccTransform = NULL);
377
378   FX_BOOL CompositeRect(int dest_left,
379                         int dest_top,
380                         int width,
381                         int height,
382                         FX_DWORD color,
383                         int alpha_flag = 0,
384                         void* pIccTransform = NULL);
385
386   FX_BOOL ConvertColorScale(FX_DWORD forecolor, FX_DWORD backcolor);
387
388   FX_BOOL DitherFS(const FX_DWORD* pPalette,
389                    int pal_size,
390                    const FX_RECT* pRect = NULL);
391
392  protected:
393   uint8_t* m_pBuffer;
394
395   FX_BOOL m_bExtBuf;
396
397   FX_BOOL GetGrayData(void* pIccTransform = NULL);
398 };
399 class CFX_DIBExtractor {
400  public:
401   CFX_DIBExtractor(const CFX_DIBSource* pSrc);
402
403   ~CFX_DIBExtractor();
404
405   operator CFX_DIBitmap*() { return m_pBitmap; }
406
407  private:
408   CFX_DIBitmap* m_pBitmap;
409 };
410 typedef CFX_CountRef<CFX_DIBitmap> CFX_DIBitmapRef;
411 class CFX_FilteredDIB : public CFX_DIBSource {
412  public:
413   CFX_FilteredDIB();
414
415   ~CFX_FilteredDIB();
416
417   void LoadSrc(const CFX_DIBSource* pSrc, FX_BOOL bAutoDropSrc = FALSE);
418
419   virtual FXDIB_Format GetDestFormat() = 0;
420
421   virtual FX_DWORD* GetDestPalette() = 0;
422
423   virtual void TranslateScanline(uint8_t* dest_buf,
424                                  const uint8_t* src_buf) const = 0;
425
426   virtual void TranslateDownSamples(uint8_t* dest_buf,
427                                     const uint8_t* src_buf,
428                                     int pixels,
429                                     int Bpp) const = 0;
430
431  protected:
432   virtual const uint8_t* GetScanline(int line) const;
433   virtual void DownSampleScanline(int line,
434                                   uint8_t* dest_scan,
435                                   int dest_bpp,
436                                   int dest_width,
437                                   FX_BOOL bFlipX,
438                                   int clip_left,
439                                   int clip_width) const;
440
441   const CFX_DIBSource* m_pSrc;
442
443   FX_BOOL m_bAutoDropSrc;
444
445   uint8_t* m_pScanline;
446 };
447 class IFX_ScanlineComposer {
448  public:
449   virtual ~IFX_ScanlineComposer() {}
450
451   virtual void ComposeScanline(int line,
452                                const uint8_t* scanline,
453                                const uint8_t* scan_extra_alpha = NULL) = 0;
454
455   virtual FX_BOOL SetInfo(int width,
456                           int height,
457                           FXDIB_Format src_format,
458                           FX_DWORD* pSrcPalette) = 0;
459 };
460 class CFX_ScanlineCompositor {
461  public:
462   CFX_ScanlineCompositor();
463
464   ~CFX_ScanlineCompositor();
465
466   FX_BOOL Init(FXDIB_Format dest_format,
467                FXDIB_Format src_format,
468                int32_t width,
469                FX_DWORD* pSrcPalette,
470                FX_DWORD mask_color,
471                int blend_type,
472                FX_BOOL bClip,
473                FX_BOOL bRgbByteOrder = FALSE,
474                int alpha_flag = 0,
475                void* pIccTransform = NULL);
476
477   void CompositeRgbBitmapLine(uint8_t* dest_scan,
478                               const uint8_t* src_scan,
479                               int width,
480                               const uint8_t* clip_scan,
481                               const uint8_t* src_extra_alpha = NULL,
482                               uint8_t* dst_extra_alpha = NULL);
483
484   void CompositePalBitmapLine(uint8_t* dest_scan,
485                               const uint8_t* src_scan,
486                               int src_left,
487                               int width,
488                               const uint8_t* clip_scan,
489                               const uint8_t* src_extra_alpha = NULL,
490                               uint8_t* dst_extra_alpha = NULL);
491
492   void CompositeByteMaskLine(uint8_t* dest_scan,
493                              const uint8_t* src_scan,
494                              int width,
495                              const uint8_t* clip_scan,
496                              uint8_t* dst_extra_alpha = NULL);
497
498   void CompositeBitMaskLine(uint8_t* dest_scan,
499                             const uint8_t* src_scan,
500                             int src_left,
501                             int width,
502                             const uint8_t* clip_scan,
503                             uint8_t* dst_extra_alpha = NULL);
504
505  protected:
506   int m_Transparency;
507   FXDIB_Format m_SrcFormat, m_DestFormat;
508   FX_DWORD* m_pSrcPalette;
509
510   int m_MaskAlpha, m_MaskRed, m_MaskGreen, m_MaskBlue, m_MaskBlack;
511   int m_BlendType;
512   void* m_pIccTransform;
513   uint8_t* m_pCacheScanline;
514   int m_CacheSize;
515   FX_BOOL m_bRgbByteOrder;
516 };
517 class CFX_BitmapComposer : public IFX_ScanlineComposer {
518  public:
519   CFX_BitmapComposer();
520
521   ~CFX_BitmapComposer();
522
523   void Compose(CFX_DIBitmap* pDest,
524                const CFX_ClipRgn* pClipRgn,
525                int bitmap_alpha,
526                FX_DWORD mask_color,
527                FX_RECT& dest_rect,
528                FX_BOOL bVertical,
529                FX_BOOL bFlipX,
530                FX_BOOL bFlipY,
531                FX_BOOL bRgbByteOrder = FALSE,
532                int alpha_flag = 0,
533                void* pIccTransform = NULL,
534                int blend_type = FXDIB_BLEND_NORMAL);
535
536   virtual FX_BOOL SetInfo(int width,
537                           int height,
538                           FXDIB_Format src_format,
539                           FX_DWORD* pSrcPalette);
540
541   virtual void ComposeScanline(int line,
542                                const uint8_t* scanline,
543                                const uint8_t* scan_extra_alpha);
544
545  protected:
546   void DoCompose(uint8_t* dest_scan,
547                  const uint8_t* src_scan,
548                  int dest_width,
549                  const uint8_t* clip_scan,
550                  const uint8_t* src_extra_alpha = NULL,
551                  uint8_t* dst_extra_alpha = NULL);
552   CFX_DIBitmap* m_pBitmap;
553   const CFX_ClipRgn* m_pClipRgn;
554   FXDIB_Format m_SrcFormat;
555   int m_DestLeft, m_DestTop, m_DestWidth, m_DestHeight, m_BitmapAlpha;
556   FX_DWORD m_MaskColor;
557   const CFX_DIBitmap* m_pClipMask;
558   CFX_ScanlineCompositor m_Compositor;
559   FX_BOOL m_bVertical, m_bFlipX, m_bFlipY;
560   int m_AlphaFlag;
561   void* m_pIccTransform;
562   FX_BOOL m_bRgbByteOrder;
563   int m_BlendType;
564   void ComposeScanlineV(int line,
565                         const uint8_t* scanline,
566                         const uint8_t* scan_extra_alpha = NULL);
567   uint8_t* m_pScanlineV;
568   uint8_t* m_pClipScanV;
569   uint8_t* m_pAddClipScan;
570   uint8_t* m_pScanlineAlphaV;
571 };
572 class CFX_BitmapStorer : public IFX_ScanlineComposer {
573  public:
574   CFX_BitmapStorer();
575
576   ~CFX_BitmapStorer();
577
578   virtual void ComposeScanline(int line,
579                                const uint8_t* scanline,
580                                const uint8_t* scan_extra_alpha);
581
582   virtual FX_BOOL SetInfo(int width,
583                           int height,
584                           FXDIB_Format src_format,
585                           FX_DWORD* pSrcPalette);
586
587   CFX_DIBitmap* GetBitmap() { return m_pBitmap; }
588
589   CFX_DIBitmap* Detach();
590
591   void Replace(CFX_DIBitmap* pBitmap);
592
593  private:
594   CFX_DIBitmap* m_pBitmap;
595 };
596 class CStretchEngine;
597 class CFX_ImageStretcher {
598  public:
599   CFX_ImageStretcher();
600   ~CFX_ImageStretcher();
601
602   FX_BOOL Start(IFX_ScanlineComposer* pDest,
603                 const CFX_DIBSource* pBitmap,
604                 int dest_width,
605                 int dest_height,
606                 const FX_RECT& bitmap_rect,
607                 FX_DWORD flags);
608
609   FX_BOOL Continue(IFX_Pause* pPause);
610   FX_BOOL StartQuickStretch();
611   FX_BOOL StartStretch();
612   FX_BOOL ContinueQuickStretch(IFX_Pause* pPause);
613   FX_BOOL ContinueStretch(IFX_Pause* pPause);
614
615   IFX_ScanlineComposer* m_pDest;
616   const CFX_DIBSource* m_pSource;
617   CStretchEngine* m_pStretchEngine;
618   FX_DWORD m_Flags;
619   FX_BOOL m_bFlipX;
620   FX_BOOL m_bFlipY;
621   int m_DestWidth;
622   int m_DestHeight;
623   FX_RECT m_ClipRect;
624   int m_LineIndex;
625   int m_DestBPP;
626   uint8_t* m_pScanline;
627   uint8_t* m_pMaskScanline;
628   FXDIB_Format m_DestFormat;
629 };
630 class CFX_ImageTransformer {
631  public:
632   CFX_ImageTransformer();
633   ~CFX_ImageTransformer();
634
635   FX_BOOL Start(const CFX_DIBSource* pSrc,
636                 const CFX_AffineMatrix* pMatrix,
637                 int flags,
638                 const FX_RECT* pClip);
639
640   FX_BOOL Continue(IFX_Pause* pPause);
641
642   CFX_AffineMatrix* m_pMatrix;
643   FX_RECT m_StretchClip;
644   int m_ResultLeft;
645   int m_ResultTop;
646   int m_ResultWidth;
647   int m_ResultHeight;
648   CFX_AffineMatrix m_dest2stretch;
649   CFX_ImageStretcher m_Stretcher;
650   CFX_BitmapStorer m_Storer;
651   FX_DWORD m_Flags;
652   int m_Status;
653 };
654 class CFX_ImageRenderer {
655  public:
656   CFX_ImageRenderer();
657   ~CFX_ImageRenderer();
658
659   FX_BOOL Start(CFX_DIBitmap* pDevice,
660                 const CFX_ClipRgn* pClipRgn,
661                 const CFX_DIBSource* pSource,
662                 int bitmap_alpha,
663                 FX_DWORD mask_color,
664                 const CFX_AffineMatrix* pMatrix,
665                 FX_DWORD dib_flags,
666                 FX_BOOL bRgbByteOrder = FALSE,
667                 int alpha_flag = 0,
668                 void* pIccTransform = NULL,
669                 int blend_type = FXDIB_BLEND_NORMAL);
670
671   FX_BOOL Continue(IFX_Pause* pPause);
672
673  protected:
674   CFX_DIBitmap* m_pDevice;
675   const CFX_ClipRgn* m_pClipRgn;
676   int m_BitmapAlpha;
677   FX_DWORD m_MaskColor;
678   CFX_AffineMatrix m_Matrix;
679   CFX_ImageTransformer* m_pTransformer;
680   CFX_ImageStretcher m_Stretcher;
681   CFX_BitmapComposer m_Composer;
682   int m_Status;
683   FX_RECT m_ClipBox;
684   FX_DWORD m_Flags;
685   int m_AlphaFlag;
686   void* m_pIccTransform;
687   FX_BOOL m_bRgbByteOrder;
688   int m_BlendType;
689 };
690
691 #endif  // CORE_INCLUDE_FXGE_FX_DIB_H_