Remove "using namespace agg" to make it clear which code is using agg, and also so...
[pdfium.git] / core / src / fxge / agg / agg23 / fx_agg_driver.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/fxge/fx_ge.h"
8 #include "../../dib/dib_int.h"
9 #include "../../ge/text_int.h"
10 #include "../../../../include/fxcodec/fx_codec.h"
11 #include "agg_pixfmt_gray.h"
12 #include "agg_path_storage.h"
13 #include "agg_scanline_u.h"
14 #include "agg_rasterizer_scanline_aa.h"
15 #include "agg_renderer_scanline.h"
16 #include "agg_curves.h"
17 #include "agg_conv_stroke.h"
18 #include "agg_conv_dash.h"
19 #include "../include/fx_agg_driver.h"
20 void _HardClip(FX_FLOAT& x, FX_FLOAT& y)
21 {
22     if (x > 50000) {
23         x = 50000;
24     }
25     if (x < -50000) {
26         x = -50000;
27     }
28     if (y > 50000) {
29         y = 50000;
30     }
31     if (y < -50000) {
32         y = -50000;
33     }
34 }
35 void CAgg_PathData::BuildPath(const CFX_PathData* pPathData, const CFX_AffineMatrix* pObject2Device)
36 {
37     int nPoints = pPathData->GetPointCount();
38     FX_PATHPOINT* pPoints = pPathData->GetPoints();
39     for (int i = 0; i < nPoints; i ++) {
40         FX_FLOAT x = pPoints[i].m_PointX, y = pPoints[i].m_PointY;
41         if (pObject2Device) {
42             pObject2Device->Transform(x, y);
43         }
44         _HardClip(x, y);
45         int point_type = pPoints[i].m_Flag & FXPT_TYPE;
46         if (point_type == FXPT_MOVETO) {
47             m_PathData.move_to(x, y);
48         } else if (point_type == FXPT_LINETO) {
49             if (pPoints[i - 1].m_Flag == FXPT_MOVETO && (i == nPoints - 1 || pPoints[i + 1].m_Flag == FXPT_MOVETO) &&
50                     pPoints[i].m_PointX == pPoints[i - 1].m_PointX && pPoints[i].m_PointY == pPoints[i - 1].m_PointY) {
51                 x += 1;
52             }
53             m_PathData.line_to(x, y);
54         } else if (point_type == FXPT_BEZIERTO) {
55             FX_FLOAT x0 = pPoints[i - 1].m_PointX, y0 = pPoints[i - 1].m_PointY;
56             FX_FLOAT x2 = pPoints[i + 1].m_PointX, y2 = pPoints[i + 1].m_PointY;
57             FX_FLOAT x3 = pPoints[i + 2].m_PointX, y3 = pPoints[i + 2].m_PointY;
58             if (pObject2Device) {
59                 pObject2Device->Transform(x0, y0);
60                 pObject2Device->Transform(x2, y2);
61                 pObject2Device->Transform(x3, y3);
62             }
63             agg::curve4 curve(x0, y0, x, y, x2, y2, x3, y3);
64             i += 2;
65             m_PathData.add_path_curve(curve);
66         }
67         if (pPoints[i].m_Flag & FXPT_CLOSEFIGURE) {
68             m_PathData.end_poly();
69         }
70     }
71 }
72 namespace agg
73 {
74 template<class BaseRenderer> class renderer_scanline_aa_offset
75 {
76 public:
77     typedef BaseRenderer base_ren_type;
78     typedef typename base_ren_type::color_type color_type;
79     renderer_scanline_aa_offset(base_ren_type& ren, unsigned left, unsigned top) :
80         m_ren(&ren), m_left(left), m_top(top)
81     {}
82     void color(const color_type& c)
83     {
84         m_color = c;
85     }
86     const color_type& color() const
87     {
88         return m_color;
89     }
90     void prepare(unsigned) {}
91     template<class Scanline> void render(const Scanline& sl)
92     {
93         int y = sl.y();
94         unsigned num_spans = sl.num_spans();
95         typename Scanline::const_iterator span = sl.begin();
96         for(;;) {
97             int x = span->x;
98             if(span->len > 0) {
99                 m_ren->blend_solid_hspan(x - m_left, y - m_top, (unsigned)span->len,
100                                          m_color,
101                                          span->covers);
102             } else {
103                 m_ren->blend_hline(x - m_left, y - m_top, (unsigned)(x - span->len - 1),
104                                    m_color,
105                                    *(span->covers));
106             }
107             if(--num_spans == 0) {
108                 break;
109             }
110             ++span;
111         }
112     }
113 private:
114     base_ren_type* m_ren;
115     color_type m_color;
116     unsigned m_left, m_top;
117 };
118 }
119 static void RasterizeStroke(agg::rasterizer_scanline_aa& rasterizer, agg::path_storage& path_data,
120                             const CFX_AffineMatrix* pObject2Device,
121                             const CFX_GraphStateData* pGraphState, FX_FLOAT scale = 1.0f,
122                             FX_BOOL bStrokeAdjust = FALSE, FX_BOOL bTextMode = FALSE)
123 {
124     agg::line_cap_e cap;
125     switch (pGraphState->m_LineCap) {
126         case CFX_GraphStateData::LineCapRound:
127             cap = agg::round_cap;
128             break;
129         case CFX_GraphStateData::LineCapSquare:
130             cap = agg::square_cap;
131             break;
132         default:
133             cap = agg::butt_cap;
134             break;
135     }
136     agg::line_join_e join;
137     switch (pGraphState->m_LineJoin) {
138         case CFX_GraphStateData::LineJoinRound:
139             join = agg::round_join;
140             break;
141         case CFX_GraphStateData::LineJoinBevel:
142             join = agg::bevel_join;
143             break;
144         default:
145             join = agg::miter_join_revert;
146             break;
147     }
148     FX_FLOAT width = pGraphState->m_LineWidth * scale;
149     FX_FLOAT unit = 1.f;
150     if (pObject2Device) {
151         unit = FXSYS_Div(1.0f, (pObject2Device->GetXUnit() + pObject2Device->GetYUnit()) / 2);
152     }
153     if (width < unit) {
154         width = unit;
155     }
156     if (pGraphState->m_DashArray == NULL) {
157         agg::conv_stroke<agg::path_storage> stroke(path_data);
158         stroke.line_join(join);
159         stroke.line_cap(cap);
160         stroke.miter_limit(pGraphState->m_MiterLimit);
161         stroke.width(width);
162         rasterizer.add_path_transformed(stroke, pObject2Device);
163     } else {
164         typedef agg::conv_dash<agg::path_storage> dash_converter;
165         dash_converter dash(path_data);
166         for (int i = 0; i < (pGraphState->m_DashCount + 1) / 2; i ++) {
167             FX_FLOAT on = pGraphState->m_DashArray[i * 2];
168             if (on <= 0.000001f) {
169                 on = 1.0f / 10;
170             }
171             FX_FLOAT off = i * 2 + 1 == pGraphState->m_DashCount ? on :
172                            pGraphState->m_DashArray[i * 2 + 1];
173             if (off < 0) {
174                 off = 0;
175             }
176             dash.add_dash(on * scale, off * scale);
177         }
178         dash.dash_start(pGraphState->m_DashPhase * scale);
179         typedef agg::conv_stroke<dash_converter> dash_stroke;
180         dash_stroke stroke(dash);
181         stroke.line_join(join);
182         stroke.line_cap(cap);
183         stroke.miter_limit(pGraphState->m_MiterLimit);
184         stroke.width(width);
185         rasterizer.add_path_transformed(stroke, pObject2Device);
186     }
187 }
188 IFX_RenderDeviceDriver* IFX_RenderDeviceDriver::CreateFxgeDriver(CFX_DIBitmap* pBitmap, FX_BOOL bRgbByteOrder, CFX_DIBitmap* pOriDevice, FX_BOOL bGroupKnockout)
189 {
190     return FX_NEW CFX_AggDeviceDriver(pBitmap, 0, bRgbByteOrder, pOriDevice, bGroupKnockout);
191 }
192 CFX_AggDeviceDriver::CFX_AggDeviceDriver(CFX_DIBitmap* pBitmap, int dither_bits, FX_BOOL bRgbByteOrder, CFX_DIBitmap* pOriDevice, FX_BOOL bGroupKnockout)
193 {
194     m_pBitmap = pBitmap;
195     m_DitherBits = dither_bits;
196     m_pClipRgn = NULL;
197     m_pPlatformBitmap = NULL;
198     m_pPlatformGraphics = NULL;
199     m_pDwRenderTartget = NULL;
200     m_bRgbByteOrder = bRgbByteOrder;
201     m_pOriDevice = pOriDevice;
202     m_bGroupKnockout = bGroupKnockout;
203     m_FillFlags = 0;
204     InitPlatform();
205 }
206 CFX_AggDeviceDriver::~CFX_AggDeviceDriver()
207 {
208     if (m_pClipRgn) {
209         delete m_pClipRgn;
210     }
211     for (int i = 0; i < m_StateStack.GetSize(); i ++)
212         if (m_StateStack[i]) {
213             delete (CFX_ClipRgn*)m_StateStack[i];
214         }
215     DestroyPlatform();
216 }
217 #if ((_FXM_PLATFORM_  != _FXM_PLATFORM_APPLE_)|| defined(_FPDFAPI_MINI_))
218 void CFX_AggDeviceDriver::InitPlatform()
219 {
220 }
221 void CFX_AggDeviceDriver::DestroyPlatform()
222 {
223 }
224 FX_BOOL CFX_AggDeviceDriver::DrawDeviceText(int nChars, const FXTEXT_CHARPOS* pCharPos, CFX_Font* pFont,
225         CFX_FontCache* pCache, const CFX_AffineMatrix* pObject2Device, FX_FLOAT font_size, FX_DWORD color,
226         int alpha_flag, void* pIccTransform)
227 {
228     return FALSE;
229 }
230 #endif
231 int CFX_AggDeviceDriver::GetDeviceCaps(int caps_id)
232 {
233     switch (caps_id) {
234         case FXDC_DEVICE_CLASS:
235             return FXDC_DISPLAY;
236         case FXDC_PIXEL_WIDTH:
237             return m_pBitmap->GetWidth();
238         case FXDC_PIXEL_HEIGHT:
239             return m_pBitmap->GetHeight();
240         case FXDC_BITS_PIXEL:
241             return m_pBitmap->GetBPP();
242         case FXDC_HORZ_SIZE:
243         case FXDC_VERT_SIZE:
244             return 0;
245         case FXDC_RENDER_CAPS: {
246                 int flags = FXRC_GET_BITS | FXRC_ALPHA_PATH | FXRC_ALPHA_IMAGE | FXRC_BLEND_MODE | FXRC_SOFT_CLIP;
247                 if (m_pBitmap->HasAlpha()) {
248                     flags |= FXRC_ALPHA_OUTPUT;
249                 } else if (m_pBitmap->IsAlphaMask()) {
250                     if (m_pBitmap->GetBPP() == 1) {
251                         flags |= FXRC_BITMASK_OUTPUT;
252                     } else {
253                         flags |= FXRC_BYTEMASK_OUTPUT;
254                     }
255                 }
256                 if (m_pBitmap->IsCmykImage()) {
257                     flags |= FXRC_CMYK_OUTPUT;
258                 }
259                 return flags;
260             }
261         case FXDC_DITHER_BITS:
262             return m_DitherBits;
263     }
264     return 0;
265 }
266 void CFX_AggDeviceDriver::SaveState()
267 {
268     void* pClip = NULL;
269     if (m_pClipRgn) {
270         pClip = FX_NEW CFX_ClipRgn(*m_pClipRgn);
271         if (!pClip) {
272             return;
273         }
274     }
275     m_StateStack.Add(pClip);
276 }
277 void CFX_AggDeviceDriver::RestoreState(FX_BOOL bKeepSaved)
278 {
279     if (m_StateStack.GetSize() == 0) {
280         if (m_pClipRgn) {
281             delete m_pClipRgn;
282             m_pClipRgn = NULL;
283         }
284         return;
285     }
286     CFX_ClipRgn* pSavedClip = (CFX_ClipRgn*)m_StateStack[m_StateStack.GetSize() - 1];
287     if (m_pClipRgn) {
288         delete m_pClipRgn;
289         m_pClipRgn = NULL;
290     }
291     if (bKeepSaved) {
292         if (pSavedClip) {
293             m_pClipRgn = FX_NEW CFX_ClipRgn(*pSavedClip);
294         }
295     } else {
296         m_StateStack.RemoveAt(m_StateStack.GetSize() - 1);
297         m_pClipRgn = pSavedClip;
298     }
299 }
300 void CFX_AggDeviceDriver::SetClipMask(agg::rasterizer_scanline_aa& rasterizer)
301 {
302     FX_RECT path_rect(rasterizer.min_x(), rasterizer.min_y(),
303                       rasterizer.max_x() + 1, rasterizer.max_y() + 1);
304     path_rect.Intersect(m_pClipRgn->GetBox());
305     CFX_DIBitmapRef mask;
306     CFX_DIBitmap* pThisLayer = mask.New();
307     if (!pThisLayer) {
308         return;
309     }
310     pThisLayer->Create(path_rect.Width(), path_rect.Height(), FXDIB_8bppMask);
311     pThisLayer->Clear(0);
312     agg::rendering_buffer raw_buf(pThisLayer->GetBuffer(), pThisLayer->GetWidth(), pThisLayer->GetHeight(), pThisLayer->GetPitch());
313     agg::pixfmt_gray8 pixel_buf(raw_buf);
314     agg::renderer_base<agg::pixfmt_gray8> base_buf(pixel_buf);
315     agg::renderer_scanline_aa_offset<agg::renderer_base<agg::pixfmt_gray8> > final_render(base_buf, path_rect.left, path_rect.top);
316     final_render.color(agg::gray8(255));
317     agg::scanline_u8 scanline;
318     agg::render_scanlines(rasterizer, scanline, final_render, (m_FillFlags & FXFILL_NOPATHSMOOTH) != 0);
319     m_pClipRgn->IntersectMaskF(path_rect.left, path_rect.top, mask);
320 }
321 FX_BOOL CFX_AggDeviceDriver::SetClip_PathFill(const CFX_PathData* pPathData,
322         const CFX_AffineMatrix* pObject2Device,
323         int fill_mode
324                                              )
325 {
326     m_FillFlags = fill_mode;
327     if (m_pClipRgn == NULL) {
328         m_pClipRgn = FX_NEW CFX_ClipRgn(GetDeviceCaps(FXDC_PIXEL_WIDTH), GetDeviceCaps(FXDC_PIXEL_HEIGHT));
329         if (!m_pClipRgn) {
330             return FALSE;
331         }
332     }
333     if (pPathData->GetPointCount() == 5 || pPathData->GetPointCount() == 4) {
334         CFX_FloatRect rectf;
335         if (pPathData->IsRect(pObject2Device, &rectf)) {
336             rectf.Intersect(CFX_FloatRect(0, 0, (FX_FLOAT)GetDeviceCaps(FXDC_PIXEL_WIDTH), (FX_FLOAT)GetDeviceCaps(FXDC_PIXEL_HEIGHT)));
337             FX_RECT rect = rectf.GetOutterRect();
338             m_pClipRgn->IntersectRect(rect);
339             return TRUE;
340         }
341     }
342     CAgg_PathData path_data;
343     path_data.BuildPath(pPathData, pObject2Device);
344     path_data.m_PathData.end_poly();
345     agg::rasterizer_scanline_aa rasterizer;
346     rasterizer.clip_box(0.0f, 0.0f, (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_WIDTH)), (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_HEIGHT)));
347     rasterizer.add_path(path_data.m_PathData);
348     rasterizer.filling_rule((fill_mode & 3) == FXFILL_WINDING ? agg::fill_non_zero : agg::fill_even_odd);
349     SetClipMask(rasterizer);
350     return TRUE;
351 }
352 FX_BOOL CFX_AggDeviceDriver::SetClip_PathStroke(const CFX_PathData* pPathData,
353         const CFX_AffineMatrix* pObject2Device,
354         const CFX_GraphStateData* pGraphState
355                                                )
356 {
357     if (m_pClipRgn == NULL) {
358         m_pClipRgn = FX_NEW CFX_ClipRgn(GetDeviceCaps(FXDC_PIXEL_WIDTH), GetDeviceCaps(FXDC_PIXEL_HEIGHT));
359         if (!m_pClipRgn) {
360             return FALSE;
361         }
362     }
363     CAgg_PathData path_data;
364     path_data.BuildPath(pPathData, NULL);
365     agg::rasterizer_scanline_aa rasterizer;
366     rasterizer.clip_box(0.0f, 0.0f, (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_WIDTH)), (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_HEIGHT)));
367     RasterizeStroke(rasterizer, path_data.m_PathData, pObject2Device, pGraphState);
368     rasterizer.filling_rule(agg::fill_non_zero);
369     SetClipMask(rasterizer);
370     return TRUE;
371 }
372 class CFX_Renderer : public CFX_Object
373 {
374 private:
375     int                 m_Alpha,
376                 m_Red,
377                 m_Green,
378                 m_Blue,
379                 m_Gray;
380     FX_DWORD    m_Color;
381     FX_BOOL             m_bFullCover;
382     FX_BOOL     m_bRgbByteOrder;
383     CFX_DIBitmap* m_pOriDevice;
384     FX_RECT             m_ClipBox;
385     const CFX_DIBitmap* m_pClipMask;
386     CFX_DIBitmap*       m_pDevice;
387     const CFX_ClipRgn* m_pClipRgn;
388     void (CFX_Renderer::*composite_span)(FX_LPBYTE, int, int, int, FX_LPBYTE, int, int, FX_LPBYTE, FX_LPBYTE);
389 public:
390     void prepare(unsigned) {}
391     void CompositeSpan(FX_LPBYTE dest_scan, FX_LPBYTE ori_scan, int Bpp, FX_BOOL bDestAlpha,
392                        int span_left, int span_len, FX_LPBYTE cover_scan,
393                        int clip_left, int clip_right, FX_LPBYTE clip_scan)
394     {
395         ASSERT(!m_pDevice->IsCmykImage());
396         int col_start = span_left < clip_left ? clip_left - span_left : 0;
397         int col_end = (span_left + span_len) < clip_right ? span_len : (clip_right - span_left);
398         if (Bpp) {
399             dest_scan += col_start * Bpp;
400             ori_scan += col_start * Bpp;
401         } else {
402             dest_scan += col_start / 8;
403             ori_scan += col_start / 8;
404         }
405         if (m_bRgbByteOrder) {
406             if (Bpp == 4 && bDestAlpha) {
407                 for (int col = col_start; col < col_end; col ++) {
408                     int src_alpha;
409                     if (clip_scan) {
410                         src_alpha = m_Alpha * clip_scan[col] / 255;
411                     } else {
412                         src_alpha = m_Alpha;
413                     }
414                     FX_BYTE dest_alpha = ori_scan[3] + src_alpha - ori_scan[3] * src_alpha / 255;
415                     dest_scan[3] = dest_alpha;
416                     int alpha_ratio = src_alpha * 255 / dest_alpha;
417                     if (m_bFullCover) {
418                         *dest_scan++ = FXDIB_ALPHA_MERGE(*ori_scan++, m_Red, alpha_ratio);
419                         *dest_scan++ = FXDIB_ALPHA_MERGE(*ori_scan++, m_Green, alpha_ratio);
420                         *dest_scan++ = FXDIB_ALPHA_MERGE(*ori_scan++, m_Blue, alpha_ratio);
421                         dest_scan++;
422                         ori_scan++;
423                     } else {
424                         int r = FXDIB_ALPHA_MERGE(*ori_scan++, m_Red, alpha_ratio);
425                         int g = FXDIB_ALPHA_MERGE(*ori_scan++, m_Green, alpha_ratio);
426                         int b = FXDIB_ALPHA_MERGE(*ori_scan++, m_Blue, alpha_ratio);
427                         ori_scan ++;
428                         *dest_scan = FXDIB_ALPHA_MERGE( *dest_scan, r, cover_scan[col]);
429                         dest_scan ++;
430                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, g, cover_scan[col]);
431                         dest_scan ++;
432                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, b, cover_scan[col]);
433                         dest_scan += 2;
434                     }
435                 }
436                 return;
437             } else if (Bpp == 3 || Bpp == 4) {
438                 for (int col = col_start; col < col_end; col ++) {
439                     int src_alpha;
440                     if (clip_scan) {
441                         src_alpha = m_Alpha * clip_scan[col] / 255 ;
442                     } else {
443                         src_alpha = m_Alpha;
444                     }
445                     int r = FXDIB_ALPHA_MERGE(*ori_scan++, m_Red, src_alpha);
446                     int g = FXDIB_ALPHA_MERGE(*ori_scan++, m_Green, src_alpha);
447                     int b = FXDIB_ALPHA_MERGE(*ori_scan, m_Blue, src_alpha);
448                     ori_scan += Bpp - 2;
449                     *dest_scan = FXDIB_ALPHA_MERGE( *dest_scan, r, cover_scan[col]);
450                     dest_scan ++;
451                     *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, g, cover_scan[col]);
452                     dest_scan ++;
453                     *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, b, cover_scan[col]);
454                     dest_scan += Bpp - 2;
455                 }
456             }
457             return;
458         }
459         if (Bpp == 4 && bDestAlpha) {
460             for (int col = col_start; col < col_end; col ++) {
461                 int src_alpha;
462                 if (clip_scan) {
463                     src_alpha = m_Alpha * clip_scan[col] / 255;
464                 } else {
465                     src_alpha = m_Alpha;
466                 }
467                 int src_alpha_covered = src_alpha * cover_scan[col] / 255;
468                 if (src_alpha_covered == 0) {
469                     dest_scan += 4;
470                     continue;
471                 }
472                 if (cover_scan[col] == 255) {
473                     dest_scan[3] = src_alpha_covered;
474                     *dest_scan ++ = m_Blue;
475                     *dest_scan ++ = m_Green;
476                     *dest_scan = m_Red;
477                     dest_scan += 2;
478                     continue;
479                 } else {
480                     if (dest_scan[3] == 0) {
481                         dest_scan[3] = src_alpha_covered;
482                         *dest_scan ++ = m_Blue;
483                         *dest_scan ++ = m_Green;
484                         *dest_scan = m_Red;
485                         dest_scan += 2;
486                         continue;
487                     }
488                     FX_BYTE cover = cover_scan[col];
489                     dest_scan[3] = FXDIB_ALPHA_MERGE(dest_scan[3], src_alpha, cover);
490                     *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, cover);
491                     dest_scan ++;
492                     *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, cover);
493                     dest_scan ++;
494                     *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, cover);
495                     dest_scan += 2;
496                 }
497             }
498             return;
499         } else if (Bpp == 3 || Bpp == 4) {
500             for (int col = col_start; col < col_end; col ++) {
501                 int src_alpha;
502                 if (clip_scan) {
503                     src_alpha = m_Alpha * clip_scan[col] / 255;
504                 } else {
505                     src_alpha = m_Alpha;
506                 }
507                 if (m_bFullCover) {
508                     *dest_scan++ = FXDIB_ALPHA_MERGE(*ori_scan++, m_Blue, src_alpha);
509                     *dest_scan++ = FXDIB_ALPHA_MERGE(*ori_scan++, m_Green, src_alpha);
510                     *dest_scan = FXDIB_ALPHA_MERGE(*ori_scan, m_Red, src_alpha);
511                     dest_scan += Bpp - 2;
512                     ori_scan += Bpp - 2;
513                     continue;
514                 }
515                 int b = FXDIB_ALPHA_MERGE(*ori_scan++, m_Blue, src_alpha);
516                 int g = FXDIB_ALPHA_MERGE(*ori_scan++, m_Green, src_alpha);
517                 int r = FXDIB_ALPHA_MERGE(*ori_scan, m_Red, src_alpha);
518                 ori_scan += Bpp - 2;
519                 *dest_scan = FXDIB_ALPHA_MERGE( *dest_scan, b, cover_scan[col]);
520                 dest_scan ++;
521                 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, g, cover_scan[col]);
522                 dest_scan ++;
523                 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, r, cover_scan[col]);
524                 dest_scan += Bpp - 2;
525                 continue;
526             }
527             return;
528         } else if (Bpp == 1) {
529             for (int col = col_start; col < col_end; col ++) {
530                 int src_alpha;
531                 if (clip_scan) {
532                     src_alpha = m_Alpha * clip_scan[col] / 255;
533                 } else {
534                     src_alpha = m_Alpha;
535                 }
536                 if (m_bFullCover) {
537                     *dest_scan = FXDIB_ALPHA_MERGE(*ori_scan++, m_Gray, src_alpha);
538                 } else {
539                     int gray = FXDIB_ALPHA_MERGE(*ori_scan++, m_Gray, src_alpha);
540                     *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, cover_scan[col]);
541                     dest_scan++;
542                 }
543             }
544         } else {
545             int index = 0;
546             if (m_pDevice->GetPalette() == NULL) {
547                 index = ((FX_BYTE)m_Color == 0xff) ? 1 : 0;
548             } else {
549                 for (int i = 0; i < 2; i ++)
550                     if (FXARGB_TODIB(m_pDevice->GetPalette()[i]) == m_Color) {
551                         index = i;
552                     }
553             }
554             FX_LPBYTE dest_scan1 = dest_scan;
555             for (int col = col_start; col < col_end; col ++) {
556                 int src_alpha;
557                 if (clip_scan) {
558                     src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255;
559                 } else {
560                     src_alpha = m_Alpha * cover_scan[col] / 255;
561                 }
562                 if (src_alpha) {
563                     if (!index) {
564                         *dest_scan1 &= ~(1 << (7 - (col + span_left) % 8));
565                     } else {
566                         *dest_scan1 |= 1 << (7 - (col + span_left) % 8);
567                     }
568                 }
569                 dest_scan1 = dest_scan + (span_left % 8 + col - col_start + 1) / 8;
570             }
571         }
572     }
573     void CompositeSpan1bpp(FX_LPBYTE dest_scan, int Bpp,
574                            int span_left, int span_len, FX_LPBYTE cover_scan,
575                            int clip_left, int clip_right, FX_LPBYTE clip_scan,
576                            FX_LPBYTE dest_extra_alpha_scan)
577     {
578         ASSERT(!m_bRgbByteOrder);
579         ASSERT(!m_pDevice->IsCmykImage());
580         int col_start = span_left < clip_left ? clip_left - span_left : 0;
581         int col_end = (span_left + span_len) < clip_right ? span_len : (clip_right - span_left);
582         dest_scan += col_start / 8;
583         int index = 0;
584         if (m_pDevice->GetPalette() == NULL) {
585             index = ((FX_BYTE)m_Color == 0xff) ? 1 : 0;
586         } else {
587             for (int i = 0; i < 2; i ++)
588                 if (FXARGB_TODIB(m_pDevice->GetPalette()[i]) == m_Color) {
589                     index = i;
590                 }
591         }
592         FX_LPBYTE dest_scan1 = dest_scan;
593         for (int col = col_start; col < col_end; col ++) {
594             int src_alpha;
595             if (clip_scan) {
596                 src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255;
597             } else {
598                 src_alpha = m_Alpha * cover_scan[col] / 255;
599             }
600             if (src_alpha) {
601                 if (!index) {
602                     *dest_scan1 &= ~(1 << (7 - (col + span_left) % 8));
603                 } else {
604                     *dest_scan1 |= 1 << (7 - (col + span_left) % 8);
605                 }
606             }
607             dest_scan1 = dest_scan + (span_left % 8 + col - col_start + 1) / 8;
608         }
609     }
610     void CompositeSpanGray(FX_LPBYTE dest_scan, int Bpp,
611                            int span_left, int span_len, FX_LPBYTE cover_scan,
612                            int clip_left, int clip_right, FX_LPBYTE clip_scan,
613                            FX_LPBYTE dest_extra_alpha_scan)
614     {
615         ASSERT(!m_bRgbByteOrder);
616         int col_start = span_left < clip_left ? clip_left - span_left : 0;
617         int col_end = (span_left + span_len) < clip_right ? span_len : (clip_right - span_left);
618         dest_scan += col_start;
619         Bpp;
620         if (dest_extra_alpha_scan) {
621             for (int col = col_start; col < col_end; col ++) {
622                 int src_alpha;
623                 if (m_bFullCover) {
624                     if (clip_scan) {
625                         src_alpha = m_Alpha * clip_scan[col] / 255;
626                     } else {
627                         src_alpha = m_Alpha;
628                     }
629                 } else {
630                     if (clip_scan) {
631                         src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255;
632                     } else {
633                         src_alpha = m_Alpha * cover_scan[col] / 255;
634                     }
635                 }
636                 if (src_alpha) {
637                     if (src_alpha == 255) {
638                         *dest_scan = m_Gray;
639                         *dest_extra_alpha_scan = m_Alpha;
640                     } else {
641                         FX_BYTE dest_alpha = (*dest_extra_alpha_scan) + src_alpha -
642                                              (*dest_extra_alpha_scan) * src_alpha / 255;
643                         *dest_extra_alpha_scan++ = dest_alpha;
644                         int alpha_ratio = src_alpha * 255 / dest_alpha;
645                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Gray, alpha_ratio);
646                         dest_scan ++;
647                         continue;
648                     }
649                 }
650                 dest_extra_alpha_scan ++;
651                 dest_scan ++;
652             }
653         } else {
654             for (int col = col_start; col < col_end; col ++) {
655                 int src_alpha;
656                 if (clip_scan) {
657                     src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255;
658                 } else {
659                     src_alpha = m_Alpha * cover_scan[col] / 255;
660                 }
661                 if (src_alpha) {
662                     if (src_alpha == 255) {
663                         *dest_scan = m_Gray;
664                     } else {
665                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Gray, src_alpha);
666                     }
667                 }
668                 dest_scan ++;
669             }
670         }
671     }
672     void CompositeSpanARGB(FX_LPBYTE dest_scan, int Bpp,
673                            int span_left, int span_len, FX_LPBYTE cover_scan,
674                            int clip_left, int clip_right, FX_LPBYTE clip_scan,
675                            FX_LPBYTE dest_extra_alpha_scan)
676     {
677         int col_start = span_left < clip_left ? clip_left - span_left : 0;
678         int col_end = (span_left + span_len) < clip_right ? span_len : (clip_right - span_left);
679         dest_scan += col_start * Bpp;
680         if (m_bRgbByteOrder) {
681             for (int col = col_start; col < col_end; col ++) {
682                 int src_alpha;
683                 if (m_bFullCover) {
684                     if (clip_scan) {
685                         src_alpha = m_Alpha * clip_scan[col] / 255;
686                     } else {
687                         src_alpha = m_Alpha;
688                     }
689                 } else {
690                     if (clip_scan) {
691                         src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255;
692                     } else {
693                         src_alpha = m_Alpha * cover_scan[col] / 255;
694                     }
695                 }
696                 if (src_alpha) {
697                     if (src_alpha == 255) {
698                         *(FX_DWORD*)dest_scan = m_Color;
699                     } else {
700                         FX_BYTE dest_alpha = dest_scan[3] + src_alpha - dest_scan[3] * src_alpha / 255;
701                         dest_scan[3] = dest_alpha;
702                         int alpha_ratio = src_alpha * 255 / dest_alpha;
703                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, alpha_ratio);
704                         dest_scan ++;
705                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, alpha_ratio);
706                         dest_scan ++;
707                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, alpha_ratio);
708                         dest_scan += 2;
709                         continue;
710                     }
711                 }
712                 dest_scan += 4;
713             }
714             return;
715         }
716         for (int col = col_start; col < col_end; col ++) {
717             int src_alpha;
718             if (m_bFullCover) {
719                 if (clip_scan) {
720                     src_alpha = m_Alpha * clip_scan[col] / 255;
721                 } else {
722                     src_alpha = m_Alpha;
723                 }
724             } else {
725                 if (clip_scan) {
726                     src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255;
727                 } else {
728                     src_alpha = m_Alpha * cover_scan[col] / 255;
729                 }
730             }
731             if (src_alpha) {
732                 if (src_alpha == 255) {
733                     *(FX_DWORD*)dest_scan = m_Color;
734                 } else {
735                     if (dest_scan[3] == 0) {
736                         dest_scan[3] = src_alpha;
737                         *dest_scan++ = m_Blue;
738                         *dest_scan++ = m_Green;
739                         *dest_scan = m_Red;
740                         dest_scan += 2;
741                         continue;
742                     }
743                     FX_BYTE dest_alpha = dest_scan[3] + src_alpha - dest_scan[3] * src_alpha / 255;
744                     dest_scan[3] = dest_alpha;
745                     int alpha_ratio = src_alpha * 255 / dest_alpha;
746                     *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, alpha_ratio);
747                     dest_scan ++;
748                     *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, alpha_ratio);
749                     dest_scan ++;
750                     *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, alpha_ratio);
751                     dest_scan += 2;
752                     continue;
753                 }
754             }
755             dest_scan += Bpp;
756         }
757     }
758     void CompositeSpanRGB(FX_LPBYTE dest_scan, int Bpp,
759                           int span_left, int span_len, FX_LPBYTE cover_scan,
760                           int clip_left, int clip_right, FX_LPBYTE clip_scan,
761                           FX_LPBYTE dest_extra_alpha_scan)
762     {
763         int col_start = span_left < clip_left ? clip_left - span_left : 0;
764         int col_end = (span_left + span_len) < clip_right ? span_len : (clip_right - span_left);
765         dest_scan += col_start * Bpp;
766         if (m_bRgbByteOrder) {
767             for (int col = col_start; col < col_end; col ++) {
768                 int src_alpha;
769                 if (clip_scan) {
770                     src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255;
771                 } else {
772                     src_alpha = m_Alpha * cover_scan[col] / 255;
773                 }
774                 if (src_alpha) {
775                     if (src_alpha == 255) {
776                         if (Bpp == 4) {
777                             *(FX_DWORD*)dest_scan = m_Color;
778                         } else if (Bpp == 3) {
779                             *dest_scan++ = m_Red;
780                             *dest_scan++ = m_Green;
781                             *dest_scan++ = m_Blue;
782                             continue;
783                         }
784                     } else {
785                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, src_alpha);
786                         dest_scan++;
787                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, src_alpha);
788                         dest_scan++;
789                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, src_alpha);
790                         dest_scan += Bpp - 2;
791                         continue;
792                     }
793                 }
794                 dest_scan += Bpp;
795             }
796             return;
797         }
798         if (Bpp == 3 && dest_extra_alpha_scan) {
799             for (int col = col_start; col < col_end; col ++) {
800                 int src_alpha;
801                 if (m_bFullCover) {
802                     if (clip_scan) {
803                         src_alpha = m_Alpha * clip_scan[col] / 255;
804                     } else {
805                         src_alpha = m_Alpha;
806                     }
807                 } else {
808                     if (clip_scan) {
809                         src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255;
810                     } else {
811                         src_alpha = m_Alpha * cover_scan[col] / 255;
812                     }
813                 }
814                 if (src_alpha) {
815                     if (src_alpha == 255) {
816                         *dest_scan++ = (FX_BYTE)m_Blue;
817                         *dest_scan++ = (FX_BYTE)m_Green;
818                         *dest_scan++ = (FX_BYTE)m_Red;
819                         *dest_extra_alpha_scan++ = (FX_BYTE)m_Alpha;
820                         continue;
821                     } else {
822                         FX_BYTE dest_alpha = (*dest_extra_alpha_scan) + src_alpha -
823                                              (*dest_extra_alpha_scan) * src_alpha / 255;
824                         *dest_extra_alpha_scan++ = dest_alpha;
825                         int alpha_ratio = src_alpha * 255 / dest_alpha;
826                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, alpha_ratio);
827                         dest_scan ++;
828                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, alpha_ratio);
829                         dest_scan ++;
830                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, alpha_ratio);
831                         dest_scan ++;
832                         continue;
833                     }
834                 }
835                 dest_extra_alpha_scan++;
836                 dest_scan += Bpp;
837             }
838         } else {
839             for (int col = col_start; col < col_end; col ++) {
840                 int src_alpha;
841                 if (m_bFullCover) {
842                     if (clip_scan) {
843                         src_alpha = m_Alpha * clip_scan[col] / 255;
844                     } else {
845                         src_alpha = m_Alpha;
846                     }
847                 } else {
848                     if (clip_scan) {
849                         src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255;
850                     } else {
851                         src_alpha = m_Alpha * cover_scan[col] / 255;
852                     }
853                 }
854                 if (src_alpha) {
855                     if (src_alpha == 255) {
856                         if (Bpp == 4) {
857                             *(FX_DWORD*)dest_scan = m_Color;
858                         } else if (Bpp == 3) {
859                             *dest_scan++ = m_Blue;
860                             *dest_scan++ = m_Green;
861                             *dest_scan++ = m_Red;
862                             continue;
863                         }
864                     } else {
865                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, src_alpha);
866                         dest_scan ++;
867                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, src_alpha);
868                         dest_scan ++;
869                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, src_alpha);
870                         dest_scan += Bpp - 2;
871                         continue;
872                     }
873                 }
874                 dest_scan += Bpp;
875             }
876         }
877     }
878     void CompositeSpanCMYK(FX_LPBYTE dest_scan, int Bpp,
879                            int span_left, int span_len, FX_LPBYTE cover_scan,
880                            int clip_left, int clip_right, FX_LPBYTE clip_scan,
881                            FX_LPBYTE dest_extra_alpha_scan)
882     {
883         ASSERT(!m_bRgbByteOrder);
884         int col_start = span_left < clip_left ? clip_left - span_left : 0;
885         int col_end = (span_left + span_len) < clip_right ? span_len : (clip_right - span_left);
886         dest_scan += col_start * 4;
887         Bpp;
888         if (dest_extra_alpha_scan) {
889             for (int col = col_start; col < col_end; col ++) {
890                 int src_alpha;
891                 if (m_bFullCover) {
892                     if (clip_scan) {
893                         src_alpha = m_Alpha * clip_scan[col] / 255;
894                     } else {
895                         src_alpha = m_Alpha;
896                     }
897                 } else {
898                     if (clip_scan) {
899                         src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255;
900                     } else {
901                         src_alpha = m_Alpha * cover_scan[col] / 255;
902                     }
903                 }
904                 if (src_alpha) {
905                     if (src_alpha == 255) {
906                         *(FX_CMYK*)dest_scan = m_Color;
907                         *dest_extra_alpha_scan = (FX_BYTE)m_Alpha;
908                     } else {
909                         FX_BYTE dest_alpha = (*dest_extra_alpha_scan) + src_alpha -
910                                              (*dest_extra_alpha_scan) * src_alpha / 255;
911                         *dest_extra_alpha_scan++ = dest_alpha;
912                         int alpha_ratio = src_alpha * 255 / dest_alpha;
913                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, alpha_ratio);
914                         dest_scan ++;
915                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, alpha_ratio);
916                         dest_scan ++;
917                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, alpha_ratio);
918                         dest_scan ++;
919                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Gray, alpha_ratio);
920                         dest_scan ++;
921                         continue;
922                     }
923                 }
924                 dest_extra_alpha_scan++;
925                 dest_scan += 4;
926             }
927         } else {
928             for (int col = col_start; col < col_end; col ++) {
929                 int src_alpha;
930                 if (clip_scan) {
931                     src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255;
932                 } else {
933                     src_alpha = m_Alpha * cover_scan[col] / 255;
934                 }
935                 if (src_alpha) {
936                     if (src_alpha == 255) {
937                         *(FX_CMYK*)dest_scan = m_Color;
938                     } else {
939                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, src_alpha);
940                         dest_scan ++;
941                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, src_alpha);
942                         dest_scan ++;
943                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, src_alpha);
944                         dest_scan ++;
945                         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Gray, src_alpha);
946                         dest_scan ++;
947                         continue;
948                     }
949                 }
950                 dest_scan += 4;
951             }
952         }
953     }
954     template<class Scanline> void render(const Scanline& sl)
955     {
956         if (m_pOriDevice == NULL && composite_span == NULL) {
957             return;
958         }
959         int y = sl.y();
960         if (y < m_ClipBox.top || y >= m_ClipBox.bottom) {
961             return;
962         }
963         FX_LPBYTE dest_scan = m_pDevice->GetBuffer() + m_pDevice->GetPitch() * y;
964         FX_LPBYTE dest_scan_extra_alpha = NULL;
965         CFX_DIBitmap* pAlphaMask = m_pDevice->m_pAlphaMask;
966         if (pAlphaMask) {
967             dest_scan_extra_alpha = pAlphaMask->GetBuffer() + pAlphaMask->GetPitch() * y;
968         }
969         FX_LPBYTE ori_scan = NULL;
970         if (m_pOriDevice) {
971             ori_scan = m_pOriDevice->GetBuffer() + m_pOriDevice->GetPitch() * y;
972         }
973         int Bpp = m_pDevice->GetBPP() / 8;
974         FX_BOOL bDestAlpha = m_pDevice->HasAlpha() || m_pDevice->IsAlphaMask();
975         unsigned num_spans = sl.num_spans();
976         typename Scanline::const_iterator span = sl.begin();
977         while (1) {
978             int x = span->x;
979             ASSERT(span->len > 0);
980             FX_LPBYTE dest_pos = NULL;
981             FX_LPBYTE dest_extra_alpha_pos = NULL;
982             FX_LPBYTE ori_pos = NULL;
983             if (Bpp) {
984                 ori_pos = ori_scan ? ori_scan + x * Bpp : NULL;
985                 dest_pos = dest_scan + x * Bpp;
986                 dest_extra_alpha_pos = dest_scan_extra_alpha ? dest_scan_extra_alpha + x : NULL;
987             } else {
988                 dest_pos = dest_scan + x / 8;
989                 ori_pos = ori_scan ? ori_scan + x / 8 : NULL;
990             }
991             FX_LPBYTE clip_pos = NULL;
992             if (m_pClipMask) {
993                 clip_pos = m_pClipMask->GetBuffer() + (y - m_ClipBox.top) * m_pClipMask->GetPitch() + x - m_ClipBox.left;
994             }
995             if (ori_pos) {
996                 CompositeSpan(dest_pos, ori_pos, Bpp, bDestAlpha, x, span->len, span->covers, m_ClipBox.left, m_ClipBox.right, clip_pos);
997             } else {
998                 (this->*composite_span)(dest_pos, Bpp, x, span->len, span->covers, m_ClipBox.left, m_ClipBox.right, clip_pos, dest_extra_alpha_pos);
999             }
1000             if(--num_spans == 0) {
1001                 break;
1002             }
1003             ++span;
1004         }
1005     }
1006
1007     FX_BOOL Init(CFX_DIBitmap* pDevice, CFX_DIBitmap* pOriDevice, const CFX_ClipRgn* pClipRgn, FX_DWORD color, FX_BOOL bFullCover, FX_BOOL bRgbByteOrder,
1008                  int alpha_flag = 0, void* pIccTransform = NULL)
1009     {
1010         m_pDevice = pDevice;
1011         m_pClipRgn = pClipRgn;
1012         composite_span = NULL;
1013         m_bRgbByteOrder = bRgbByteOrder;
1014         m_pOriDevice = pOriDevice;
1015         if (m_pClipRgn) {
1016             m_ClipBox = m_pClipRgn->GetBox();
1017         } else {
1018             m_ClipBox.left = m_ClipBox.top = 0;
1019             m_ClipBox.right = m_pDevice->GetWidth();
1020             m_ClipBox.bottom = m_pDevice->GetHeight();
1021         }
1022         m_pClipMask = NULL;
1023         if (m_pClipRgn && m_pClipRgn->GetType() == CFX_ClipRgn::MaskF) {
1024             m_pClipMask = m_pClipRgn->GetMask();
1025         }
1026         m_bFullCover = bFullCover;
1027         FX_BOOL bObjectCMYK = FXGETFLAG_COLORTYPE(alpha_flag);
1028         FX_BOOL bDeviceCMYK = pDevice->IsCmykImage();
1029         m_Alpha = bObjectCMYK ? FXGETFLAG_ALPHA_FILL(alpha_flag) : FXARGB_A(color);
1030         ICodec_IccModule* pIccModule = NULL;
1031         if (!CFX_GEModule::Get()->GetCodecModule() || !CFX_GEModule::Get()->GetCodecModule()->GetIccModule()) {
1032             pIccTransform = NULL;
1033         } else {
1034             pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
1035         }
1036         if (m_pDevice->GetBPP() == 8) {
1037             ASSERT(!m_bRgbByteOrder);
1038             composite_span = &CFX_Renderer::CompositeSpanGray;
1039             if (m_pDevice->IsAlphaMask()) {
1040                 m_Gray = 255;
1041             } else {
1042                 if (pIccTransform) {
1043                     FX_BYTE gray;
1044                     color = bObjectCMYK ? FXCMYK_TODIB(color) : FXARGB_TODIB(color);
1045                     pIccModule->TranslateScanline(pIccTransform, &gray, (FX_LPCBYTE)&color, 1);
1046                     m_Gray = gray;
1047                 } else {
1048                     if (bObjectCMYK) {
1049                         FX_BYTE r, g, b;
1050                         AdobeCMYK_to_sRGB1(FXSYS_GetCValue(color), FXSYS_GetMValue(color), FXSYS_GetYValue(color), FXSYS_GetKValue(color),
1051                                            r, g, b);
1052                         m_Gray = FXRGB2GRAY(r, g, b);
1053                     } else {
1054                         m_Gray = FXRGB2GRAY(FXARGB_R(color), FXARGB_G(color), FXARGB_B(color));
1055                     }
1056                 }
1057             }
1058             return TRUE;
1059         }
1060         if (bDeviceCMYK) {
1061             ASSERT(!m_bRgbByteOrder);
1062             composite_span = &CFX_Renderer::CompositeSpanCMYK;
1063             if (bObjectCMYK) {
1064                 m_Color = FXCMYK_TODIB(color);
1065                 if (pIccTransform) {
1066                     pIccModule->TranslateScanline(pIccTransform, (FX_LPBYTE)&m_Color, (FX_LPCBYTE)&m_Color, 1);
1067                 }
1068             } else {
1069                 if (!pIccTransform) {
1070                     return FALSE;
1071                 }
1072                 color = FXARGB_TODIB(color);
1073                 pIccModule->TranslateScanline(pIccTransform, (FX_LPBYTE)&m_Color, (FX_LPCBYTE)&color, 1);
1074             }
1075             m_Red = ((FX_LPBYTE)&m_Color)[0];
1076             m_Green = ((FX_LPBYTE)&m_Color)[1];
1077             m_Blue = ((FX_LPBYTE)&m_Color)[2];
1078             m_Gray = ((FX_LPBYTE)&m_Color)[3];
1079         } else {
1080             composite_span = (pDevice->GetFormat() == FXDIB_Argb) ? &CFX_Renderer::CompositeSpanARGB : &CFX_Renderer::CompositeSpanRGB;
1081             if (pIccTransform) {
1082                 color = bObjectCMYK ? FXCMYK_TODIB(color) : FXARGB_TODIB(color);
1083                 pIccModule->TranslateScanline(pIccTransform, (FX_LPBYTE)&m_Color, (FX_LPCBYTE)&color, 1);
1084                 ((FX_LPBYTE)&m_Color)[3] = m_Alpha;
1085                 m_Red = ((FX_LPBYTE)&m_Color)[2];
1086                 m_Green = ((FX_LPBYTE)&m_Color)[1];
1087                 m_Blue = ((FX_LPBYTE)&m_Color)[0];
1088                 if (m_bRgbByteOrder) {
1089                     m_Color = FXARGB_TODIB(m_Color);
1090                     m_Color = FXARGB_TOBGRORDERDIB(m_Color);
1091                 }
1092             } else {
1093                 if (bObjectCMYK) {
1094                     FX_BYTE r, g, b;
1095                     AdobeCMYK_to_sRGB1(FXSYS_GetCValue(color), FXSYS_GetMValue(color), FXSYS_GetYValue(color), FXSYS_GetKValue(color),
1096                                        r, g, b);
1097                     m_Color = FXARGB_MAKE(m_Alpha, r, g, b);
1098                     if (m_bRgbByteOrder) {
1099                         m_Color = FXARGB_TOBGRORDERDIB(m_Color);
1100                     } else {
1101                         m_Color = FXARGB_TODIB(m_Color);
1102                     }
1103                     m_Red = r;
1104                     m_Green = g;
1105                     m_Blue = b;
1106                 } else {
1107                     if (m_bRgbByteOrder) {
1108                         m_Color = FXARGB_TOBGRORDERDIB(color);
1109                     } else {
1110                         m_Color = FXARGB_TODIB(color);
1111                     }
1112                     ArgbDecode(color, m_Alpha, m_Red, m_Green, m_Blue);
1113                 }
1114             }
1115         }
1116         if (m_pDevice->GetBPP() == 1) {
1117             composite_span = &CFX_Renderer::CompositeSpan1bpp;
1118         }
1119         return TRUE;
1120     }
1121 };
1122 FX_BOOL CFX_AggDeviceDriver::RenderRasterizer(agg::rasterizer_scanline_aa& rasterizer, FX_DWORD color, FX_BOOL bFullCover, FX_BOOL bGroupKnockout,
1123         int alpha_flag, void* pIccTransform)
1124 {
1125     CFX_DIBitmap* pt = bGroupKnockout ? m_pOriDevice : NULL;
1126     CFX_Renderer render;
1127     if (!render.Init(m_pBitmap, pt, m_pClipRgn, color, bFullCover, m_bRgbByteOrder, alpha_flag, pIccTransform)) {
1128         return FALSE;
1129     }
1130     agg::scanline_u8 scanline;
1131     agg::render_scanlines(rasterizer, scanline, render, (m_FillFlags & FXFILL_NOPATHSMOOTH) != 0);
1132     return TRUE;
1133 }
1134 FX_BOOL CFX_AggDeviceDriver::DrawPath(const CFX_PathData* pPathData,
1135                                       const CFX_AffineMatrix* pObject2Device,
1136                                       const CFX_GraphStateData* pGraphState,
1137                                       FX_DWORD fill_color,
1138                                       FX_DWORD stroke_color,
1139                                       int fill_mode,
1140                                       int alpha_flag,
1141                                       void* pIccTransform,
1142                                       int blend_type
1143                                      )
1144 {
1145     if (blend_type != FXDIB_BLEND_NORMAL) {
1146         return FALSE;
1147     }
1148     if (GetBuffer() == NULL) {
1149         return TRUE;
1150     }
1151     m_FillFlags = fill_mode;
1152     if ((fill_mode & 3) && fill_color) {
1153         CAgg_PathData path_data;
1154         path_data.BuildPath(pPathData, pObject2Device);
1155         agg::rasterizer_scanline_aa rasterizer;
1156         rasterizer.clip_box(0.0f, 0.0f, (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_WIDTH)), (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_HEIGHT)));
1157         rasterizer.add_path(path_data.m_PathData);
1158         rasterizer.filling_rule((fill_mode & 3) == FXFILL_WINDING ? agg::fill_non_zero : agg::fill_even_odd);
1159         if (!RenderRasterizer(rasterizer, fill_color, fill_mode & FXFILL_FULLCOVER, FALSE, alpha_flag, pIccTransform)) {
1160             return FALSE;
1161         }
1162     }
1163     int stroke_alpha = FXGETFLAG_COLORTYPE(alpha_flag) ? FXGETFLAG_ALPHA_STROKE(alpha_flag) : FXARGB_A(stroke_color);
1164     if (pGraphState && stroke_alpha) {
1165         if (fill_mode & FX_ZEROAREA_FILL) {
1166             CAgg_PathData path_data;
1167             path_data.BuildPath(pPathData, pObject2Device);
1168             agg::rasterizer_scanline_aa rasterizer;
1169             rasterizer.clip_box(0.0f, 0.0f, (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_WIDTH)), (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_HEIGHT)));
1170             RasterizeStroke(rasterizer, path_data.m_PathData, NULL, pGraphState, 1, FALSE, fill_mode & FX_STROKE_TEXT_MODE);
1171             int fill_flag = FXGETFLAG_COLORTYPE(alpha_flag) << 8 | FXGETFLAG_ALPHA_STROKE(alpha_flag);
1172             if (!RenderRasterizer(rasterizer, stroke_color, fill_mode & FXFILL_FULLCOVER, m_bGroupKnockout, fill_flag, pIccTransform)) {
1173                 return FALSE;
1174             }
1175             return TRUE;
1176         }
1177         CFX_AffineMatrix matrix1, matrix2;
1178         if (pObject2Device) {
1179             matrix1.a = FX_MAX(FXSYS_fabs(pObject2Device->a), FXSYS_fabs(pObject2Device->b));
1180             matrix1.d = matrix1.a;
1181             matrix2.Set(pObject2Device->a / matrix1.a, pObject2Device->b / matrix1.a,
1182                         pObject2Device->c / matrix1.d, pObject2Device->d / matrix1.d,
1183                         0, 0);
1184             CFX_AffineMatrix mtRervese;
1185             mtRervese.SetReverse(matrix2);
1186             matrix1 = *pObject2Device;
1187             matrix1.Concat(mtRervese);
1188         }
1189         CAgg_PathData path_data;
1190         path_data.BuildPath(pPathData, &matrix1);
1191         agg::rasterizer_scanline_aa rasterizer;
1192         rasterizer.clip_box(0.0f, 0.0f, (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_WIDTH)), (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_HEIGHT)));
1193         RasterizeStroke(rasterizer, path_data.m_PathData, &matrix2, pGraphState, matrix1.a, FALSE, fill_mode & FX_STROKE_TEXT_MODE);
1194         int fill_flag = FXGETFLAG_COLORTYPE(alpha_flag) << 8 | FXGETFLAG_ALPHA_STROKE(alpha_flag);
1195         if (!RenderRasterizer(rasterizer, stroke_color, fill_mode & FXFILL_FULLCOVER, m_bGroupKnockout, fill_flag, pIccTransform)) {
1196             return FALSE;
1197         }
1198     }
1199     return TRUE;
1200 }
1201 void RgbByteOrderSetPixel(CFX_DIBitmap* pBitmap, int x, int y, FX_DWORD argb)
1202 {
1203     if (x < 0 || x >= pBitmap->GetWidth() || y < 0 || y >= pBitmap->GetHeight()) {
1204         return;
1205     }
1206     FX_LPBYTE pos = (FX_BYTE*)pBitmap->GetBuffer() + y * pBitmap->GetPitch() + x * pBitmap->GetBPP() / 8;
1207     if (pBitmap->GetFormat() == FXDIB_Argb) {
1208         FXARGB_SETRGBORDERDIB(pos, ArgbGamma(argb));
1209     } else {
1210         int alpha = FXARGB_A(argb);
1211         pos[0] = (FXARGB_R(argb) * alpha + pos[0] * (255 - alpha)) / 255;
1212         pos[1] = (FXARGB_G(argb) * alpha + pos[1] * (255 - alpha)) / 255;
1213         pos[2] = (FXARGB_B(argb) * alpha + pos[2] * (255 - alpha)) / 255;
1214     }
1215 }
1216 void RgbByteOrderCompositeRect(CFX_DIBitmap* pBitmap, int left, int top, int width, int height, FX_ARGB argb)
1217 {
1218     int src_alpha = FXARGB_A(argb);
1219     if (src_alpha == 0) {
1220         return;
1221     }
1222     FX_RECT rect(left, top, left + width, top + height);
1223     rect.Intersect(0, 0, pBitmap->GetWidth(), pBitmap->GetHeight());
1224     width = rect.Width();
1225     int src_r = FXARGB_R(argb), src_g = FXARGB_G(argb), src_b = FXARGB_B(argb);
1226     int Bpp = pBitmap->GetBPP() / 8;
1227     FX_BOOL bAlpha = pBitmap->HasAlpha();
1228     int dib_argb = FXARGB_TOBGRORDERDIB(argb);
1229     FX_BYTE* pBuffer = pBitmap->GetBuffer();
1230     if (src_alpha == 255) {
1231         for (int row = rect.top; row < rect.bottom; row ++) {
1232             FX_LPBYTE dest_scan = pBuffer + row * pBitmap->GetPitch() + rect.left * Bpp;
1233             if (Bpp == 4) {
1234                 FX_DWORD* scan = (FX_DWORD*)dest_scan;
1235                 for (int col = 0; col < width; col ++) {
1236                     *scan ++ = dib_argb;
1237                 }
1238             } else {
1239                 for (int col = 0; col < width; col ++) {
1240                     *dest_scan ++ = src_r;
1241                     *dest_scan ++ = src_g;
1242                     *dest_scan ++ = src_b;
1243                 }
1244             }
1245         }
1246         return;
1247     }
1248     src_r = FX_GAMMA(src_r);
1249     src_g = FX_GAMMA(src_g);
1250     src_b = FX_GAMMA(src_b);
1251     for (int row = rect.top; row < rect.bottom; row ++) {
1252         FX_LPBYTE dest_scan = pBuffer + row * pBitmap->GetPitch() + rect.left * Bpp;
1253         if (bAlpha) {
1254             for (int col = 0; col < width; col ++) {
1255                 FX_BYTE back_alpha = dest_scan[3];
1256                 if (back_alpha == 0) {
1257                     FXARGB_SETRGBORDERDIB(dest_scan, FXARGB_MAKE(src_alpha, src_r, src_g, src_b));
1258                     dest_scan += 4;
1259                     continue;
1260                 }
1261                 FX_BYTE dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
1262                 dest_scan[3] = dest_alpha;
1263                 int alpha_ratio = src_alpha * 255 / dest_alpha;
1264                 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, alpha_ratio);
1265                 dest_scan++;
1266                 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, alpha_ratio);
1267                 dest_scan++;
1268                 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, alpha_ratio);
1269                 dest_scan += 2;
1270             }
1271         } else {
1272             for (int col = 0; col < width; col ++) {
1273                 *dest_scan = FX_GAMMA_INVERSE(FXDIB_ALPHA_MERGE(FX_GAMMA(*dest_scan), src_r, src_alpha));
1274                 dest_scan++;
1275                 *dest_scan = FX_GAMMA_INVERSE(FXDIB_ALPHA_MERGE(FX_GAMMA(*dest_scan), src_g, src_alpha));
1276                 dest_scan++;
1277                 *dest_scan = FX_GAMMA_INVERSE(FXDIB_ALPHA_MERGE(FX_GAMMA(*dest_scan), src_b, src_alpha));
1278                 dest_scan++;
1279                 if (Bpp == 4) {
1280                     dest_scan++;
1281                 }
1282             }
1283         }
1284     }
1285 }
1286 void RgbByteOrderTransferBitmap(CFX_DIBitmap* pBitmap, int dest_left, int dest_top, int width, int height,
1287                                 const CFX_DIBSource* pSrcBitmap, int src_left, int src_top)
1288 {
1289     if (pBitmap == NULL) {
1290         return;
1291     }
1292     pBitmap->GetOverlapRect(dest_left, dest_top, width, height, pSrcBitmap->GetWidth(), pSrcBitmap->GetHeight(), src_left, src_top, NULL);
1293     if (width == 0 || height == 0) {
1294         return;
1295     }
1296     int Bpp = pBitmap->GetBPP() / 8;
1297     FXDIB_Format dest_format = pBitmap->GetFormat();
1298     FXDIB_Format src_format = pSrcBitmap->GetFormat();
1299     int pitch = pBitmap->GetPitch();
1300     FX_BYTE* buffer = pBitmap->GetBuffer();
1301     if (dest_format == src_format) {
1302         for (int row = 0; row < height; row ++) {
1303             FX_LPBYTE dest_scan = buffer + (dest_top + row) * pitch + dest_left * Bpp;
1304             FX_LPBYTE src_scan = (FX_LPBYTE)pSrcBitmap->GetScanline(src_top + row) + src_left * Bpp;
1305             if (Bpp == 4) {
1306                 for (int col = 0; col < width; col ++) {
1307                     FXARGB_SETDIB(dest_scan, FXARGB_MAKE(src_scan[3], src_scan[0], src_scan[1], src_scan[2]));
1308                     dest_scan += 4;
1309                     src_scan += 4;
1310                 }
1311             } else {
1312                 for (int col = 0; col < width; col ++) {
1313                     *dest_scan++ = src_scan[2];
1314                     *dest_scan++ = src_scan[1];
1315                     *dest_scan++ = src_scan[0];
1316                     src_scan += 3;
1317                 }
1318             }
1319         }
1320         return;
1321     }
1322     int src_pitch = pSrcBitmap->GetPitch();
1323     FX_ARGB* src_pal = pSrcBitmap->GetPalette();
1324     FX_LPBYTE dest_buf = buffer + dest_top * pitch + dest_left * Bpp;
1325     if (dest_format == FXDIB_Rgb) {
1326         if (src_format == FXDIB_Rgb32) {
1327             for (int row = 0; row < height; row ++) {
1328                 FX_LPBYTE dest_scan = dest_buf + row * pitch;
1329                 FX_LPBYTE src_scan = (FX_BYTE*)pSrcBitmap->GetScanline(src_top + row) + src_left * 4;
1330                 for (int col = 0; col < width; col ++) {
1331                     *dest_scan++ = src_scan[2];
1332                     *dest_scan++ = src_scan[1];
1333                     *dest_scan++ = src_scan[0];
1334                     src_scan += 4;
1335                 }
1336             }
1337         } else {
1338             ASSERT(FALSE);
1339         }
1340     } else if (dest_format == FXDIB_Argb || dest_format == FXDIB_Rgb32) {
1341         if (src_format == FXDIB_Rgb) {
1342             for (int row = 0; row < height; row ++) {
1343                 FX_BYTE* dest_scan = (FX_BYTE*)(dest_buf + row * pitch);
1344                 FX_LPBYTE src_scan = (FX_BYTE*)pSrcBitmap->GetScanline(src_top + row) + src_left * 3;
1345                 if (src_format == FXDIB_Argb) {
1346                     for (int col = 0; col < width; col ++) {
1347                         FXARGB_SETDIB(dest_scan, FXARGB_MAKE(0xff, FX_GAMMA(src_scan[0]), FX_GAMMA(src_scan[1]), FX_GAMMA(src_scan[2])));
1348                         dest_scan += 4;
1349                         src_scan += 3;
1350                     }
1351                 } else {
1352                     for (int col = 0; col < width; col ++) {
1353                         FXARGB_SETDIB(dest_scan, FXARGB_MAKE(0xff, src_scan[0], src_scan[1], src_scan[2]));
1354                         dest_scan += 4;
1355                         src_scan += 3;
1356                     }
1357                 }
1358             }
1359         } else if (src_format == FXDIB_Rgb32) {
1360             ASSERT(dest_format == FXDIB_Argb);
1361             for (int row = 0; row < height; row ++) {
1362                 FX_LPBYTE dest_scan = dest_buf + row * pitch;
1363                 FX_LPBYTE src_scan = (FX_LPBYTE)(pSrcBitmap->GetScanline(src_top + row) + src_left * 4);
1364                 for (int col = 0; col < width; col++) {
1365                     FXARGB_SETDIB(dest_scan, FXARGB_MAKE(0xff, src_scan[0], src_scan[1], src_scan[2]));
1366                     src_scan  += 4;
1367                     dest_scan += 4;
1368                 }
1369             }
1370         }
1371     } else {
1372         ASSERT(FALSE);
1373     }
1374 }
1375 FX_ARGB _DefaultCMYK2ARGB(FX_CMYK cmyk, FX_BYTE alpha)
1376 {
1377     FX_BYTE r, g, b;
1378     AdobeCMYK_to_sRGB1(FXSYS_GetCValue(cmyk), FXSYS_GetMValue(cmyk), FXSYS_GetYValue(cmyk), FXSYS_GetKValue(cmyk),
1379                        r, g, b);
1380     return ArgbEncode(alpha, r, g, b);
1381 }
1382 FX_BOOL _DibSetPixel(CFX_DIBitmap* pDevice, int x, int y, FX_DWORD color, int alpha_flag, void* pIccTransform)
1383 {
1384     FX_BOOL bObjCMYK = FXGETFLAG_COLORTYPE(alpha_flag);
1385     int alpha = bObjCMYK ? FXGETFLAG_ALPHA_FILL(alpha_flag) : FXARGB_A(color);
1386     if (pIccTransform) {
1387         ICodec_IccModule* pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
1388         color = bObjCMYK ? FXCMYK_TODIB(color) : FXARGB_TODIB(color);
1389         pIccModule->TranslateScanline(pIccTransform, (FX_LPBYTE)&color, (FX_LPBYTE)&color, 1);
1390         color = bObjCMYK ? FXCMYK_TODIB(color) : FXARGB_TODIB(color);
1391         if (!pDevice->IsCmykImage()) {
1392             color = (color & 0xffffff) | (alpha << 24);
1393         }
1394     } else {
1395         if (pDevice->IsCmykImage()) {
1396             if (!bObjCMYK) {
1397                 return FALSE;
1398             }
1399         } else {
1400             if (bObjCMYK) {
1401                 color = _DefaultCMYK2ARGB(color, alpha);
1402             }
1403         }
1404     }
1405     pDevice->SetPixel(x, y, color);
1406     if (pDevice->m_pAlphaMask) {
1407         pDevice->m_pAlphaMask->SetPixel(x, y, alpha << 24);
1408     }
1409     return TRUE;
1410 }
1411 FX_BOOL CFX_AggDeviceDriver::SetPixel(int x, int y, FX_DWORD color, int alpha_flag, void* pIccTransform)
1412 {
1413     if (m_pBitmap->GetBuffer() == NULL) {
1414         return TRUE;
1415     }
1416     if (!CFX_GEModule::Get()->GetCodecModule() || !CFX_GEModule::Get()->GetCodecModule()->GetIccModule()) {
1417         pIccTransform = NULL;
1418     }
1419     if (m_pClipRgn == NULL) {
1420         if (m_bRgbByteOrder) {
1421             RgbByteOrderSetPixel(m_pBitmap, x, y, color);
1422         } else {
1423             return _DibSetPixel(m_pBitmap, x, y, color, alpha_flag, pIccTransform);
1424         }
1425     } else if (m_pClipRgn->GetBox().Contains(x, y)) {
1426         if (m_pClipRgn->GetType() == CFX_ClipRgn::RectI) {
1427             if (m_bRgbByteOrder) {
1428                 RgbByteOrderSetPixel(m_pBitmap, x, y, color);
1429             } else {
1430                 return _DibSetPixel(m_pBitmap, x, y, color, alpha_flag, pIccTransform);
1431             }
1432         } else if (m_pClipRgn->GetType() == CFX_ClipRgn::MaskF) {
1433             const CFX_DIBitmap* pMask = m_pClipRgn->GetMask();
1434             FX_BOOL bCMYK = FXGETFLAG_COLORTYPE(alpha_flag);
1435             int new_alpha = bCMYK ? FXGETFLAG_ALPHA_FILL(alpha_flag) : FXARGB_A(color);
1436             new_alpha = new_alpha * pMask->GetScanline(y)[x] / 255;
1437             if (m_bRgbByteOrder) {
1438                 RgbByteOrderSetPixel(m_pBitmap, x, y, (color & 0xffffff) | (new_alpha << 24));
1439                 return TRUE;
1440             }
1441             if (bCMYK) {
1442                 FXSETFLAG_ALPHA_FILL(alpha_flag, new_alpha);
1443             } else {
1444                 color = (color & 0xffffff) | (new_alpha << 24);
1445             }
1446             return _DibSetPixel(m_pBitmap, x, y, color, alpha_flag, pIccTransform);
1447         }
1448     }
1449     return TRUE;
1450 }
1451 FX_BOOL CFX_AggDeviceDriver::FillRect(const FX_RECT* pRect, FX_DWORD fill_color, int alpha_flag, void* pIccTransform, int blend_type)
1452 {
1453     if (blend_type != FXDIB_BLEND_NORMAL) {
1454         return FALSE;
1455     }
1456     if (m_pBitmap->GetBuffer() == NULL) {
1457         return TRUE;
1458     }
1459     FX_RECT clip_rect;
1460     GetClipBox(&clip_rect);
1461     FX_RECT draw_rect = clip_rect;
1462     if (pRect) {
1463         draw_rect.Intersect(*pRect);
1464     }
1465     if (draw_rect.IsEmpty()) {
1466         return TRUE;
1467     }
1468     if (m_pClipRgn == NULL || m_pClipRgn->GetType() == CFX_ClipRgn::RectI) {
1469         if (m_bRgbByteOrder) {
1470             RgbByteOrderCompositeRect(m_pBitmap, draw_rect.left, draw_rect.top, draw_rect.Width(), draw_rect.Height(), fill_color);
1471         } else {
1472             m_pBitmap->CompositeRect(draw_rect.left, draw_rect.top, draw_rect.Width(), draw_rect.Height(), fill_color, alpha_flag, pIccTransform);
1473         }
1474         return TRUE;
1475     }
1476     m_pBitmap->CompositeMask(draw_rect.left, draw_rect.top, draw_rect.Width(), draw_rect.Height(), (const CFX_DIBitmap*)m_pClipRgn->GetMask(),
1477                              fill_color, draw_rect.left - clip_rect.left, draw_rect.top - clip_rect.top, FXDIB_BLEND_NORMAL, NULL, m_bRgbByteOrder, alpha_flag, pIccTransform);
1478     return TRUE;
1479 }
1480 FX_BOOL CFX_AggDeviceDriver::GetClipBox(FX_RECT* pRect)
1481 {
1482     if (m_pClipRgn == NULL) {
1483         pRect->left = pRect->top = 0;
1484         pRect->right = GetDeviceCaps(FXDC_PIXEL_WIDTH);
1485         pRect->bottom = GetDeviceCaps(FXDC_PIXEL_HEIGHT);
1486         return TRUE;
1487     }
1488     *pRect = m_pClipRgn->GetBox();
1489     return TRUE;
1490 }
1491 FX_BOOL CFX_AggDeviceDriver::GetDIBits(CFX_DIBitmap* pBitmap, int left, int top, void* pIccTransform, FX_BOOL bDEdge)
1492 {
1493     if (m_pBitmap->GetBuffer() == NULL) {
1494         return TRUE;
1495     }
1496     if (bDEdge) {
1497         if (m_bRgbByteOrder) {
1498             RgbByteOrderTransferBitmap(pBitmap, 0, 0, pBitmap->GetWidth(), pBitmap->GetHeight(), m_pBitmap, left, top);
1499         } else {
1500             return pBitmap->TransferBitmap(0, 0, pBitmap->GetWidth(), pBitmap->GetHeight(), m_pBitmap, left, top, pIccTransform);
1501         }
1502         return TRUE;
1503     }
1504     FX_RECT rect(left, top, left + pBitmap->GetWidth(), top + pBitmap->GetHeight());
1505     CFX_DIBitmap *pBack = NULL;
1506     if (m_pOriDevice) {
1507         pBack = m_pOriDevice->Clone(&rect);
1508         if (!pBack) {
1509             return TRUE;
1510         }
1511         pBack->CompositeBitmap(0, 0, pBack->GetWidth(), pBack->GetHeight(), m_pBitmap, 0, 0);
1512     } else {
1513         pBack = m_pBitmap->Clone(&rect);
1514     }
1515     if (!pBack) {
1516         return TRUE;
1517     }
1518     FX_BOOL bRet = TRUE;
1519     left = left >= 0 ? 0 : left;
1520     top = top >= 0 ? 0 : top;
1521     if (m_bRgbByteOrder) {
1522         RgbByteOrderTransferBitmap(pBitmap, 0, 0, rect.Width(), rect.Height(), pBack, left, top);
1523     } else {
1524         bRet = pBitmap->TransferBitmap(0, 0, rect.Width(), rect.Height(), pBack, left, top, pIccTransform);
1525     }
1526     delete pBack;
1527     return bRet;
1528 }
1529 FX_BOOL CFX_AggDeviceDriver::SetDIBits(const CFX_DIBSource* pBitmap, FX_DWORD argb, const FX_RECT* pSrcRect, int left, int top, int blend_type,
1530                                        int alpha_flag, void* pIccTransform)
1531 {
1532     if (m_pBitmap->GetBuffer() == NULL) {
1533         return TRUE;
1534     }
1535     if (pBitmap->IsAlphaMask())
1536         return m_pBitmap->CompositeMask(left, top, pSrcRect->Width(), pSrcRect->Height(), pBitmap, argb,
1537                                         pSrcRect->left, pSrcRect->top, blend_type, m_pClipRgn, m_bRgbByteOrder, alpha_flag, pIccTransform);
1538     return m_pBitmap->CompositeBitmap(left, top, pSrcRect->Width(), pSrcRect->Height(), pBitmap,
1539                                       pSrcRect->left, pSrcRect->top, blend_type, m_pClipRgn, m_bRgbByteOrder, pIccTransform);
1540 }
1541 FX_BOOL CFX_AggDeviceDriver::StretchDIBits(const CFX_DIBSource* pSource, FX_DWORD argb, int dest_left, int dest_top,
1542         int dest_width, int dest_height, const FX_RECT* pClipRect, FX_DWORD flags,
1543         int alpha_flag, void* pIccTransform, int blend_type)
1544 {
1545     if (m_pBitmap->GetBuffer() == NULL) {
1546         return TRUE;
1547     }
1548     if (dest_width == pSource->GetWidth() && dest_height == pSource->GetHeight()) {
1549         FX_RECT rect(0, 0, dest_width, dest_height);
1550         return SetDIBits(pSource, argb, &rect, dest_left, dest_top, blend_type, alpha_flag, pIccTransform);
1551     }
1552     FX_RECT dest_rect(dest_left, dest_top, dest_left + dest_width, dest_top + dest_height);
1553     dest_rect.Normalize();
1554     FX_RECT dest_clip = dest_rect;
1555     dest_clip.Intersect(*pClipRect);
1556     CFX_BitmapComposer composer;
1557     composer.Compose(m_pBitmap, m_pClipRgn, 255, argb, dest_clip, FALSE, FALSE, FALSE, m_bRgbByteOrder, alpha_flag, pIccTransform, blend_type);
1558     dest_clip.Offset(-dest_rect.left, -dest_rect.top);
1559     CFX_ImageStretcher stretcher;
1560     if (stretcher.Start(&composer, pSource, dest_width, dest_height, dest_clip, flags)) {
1561         stretcher.Continue(NULL);
1562     }
1563     return TRUE;
1564 }
1565 FX_BOOL CFX_AggDeviceDriver::StartDIBits(const CFX_DIBSource* pSource, int bitmap_alpha, FX_DWORD argb,
1566         const CFX_AffineMatrix* pMatrix, FX_DWORD render_flags, FX_LPVOID& handle,
1567         int alpha_flag, void* pIccTransform, int blend_type)
1568 {
1569     if (m_pBitmap->GetBuffer() == NULL) {
1570         return TRUE;
1571     }
1572     CFX_ImageRenderer* pRenderer = FX_NEW CFX_ImageRenderer;
1573     if (!pRenderer) {
1574         return FALSE;
1575     }
1576     pRenderer->Start(m_pBitmap, m_pClipRgn, pSource, bitmap_alpha, argb, pMatrix, render_flags, m_bRgbByteOrder, alpha_flag, pIccTransform);
1577     handle = pRenderer;
1578     return TRUE;
1579 }
1580 FX_BOOL CFX_AggDeviceDriver::ContinueDIBits(FX_LPVOID pHandle, IFX_Pause* pPause)
1581 {
1582     if (m_pBitmap->GetBuffer() == NULL) {
1583         return TRUE;
1584     }
1585     return ((CFX_ImageRenderer*)pHandle)->Continue(pPause);
1586 }
1587 void CFX_AggDeviceDriver::CancelDIBits(FX_LPVOID pHandle)
1588 {
1589     if (m_pBitmap->GetBuffer() == NULL) {
1590         return;
1591     }
1592     delete (CFX_ImageRenderer*)pHandle;
1593 }
1594 CFX_FxgeDevice::CFX_FxgeDevice()
1595 {
1596     m_bOwnedBitmap = FALSE;
1597 }
1598 FX_BOOL CFX_FxgeDevice::Attach(CFX_DIBitmap* pBitmap, int dither_bits, FX_BOOL bRgbByteOrder, CFX_DIBitmap* pOriDevice, FX_BOOL bGroupKnockout)
1599 {
1600     if (pBitmap == NULL) {
1601         return FALSE;
1602     }
1603     SetBitmap(pBitmap);
1604     IFX_RenderDeviceDriver* pDriver = FX_NEW CFX_AggDeviceDriver(pBitmap, dither_bits, bRgbByteOrder, pOriDevice, bGroupKnockout);
1605     if (!pDriver) {
1606         return FALSE;
1607     }
1608     SetDeviceDriver(pDriver);
1609     return TRUE;
1610 }
1611 FX_BOOL CFX_FxgeDevice::Create(int width, int height, FXDIB_Format format, int dither_bits, CFX_DIBitmap* pOriDevice)
1612 {
1613     m_bOwnedBitmap = TRUE;
1614     CFX_DIBitmap* pBitmap = FX_NEW CFX_DIBitmap;
1615     if (!pBitmap) {
1616         return FALSE;
1617     }
1618     if (!pBitmap->Create(width, height, format)) {
1619         delete pBitmap;
1620         return FALSE;
1621     }
1622     SetBitmap(pBitmap);
1623     IFX_RenderDeviceDriver* pDriver = FX_NEW CFX_AggDeviceDriver(pBitmap, dither_bits, FALSE, pOriDevice, FALSE);
1624     if (!pDriver) {
1625         return FALSE;
1626     }
1627     SetDeviceDriver(pDriver);
1628     return TRUE;
1629 }
1630 CFX_FxgeDevice::~CFX_FxgeDevice()
1631 {
1632     if (m_bOwnedBitmap && GetBitmap()) {
1633         delete GetBitmap();
1634     }
1635 }