Index: core/src/fxge/agg/src/fx_agg_driver.cpp |
diff --git a/core/src/fxge/agg/src/fx_agg_driver.cpp b/core/src/fxge/agg/src/fx_agg_driver.cpp |
index 118db7bf1fac8e9a377ee75cf4d805672017c5f5..fd3ea2509631575f76576c75af4d627f5851e5d1 100644 |
--- a/core/src/fxge/agg/src/fx_agg_driver.cpp |
+++ b/core/src/fxge/agg/src/fx_agg_driver.cpp |
@@ -1,7 +1,7 @@ |
// Copyright 2014 PDFium Authors. All rights reserved. |
// Use of this source code is governed by a BSD-style license that can be |
// found in the LICENSE file. |
- |
+ |
// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com |
#include "../../../../include/fxge/fx_ge.h" |
@@ -17,1105 +17,1191 @@ |
#include "../../../../../third_party/agg23/agg_conv_stroke.h" |
#include "../../../../../third_party/agg23/agg_conv_dash.h" |
#include "../include/fx_agg_driver.h" |
-void _HardClip(FX_FLOAT& x, FX_FLOAT& y) |
-{ |
- if (x > 50000) { |
- x = 50000; |
- } |
- if (x < -50000) { |
- x = -50000; |
- } |
- if (y > 50000) { |
- y = 50000; |
- } |
- if (y < -50000) { |
- y = -50000; |
- } |
+void _HardClip(FX_FLOAT& x, FX_FLOAT& y) { |
+ if (x > 50000) { |
+ x = 50000; |
+ } |
+ if (x < -50000) { |
+ x = -50000; |
+ } |
+ if (y > 50000) { |
+ y = 50000; |
+ } |
+ if (y < -50000) { |
+ y = -50000; |
+ } |
} |
-void CAgg_PathData::BuildPath(const CFX_PathData* pPathData, const CFX_AffineMatrix* pObject2Device) |
-{ |
- int nPoints = pPathData->GetPointCount(); |
- FX_PATHPOINT* pPoints = pPathData->GetPoints(); |
- for (int i = 0; i < nPoints; i ++) { |
- FX_FLOAT x = pPoints[i].m_PointX, y = pPoints[i].m_PointY; |
- if (pObject2Device) { |
- pObject2Device->Transform(x, y); |
- } |
- _HardClip(x, y); |
- int point_type = pPoints[i].m_Flag & FXPT_TYPE; |
- if (point_type == FXPT_MOVETO) { |
- m_PathData.move_to(x, y); |
- } else if (point_type == FXPT_LINETO) { |
- if (pPoints[i - 1].m_Flag == FXPT_MOVETO && (i == nPoints - 1 || pPoints[i + 1].m_Flag == FXPT_MOVETO) && |
- pPoints[i].m_PointX == pPoints[i - 1].m_PointX && pPoints[i].m_PointY == pPoints[i - 1].m_PointY) { |
- x += 1; |
- } |
- m_PathData.line_to(x, y); |
- } else if (point_type == FXPT_BEZIERTO) { |
- FX_FLOAT x0 = pPoints[i - 1].m_PointX, y0 = pPoints[i - 1].m_PointY; |
- FX_FLOAT x2 = pPoints[i + 1].m_PointX, y2 = pPoints[i + 1].m_PointY; |
- FX_FLOAT x3 = pPoints[i + 2].m_PointX, y3 = pPoints[i + 2].m_PointY; |
- if (pObject2Device) { |
- pObject2Device->Transform(x0, y0); |
- pObject2Device->Transform(x2, y2); |
- pObject2Device->Transform(x3, y3); |
- } |
- agg::curve4 curve(x0, y0, x, y, x2, y2, x3, y3); |
- i += 2; |
- m_PathData.add_path_curve(curve); |
- } |
- if (pPoints[i].m_Flag & FXPT_CLOSEFIGURE) { |
- m_PathData.end_poly(); |
- } |
- } |
+void CAgg_PathData::BuildPath(const CFX_PathData* pPathData, |
+ const CFX_AffineMatrix* pObject2Device) { |
+ int nPoints = pPathData->GetPointCount(); |
+ FX_PATHPOINT* pPoints = pPathData->GetPoints(); |
+ for (int i = 0; i < nPoints; i++) { |
+ FX_FLOAT x = pPoints[i].m_PointX, y = pPoints[i].m_PointY; |
+ if (pObject2Device) { |
+ pObject2Device->Transform(x, y); |
+ } |
+ _HardClip(x, y); |
+ int point_type = pPoints[i].m_Flag & FXPT_TYPE; |
+ if (point_type == FXPT_MOVETO) { |
+ m_PathData.move_to(x, y); |
+ } else if (point_type == FXPT_LINETO) { |
+ if (pPoints[i - 1].m_Flag == FXPT_MOVETO && |
+ (i == nPoints - 1 || pPoints[i + 1].m_Flag == FXPT_MOVETO) && |
+ pPoints[i].m_PointX == pPoints[i - 1].m_PointX && |
+ pPoints[i].m_PointY == pPoints[i - 1].m_PointY) { |
+ x += 1; |
+ } |
+ m_PathData.line_to(x, y); |
+ } else if (point_type == FXPT_BEZIERTO) { |
+ FX_FLOAT x0 = pPoints[i - 1].m_PointX, y0 = pPoints[i - 1].m_PointY; |
+ FX_FLOAT x2 = pPoints[i + 1].m_PointX, y2 = pPoints[i + 1].m_PointY; |
+ FX_FLOAT x3 = pPoints[i + 2].m_PointX, y3 = pPoints[i + 2].m_PointY; |
+ if (pObject2Device) { |
+ pObject2Device->Transform(x0, y0); |
+ pObject2Device->Transform(x2, y2); |
+ pObject2Device->Transform(x3, y3); |
+ } |
+ agg::curve4 curve(x0, y0, x, y, x2, y2, x3, y3); |
+ i += 2; |
+ m_PathData.add_path_curve(curve); |
+ } |
+ if (pPoints[i].m_Flag & FXPT_CLOSEFIGURE) { |
+ m_PathData.end_poly(); |
+ } |
+ } |
} |
-namespace agg |
-{ |
-template<class BaseRenderer> class renderer_scanline_aa_offset |
-{ |
-public: |
- typedef BaseRenderer base_ren_type; |
- typedef typename base_ren_type::color_type color_type; |
- renderer_scanline_aa_offset(base_ren_type& ren, unsigned left, unsigned top) : |
- m_ren(&ren), m_left(left), m_top(top) |
- {} |
- void color(const color_type& c) |
- { |
- m_color = c; |
- } |
- const color_type& color() const |
- { |
- return m_color; |
- } |
- void prepare(unsigned) {} |
- template<class Scanline> void render(const Scanline& sl) |
- { |
- int y = sl.y(); |
- unsigned num_spans = sl.num_spans(); |
- typename Scanline::const_iterator span = sl.begin(); |
- for(;;) { |
- int x = span->x; |
- if(span->len > 0) { |
- m_ren->blend_solid_hspan(x - m_left, y - m_top, (unsigned)span->len, |
- m_color, |
- span->covers); |
- } else { |
- m_ren->blend_hline(x - m_left, y - m_top, (unsigned)(x - span->len - 1), |
- m_color, |
- *(span->covers)); |
- } |
- if(--num_spans == 0) { |
- break; |
- } |
- ++span; |
- } |
- } |
-private: |
- base_ren_type* m_ren; |
- color_type m_color; |
- unsigned m_left, m_top; |
+namespace agg { |
+template <class BaseRenderer> |
+class renderer_scanline_aa_offset { |
+ public: |
+ typedef BaseRenderer base_ren_type; |
+ typedef typename base_ren_type::color_type color_type; |
+ renderer_scanline_aa_offset(base_ren_type& ren, unsigned left, unsigned top) |
+ : m_ren(&ren), m_left(left), m_top(top) {} |
+ void color(const color_type& c) { m_color = c; } |
+ const color_type& color() const { return m_color; } |
+ void prepare(unsigned) {} |
+ template <class Scanline> |
+ void render(const Scanline& sl) { |
+ int y = sl.y(); |
+ unsigned num_spans = sl.num_spans(); |
+ typename Scanline::const_iterator span = sl.begin(); |
+ for (;;) { |
+ int x = span->x; |
+ if (span->len > 0) { |
+ m_ren->blend_solid_hspan(x - m_left, y - m_top, (unsigned)span->len, |
+ m_color, span->covers); |
+ } else { |
+ m_ren->blend_hline(x - m_left, y - m_top, (unsigned)(x - span->len - 1), |
+ m_color, *(span->covers)); |
+ } |
+ if (--num_spans == 0) { |
+ break; |
+ } |
+ ++span; |
+ } |
+ } |
+ |
+ private: |
+ base_ren_type* m_ren; |
+ color_type m_color; |
+ unsigned m_left, m_top; |
}; |
} |
-static void RasterizeStroke(agg::rasterizer_scanline_aa& rasterizer, agg::path_storage& path_data, |
+static void RasterizeStroke(agg::rasterizer_scanline_aa& rasterizer, |
+ agg::path_storage& path_data, |
const CFX_AffineMatrix* pObject2Device, |
- const CFX_GraphStateData* pGraphState, FX_FLOAT scale = 1.0f, |
- FX_BOOL bStrokeAdjust = FALSE, FX_BOOL bTextMode = FALSE) |
-{ |
- agg::line_cap_e cap; |
- switch (pGraphState->m_LineCap) { |
- case CFX_GraphStateData::LineCapRound: |
- cap = agg::round_cap; |
- break; |
- case CFX_GraphStateData::LineCapSquare: |
- cap = agg::square_cap; |
- break; |
- default: |
- cap = agg::butt_cap; |
- break; |
- } |
- agg::line_join_e join; |
- switch (pGraphState->m_LineJoin) { |
- case CFX_GraphStateData::LineJoinRound: |
- join = agg::round_join; |
- break; |
- case CFX_GraphStateData::LineJoinBevel: |
- join = agg::bevel_join; |
- break; |
- default: |
- join = agg::miter_join_revert; |
- break; |
- } |
- FX_FLOAT width = pGraphState->m_LineWidth * scale; |
- FX_FLOAT unit = 1.f; |
- if (pObject2Device) { |
- unit = FXSYS_Div(1.0f, (pObject2Device->GetXUnit() + pObject2Device->GetYUnit()) / 2); |
- } |
- if (width < unit) { |
- width = unit; |
- } |
- if (pGraphState->m_DashArray == NULL) { |
- agg::conv_stroke<agg::path_storage> stroke(path_data); |
- stroke.line_join(join); |
- stroke.line_cap(cap); |
- stroke.miter_limit(pGraphState->m_MiterLimit); |
- stroke.width(width); |
- rasterizer.add_path_transformed(stroke, pObject2Device); |
- } else { |
- typedef agg::conv_dash<agg::path_storage> dash_converter; |
- dash_converter dash(path_data); |
- for (int i = 0; i < (pGraphState->m_DashCount + 1) / 2; i ++) { |
- FX_FLOAT on = pGraphState->m_DashArray[i * 2]; |
- if (on <= 0.000001f) { |
- on = 1.0f / 10; |
- } |
- FX_FLOAT off = i * 2 + 1 == pGraphState->m_DashCount ? on : |
- pGraphState->m_DashArray[i * 2 + 1]; |
- if (off < 0) { |
- off = 0; |
- } |
- dash.add_dash(on * scale, off * scale); |
- } |
- dash.dash_start(pGraphState->m_DashPhase * scale); |
- typedef agg::conv_stroke<dash_converter> dash_stroke; |
- dash_stroke stroke(dash); |
- stroke.line_join(join); |
- stroke.line_cap(cap); |
- stroke.miter_limit(pGraphState->m_MiterLimit); |
- stroke.width(width); |
- rasterizer.add_path_transformed(stroke, pObject2Device); |
- } |
-} |
-IFX_RenderDeviceDriver* IFX_RenderDeviceDriver::CreateFxgeDriver(CFX_DIBitmap* pBitmap, FX_BOOL bRgbByteOrder, CFX_DIBitmap* pOriDevice, FX_BOOL bGroupKnockout) |
-{ |
- return new CFX_AggDeviceDriver(pBitmap, 0, bRgbByteOrder, pOriDevice, bGroupKnockout); |
-} |
-CFX_AggDeviceDriver::CFX_AggDeviceDriver(CFX_DIBitmap* pBitmap, int dither_bits, FX_BOOL bRgbByteOrder, CFX_DIBitmap* pOriDevice, FX_BOOL bGroupKnockout) |
-{ |
- m_pBitmap = pBitmap; |
- m_DitherBits = dither_bits; |
- m_pClipRgn = NULL; |
- m_pPlatformBitmap = NULL; |
- m_pPlatformGraphics = NULL; |
- m_pDwRenderTartget = NULL; |
- m_bRgbByteOrder = bRgbByteOrder; |
- m_pOriDevice = pOriDevice; |
- m_bGroupKnockout = bGroupKnockout; |
- m_FillFlags = 0; |
- InitPlatform(); |
+ const CFX_GraphStateData* pGraphState, |
+ FX_FLOAT scale = 1.0f, |
+ FX_BOOL bStrokeAdjust = FALSE, |
+ FX_BOOL bTextMode = FALSE) { |
+ agg::line_cap_e cap; |
+ switch (pGraphState->m_LineCap) { |
+ case CFX_GraphStateData::LineCapRound: |
+ cap = agg::round_cap; |
+ break; |
+ case CFX_GraphStateData::LineCapSquare: |
+ cap = agg::square_cap; |
+ break; |
+ default: |
+ cap = agg::butt_cap; |
+ break; |
+ } |
+ agg::line_join_e join; |
+ switch (pGraphState->m_LineJoin) { |
+ case CFX_GraphStateData::LineJoinRound: |
+ join = agg::round_join; |
+ break; |
+ case CFX_GraphStateData::LineJoinBevel: |
+ join = agg::bevel_join; |
+ break; |
+ default: |
+ join = agg::miter_join_revert; |
+ break; |
+ } |
+ FX_FLOAT width = pGraphState->m_LineWidth * scale; |
+ FX_FLOAT unit = 1.f; |
+ if (pObject2Device) { |
+ unit = FXSYS_Div( |
+ 1.0f, (pObject2Device->GetXUnit() + pObject2Device->GetYUnit()) / 2); |
+ } |
+ if (width < unit) { |
+ width = unit; |
+ } |
+ if (pGraphState->m_DashArray == NULL) { |
+ agg::conv_stroke<agg::path_storage> stroke(path_data); |
+ stroke.line_join(join); |
+ stroke.line_cap(cap); |
+ stroke.miter_limit(pGraphState->m_MiterLimit); |
+ stroke.width(width); |
+ rasterizer.add_path_transformed(stroke, pObject2Device); |
+ } else { |
+ typedef agg::conv_dash<agg::path_storage> dash_converter; |
+ dash_converter dash(path_data); |
+ for (int i = 0; i < (pGraphState->m_DashCount + 1) / 2; i++) { |
+ FX_FLOAT on = pGraphState->m_DashArray[i * 2]; |
+ if (on <= 0.000001f) { |
+ on = 1.0f / 10; |
+ } |
+ FX_FLOAT off = i * 2 + 1 == pGraphState->m_DashCount |
+ ? on |
+ : pGraphState->m_DashArray[i * 2 + 1]; |
+ if (off < 0) { |
+ off = 0; |
+ } |
+ dash.add_dash(on * scale, off * scale); |
+ } |
+ dash.dash_start(pGraphState->m_DashPhase * scale); |
+ typedef agg::conv_stroke<dash_converter> dash_stroke; |
+ dash_stroke stroke(dash); |
+ stroke.line_join(join); |
+ stroke.line_cap(cap); |
+ stroke.miter_limit(pGraphState->m_MiterLimit); |
+ stroke.width(width); |
+ rasterizer.add_path_transformed(stroke, pObject2Device); |
+ } |
} |
-CFX_AggDeviceDriver::~CFX_AggDeviceDriver() |
-{ |
- delete m_pClipRgn; |
- for (int i = 0; i < m_StateStack.GetSize(); i ++) |
- delete (CFX_ClipRgn*)m_StateStack[i]; |
- DestroyPlatform(); |
+IFX_RenderDeviceDriver* IFX_RenderDeviceDriver::CreateFxgeDriver( |
+ CFX_DIBitmap* pBitmap, |
+ FX_BOOL bRgbByteOrder, |
+ CFX_DIBitmap* pOriDevice, |
+ FX_BOOL bGroupKnockout) { |
+ return new CFX_AggDeviceDriver(pBitmap, 0, bRgbByteOrder, pOriDevice, |
+ bGroupKnockout); |
} |
-#if _FXM_PLATFORM_ != _FXM_PLATFORM_APPLE_ |
-void CFX_AggDeviceDriver::InitPlatform() |
-{ |
+CFX_AggDeviceDriver::CFX_AggDeviceDriver(CFX_DIBitmap* pBitmap, |
+ int dither_bits, |
+ FX_BOOL bRgbByteOrder, |
+ CFX_DIBitmap* pOriDevice, |
+ FX_BOOL bGroupKnockout) { |
+ m_pBitmap = pBitmap; |
+ m_DitherBits = dither_bits; |
+ m_pClipRgn = NULL; |
+ m_pPlatformBitmap = NULL; |
+ m_pPlatformGraphics = NULL; |
+ m_pDwRenderTartget = NULL; |
+ m_bRgbByteOrder = bRgbByteOrder; |
+ m_pOriDevice = pOriDevice; |
+ m_bGroupKnockout = bGroupKnockout; |
+ m_FillFlags = 0; |
+ InitPlatform(); |
} |
-void CFX_AggDeviceDriver::DestroyPlatform() |
-{ |
+CFX_AggDeviceDriver::~CFX_AggDeviceDriver() { |
+ delete m_pClipRgn; |
+ for (int i = 0; i < m_StateStack.GetSize(); i++) |
+ delete (CFX_ClipRgn*)m_StateStack[i]; |
+ DestroyPlatform(); |
} |
-FX_BOOL CFX_AggDeviceDriver::DrawDeviceText(int nChars, const FXTEXT_CHARPOS* pCharPos, CFX_Font* pFont, |
- CFX_FontCache* pCache, const CFX_AffineMatrix* pObject2Device, FX_FLOAT font_size, FX_DWORD color, |
- int alpha_flag, void* pIccTransform) |
-{ |
- return FALSE; |
+#if _FXM_PLATFORM_ != _FXM_PLATFORM_APPLE_ |
+void CFX_AggDeviceDriver::InitPlatform() {} |
+void CFX_AggDeviceDriver::DestroyPlatform() {} |
+FX_BOOL CFX_AggDeviceDriver::DrawDeviceText( |
+ int nChars, |
+ const FXTEXT_CHARPOS* pCharPos, |
+ CFX_Font* pFont, |
+ CFX_FontCache* pCache, |
+ const CFX_AffineMatrix* pObject2Device, |
+ FX_FLOAT font_size, |
+ FX_DWORD color, |
+ int alpha_flag, |
+ void* pIccTransform) { |
+ return FALSE; |
} |
#endif |
-int CFX_AggDeviceDriver::GetDeviceCaps(int caps_id) |
-{ |
- switch (caps_id) { |
- case FXDC_DEVICE_CLASS: |
- return FXDC_DISPLAY; |
- case FXDC_PIXEL_WIDTH: |
- return m_pBitmap->GetWidth(); |
- case FXDC_PIXEL_HEIGHT: |
- return m_pBitmap->GetHeight(); |
- case FXDC_BITS_PIXEL: |
- return m_pBitmap->GetBPP(); |
- case FXDC_HORZ_SIZE: |
- case FXDC_VERT_SIZE: |
- return 0; |
- case FXDC_RENDER_CAPS: { |
- int flags = FXRC_GET_BITS | FXRC_ALPHA_PATH | FXRC_ALPHA_IMAGE | FXRC_BLEND_MODE | FXRC_SOFT_CLIP; |
- if (m_pBitmap->HasAlpha()) { |
- flags |= FXRC_ALPHA_OUTPUT; |
- } else if (m_pBitmap->IsAlphaMask()) { |
- if (m_pBitmap->GetBPP() == 1) { |
- flags |= FXRC_BITMASK_OUTPUT; |
- } else { |
- flags |= FXRC_BYTEMASK_OUTPUT; |
- } |
- } |
- if (m_pBitmap->IsCmykImage()) { |
- flags |= FXRC_CMYK_OUTPUT; |
- } |
- return flags; |
- } |
- case FXDC_DITHER_BITS: |
- return m_DitherBits; |
- } |
- return 0; |
+int CFX_AggDeviceDriver::GetDeviceCaps(int caps_id) { |
+ switch (caps_id) { |
+ case FXDC_DEVICE_CLASS: |
+ return FXDC_DISPLAY; |
+ case FXDC_PIXEL_WIDTH: |
+ return m_pBitmap->GetWidth(); |
+ case FXDC_PIXEL_HEIGHT: |
+ return m_pBitmap->GetHeight(); |
+ case FXDC_BITS_PIXEL: |
+ return m_pBitmap->GetBPP(); |
+ case FXDC_HORZ_SIZE: |
+ case FXDC_VERT_SIZE: |
+ return 0; |
+ case FXDC_RENDER_CAPS: { |
+ int flags = FXRC_GET_BITS | FXRC_ALPHA_PATH | FXRC_ALPHA_IMAGE | |
+ FXRC_BLEND_MODE | FXRC_SOFT_CLIP; |
+ if (m_pBitmap->HasAlpha()) { |
+ flags |= FXRC_ALPHA_OUTPUT; |
+ } else if (m_pBitmap->IsAlphaMask()) { |
+ if (m_pBitmap->GetBPP() == 1) { |
+ flags |= FXRC_BITMASK_OUTPUT; |
+ } else { |
+ flags |= FXRC_BYTEMASK_OUTPUT; |
+ } |
+ } |
+ if (m_pBitmap->IsCmykImage()) { |
+ flags |= FXRC_CMYK_OUTPUT; |
+ } |
+ return flags; |
+ } |
+ case FXDC_DITHER_BITS: |
+ return m_DitherBits; |
+ } |
+ return 0; |
} |
-void CFX_AggDeviceDriver::SaveState() |
-{ |
- void* pClip = NULL; |
- if (m_pClipRgn) { |
- pClip = new CFX_ClipRgn(*m_pClipRgn); |
- } |
- m_StateStack.Add(pClip); |
+void CFX_AggDeviceDriver::SaveState() { |
+ void* pClip = NULL; |
+ if (m_pClipRgn) { |
+ pClip = new CFX_ClipRgn(*m_pClipRgn); |
+ } |
+ m_StateStack.Add(pClip); |
} |
-void CFX_AggDeviceDriver::RestoreState(FX_BOOL bKeepSaved) |
-{ |
- if (m_StateStack.GetSize() == 0) { |
- delete m_pClipRgn; |
- m_pClipRgn = NULL; |
- return; |
- } |
- CFX_ClipRgn* pSavedClip = (CFX_ClipRgn*)m_StateStack[m_StateStack.GetSize() - 1]; |
+void CFX_AggDeviceDriver::RestoreState(FX_BOOL bKeepSaved) { |
+ if (m_StateStack.GetSize() == 0) { |
delete m_pClipRgn; |
m_pClipRgn = NULL; |
- if (bKeepSaved) { |
- if (pSavedClip) { |
- m_pClipRgn = new CFX_ClipRgn(*pSavedClip); |
- } |
- } else { |
- m_StateStack.RemoveAt(m_StateStack.GetSize() - 1); |
- m_pClipRgn = pSavedClip; |
- } |
+ return; |
+ } |
+ CFX_ClipRgn* pSavedClip = |
+ (CFX_ClipRgn*)m_StateStack[m_StateStack.GetSize() - 1]; |
+ delete m_pClipRgn; |
+ m_pClipRgn = NULL; |
+ if (bKeepSaved) { |
+ if (pSavedClip) { |
+ m_pClipRgn = new CFX_ClipRgn(*pSavedClip); |
+ } |
+ } else { |
+ m_StateStack.RemoveAt(m_StateStack.GetSize() - 1); |
+ m_pClipRgn = pSavedClip; |
+ } |
} |
-void CFX_AggDeviceDriver::SetClipMask(agg::rasterizer_scanline_aa& rasterizer) |
-{ |
- FX_RECT path_rect(rasterizer.min_x(), rasterizer.min_y(), |
- rasterizer.max_x() + 1, rasterizer.max_y() + 1); |
- path_rect.Intersect(m_pClipRgn->GetBox()); |
- CFX_DIBitmapRef mask; |
- CFX_DIBitmap* pThisLayer = mask.New(); |
- if (!pThisLayer) { |
- return; |
- } |
- pThisLayer->Create(path_rect.Width(), path_rect.Height(), FXDIB_8bppMask); |
- pThisLayer->Clear(0); |
- agg::rendering_buffer raw_buf(pThisLayer->GetBuffer(), pThisLayer->GetWidth(), pThisLayer->GetHeight(), pThisLayer->GetPitch()); |
- agg::pixfmt_gray8 pixel_buf(raw_buf); |
- agg::renderer_base<agg::pixfmt_gray8> base_buf(pixel_buf); |
- agg::renderer_scanline_aa_offset<agg::renderer_base<agg::pixfmt_gray8> > final_render(base_buf, path_rect.left, path_rect.top); |
- final_render.color(agg::gray8(255)); |
- agg::scanline_u8 scanline; |
- agg::render_scanlines(rasterizer, scanline, final_render, (m_FillFlags & FXFILL_NOPATHSMOOTH) != 0); |
- m_pClipRgn->IntersectMaskF(path_rect.left, path_rect.top, mask); |
+void CFX_AggDeviceDriver::SetClipMask(agg::rasterizer_scanline_aa& rasterizer) { |
+ FX_RECT path_rect(rasterizer.min_x(), rasterizer.min_y(), |
+ rasterizer.max_x() + 1, rasterizer.max_y() + 1); |
+ path_rect.Intersect(m_pClipRgn->GetBox()); |
+ CFX_DIBitmapRef mask; |
+ CFX_DIBitmap* pThisLayer = mask.New(); |
+ if (!pThisLayer) { |
+ return; |
+ } |
+ pThisLayer->Create(path_rect.Width(), path_rect.Height(), FXDIB_8bppMask); |
+ pThisLayer->Clear(0); |
+ agg::rendering_buffer raw_buf(pThisLayer->GetBuffer(), pThisLayer->GetWidth(), |
+ pThisLayer->GetHeight(), |
+ pThisLayer->GetPitch()); |
+ agg::pixfmt_gray8 pixel_buf(raw_buf); |
+ agg::renderer_base<agg::pixfmt_gray8> base_buf(pixel_buf); |
+ agg::renderer_scanline_aa_offset<agg::renderer_base<agg::pixfmt_gray8> > |
+ final_render(base_buf, path_rect.left, path_rect.top); |
+ final_render.color(agg::gray8(255)); |
+ agg::scanline_u8 scanline; |
+ agg::render_scanlines(rasterizer, scanline, final_render, |
+ (m_FillFlags & FXFILL_NOPATHSMOOTH) != 0); |
+ m_pClipRgn->IntersectMaskF(path_rect.left, path_rect.top, mask); |
} |
-FX_BOOL CFX_AggDeviceDriver::SetClip_PathFill(const CFX_PathData* pPathData, |
- const CFX_AffineMatrix* pObject2Device, |
- int fill_mode |
- ) |
-{ |
- m_FillFlags = fill_mode; |
- if (m_pClipRgn == NULL) { |
- m_pClipRgn = new CFX_ClipRgn(GetDeviceCaps(FXDC_PIXEL_WIDTH), GetDeviceCaps(FXDC_PIXEL_HEIGHT)); |
- } |
- if (pPathData->GetPointCount() == 5 || pPathData->GetPointCount() == 4) { |
- CFX_FloatRect rectf; |
- if (pPathData->IsRect(pObject2Device, &rectf)) { |
- rectf.Intersect(CFX_FloatRect(0, 0, (FX_FLOAT)GetDeviceCaps(FXDC_PIXEL_WIDTH), (FX_FLOAT)GetDeviceCaps(FXDC_PIXEL_HEIGHT))); |
- FX_RECT rect = rectf.GetOutterRect(); |
- m_pClipRgn->IntersectRect(rect); |
- return TRUE; |
- } |
- } |
- CAgg_PathData path_data; |
- path_data.BuildPath(pPathData, pObject2Device); |
- path_data.m_PathData.end_poly(); |
- agg::rasterizer_scanline_aa rasterizer; |
- rasterizer.clip_box(0.0f, 0.0f, (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_WIDTH)), (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_HEIGHT))); |
- rasterizer.add_path(path_data.m_PathData); |
- rasterizer.filling_rule((fill_mode & 3) == FXFILL_WINDING ? agg::fill_non_zero : agg::fill_even_odd); |
- SetClipMask(rasterizer); |
- return TRUE; |
+FX_BOOL CFX_AggDeviceDriver::SetClip_PathFill( |
+ const CFX_PathData* pPathData, |
+ const CFX_AffineMatrix* pObject2Device, |
+ int fill_mode) { |
+ m_FillFlags = fill_mode; |
+ if (m_pClipRgn == NULL) { |
+ m_pClipRgn = new CFX_ClipRgn(GetDeviceCaps(FXDC_PIXEL_WIDTH), |
+ GetDeviceCaps(FXDC_PIXEL_HEIGHT)); |
+ } |
+ if (pPathData->GetPointCount() == 5 || pPathData->GetPointCount() == 4) { |
+ CFX_FloatRect rectf; |
+ if (pPathData->IsRect(pObject2Device, &rectf)) { |
+ rectf.Intersect( |
+ CFX_FloatRect(0, 0, (FX_FLOAT)GetDeviceCaps(FXDC_PIXEL_WIDTH), |
+ (FX_FLOAT)GetDeviceCaps(FXDC_PIXEL_HEIGHT))); |
+ FX_RECT rect = rectf.GetOutterRect(); |
+ m_pClipRgn->IntersectRect(rect); |
+ return TRUE; |
+ } |
+ } |
+ CAgg_PathData path_data; |
+ path_data.BuildPath(pPathData, pObject2Device); |
+ path_data.m_PathData.end_poly(); |
+ agg::rasterizer_scanline_aa rasterizer; |
+ rasterizer.clip_box(0.0f, 0.0f, (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_WIDTH)), |
+ (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_HEIGHT))); |
+ rasterizer.add_path(path_data.m_PathData); |
+ rasterizer.filling_rule((fill_mode & 3) == FXFILL_WINDING |
+ ? agg::fill_non_zero |
+ : agg::fill_even_odd); |
+ SetClipMask(rasterizer); |
+ return TRUE; |
} |
-FX_BOOL CFX_AggDeviceDriver::SetClip_PathStroke(const CFX_PathData* pPathData, |
- const CFX_AffineMatrix* pObject2Device, |
- const CFX_GraphStateData* pGraphState |
- ) |
-{ |
- if (m_pClipRgn == NULL) { |
- m_pClipRgn = new CFX_ClipRgn(GetDeviceCaps(FXDC_PIXEL_WIDTH), GetDeviceCaps(FXDC_PIXEL_HEIGHT)); |
- } |
- CAgg_PathData path_data; |
- path_data.BuildPath(pPathData, NULL); |
- agg::rasterizer_scanline_aa rasterizer; |
- rasterizer.clip_box(0.0f, 0.0f, (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_WIDTH)), (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_HEIGHT))); |
- RasterizeStroke(rasterizer, path_data.m_PathData, pObject2Device, pGraphState); |
- rasterizer.filling_rule(agg::fill_non_zero); |
- SetClipMask(rasterizer); |
- return TRUE; |
+FX_BOOL CFX_AggDeviceDriver::SetClip_PathStroke( |
+ const CFX_PathData* pPathData, |
+ const CFX_AffineMatrix* pObject2Device, |
+ const CFX_GraphStateData* pGraphState) { |
+ if (m_pClipRgn == NULL) { |
+ m_pClipRgn = new CFX_ClipRgn(GetDeviceCaps(FXDC_PIXEL_WIDTH), |
+ GetDeviceCaps(FXDC_PIXEL_HEIGHT)); |
+ } |
+ CAgg_PathData path_data; |
+ path_data.BuildPath(pPathData, NULL); |
+ agg::rasterizer_scanline_aa rasterizer; |
+ rasterizer.clip_box(0.0f, 0.0f, (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_WIDTH)), |
+ (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_HEIGHT))); |
+ RasterizeStroke(rasterizer, path_data.m_PathData, pObject2Device, |
+ pGraphState); |
+ rasterizer.filling_rule(agg::fill_non_zero); |
+ SetClipMask(rasterizer); |
+ return TRUE; |
} |
-class CFX_Renderer |
-{ |
-private: |
- int m_Alpha, |
- m_Red, |
- m_Green, |
- m_Blue, |
- m_Gray; |
- FX_DWORD m_Color; |
- FX_BOOL m_bFullCover; |
- FX_BOOL m_bRgbByteOrder; |
- CFX_DIBitmap* m_pOriDevice; |
- FX_RECT m_ClipBox; |
- const CFX_DIBitmap* m_pClipMask; |
- CFX_DIBitmap* m_pDevice; |
- const CFX_ClipRgn* m_pClipRgn; |
- void (CFX_Renderer::*composite_span)(uint8_t*, int, int, int, uint8_t*, int, int, uint8_t*, uint8_t*); |
-public: |
- void prepare(unsigned) {} |
- void CompositeSpan(uint8_t* dest_scan, uint8_t* ori_scan, int Bpp, FX_BOOL bDestAlpha, |
- int span_left, int span_len, uint8_t* cover_scan, |
- int clip_left, int clip_right, uint8_t* clip_scan) |
- { |
- ASSERT(!m_pDevice->IsCmykImage()); |
- int col_start = span_left < clip_left ? clip_left - span_left : 0; |
- int col_end = (span_left + span_len) < clip_right ? span_len : (clip_right - span_left); |
- if (Bpp) { |
- dest_scan += col_start * Bpp; |
- ori_scan += col_start * Bpp; |
- } else { |
- dest_scan += col_start / 8; |
- ori_scan += col_start / 8; |
+class CFX_Renderer { |
+ private: |
+ int m_Alpha, m_Red, m_Green, m_Blue, m_Gray; |
+ FX_DWORD m_Color; |
+ FX_BOOL m_bFullCover; |
+ FX_BOOL m_bRgbByteOrder; |
+ CFX_DIBitmap* m_pOriDevice; |
+ FX_RECT m_ClipBox; |
+ const CFX_DIBitmap* m_pClipMask; |
+ CFX_DIBitmap* m_pDevice; |
+ const CFX_ClipRgn* m_pClipRgn; |
+ void (CFX_Renderer::*composite_span)(uint8_t*, |
+ int, |
+ int, |
+ int, |
+ uint8_t*, |
+ int, |
+ int, |
+ uint8_t*, |
+ uint8_t*); |
+ |
+ public: |
+ void prepare(unsigned) {} |
+ void CompositeSpan(uint8_t* dest_scan, |
+ uint8_t* ori_scan, |
+ int Bpp, |
+ FX_BOOL bDestAlpha, |
+ int span_left, |
+ int span_len, |
+ uint8_t* cover_scan, |
+ int clip_left, |
+ int clip_right, |
+ uint8_t* clip_scan) { |
+ ASSERT(!m_pDevice->IsCmykImage()); |
+ int col_start = span_left < clip_left ? clip_left - span_left : 0; |
+ int col_end = (span_left + span_len) < clip_right |
+ ? span_len |
+ : (clip_right - span_left); |
+ if (Bpp) { |
+ dest_scan += col_start * Bpp; |
+ ori_scan += col_start * Bpp; |
+ } else { |
+ dest_scan += col_start / 8; |
+ ori_scan += col_start / 8; |
+ } |
+ if (m_bRgbByteOrder) { |
+ if (Bpp == 4 && bDestAlpha) { |
+ for (int col = col_start; col < col_end; col++) { |
+ int src_alpha; |
+ if (clip_scan) { |
+ src_alpha = m_Alpha * clip_scan[col] / 255; |
+ } else { |
+ src_alpha = m_Alpha; |
+ } |
+ uint8_t dest_alpha = |
+ ori_scan[3] + src_alpha - ori_scan[3] * src_alpha / 255; |
+ dest_scan[3] = dest_alpha; |
+ int alpha_ratio = src_alpha * 255 / dest_alpha; |
+ if (m_bFullCover) { |
+ *dest_scan++ = FXDIB_ALPHA_MERGE(*ori_scan++, m_Red, alpha_ratio); |
+ *dest_scan++ = FXDIB_ALPHA_MERGE(*ori_scan++, m_Green, alpha_ratio); |
+ *dest_scan++ = FXDIB_ALPHA_MERGE(*ori_scan++, m_Blue, alpha_ratio); |
+ dest_scan++; |
+ ori_scan++; |
+ } else { |
+ int r = FXDIB_ALPHA_MERGE(*ori_scan++, m_Red, alpha_ratio); |
+ int g = FXDIB_ALPHA_MERGE(*ori_scan++, m_Green, alpha_ratio); |
+ int b = FXDIB_ALPHA_MERGE(*ori_scan++, m_Blue, alpha_ratio); |
+ ori_scan++; |
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, r, cover_scan[col]); |
+ dest_scan++; |
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, g, cover_scan[col]); |
+ dest_scan++; |
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, b, cover_scan[col]); |
+ dest_scan += 2; |
+ } |
} |
- if (m_bRgbByteOrder) { |
- if (Bpp == 4 && bDestAlpha) { |
- for (int col = col_start; col < col_end; col ++) { |
- int src_alpha; |
- if (clip_scan) { |
- src_alpha = m_Alpha * clip_scan[col] / 255; |
- } else { |
- src_alpha = m_Alpha; |
- } |
- uint8_t dest_alpha = ori_scan[3] + src_alpha - ori_scan[3] * src_alpha / 255; |
- dest_scan[3] = dest_alpha; |
- int alpha_ratio = src_alpha * 255 / dest_alpha; |
- if (m_bFullCover) { |
- *dest_scan++ = FXDIB_ALPHA_MERGE(*ori_scan++, m_Red, alpha_ratio); |
- *dest_scan++ = FXDIB_ALPHA_MERGE(*ori_scan++, m_Green, alpha_ratio); |
- *dest_scan++ = FXDIB_ALPHA_MERGE(*ori_scan++, m_Blue, alpha_ratio); |
- dest_scan++; |
- ori_scan++; |
- } else { |
- int r = FXDIB_ALPHA_MERGE(*ori_scan++, m_Red, alpha_ratio); |
- int g = FXDIB_ALPHA_MERGE(*ori_scan++, m_Green, alpha_ratio); |
- int b = FXDIB_ALPHA_MERGE(*ori_scan++, m_Blue, alpha_ratio); |
- ori_scan ++; |
- *dest_scan = FXDIB_ALPHA_MERGE( *dest_scan, r, cover_scan[col]); |
- dest_scan ++; |
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, g, cover_scan[col]); |
- dest_scan ++; |
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, b, cover_scan[col]); |
- dest_scan += 2; |
- } |
- } |
- return; |
- } |
- if (Bpp == 3 || Bpp == 4) { |
- for (int col = col_start; col < col_end; col ++) { |
- int src_alpha; |
- if (clip_scan) { |
- src_alpha = m_Alpha * clip_scan[col] / 255 ; |
- } else { |
- src_alpha = m_Alpha; |
- } |
- int r = FXDIB_ALPHA_MERGE(*ori_scan++, m_Red, src_alpha); |
- int g = FXDIB_ALPHA_MERGE(*ori_scan++, m_Green, src_alpha); |
- int b = FXDIB_ALPHA_MERGE(*ori_scan, m_Blue, src_alpha); |
- ori_scan += Bpp - 2; |
- *dest_scan = FXDIB_ALPHA_MERGE( *dest_scan, r, cover_scan[col]); |
- dest_scan ++; |
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, g, cover_scan[col]); |
- dest_scan ++; |
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, b, cover_scan[col]); |
- dest_scan += Bpp - 2; |
- } |
- } |
- return; |
+ return; |
+ } |
+ if (Bpp == 3 || Bpp == 4) { |
+ for (int col = col_start; col < col_end; col++) { |
+ int src_alpha; |
+ if (clip_scan) { |
+ src_alpha = m_Alpha * clip_scan[col] / 255; |
+ } else { |
+ src_alpha = m_Alpha; |
+ } |
+ int r = FXDIB_ALPHA_MERGE(*ori_scan++, m_Red, src_alpha); |
+ int g = FXDIB_ALPHA_MERGE(*ori_scan++, m_Green, src_alpha); |
+ int b = FXDIB_ALPHA_MERGE(*ori_scan, m_Blue, src_alpha); |
+ ori_scan += Bpp - 2; |
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, r, cover_scan[col]); |
+ dest_scan++; |
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, g, cover_scan[col]); |
+ dest_scan++; |
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, b, cover_scan[col]); |
+ dest_scan += Bpp - 2; |
} |
- if (Bpp == 4 && bDestAlpha) { |
- for (int col = col_start; col < col_end; col ++) { |
- int src_alpha; |
- if (clip_scan) { |
- src_alpha = m_Alpha * clip_scan[col] / 255; |
- } else { |
- src_alpha = m_Alpha; |
- } |
- int src_alpha_covered = src_alpha * cover_scan[col] / 255; |
- if (src_alpha_covered == 0) { |
- dest_scan += 4; |
- continue; |
- } |
- if (cover_scan[col] == 255) { |
- dest_scan[3] = src_alpha_covered; |
- *dest_scan ++ = m_Blue; |
- *dest_scan ++ = m_Green; |
- *dest_scan = m_Red; |
- dest_scan += 2; |
- continue; |
- } else { |
- if (dest_scan[3] == 0) { |
- dest_scan[3] = src_alpha_covered; |
- *dest_scan ++ = m_Blue; |
- *dest_scan ++ = m_Green; |
- *dest_scan = m_Red; |
- dest_scan += 2; |
- continue; |
- } |
- uint8_t cover = cover_scan[col]; |
- dest_scan[3] = FXDIB_ALPHA_MERGE(dest_scan[3], src_alpha, cover); |
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, cover); |
- dest_scan ++; |
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, cover); |
- dest_scan ++; |
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, cover); |
- dest_scan += 2; |
- } |
- } |
- return; |
+ } |
+ return; |
+ } |
+ if (Bpp == 4 && bDestAlpha) { |
+ for (int col = col_start; col < col_end; col++) { |
+ int src_alpha; |
+ if (clip_scan) { |
+ src_alpha = m_Alpha * clip_scan[col] / 255; |
+ } else { |
+ src_alpha = m_Alpha; |
} |
- if (Bpp == 3 || Bpp == 4) { |
- for (int col = col_start; col < col_end; col ++) { |
- int src_alpha; |
- if (clip_scan) { |
- src_alpha = m_Alpha * clip_scan[col] / 255; |
- } else { |
- src_alpha = m_Alpha; |
- } |
- if (m_bFullCover) { |
- *dest_scan++ = FXDIB_ALPHA_MERGE(*ori_scan++, m_Blue, src_alpha); |
- *dest_scan++ = FXDIB_ALPHA_MERGE(*ori_scan++, m_Green, src_alpha); |
- *dest_scan = FXDIB_ALPHA_MERGE(*ori_scan, m_Red, src_alpha); |
- dest_scan += Bpp - 2; |
- ori_scan += Bpp - 2; |
- continue; |
- } |
- int b = FXDIB_ALPHA_MERGE(*ori_scan++, m_Blue, src_alpha); |
- int g = FXDIB_ALPHA_MERGE(*ori_scan++, m_Green, src_alpha); |
- int r = FXDIB_ALPHA_MERGE(*ori_scan, m_Red, src_alpha); |
- ori_scan += Bpp - 2; |
- *dest_scan = FXDIB_ALPHA_MERGE( *dest_scan, b, cover_scan[col]); |
- dest_scan ++; |
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, g, cover_scan[col]); |
- dest_scan ++; |
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, r, cover_scan[col]); |
- dest_scan += Bpp - 2; |
- continue; |
- } |
- return; |
+ int src_alpha_covered = src_alpha * cover_scan[col] / 255; |
+ if (src_alpha_covered == 0) { |
+ dest_scan += 4; |
+ continue; |
} |
- if (Bpp == 1) { |
- for (int col = col_start; col < col_end; col ++) { |
- int src_alpha; |
- if (clip_scan) { |
- src_alpha = m_Alpha * clip_scan[col] / 255; |
- } else { |
- src_alpha = m_Alpha; |
- } |
- if (m_bFullCover) { |
- *dest_scan = FXDIB_ALPHA_MERGE(*ori_scan++, m_Gray, src_alpha); |
- } else { |
- int gray = FXDIB_ALPHA_MERGE(*ori_scan++, m_Gray, src_alpha); |
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, cover_scan[col]); |
- dest_scan++; |
- } |
- } |
+ if (cover_scan[col] == 255) { |
+ dest_scan[3] = src_alpha_covered; |
+ *dest_scan++ = m_Blue; |
+ *dest_scan++ = m_Green; |
+ *dest_scan = m_Red; |
+ dest_scan += 2; |
+ continue; |
} else { |
- int index = 0; |
- if (m_pDevice->GetPalette() == NULL) { |
- index = ((uint8_t)m_Color == 0xff) ? 1 : 0; |
- } else { |
- for (int i = 0; i < 2; i ++) |
- if (FXARGB_TODIB(m_pDevice->GetPalette()[i]) == m_Color) { |
- index = i; |
- } |
- } |
- uint8_t* dest_scan1 = dest_scan; |
- for (int col = col_start; col < col_end; col ++) { |
- int src_alpha; |
- if (clip_scan) { |
- src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255; |
- } else { |
- src_alpha = m_Alpha * cover_scan[col] / 255; |
- } |
- if (src_alpha) { |
- if (!index) { |
- *dest_scan1 &= ~(1 << (7 - (col + span_left) % 8)); |
- } else { |
- *dest_scan1 |= 1 << (7 - (col + span_left) % 8); |
- } |
- } |
- dest_scan1 = dest_scan + (span_left % 8 + col - col_start + 1) / 8; |
- } |
+ if (dest_scan[3] == 0) { |
+ dest_scan[3] = src_alpha_covered; |
+ *dest_scan++ = m_Blue; |
+ *dest_scan++ = m_Green; |
+ *dest_scan = m_Red; |
+ dest_scan += 2; |
+ continue; |
+ } |
+ uint8_t cover = cover_scan[col]; |
+ dest_scan[3] = FXDIB_ALPHA_MERGE(dest_scan[3], src_alpha, cover); |
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, cover); |
+ dest_scan++; |
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, cover); |
+ dest_scan++; |
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, cover); |
+ dest_scan += 2; |
} |
- } |
- void CompositeSpan1bpp(uint8_t* dest_scan, int Bpp, |
- int span_left, int span_len, uint8_t* cover_scan, |
- int clip_left, int clip_right, uint8_t* clip_scan, |
- uint8_t* dest_extra_alpha_scan) |
- { |
- ASSERT(!m_bRgbByteOrder); |
- ASSERT(!m_pDevice->IsCmykImage()); |
- int col_start = span_left < clip_left ? clip_left - span_left : 0; |
- int col_end = (span_left + span_len) < clip_right ? span_len : (clip_right - span_left); |
- dest_scan += col_start / 8; |
- int index = 0; |
- if (m_pDevice->GetPalette() == NULL) { |
- index = ((uint8_t)m_Color == 0xff) ? 1 : 0; |
+ } |
+ return; |
+ } |
+ if (Bpp == 3 || Bpp == 4) { |
+ for (int col = col_start; col < col_end; col++) { |
+ int src_alpha; |
+ if (clip_scan) { |
+ src_alpha = m_Alpha * clip_scan[col] / 255; |
} else { |
- for (int i = 0; i < 2; i ++) |
- if (FXARGB_TODIB(m_pDevice->GetPalette()[i]) == m_Color) { |
- index = i; |
- } |
+ src_alpha = m_Alpha; |
} |
- uint8_t* dest_scan1 = dest_scan; |
- for (int col = col_start; col < col_end; col ++) { |
- int src_alpha; |
- if (clip_scan) { |
- src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255; |
- } else { |
- src_alpha = m_Alpha * cover_scan[col] / 255; |
- } |
- if (src_alpha) { |
- if (!index) { |
- *dest_scan1 &= ~(1 << (7 - (col + span_left) % 8)); |
- } else { |
- *dest_scan1 |= 1 << (7 - (col + span_left) % 8); |
- } |
- } |
- dest_scan1 = dest_scan + (span_left % 8 + col - col_start + 1) / 8; |
+ if (m_bFullCover) { |
+ *dest_scan++ = FXDIB_ALPHA_MERGE(*ori_scan++, m_Blue, src_alpha); |
+ *dest_scan++ = FXDIB_ALPHA_MERGE(*ori_scan++, m_Green, src_alpha); |
+ *dest_scan = FXDIB_ALPHA_MERGE(*ori_scan, m_Red, src_alpha); |
+ dest_scan += Bpp - 2; |
+ ori_scan += Bpp - 2; |
+ continue; |
} |
- } |
- void CompositeSpanGray(uint8_t* dest_scan, int Bpp, |
- int span_left, int span_len, uint8_t* cover_scan, |
- int clip_left, int clip_right, uint8_t* clip_scan, |
- uint8_t* dest_extra_alpha_scan) |
- { |
- ASSERT(!m_bRgbByteOrder); |
- int col_start = span_left < clip_left ? clip_left - span_left : 0; |
- int col_end = (span_left + span_len) < clip_right ? span_len : (clip_right - span_left); |
- dest_scan += col_start; |
- if (dest_extra_alpha_scan) { |
- for (int col = col_start; col < col_end; col ++) { |
- int src_alpha; |
- if (m_bFullCover) { |
- if (clip_scan) { |
- src_alpha = m_Alpha * clip_scan[col] / 255; |
- } else { |
- src_alpha = m_Alpha; |
- } |
- } else { |
- if (clip_scan) { |
- src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255; |
- } else { |
- src_alpha = m_Alpha * cover_scan[col] / 255; |
- } |
- } |
- if (src_alpha) { |
- if (src_alpha == 255) { |
- *dest_scan = m_Gray; |
- *dest_extra_alpha_scan = m_Alpha; |
- } else { |
- uint8_t dest_alpha = (*dest_extra_alpha_scan) + src_alpha - |
- (*dest_extra_alpha_scan) * src_alpha / 255; |
- *dest_extra_alpha_scan++ = dest_alpha; |
- int alpha_ratio = src_alpha * 255 / dest_alpha; |
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Gray, alpha_ratio); |
- dest_scan ++; |
- continue; |
- } |
- } |
- dest_extra_alpha_scan ++; |
- dest_scan ++; |
- } |
+ int b = FXDIB_ALPHA_MERGE(*ori_scan++, m_Blue, src_alpha); |
+ int g = FXDIB_ALPHA_MERGE(*ori_scan++, m_Green, src_alpha); |
+ int r = FXDIB_ALPHA_MERGE(*ori_scan, m_Red, src_alpha); |
+ ori_scan += Bpp - 2; |
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, b, cover_scan[col]); |
+ dest_scan++; |
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, g, cover_scan[col]); |
+ dest_scan++; |
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, r, cover_scan[col]); |
+ dest_scan += Bpp - 2; |
+ continue; |
+ } |
+ return; |
+ } |
+ if (Bpp == 1) { |
+ for (int col = col_start; col < col_end; col++) { |
+ int src_alpha; |
+ if (clip_scan) { |
+ src_alpha = m_Alpha * clip_scan[col] / 255; |
} else { |
- for (int col = col_start; col < col_end; col ++) { |
- int src_alpha; |
- if (clip_scan) { |
- src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255; |
- } else { |
- src_alpha = m_Alpha * cover_scan[col] / 255; |
- } |
- if (src_alpha) { |
- if (src_alpha == 255) { |
- *dest_scan = m_Gray; |
- } else { |
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Gray, src_alpha); |
- } |
- } |
- dest_scan ++; |
- } |
+ src_alpha = m_Alpha; |
} |
- } |
- void CompositeSpanARGB(uint8_t* dest_scan, int Bpp, |
- int span_left, int span_len, uint8_t* cover_scan, |
- int clip_left, int clip_right, uint8_t* clip_scan, |
- uint8_t* dest_extra_alpha_scan) |
- { |
- int col_start = span_left < clip_left ? clip_left - span_left : 0; |
- int col_end = (span_left + span_len) < clip_right ? span_len : (clip_right - span_left); |
- dest_scan += col_start * Bpp; |
- if (m_bRgbByteOrder) { |
- for (int col = col_start; col < col_end; col ++) { |
- int src_alpha; |
- if (m_bFullCover) { |
- if (clip_scan) { |
- src_alpha = m_Alpha * clip_scan[col] / 255; |
- } else { |
- src_alpha = m_Alpha; |
- } |
- } else { |
- if (clip_scan) { |
- src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255; |
- } else { |
- src_alpha = m_Alpha * cover_scan[col] / 255; |
- } |
- } |
- if (src_alpha) { |
- if (src_alpha == 255) { |
- *(FX_DWORD*)dest_scan = m_Color; |
- } else { |
- uint8_t dest_alpha = dest_scan[3] + src_alpha - dest_scan[3] * src_alpha / 255; |
- dest_scan[3] = dest_alpha; |
- int alpha_ratio = src_alpha * 255 / dest_alpha; |
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, alpha_ratio); |
- dest_scan ++; |
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, alpha_ratio); |
- dest_scan ++; |
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, alpha_ratio); |
- dest_scan += 2; |
- continue; |
- } |
- } |
- dest_scan += 4; |
- } |
- return; |
+ if (m_bFullCover) { |
+ *dest_scan = FXDIB_ALPHA_MERGE(*ori_scan++, m_Gray, src_alpha); |
+ } else { |
+ int gray = FXDIB_ALPHA_MERGE(*ori_scan++, m_Gray, src_alpha); |
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, cover_scan[col]); |
+ dest_scan++; |
} |
- for (int col = col_start; col < col_end; col ++) { |
- int src_alpha; |
- if (m_bFullCover) { |
- if (clip_scan) { |
- src_alpha = m_Alpha * clip_scan[col] / 255; |
- } else { |
- src_alpha = m_Alpha; |
- } |
- } else { |
- if (clip_scan) { |
- src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255; |
- } else { |
- src_alpha = m_Alpha * cover_scan[col] / 255; |
- } |
- } |
- if (src_alpha) { |
- if (src_alpha == 255) { |
- *(FX_DWORD*)dest_scan = m_Color; |
- } else { |
- if (dest_scan[3] == 0) { |
- dest_scan[3] = src_alpha; |
- *dest_scan++ = m_Blue; |
- *dest_scan++ = m_Green; |
- *dest_scan = m_Red; |
- dest_scan += 2; |
- continue; |
- } |
- uint8_t dest_alpha = dest_scan[3] + src_alpha - dest_scan[3] * src_alpha / 255; |
- dest_scan[3] = dest_alpha; |
- int alpha_ratio = src_alpha * 255 / dest_alpha; |
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, alpha_ratio); |
- dest_scan ++; |
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, alpha_ratio); |
- dest_scan ++; |
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, alpha_ratio); |
- dest_scan += 2; |
- continue; |
- } |
- } |
- dest_scan += Bpp; |
+ } |
+ } else { |
+ int index = 0; |
+ if (m_pDevice->GetPalette() == NULL) { |
+ index = ((uint8_t)m_Color == 0xff) ? 1 : 0; |
+ } else { |
+ for (int i = 0; i < 2; i++) |
+ if (FXARGB_TODIB(m_pDevice->GetPalette()[i]) == m_Color) { |
+ index = i; |
+ } |
+ } |
+ uint8_t* dest_scan1 = dest_scan; |
+ for (int col = col_start; col < col_end; col++) { |
+ int src_alpha; |
+ if (clip_scan) { |
+ src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255; |
+ } else { |
+ src_alpha = m_Alpha * cover_scan[col] / 255; |
+ } |
+ if (src_alpha) { |
+ if (!index) { |
+ *dest_scan1 &= ~(1 << (7 - (col + span_left) % 8)); |
+ } else { |
+ *dest_scan1 |= 1 << (7 - (col + span_left) % 8); |
+ } |
+ } |
+ dest_scan1 = dest_scan + (span_left % 8 + col - col_start + 1) / 8; |
+ } |
+ } |
+ } |
+ void CompositeSpan1bpp(uint8_t* dest_scan, |
+ int Bpp, |
+ int span_left, |
+ int span_len, |
+ uint8_t* cover_scan, |
+ int clip_left, |
+ int clip_right, |
+ uint8_t* clip_scan, |
+ uint8_t* dest_extra_alpha_scan) { |
+ ASSERT(!m_bRgbByteOrder); |
+ ASSERT(!m_pDevice->IsCmykImage()); |
+ int col_start = span_left < clip_left ? clip_left - span_left : 0; |
+ int col_end = (span_left + span_len) < clip_right |
+ ? span_len |
+ : (clip_right - span_left); |
+ dest_scan += col_start / 8; |
+ int index = 0; |
+ if (m_pDevice->GetPalette() == NULL) { |
+ index = ((uint8_t)m_Color == 0xff) ? 1 : 0; |
+ } else { |
+ for (int i = 0; i < 2; i++) |
+ if (FXARGB_TODIB(m_pDevice->GetPalette()[i]) == m_Color) { |
+ index = i; |
} |
} |
- void CompositeSpanRGB(uint8_t* dest_scan, int Bpp, |
- int span_left, int span_len, uint8_t* cover_scan, |
- int clip_left, int clip_right, uint8_t* clip_scan, |
- uint8_t* dest_extra_alpha_scan) |
- { |
- int col_start = span_left < clip_left ? clip_left - span_left : 0; |
- int col_end = (span_left + span_len) < clip_right ? span_len : (clip_right - span_left); |
- dest_scan += col_start * Bpp; |
- if (m_bRgbByteOrder) { |
- for (int col = col_start; col < col_end; col ++) { |
- int src_alpha; |
- if (clip_scan) { |
- src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255; |
- } else { |
- src_alpha = m_Alpha * cover_scan[col] / 255; |
- } |
- if (src_alpha) { |
- if (src_alpha == 255) { |
- if (Bpp == 4) { |
- *(FX_DWORD*)dest_scan = m_Color; |
- } else if (Bpp == 3) { |
- *dest_scan++ = m_Red; |
- *dest_scan++ = m_Green; |
- *dest_scan++ = m_Blue; |
- continue; |
- } |
- } else { |
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, src_alpha); |
- dest_scan++; |
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, src_alpha); |
- dest_scan++; |
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, src_alpha); |
- dest_scan += Bpp - 2; |
- continue; |
- } |
- } |
- dest_scan += Bpp; |
- } |
- return; |
+ uint8_t* dest_scan1 = dest_scan; |
+ for (int col = col_start; col < col_end; col++) { |
+ int src_alpha; |
+ if (clip_scan) { |
+ src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255; |
+ } else { |
+ src_alpha = m_Alpha * cover_scan[col] / 255; |
+ } |
+ if (src_alpha) { |
+ if (!index) { |
+ *dest_scan1 &= ~(1 << (7 - (col + span_left) % 8)); |
+ } else { |
+ *dest_scan1 |= 1 << (7 - (col + span_left) % 8); |
} |
- if (Bpp == 3 && dest_extra_alpha_scan) { |
- for (int col = col_start; col < col_end; col ++) { |
- int src_alpha; |
- if (m_bFullCover) { |
- if (clip_scan) { |
- src_alpha = m_Alpha * clip_scan[col] / 255; |
- } else { |
- src_alpha = m_Alpha; |
- } |
- } else { |
- if (clip_scan) { |
- src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255; |
- } else { |
- src_alpha = m_Alpha * cover_scan[col] / 255; |
- } |
- } |
- if (src_alpha) { |
- if (src_alpha == 255) { |
- *dest_scan++ = (uint8_t)m_Blue; |
- *dest_scan++ = (uint8_t)m_Green; |
- *dest_scan++ = (uint8_t)m_Red; |
- *dest_extra_alpha_scan++ = (uint8_t)m_Alpha; |
- continue; |
- } else { |
- uint8_t dest_alpha = (*dest_extra_alpha_scan) + src_alpha - |
- (*dest_extra_alpha_scan) * src_alpha / 255; |
- *dest_extra_alpha_scan++ = dest_alpha; |
- int alpha_ratio = src_alpha * 255 / dest_alpha; |
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, alpha_ratio); |
- dest_scan ++; |
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, alpha_ratio); |
- dest_scan ++; |
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, alpha_ratio); |
- dest_scan ++; |
- continue; |
- } |
- } |
- dest_extra_alpha_scan++; |
- dest_scan += Bpp; |
- } |
+ } |
+ dest_scan1 = dest_scan + (span_left % 8 + col - col_start + 1) / 8; |
+ } |
+ } |
+ void CompositeSpanGray(uint8_t* dest_scan, |
+ int Bpp, |
+ int span_left, |
+ int span_len, |
+ uint8_t* cover_scan, |
+ int clip_left, |
+ int clip_right, |
+ uint8_t* clip_scan, |
+ uint8_t* dest_extra_alpha_scan) { |
+ ASSERT(!m_bRgbByteOrder); |
+ int col_start = span_left < clip_left ? clip_left - span_left : 0; |
+ int col_end = (span_left + span_len) < clip_right |
+ ? span_len |
+ : (clip_right - span_left); |
+ dest_scan += col_start; |
+ if (dest_extra_alpha_scan) { |
+ for (int col = col_start; col < col_end; col++) { |
+ int src_alpha; |
+ if (m_bFullCover) { |
+ if (clip_scan) { |
+ src_alpha = m_Alpha * clip_scan[col] / 255; |
+ } else { |
+ src_alpha = m_Alpha; |
+ } |
} else { |
- for (int col = col_start; col < col_end; col ++) { |
- int src_alpha; |
- if (m_bFullCover) { |
- if (clip_scan) { |
- src_alpha = m_Alpha * clip_scan[col] / 255; |
- } else { |
- src_alpha = m_Alpha; |
- } |
- } else { |
- if (clip_scan) { |
- src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255; |
- } else { |
- src_alpha = m_Alpha * cover_scan[col] / 255; |
- } |
- } |
- if (src_alpha) { |
- if (src_alpha == 255) { |
- if (Bpp == 4) { |
- *(FX_DWORD*)dest_scan = m_Color; |
- } else if (Bpp == 3) { |
- *dest_scan++ = m_Blue; |
- *dest_scan++ = m_Green; |
- *dest_scan++ = m_Red; |
- continue; |
- } |
- } else { |
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, src_alpha); |
- dest_scan ++; |
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, src_alpha); |
- dest_scan ++; |
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, src_alpha); |
- dest_scan += Bpp - 2; |
- continue; |
- } |
- } |
- dest_scan += Bpp; |
- } |
+ if (clip_scan) { |
+ src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255; |
+ } else { |
+ src_alpha = m_Alpha * cover_scan[col] / 255; |
+ } |
} |
- } |
- void CompositeSpanCMYK(uint8_t* dest_scan, int Bpp, |
- int span_left, int span_len, uint8_t* cover_scan, |
- int clip_left, int clip_right, uint8_t* clip_scan, |
- uint8_t* dest_extra_alpha_scan) |
- { |
- ASSERT(!m_bRgbByteOrder); |
- int col_start = span_left < clip_left ? clip_left - span_left : 0; |
- int col_end = (span_left + span_len) < clip_right ? span_len : (clip_right - span_left); |
- dest_scan += col_start * 4; |
- if (dest_extra_alpha_scan) { |
- for (int col = col_start; col < col_end; col ++) { |
- int src_alpha; |
- if (m_bFullCover) { |
- if (clip_scan) { |
- src_alpha = m_Alpha * clip_scan[col] / 255; |
- } else { |
- src_alpha = m_Alpha; |
- } |
- } else { |
- if (clip_scan) { |
- src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255; |
- } else { |
- src_alpha = m_Alpha * cover_scan[col] / 255; |
- } |
- } |
- if (src_alpha) { |
- if (src_alpha == 255) { |
- *(FX_CMYK*)dest_scan = m_Color; |
- *dest_extra_alpha_scan = (uint8_t)m_Alpha; |
- } else { |
- uint8_t dest_alpha = (*dest_extra_alpha_scan) + src_alpha - |
- (*dest_extra_alpha_scan) * src_alpha / 255; |
- *dest_extra_alpha_scan++ = dest_alpha; |
- int alpha_ratio = src_alpha * 255 / dest_alpha; |
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, alpha_ratio); |
- dest_scan ++; |
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, alpha_ratio); |
- dest_scan ++; |
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, alpha_ratio); |
- dest_scan ++; |
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Gray, alpha_ratio); |
- dest_scan ++; |
- continue; |
- } |
- } |
- dest_extra_alpha_scan++; |
- dest_scan += 4; |
- } |
+ if (src_alpha) { |
+ if (src_alpha == 255) { |
+ *dest_scan = m_Gray; |
+ *dest_extra_alpha_scan = m_Alpha; |
+ } else { |
+ uint8_t dest_alpha = (*dest_extra_alpha_scan) + src_alpha - |
+ (*dest_extra_alpha_scan) * src_alpha / 255; |
+ *dest_extra_alpha_scan++ = dest_alpha; |
+ int alpha_ratio = src_alpha * 255 / dest_alpha; |
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Gray, alpha_ratio); |
+ dest_scan++; |
+ continue; |
+ } |
+ } |
+ dest_extra_alpha_scan++; |
+ dest_scan++; |
+ } |
+ } else { |
+ for (int col = col_start; col < col_end; col++) { |
+ int src_alpha; |
+ if (clip_scan) { |
+ src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255; |
} else { |
- for (int col = col_start; col < col_end; col ++) { |
- int src_alpha; |
- if (clip_scan) { |
- src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255; |
- } else { |
- src_alpha = m_Alpha * cover_scan[col] / 255; |
- } |
- if (src_alpha) { |
- if (src_alpha == 255) { |
- *(FX_CMYK*)dest_scan = m_Color; |
- } else { |
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, src_alpha); |
- dest_scan ++; |
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, src_alpha); |
- dest_scan ++; |
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, src_alpha); |
- dest_scan ++; |
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Gray, src_alpha); |
- dest_scan ++; |
- continue; |
- } |
- } |
- dest_scan += 4; |
- } |
+ src_alpha = m_Alpha * cover_scan[col] / 255; |
} |
- } |
- template<class Scanline> void render(const Scanline& sl) |
- { |
- if (m_pOriDevice == NULL && composite_span == NULL) { |
- return; |
+ if (src_alpha) { |
+ if (src_alpha == 255) { |
+ *dest_scan = m_Gray; |
+ } else { |
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Gray, src_alpha); |
+ } |
+ } |
+ dest_scan++; |
+ } |
+ } |
+ } |
+ void CompositeSpanARGB(uint8_t* dest_scan, |
+ int Bpp, |
+ int span_left, |
+ int span_len, |
+ uint8_t* cover_scan, |
+ int clip_left, |
+ int clip_right, |
+ uint8_t* clip_scan, |
+ uint8_t* dest_extra_alpha_scan) { |
+ int col_start = span_left < clip_left ? clip_left - span_left : 0; |
+ int col_end = (span_left + span_len) < clip_right |
+ ? span_len |
+ : (clip_right - span_left); |
+ dest_scan += col_start * Bpp; |
+ if (m_bRgbByteOrder) { |
+ for (int col = col_start; col < col_end; col++) { |
+ int src_alpha; |
+ if (m_bFullCover) { |
+ if (clip_scan) { |
+ src_alpha = m_Alpha * clip_scan[col] / 255; |
+ } else { |
+ src_alpha = m_Alpha; |
+ } |
+ } else { |
+ if (clip_scan) { |
+ src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255; |
+ } else { |
+ src_alpha = m_Alpha * cover_scan[col] / 255; |
+ } |
} |
- int y = sl.y(); |
- if (y < m_ClipBox.top || y >= m_ClipBox.bottom) { |
- return; |
+ if (src_alpha) { |
+ if (src_alpha == 255) { |
+ *(FX_DWORD*)dest_scan = m_Color; |
+ } else { |
+ uint8_t dest_alpha = |
+ dest_scan[3] + src_alpha - dest_scan[3] * src_alpha / 255; |
+ dest_scan[3] = dest_alpha; |
+ int alpha_ratio = src_alpha * 255 / dest_alpha; |
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, alpha_ratio); |
+ dest_scan++; |
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, alpha_ratio); |
+ dest_scan++; |
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, alpha_ratio); |
+ dest_scan += 2; |
+ continue; |
+ } |
} |
- uint8_t* dest_scan = m_pDevice->GetBuffer() + m_pDevice->GetPitch() * y; |
- uint8_t* dest_scan_extra_alpha = NULL; |
- CFX_DIBitmap* pAlphaMask = m_pDevice->m_pAlphaMask; |
- if (pAlphaMask) { |
- dest_scan_extra_alpha = pAlphaMask->GetBuffer() + pAlphaMask->GetPitch() * y; |
+ dest_scan += 4; |
+ } |
+ return; |
+ } |
+ for (int col = col_start; col < col_end; col++) { |
+ int src_alpha; |
+ if (m_bFullCover) { |
+ if (clip_scan) { |
+ src_alpha = m_Alpha * clip_scan[col] / 255; |
+ } else { |
+ src_alpha = m_Alpha; |
} |
- uint8_t* ori_scan = NULL; |
- if (m_pOriDevice) { |
- ori_scan = m_pOriDevice->GetBuffer() + m_pOriDevice->GetPitch() * y; |
+ } else { |
+ if (clip_scan) { |
+ src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255; |
+ } else { |
+ src_alpha = m_Alpha * cover_scan[col] / 255; |
} |
- int Bpp = m_pDevice->GetBPP() / 8; |
- FX_BOOL bDestAlpha = m_pDevice->HasAlpha() || m_pDevice->IsAlphaMask(); |
- unsigned num_spans = sl.num_spans(); |
- typename Scanline::const_iterator span = sl.begin(); |
- while (1) { |
- int x = span->x; |
- ASSERT(span->len > 0); |
- uint8_t* dest_pos = NULL; |
- uint8_t* dest_extra_alpha_pos = NULL; |
- uint8_t* ori_pos = NULL; |
- if (Bpp) { |
- ori_pos = ori_scan ? ori_scan + x * Bpp : NULL; |
- dest_pos = dest_scan + x * Bpp; |
- dest_extra_alpha_pos = dest_scan_extra_alpha ? dest_scan_extra_alpha + x : NULL; |
- } else { |
- dest_pos = dest_scan + x / 8; |
- ori_pos = ori_scan ? ori_scan + x / 8 : NULL; |
- } |
- uint8_t* clip_pos = NULL; |
- if (m_pClipMask) { |
- clip_pos = m_pClipMask->GetBuffer() + (y - m_ClipBox.top) * m_pClipMask->GetPitch() + x - m_ClipBox.left; |
- } |
- if (ori_pos) { |
- CompositeSpan(dest_pos, ori_pos, Bpp, bDestAlpha, x, span->len, span->covers, m_ClipBox.left, m_ClipBox.right, clip_pos); |
- } else { |
- (this->*composite_span)(dest_pos, Bpp, x, span->len, span->covers, m_ClipBox.left, m_ClipBox.right, clip_pos, dest_extra_alpha_pos); |
- } |
- if(--num_spans == 0) { |
- break; |
+ } |
+ if (src_alpha) { |
+ if (src_alpha == 255) { |
+ *(FX_DWORD*)dest_scan = m_Color; |
+ } else { |
+ if (dest_scan[3] == 0) { |
+ dest_scan[3] = src_alpha; |
+ *dest_scan++ = m_Blue; |
+ *dest_scan++ = m_Green; |
+ *dest_scan = m_Red; |
+ dest_scan += 2; |
+ continue; |
+ } |
+ uint8_t dest_alpha = |
+ dest_scan[3] + src_alpha - dest_scan[3] * src_alpha / 255; |
+ dest_scan[3] = dest_alpha; |
+ int alpha_ratio = src_alpha * 255 / dest_alpha; |
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, alpha_ratio); |
+ dest_scan++; |
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, alpha_ratio); |
+ dest_scan++; |
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, alpha_ratio); |
+ dest_scan += 2; |
+ continue; |
+ } |
+ } |
+ dest_scan += Bpp; |
+ } |
+ } |
+ void CompositeSpanRGB(uint8_t* dest_scan, |
+ int Bpp, |
+ int span_left, |
+ int span_len, |
+ uint8_t* cover_scan, |
+ int clip_left, |
+ int clip_right, |
+ uint8_t* clip_scan, |
+ uint8_t* dest_extra_alpha_scan) { |
+ int col_start = span_left < clip_left ? clip_left - span_left : 0; |
+ int col_end = (span_left + span_len) < clip_right |
+ ? span_len |
+ : (clip_right - span_left); |
+ dest_scan += col_start * Bpp; |
+ if (m_bRgbByteOrder) { |
+ for (int col = col_start; col < col_end; col++) { |
+ int src_alpha; |
+ if (clip_scan) { |
+ src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255; |
+ } else { |
+ src_alpha = m_Alpha * cover_scan[col] / 255; |
+ } |
+ if (src_alpha) { |
+ if (src_alpha == 255) { |
+ if (Bpp == 4) { |
+ *(FX_DWORD*)dest_scan = m_Color; |
+ } else if (Bpp == 3) { |
+ *dest_scan++ = m_Red; |
+ *dest_scan++ = m_Green; |
+ *dest_scan++ = m_Blue; |
+ continue; |
} |
- ++span; |
+ } else { |
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, src_alpha); |
+ dest_scan++; |
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, src_alpha); |
+ dest_scan++; |
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, src_alpha); |
+ dest_scan += Bpp - 2; |
+ continue; |
+ } |
} |
- } |
- |
- FX_BOOL Init(CFX_DIBitmap* pDevice, CFX_DIBitmap* pOriDevice, const CFX_ClipRgn* pClipRgn, FX_DWORD color, FX_BOOL bFullCover, FX_BOOL bRgbByteOrder, |
- int alpha_flag = 0, void* pIccTransform = NULL) |
- { |
- m_pDevice = pDevice; |
- m_pClipRgn = pClipRgn; |
- composite_span = NULL; |
- m_bRgbByteOrder = bRgbByteOrder; |
- m_pOriDevice = pOriDevice; |
- if (m_pClipRgn) { |
- m_ClipBox = m_pClipRgn->GetBox(); |
+ dest_scan += Bpp; |
+ } |
+ return; |
+ } |
+ if (Bpp == 3 && dest_extra_alpha_scan) { |
+ for (int col = col_start; col < col_end; col++) { |
+ int src_alpha; |
+ if (m_bFullCover) { |
+ if (clip_scan) { |
+ src_alpha = m_Alpha * clip_scan[col] / 255; |
+ } else { |
+ src_alpha = m_Alpha; |
+ } |
} else { |
- m_ClipBox.left = m_ClipBox.top = 0; |
- m_ClipBox.right = m_pDevice->GetWidth(); |
- m_ClipBox.bottom = m_pDevice->GetHeight(); |
+ if (clip_scan) { |
+ src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255; |
+ } else { |
+ src_alpha = m_Alpha * cover_scan[col] / 255; |
+ } |
} |
- m_pClipMask = NULL; |
- if (m_pClipRgn && m_pClipRgn->GetType() == CFX_ClipRgn::MaskF) { |
- m_pClipMask = m_pClipRgn->GetMask(); |
+ if (src_alpha) { |
+ if (src_alpha == 255) { |
+ *dest_scan++ = (uint8_t)m_Blue; |
+ *dest_scan++ = (uint8_t)m_Green; |
+ *dest_scan++ = (uint8_t)m_Red; |
+ *dest_extra_alpha_scan++ = (uint8_t)m_Alpha; |
+ continue; |
+ } else { |
+ uint8_t dest_alpha = (*dest_extra_alpha_scan) + src_alpha - |
+ (*dest_extra_alpha_scan) * src_alpha / 255; |
+ *dest_extra_alpha_scan++ = dest_alpha; |
+ int alpha_ratio = src_alpha * 255 / dest_alpha; |
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, alpha_ratio); |
+ dest_scan++; |
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, alpha_ratio); |
+ dest_scan++; |
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, alpha_ratio); |
+ dest_scan++; |
+ continue; |
+ } |
} |
- m_bFullCover = bFullCover; |
- FX_BOOL bObjectCMYK = FXGETFLAG_COLORTYPE(alpha_flag); |
- FX_BOOL bDeviceCMYK = pDevice->IsCmykImage(); |
- m_Alpha = bObjectCMYK ? FXGETFLAG_ALPHA_FILL(alpha_flag) : FXARGB_A(color); |
- ICodec_IccModule* pIccModule = NULL; |
- if (!CFX_GEModule::Get()->GetCodecModule() || !CFX_GEModule::Get()->GetCodecModule()->GetIccModule()) { |
- pIccTransform = NULL; |
+ dest_extra_alpha_scan++; |
+ dest_scan += Bpp; |
+ } |
+ } else { |
+ for (int col = col_start; col < col_end; col++) { |
+ int src_alpha; |
+ if (m_bFullCover) { |
+ if (clip_scan) { |
+ src_alpha = m_Alpha * clip_scan[col] / 255; |
+ } else { |
+ src_alpha = m_Alpha; |
+ } |
} else { |
- pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule(); |
+ if (clip_scan) { |
+ src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255; |
+ } else { |
+ src_alpha = m_Alpha * cover_scan[col] / 255; |
+ } |
} |
- if (m_pDevice->GetBPP() == 8) { |
- ASSERT(!m_bRgbByteOrder); |
- composite_span = &CFX_Renderer::CompositeSpanGray; |
- if (m_pDevice->IsAlphaMask()) { |
- m_Gray = 255; |
- } else { |
- if (pIccTransform) { |
- uint8_t gray; |
- color = bObjectCMYK ? FXCMYK_TODIB(color) : FXARGB_TODIB(color); |
- pIccModule->TranslateScanline(pIccTransform, &gray, (const uint8_t*)&color, 1); |
- m_Gray = gray; |
- } else { |
- if (bObjectCMYK) { |
- uint8_t r, g, b; |
- AdobeCMYK_to_sRGB1(FXSYS_GetCValue(color), FXSYS_GetMValue(color), FXSYS_GetYValue(color), FXSYS_GetKValue(color), |
- r, g, b); |
- m_Gray = FXRGB2GRAY(r, g, b); |
- } else { |
- m_Gray = FXRGB2GRAY(FXARGB_R(color), FXARGB_G(color), FXARGB_B(color)); |
- } |
- } |
+ if (src_alpha) { |
+ if (src_alpha == 255) { |
+ if (Bpp == 4) { |
+ *(FX_DWORD*)dest_scan = m_Color; |
+ } else if (Bpp == 3) { |
+ *dest_scan++ = m_Blue; |
+ *dest_scan++ = m_Green; |
+ *dest_scan++ = m_Red; |
+ continue; |
} |
- return TRUE; |
+ } else { |
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, src_alpha); |
+ dest_scan++; |
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, src_alpha); |
+ dest_scan++; |
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, src_alpha); |
+ dest_scan += Bpp - 2; |
+ continue; |
+ } |
} |
- if (bDeviceCMYK) { |
- ASSERT(!m_bRgbByteOrder); |
- composite_span = &CFX_Renderer::CompositeSpanCMYK; |
- if (bObjectCMYK) { |
- m_Color = FXCMYK_TODIB(color); |
- if (pIccTransform) { |
- pIccModule->TranslateScanline(pIccTransform, (uint8_t*)&m_Color, (const uint8_t*)&m_Color, 1); |
- } |
- } else { |
- if (!pIccTransform) { |
- return FALSE; |
- } |
- color = FXARGB_TODIB(color); |
- pIccModule->TranslateScanline(pIccTransform, (uint8_t*)&m_Color, (const uint8_t*)&color, 1); |
- } |
- m_Red = ((uint8_t*)&m_Color)[0]; |
- m_Green = ((uint8_t*)&m_Color)[1]; |
- m_Blue = ((uint8_t*)&m_Color)[2]; |
- m_Gray = ((uint8_t*)&m_Color)[3]; |
+ dest_scan += Bpp; |
+ } |
+ } |
+ } |
+ void CompositeSpanCMYK(uint8_t* dest_scan, |
+ int Bpp, |
+ int span_left, |
+ int span_len, |
+ uint8_t* cover_scan, |
+ int clip_left, |
+ int clip_right, |
+ uint8_t* clip_scan, |
+ uint8_t* dest_extra_alpha_scan) { |
+ ASSERT(!m_bRgbByteOrder); |
+ int col_start = span_left < clip_left ? clip_left - span_left : 0; |
+ int col_end = (span_left + span_len) < clip_right |
+ ? span_len |
+ : (clip_right - span_left); |
+ dest_scan += col_start * 4; |
+ if (dest_extra_alpha_scan) { |
+ for (int col = col_start; col < col_end; col++) { |
+ int src_alpha; |
+ if (m_bFullCover) { |
+ if (clip_scan) { |
+ src_alpha = m_Alpha * clip_scan[col] / 255; |
+ } else { |
+ src_alpha = m_Alpha; |
+ } |
} else { |
- composite_span = (pDevice->GetFormat() == FXDIB_Argb) ? &CFX_Renderer::CompositeSpanARGB : &CFX_Renderer::CompositeSpanRGB; |
- if (pIccTransform) { |
- color = bObjectCMYK ? FXCMYK_TODIB(color) : FXARGB_TODIB(color); |
- pIccModule->TranslateScanline(pIccTransform, (uint8_t*)&m_Color, (const uint8_t*)&color, 1); |
- ((uint8_t*)&m_Color)[3] = m_Alpha; |
- m_Red = ((uint8_t*)&m_Color)[2]; |
- m_Green = ((uint8_t*)&m_Color)[1]; |
- m_Blue = ((uint8_t*)&m_Color)[0]; |
- if (m_bRgbByteOrder) { |
- m_Color = FXARGB_TODIB(m_Color); |
- m_Color = FXARGB_TOBGRORDERDIB(m_Color); |
- } |
- } else { |
- if (bObjectCMYK) { |
- uint8_t r, g, b; |
- AdobeCMYK_to_sRGB1(FXSYS_GetCValue(color), FXSYS_GetMValue(color), FXSYS_GetYValue(color), FXSYS_GetKValue(color), |
- r, g, b); |
- m_Color = FXARGB_MAKE(m_Alpha, r, g, b); |
- if (m_bRgbByteOrder) { |
- m_Color = FXARGB_TOBGRORDERDIB(m_Color); |
- } else { |
- m_Color = FXARGB_TODIB(m_Color); |
- } |
- m_Red = r; |
- m_Green = g; |
- m_Blue = b; |
- } else { |
- if (m_bRgbByteOrder) { |
- m_Color = FXARGB_TOBGRORDERDIB(color); |
- } else { |
- m_Color = FXARGB_TODIB(color); |
- } |
- ArgbDecode(color, m_Alpha, m_Red, m_Green, m_Blue); |
- } |
- } |
+ if (clip_scan) { |
+ src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255; |
+ } else { |
+ src_alpha = m_Alpha * cover_scan[col] / 255; |
+ } |
} |
- if (m_pDevice->GetBPP() == 1) { |
- composite_span = &CFX_Renderer::CompositeSpan1bpp; |
+ if (src_alpha) { |
+ if (src_alpha == 255) { |
+ *(FX_CMYK*)dest_scan = m_Color; |
+ *dest_extra_alpha_scan = (uint8_t)m_Alpha; |
+ } else { |
+ uint8_t dest_alpha = (*dest_extra_alpha_scan) + src_alpha - |
+ (*dest_extra_alpha_scan) * src_alpha / 255; |
+ *dest_extra_alpha_scan++ = dest_alpha; |
+ int alpha_ratio = src_alpha * 255 / dest_alpha; |
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, alpha_ratio); |
+ dest_scan++; |
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, alpha_ratio); |
+ dest_scan++; |
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, alpha_ratio); |
+ dest_scan++; |
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Gray, alpha_ratio); |
+ dest_scan++; |
+ continue; |
+ } |
} |
- return TRUE; |
+ dest_extra_alpha_scan++; |
+ dest_scan += 4; |
+ } |
+ } else { |
+ for (int col = col_start; col < col_end; col++) { |
+ int src_alpha; |
+ if (clip_scan) { |
+ src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255; |
+ } else { |
+ src_alpha = m_Alpha * cover_scan[col] / 255; |
+ } |
+ if (src_alpha) { |
+ if (src_alpha == 255) { |
+ *(FX_CMYK*)dest_scan = m_Color; |
+ } else { |
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, src_alpha); |
+ dest_scan++; |
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, src_alpha); |
+ dest_scan++; |
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, src_alpha); |
+ dest_scan++; |
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Gray, src_alpha); |
+ dest_scan++; |
+ continue; |
+ } |
+ } |
+ dest_scan += 4; |
+ } |
+ } |
+ } |
+ template <class Scanline> |
+ void render(const Scanline& sl) { |
+ if (m_pOriDevice == NULL && composite_span == NULL) { |
+ return; |
+ } |
+ int y = sl.y(); |
+ if (y < m_ClipBox.top || y >= m_ClipBox.bottom) { |
+ return; |
+ } |
+ uint8_t* dest_scan = m_pDevice->GetBuffer() + m_pDevice->GetPitch() * y; |
+ uint8_t* dest_scan_extra_alpha = NULL; |
+ CFX_DIBitmap* pAlphaMask = m_pDevice->m_pAlphaMask; |
+ if (pAlphaMask) { |
+ dest_scan_extra_alpha = |
+ pAlphaMask->GetBuffer() + pAlphaMask->GetPitch() * y; |
+ } |
+ uint8_t* ori_scan = NULL; |
+ if (m_pOriDevice) { |
+ ori_scan = m_pOriDevice->GetBuffer() + m_pOriDevice->GetPitch() * y; |
+ } |
+ int Bpp = m_pDevice->GetBPP() / 8; |
+ FX_BOOL bDestAlpha = m_pDevice->HasAlpha() || m_pDevice->IsAlphaMask(); |
+ unsigned num_spans = sl.num_spans(); |
+ typename Scanline::const_iterator span = sl.begin(); |
+ while (1) { |
+ int x = span->x; |
+ ASSERT(span->len > 0); |
+ uint8_t* dest_pos = NULL; |
+ uint8_t* dest_extra_alpha_pos = NULL; |
+ uint8_t* ori_pos = NULL; |
+ if (Bpp) { |
+ ori_pos = ori_scan ? ori_scan + x * Bpp : NULL; |
+ dest_pos = dest_scan + x * Bpp; |
+ dest_extra_alpha_pos = |
+ dest_scan_extra_alpha ? dest_scan_extra_alpha + x : NULL; |
+ } else { |
+ dest_pos = dest_scan + x / 8; |
+ ori_pos = ori_scan ? ori_scan + x / 8 : NULL; |
+ } |
+ uint8_t* clip_pos = NULL; |
+ if (m_pClipMask) { |
+ clip_pos = m_pClipMask->GetBuffer() + |
+ (y - m_ClipBox.top) * m_pClipMask->GetPitch() + x - |
+ m_ClipBox.left; |
+ } |
+ if (ori_pos) { |
+ CompositeSpan(dest_pos, ori_pos, Bpp, bDestAlpha, x, span->len, |
+ span->covers, m_ClipBox.left, m_ClipBox.right, clip_pos); |
+ } else { |
+ (this->*composite_span)(dest_pos, Bpp, x, span->len, span->covers, |
+ m_ClipBox.left, m_ClipBox.right, clip_pos, |
+ dest_extra_alpha_pos); |
+ } |
+ if (--num_spans == 0) { |
+ break; |
+ } |
+ ++span; |
+ } |
+ } |
+ |
+ FX_BOOL Init(CFX_DIBitmap* pDevice, |
+ CFX_DIBitmap* pOriDevice, |
+ const CFX_ClipRgn* pClipRgn, |
+ FX_DWORD color, |
+ FX_BOOL bFullCover, |
+ FX_BOOL bRgbByteOrder, |
+ int alpha_flag = 0, |
+ void* pIccTransform = NULL) { |
+ m_pDevice = pDevice; |
+ m_pClipRgn = pClipRgn; |
+ composite_span = NULL; |
+ m_bRgbByteOrder = bRgbByteOrder; |
+ m_pOriDevice = pOriDevice; |
+ if (m_pClipRgn) { |
+ m_ClipBox = m_pClipRgn->GetBox(); |
+ } else { |
+ m_ClipBox.left = m_ClipBox.top = 0; |
+ m_ClipBox.right = m_pDevice->GetWidth(); |
+ m_ClipBox.bottom = m_pDevice->GetHeight(); |
+ } |
+ m_pClipMask = NULL; |
+ if (m_pClipRgn && m_pClipRgn->GetType() == CFX_ClipRgn::MaskF) { |
+ m_pClipMask = m_pClipRgn->GetMask(); |
+ } |
+ m_bFullCover = bFullCover; |
+ FX_BOOL bObjectCMYK = FXGETFLAG_COLORTYPE(alpha_flag); |
+ FX_BOOL bDeviceCMYK = pDevice->IsCmykImage(); |
+ m_Alpha = bObjectCMYK ? FXGETFLAG_ALPHA_FILL(alpha_flag) : FXARGB_A(color); |
+ ICodec_IccModule* pIccModule = NULL; |
+ if (!CFX_GEModule::Get()->GetCodecModule() || |
+ !CFX_GEModule::Get()->GetCodecModule()->GetIccModule()) { |
+ pIccTransform = NULL; |
+ } else { |
+ pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule(); |
+ } |
+ if (m_pDevice->GetBPP() == 8) { |
+ ASSERT(!m_bRgbByteOrder); |
+ composite_span = &CFX_Renderer::CompositeSpanGray; |
+ if (m_pDevice->IsAlphaMask()) { |
+ m_Gray = 255; |
+ } else { |
+ if (pIccTransform) { |
+ uint8_t gray; |
+ color = bObjectCMYK ? FXCMYK_TODIB(color) : FXARGB_TODIB(color); |
+ pIccModule->TranslateScanline(pIccTransform, &gray, |
+ (const uint8_t*)&color, 1); |
+ m_Gray = gray; |
+ } else { |
+ if (bObjectCMYK) { |
+ uint8_t r, g, b; |
+ AdobeCMYK_to_sRGB1(FXSYS_GetCValue(color), FXSYS_GetMValue(color), |
+ FXSYS_GetYValue(color), FXSYS_GetKValue(color), |
+ r, g, b); |
+ m_Gray = FXRGB2GRAY(r, g, b); |
+ } else { |
+ m_Gray = |
+ FXRGB2GRAY(FXARGB_R(color), FXARGB_G(color), FXARGB_B(color)); |
+ } |
+ } |
+ } |
+ return TRUE; |
+ } |
+ if (bDeviceCMYK) { |
+ ASSERT(!m_bRgbByteOrder); |
+ composite_span = &CFX_Renderer::CompositeSpanCMYK; |
+ if (bObjectCMYK) { |
+ m_Color = FXCMYK_TODIB(color); |
+ if (pIccTransform) { |
+ pIccModule->TranslateScanline(pIccTransform, (uint8_t*)&m_Color, |
+ (const uint8_t*)&m_Color, 1); |
+ } |
+ } else { |
+ if (!pIccTransform) { |
+ return FALSE; |
+ } |
+ color = FXARGB_TODIB(color); |
+ pIccModule->TranslateScanline(pIccTransform, (uint8_t*)&m_Color, |
+ (const uint8_t*)&color, 1); |
+ } |
+ m_Red = ((uint8_t*)&m_Color)[0]; |
+ m_Green = ((uint8_t*)&m_Color)[1]; |
+ m_Blue = ((uint8_t*)&m_Color)[2]; |
+ m_Gray = ((uint8_t*)&m_Color)[3]; |
+ } else { |
+ composite_span = (pDevice->GetFormat() == FXDIB_Argb) |
+ ? &CFX_Renderer::CompositeSpanARGB |
+ : &CFX_Renderer::CompositeSpanRGB; |
+ if (pIccTransform) { |
+ color = bObjectCMYK ? FXCMYK_TODIB(color) : FXARGB_TODIB(color); |
+ pIccModule->TranslateScanline(pIccTransform, (uint8_t*)&m_Color, |
+ (const uint8_t*)&color, 1); |
+ ((uint8_t*)&m_Color)[3] = m_Alpha; |
+ m_Red = ((uint8_t*)&m_Color)[2]; |
+ m_Green = ((uint8_t*)&m_Color)[1]; |
+ m_Blue = ((uint8_t*)&m_Color)[0]; |
+ if (m_bRgbByteOrder) { |
+ m_Color = FXARGB_TODIB(m_Color); |
+ m_Color = FXARGB_TOBGRORDERDIB(m_Color); |
+ } |
+ } else { |
+ if (bObjectCMYK) { |
+ uint8_t r, g, b; |
+ AdobeCMYK_to_sRGB1(FXSYS_GetCValue(color), FXSYS_GetMValue(color), |
+ FXSYS_GetYValue(color), FXSYS_GetKValue(color), r, |
+ g, b); |
+ m_Color = FXARGB_MAKE(m_Alpha, r, g, b); |
+ if (m_bRgbByteOrder) { |
+ m_Color = FXARGB_TOBGRORDERDIB(m_Color); |
+ } else { |
+ m_Color = FXARGB_TODIB(m_Color); |
+ } |
+ m_Red = r; |
+ m_Green = g; |
+ m_Blue = b; |
+ } else { |
+ if (m_bRgbByteOrder) { |
+ m_Color = FXARGB_TOBGRORDERDIB(color); |
+ } else { |
+ m_Color = FXARGB_TODIB(color); |
+ } |
+ ArgbDecode(color, m_Alpha, m_Red, m_Green, m_Blue); |
+ } |
+ } |
} |
-}; |
-FX_BOOL CFX_AggDeviceDriver::RenderRasterizer(agg::rasterizer_scanline_aa& rasterizer, FX_DWORD color, FX_BOOL bFullCover, FX_BOOL bGroupKnockout, |
- int alpha_flag, void* pIccTransform) |
-{ |
- CFX_DIBitmap* pt = bGroupKnockout ? m_pOriDevice : NULL; |
- CFX_Renderer render; |
- if (!render.Init(m_pBitmap, pt, m_pClipRgn, color, bFullCover, m_bRgbByteOrder, alpha_flag, pIccTransform)) { |
- return FALSE; |
+ if (m_pDevice->GetBPP() == 1) { |
+ composite_span = &CFX_Renderer::CompositeSpan1bpp; |
} |
- agg::scanline_u8 scanline; |
- agg::render_scanlines(rasterizer, scanline, render, (m_FillFlags & FXFILL_NOPATHSMOOTH) != 0); |
return TRUE; |
+ } |
+}; |
+FX_BOOL CFX_AggDeviceDriver::RenderRasterizer( |
+ agg::rasterizer_scanline_aa& rasterizer, |
+ FX_DWORD color, |
+ FX_BOOL bFullCover, |
+ FX_BOOL bGroupKnockout, |
+ int alpha_flag, |
+ void* pIccTransform) { |
+ CFX_DIBitmap* pt = bGroupKnockout ? m_pOriDevice : NULL; |
+ CFX_Renderer render; |
+ if (!render.Init(m_pBitmap, pt, m_pClipRgn, color, bFullCover, |
+ m_bRgbByteOrder, alpha_flag, pIccTransform)) { |
+ return FALSE; |
+ } |
+ agg::scanline_u8 scanline; |
+ agg::render_scanlines(rasterizer, scanline, render, |
+ (m_FillFlags & FXFILL_NOPATHSMOOTH) != 0); |
+ return TRUE; |
} |
-FX_BOOL CFX_AggDeviceDriver::DrawPath(const CFX_PathData* pPathData, |
+FX_BOOL CFX_AggDeviceDriver::DrawPath(const CFX_PathData* pPathData, |
const CFX_AffineMatrix* pObject2Device, |
const CFX_GraphStateData* pGraphState, |
FX_DWORD fill_color, |
@@ -1123,483 +1209,586 @@ FX_BOOL CFX_AggDeviceDriver::DrawPath(const CFX_PathData* pPathData, |
int fill_mode, |
int alpha_flag, |
void* pIccTransform, |
- int blend_type |
- ) |
-{ |
- if (blend_type != FXDIB_BLEND_NORMAL) { |
+ int blend_type) { |
+ if (blend_type != FXDIB_BLEND_NORMAL) { |
+ return FALSE; |
+ } |
+ if (GetBuffer() == NULL) { |
+ return TRUE; |
+ } |
+ m_FillFlags = fill_mode; |
+ if ((fill_mode & 3) && fill_color) { |
+ CAgg_PathData path_data; |
+ path_data.BuildPath(pPathData, pObject2Device); |
+ agg::rasterizer_scanline_aa rasterizer; |
+ rasterizer.clip_box(0.0f, 0.0f, (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_WIDTH)), |
+ (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_HEIGHT))); |
+ rasterizer.add_path(path_data.m_PathData); |
+ rasterizer.filling_rule((fill_mode & 3) == FXFILL_WINDING |
+ ? agg::fill_non_zero |
+ : agg::fill_even_odd); |
+ if (!RenderRasterizer(rasterizer, fill_color, fill_mode & FXFILL_FULLCOVER, |
+ FALSE, alpha_flag, pIccTransform)) { |
+ return FALSE; |
+ } |
+ } |
+ int stroke_alpha = FXGETFLAG_COLORTYPE(alpha_flag) |
+ ? FXGETFLAG_ALPHA_STROKE(alpha_flag) |
+ : FXARGB_A(stroke_color); |
+ if (pGraphState && stroke_alpha) { |
+ if (fill_mode & FX_ZEROAREA_FILL) { |
+ CAgg_PathData path_data; |
+ path_data.BuildPath(pPathData, pObject2Device); |
+ agg::rasterizer_scanline_aa rasterizer; |
+ rasterizer.clip_box(0.0f, 0.0f, |
+ (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_WIDTH)), |
+ (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_HEIGHT))); |
+ RasterizeStroke(rasterizer, path_data.m_PathData, NULL, pGraphState, 1, |
+ FALSE, fill_mode & FX_STROKE_TEXT_MODE); |
+ int fill_flag = FXGETFLAG_COLORTYPE(alpha_flag) << 8 | |
+ FXGETFLAG_ALPHA_STROKE(alpha_flag); |
+ if (!RenderRasterizer(rasterizer, stroke_color, |
+ fill_mode & FXFILL_FULLCOVER, m_bGroupKnockout, |
+ fill_flag, pIccTransform)) { |
return FALSE; |
+ } |
+ return TRUE; |
} |
- if (GetBuffer() == NULL) { |
- return TRUE; |
- } |
- m_FillFlags = fill_mode; |
- if ((fill_mode & 3) && fill_color) { |
- CAgg_PathData path_data; |
- path_data.BuildPath(pPathData, pObject2Device); |
- agg::rasterizer_scanline_aa rasterizer; |
- rasterizer.clip_box(0.0f, 0.0f, (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_WIDTH)), (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_HEIGHT))); |
- rasterizer.add_path(path_data.m_PathData); |
- rasterizer.filling_rule((fill_mode & 3) == FXFILL_WINDING ? agg::fill_non_zero : agg::fill_even_odd); |
- if (!RenderRasterizer(rasterizer, fill_color, fill_mode & FXFILL_FULLCOVER, FALSE, alpha_flag, pIccTransform)) { |
- return FALSE; |
- } |
+ CFX_AffineMatrix matrix1, matrix2; |
+ if (pObject2Device) { |
+ matrix1.a = |
+ FX_MAX(FXSYS_fabs(pObject2Device->a), FXSYS_fabs(pObject2Device->b)); |
+ matrix1.d = matrix1.a; |
+ matrix2.Set(pObject2Device->a / matrix1.a, pObject2Device->b / matrix1.a, |
+ pObject2Device->c / matrix1.d, pObject2Device->d / matrix1.d, |
+ 0, 0); |
+ CFX_AffineMatrix mtRervese; |
+ mtRervese.SetReverse(matrix2); |
+ matrix1 = *pObject2Device; |
+ matrix1.Concat(mtRervese); |
} |
- int stroke_alpha = FXGETFLAG_COLORTYPE(alpha_flag) ? FXGETFLAG_ALPHA_STROKE(alpha_flag) : FXARGB_A(stroke_color); |
- if (pGraphState && stroke_alpha) { |
- if (fill_mode & FX_ZEROAREA_FILL) { |
- CAgg_PathData path_data; |
- path_data.BuildPath(pPathData, pObject2Device); |
- agg::rasterizer_scanline_aa rasterizer; |
- rasterizer.clip_box(0.0f, 0.0f, (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_WIDTH)), (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_HEIGHT))); |
- RasterizeStroke(rasterizer, path_data.m_PathData, NULL, pGraphState, 1, FALSE, fill_mode & FX_STROKE_TEXT_MODE); |
- int fill_flag = FXGETFLAG_COLORTYPE(alpha_flag) << 8 | FXGETFLAG_ALPHA_STROKE(alpha_flag); |
- if (!RenderRasterizer(rasterizer, stroke_color, fill_mode & FXFILL_FULLCOVER, m_bGroupKnockout, fill_flag, pIccTransform)) { |
- return FALSE; |
- } |
- return TRUE; |
+ CAgg_PathData path_data; |
+ path_data.BuildPath(pPathData, &matrix1); |
+ agg::rasterizer_scanline_aa rasterizer; |
+ rasterizer.clip_box(0.0f, 0.0f, (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_WIDTH)), |
+ (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_HEIGHT))); |
+ RasterizeStroke(rasterizer, path_data.m_PathData, &matrix2, pGraphState, |
+ matrix1.a, FALSE, fill_mode & FX_STROKE_TEXT_MODE); |
+ int fill_flag = FXGETFLAG_COLORTYPE(alpha_flag) << 8 | |
+ FXGETFLAG_ALPHA_STROKE(alpha_flag); |
+ if (!RenderRasterizer(rasterizer, stroke_color, |
+ fill_mode & FXFILL_FULLCOVER, m_bGroupKnockout, |
+ fill_flag, pIccTransform)) { |
+ return FALSE; |
+ } |
+ } |
+ return TRUE; |
+} |
+void RgbByteOrderSetPixel(CFX_DIBitmap* pBitmap, int x, int y, FX_DWORD argb) { |
+ if (x < 0 || x >= pBitmap->GetWidth() || y < 0 || y >= pBitmap->GetHeight()) { |
+ return; |
+ } |
+ uint8_t* pos = (uint8_t*)pBitmap->GetBuffer() + y * pBitmap->GetPitch() + |
+ x * pBitmap->GetBPP() / 8; |
+ if (pBitmap->GetFormat() == FXDIB_Argb) { |
+ FXARGB_SETRGBORDERDIB(pos, ArgbGamma(argb)); |
+ } else { |
+ int alpha = FXARGB_A(argb); |
+ pos[0] = (FXARGB_R(argb) * alpha + pos[0] * (255 - alpha)) / 255; |
+ pos[1] = (FXARGB_G(argb) * alpha + pos[1] * (255 - alpha)) / 255; |
+ pos[2] = (FXARGB_B(argb) * alpha + pos[2] * (255 - alpha)) / 255; |
+ } |
+} |
+void RgbByteOrderCompositeRect(CFX_DIBitmap* pBitmap, |
+ int left, |
+ int top, |
+ int width, |
+ int height, |
+ FX_ARGB argb) { |
+ int src_alpha = FXARGB_A(argb); |
+ if (src_alpha == 0) { |
+ return; |
+ } |
+ FX_RECT rect(left, top, left + width, top + height); |
+ rect.Intersect(0, 0, pBitmap->GetWidth(), pBitmap->GetHeight()); |
+ width = rect.Width(); |
+ int src_r = FXARGB_R(argb), src_g = FXARGB_G(argb), src_b = FXARGB_B(argb); |
+ int Bpp = pBitmap->GetBPP() / 8; |
+ FX_BOOL bAlpha = pBitmap->HasAlpha(); |
+ int dib_argb = FXARGB_TOBGRORDERDIB(argb); |
+ uint8_t* pBuffer = pBitmap->GetBuffer(); |
+ if (src_alpha == 255) { |
+ for (int row = rect.top; row < rect.bottom; row++) { |
+ uint8_t* dest_scan = |
+ pBuffer + row * pBitmap->GetPitch() + rect.left * Bpp; |
+ if (Bpp == 4) { |
+ FX_DWORD* scan = (FX_DWORD*)dest_scan; |
+ for (int col = 0; col < width; col++) { |
+ *scan++ = dib_argb; |
} |
- CFX_AffineMatrix matrix1, matrix2; |
- if (pObject2Device) { |
- matrix1.a = FX_MAX(FXSYS_fabs(pObject2Device->a), FXSYS_fabs(pObject2Device->b)); |
- matrix1.d = matrix1.a; |
- matrix2.Set(pObject2Device->a / matrix1.a, pObject2Device->b / matrix1.a, |
- pObject2Device->c / matrix1.d, pObject2Device->d / matrix1.d, |
- 0, 0); |
- CFX_AffineMatrix mtRervese; |
- mtRervese.SetReverse(matrix2); |
- matrix1 = *pObject2Device; |
- matrix1.Concat(mtRervese); |
+ } else { |
+ for (int col = 0; col < width; col++) { |
+ *dest_scan++ = src_r; |
+ *dest_scan++ = src_g; |
+ *dest_scan++ = src_b; |
} |
- CAgg_PathData path_data; |
- path_data.BuildPath(pPathData, &matrix1); |
- agg::rasterizer_scanline_aa rasterizer; |
- rasterizer.clip_box(0.0f, 0.0f, (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_WIDTH)), (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_HEIGHT))); |
- RasterizeStroke(rasterizer, path_data.m_PathData, &matrix2, pGraphState, matrix1.a, FALSE, fill_mode & FX_STROKE_TEXT_MODE); |
- int fill_flag = FXGETFLAG_COLORTYPE(alpha_flag) << 8 | FXGETFLAG_ALPHA_STROKE(alpha_flag); |
- if (!RenderRasterizer(rasterizer, stroke_color, fill_mode & FXFILL_FULLCOVER, m_bGroupKnockout, fill_flag, pIccTransform)) { |
- return FALSE; |
+ } |
+ } |
+ return; |
+ } |
+ src_r = FX_GAMMA(src_r); |
+ src_g = FX_GAMMA(src_g); |
+ src_b = FX_GAMMA(src_b); |
+ for (int row = rect.top; row < rect.bottom; row++) { |
+ uint8_t* dest_scan = pBuffer + row * pBitmap->GetPitch() + rect.left * Bpp; |
+ if (bAlpha) { |
+ for (int col = 0; col < width; col++) { |
+ uint8_t back_alpha = dest_scan[3]; |
+ if (back_alpha == 0) { |
+ FXARGB_SETRGBORDERDIB(dest_scan, |
+ FXARGB_MAKE(src_alpha, src_r, src_g, src_b)); |
+ dest_scan += 4; |
+ continue; |
} |
- } |
- return TRUE; |
-} |
-void RgbByteOrderSetPixel(CFX_DIBitmap* pBitmap, int x, int y, FX_DWORD argb) |
-{ |
- if (x < 0 || x >= pBitmap->GetWidth() || y < 0 || y >= pBitmap->GetHeight()) { |
- return; |
- } |
- uint8_t* pos = (uint8_t*)pBitmap->GetBuffer() + y * pBitmap->GetPitch() + x * pBitmap->GetBPP() / 8; |
- if (pBitmap->GetFormat() == FXDIB_Argb) { |
- FXARGB_SETRGBORDERDIB(pos, ArgbGamma(argb)); |
+ uint8_t dest_alpha = |
+ back_alpha + src_alpha - back_alpha * src_alpha / 255; |
+ dest_scan[3] = dest_alpha; |
+ int alpha_ratio = src_alpha * 255 / dest_alpha; |
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, alpha_ratio); |
+ dest_scan++; |
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, alpha_ratio); |
+ dest_scan++; |
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, alpha_ratio); |
+ dest_scan += 2; |
+ } |
} else { |
- int alpha = FXARGB_A(argb); |
- pos[0] = (FXARGB_R(argb) * alpha + pos[0] * (255 - alpha)) / 255; |
- pos[1] = (FXARGB_G(argb) * alpha + pos[1] * (255 - alpha)) / 255; |
- pos[2] = (FXARGB_B(argb) * alpha + pos[2] * (255 - alpha)) / 255; |
+ for (int col = 0; col < width; col++) { |
+ *dest_scan = FX_GAMMA_INVERSE( |
+ FXDIB_ALPHA_MERGE(FX_GAMMA(*dest_scan), src_r, src_alpha)); |
+ dest_scan++; |
+ *dest_scan = FX_GAMMA_INVERSE( |
+ FXDIB_ALPHA_MERGE(FX_GAMMA(*dest_scan), src_g, src_alpha)); |
+ dest_scan++; |
+ *dest_scan = FX_GAMMA_INVERSE( |
+ FXDIB_ALPHA_MERGE(FX_GAMMA(*dest_scan), src_b, src_alpha)); |
+ dest_scan++; |
+ if (Bpp == 4) { |
+ dest_scan++; |
+ } |
+ } |
} |
+ } |
} |
-void RgbByteOrderCompositeRect(CFX_DIBitmap* pBitmap, int left, int top, int width, int height, FX_ARGB argb) |
-{ |
- int src_alpha = FXARGB_A(argb); |
- if (src_alpha == 0) { |
- return; |
- } |
- FX_RECT rect(left, top, left + width, top + height); |
- rect.Intersect(0, 0, pBitmap->GetWidth(), pBitmap->GetHeight()); |
- width = rect.Width(); |
- int src_r = FXARGB_R(argb), src_g = FXARGB_G(argb), src_b = FXARGB_B(argb); |
- int Bpp = pBitmap->GetBPP() / 8; |
- FX_BOOL bAlpha = pBitmap->HasAlpha(); |
- int dib_argb = FXARGB_TOBGRORDERDIB(argb); |
- uint8_t* pBuffer = pBitmap->GetBuffer(); |
- if (src_alpha == 255) { |
- for (int row = rect.top; row < rect.bottom; row ++) { |
- uint8_t* dest_scan = pBuffer + row * pBitmap->GetPitch() + rect.left * Bpp; |
- if (Bpp == 4) { |
- FX_DWORD* scan = (FX_DWORD*)dest_scan; |
- for (int col = 0; col < width; col ++) { |
- *scan ++ = dib_argb; |
- } |
- } else { |
- for (int col = 0; col < width; col ++) { |
- *dest_scan ++ = src_r; |
- *dest_scan ++ = src_g; |
- *dest_scan ++ = src_b; |
- } |
- } |
+void RgbByteOrderTransferBitmap(CFX_DIBitmap* pBitmap, |
+ int dest_left, |
+ int dest_top, |
+ int width, |
+ int height, |
+ const CFX_DIBSource* pSrcBitmap, |
+ int src_left, |
+ int src_top) { |
+ if (pBitmap == NULL) { |
+ return; |
+ } |
+ pBitmap->GetOverlapRect(dest_left, dest_top, width, height, |
+ pSrcBitmap->GetWidth(), pSrcBitmap->GetHeight(), |
+ src_left, src_top, NULL); |
+ if (width == 0 || height == 0) { |
+ return; |
+ } |
+ int Bpp = pBitmap->GetBPP() / 8; |
+ FXDIB_Format dest_format = pBitmap->GetFormat(); |
+ FXDIB_Format src_format = pSrcBitmap->GetFormat(); |
+ int pitch = pBitmap->GetPitch(); |
+ uint8_t* buffer = pBitmap->GetBuffer(); |
+ if (dest_format == src_format) { |
+ for (int row = 0; row < height; row++) { |
+ uint8_t* dest_scan = buffer + (dest_top + row) * pitch + dest_left * Bpp; |
+ uint8_t* src_scan = |
+ (uint8_t*)pSrcBitmap->GetScanline(src_top + row) + src_left * Bpp; |
+ if (Bpp == 4) { |
+ for (int col = 0; col < width; col++) { |
+ FXARGB_SETDIB(dest_scan, FXARGB_MAKE(src_scan[3], src_scan[0], |
+ src_scan[1], src_scan[2])); |
+ dest_scan += 4; |
+ src_scan += 4; |
} |
- return; |
- } |
- src_r = FX_GAMMA(src_r); |
- src_g = FX_GAMMA(src_g); |
- src_b = FX_GAMMA(src_b); |
- for (int row = rect.top; row < rect.bottom; row ++) { |
- uint8_t* dest_scan = pBuffer + row * pBitmap->GetPitch() + rect.left * Bpp; |
- if (bAlpha) { |
- for (int col = 0; col < width; col ++) { |
- uint8_t back_alpha = dest_scan[3]; |
- if (back_alpha == 0) { |
- FXARGB_SETRGBORDERDIB(dest_scan, FXARGB_MAKE(src_alpha, src_r, src_g, src_b)); |
- dest_scan += 4; |
- continue; |
- } |
- uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255; |
- dest_scan[3] = dest_alpha; |
- int alpha_ratio = src_alpha * 255 / dest_alpha; |
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, alpha_ratio); |
- dest_scan++; |
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, alpha_ratio); |
- dest_scan++; |
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, alpha_ratio); |
- dest_scan += 2; |
- } |
- } else { |
- for (int col = 0; col < width; col ++) { |
- *dest_scan = FX_GAMMA_INVERSE(FXDIB_ALPHA_MERGE(FX_GAMMA(*dest_scan), src_r, src_alpha)); |
- dest_scan++; |
- *dest_scan = FX_GAMMA_INVERSE(FXDIB_ALPHA_MERGE(FX_GAMMA(*dest_scan), src_g, src_alpha)); |
- dest_scan++; |
- *dest_scan = FX_GAMMA_INVERSE(FXDIB_ALPHA_MERGE(FX_GAMMA(*dest_scan), src_b, src_alpha)); |
- dest_scan++; |
- if (Bpp == 4) { |
- dest_scan++; |
- } |
- } |
+ } else { |
+ for (int col = 0; col < width; col++) { |
+ *dest_scan++ = src_scan[2]; |
+ *dest_scan++ = src_scan[1]; |
+ *dest_scan++ = src_scan[0]; |
+ src_scan += 3; |
} |
- } |
-} |
-void RgbByteOrderTransferBitmap(CFX_DIBitmap* pBitmap, int dest_left, int dest_top, int width, int height, |
- const CFX_DIBSource* pSrcBitmap, int src_left, int src_top) |
-{ |
- if (pBitmap == NULL) { |
- return; |
- } |
- pBitmap->GetOverlapRect(dest_left, dest_top, width, height, pSrcBitmap->GetWidth(), pSrcBitmap->GetHeight(), src_left, src_top, NULL); |
- if (width == 0 || height == 0) { |
- return; |
- } |
- int Bpp = pBitmap->GetBPP() / 8; |
- FXDIB_Format dest_format = pBitmap->GetFormat(); |
- FXDIB_Format src_format = pSrcBitmap->GetFormat(); |
- int pitch = pBitmap->GetPitch(); |
- uint8_t* buffer = pBitmap->GetBuffer(); |
- if (dest_format == src_format) { |
- for (int row = 0; row < height; row ++) { |
- uint8_t* dest_scan = buffer + (dest_top + row) * pitch + dest_left * Bpp; |
- uint8_t* src_scan = (uint8_t*)pSrcBitmap->GetScanline(src_top + row) + src_left * Bpp; |
- if (Bpp == 4) { |
- for (int col = 0; col < width; col ++) { |
- FXARGB_SETDIB(dest_scan, FXARGB_MAKE(src_scan[3], src_scan[0], src_scan[1], src_scan[2])); |
- dest_scan += 4; |
- src_scan += 4; |
- } |
- } else { |
- for (int col = 0; col < width; col ++) { |
- *dest_scan++ = src_scan[2]; |
- *dest_scan++ = src_scan[1]; |
- *dest_scan++ = src_scan[0]; |
- src_scan += 3; |
- } |
- } |
+ } |
+ } |
+ return; |
+ } |
+ uint8_t* dest_buf = buffer + dest_top * pitch + dest_left * Bpp; |
+ if (dest_format == FXDIB_Rgb) { |
+ if (src_format == FXDIB_Rgb32) { |
+ for (int row = 0; row < height; row++) { |
+ uint8_t* dest_scan = dest_buf + row * pitch; |
+ uint8_t* src_scan = |
+ (uint8_t*)pSrcBitmap->GetScanline(src_top + row) + src_left * 4; |
+ for (int col = 0; col < width; col++) { |
+ *dest_scan++ = src_scan[2]; |
+ *dest_scan++ = src_scan[1]; |
+ *dest_scan++ = src_scan[0]; |
+ src_scan += 4; |
} |
- return; |
- } |
- uint8_t* dest_buf = buffer + dest_top * pitch + dest_left * Bpp; |
- if (dest_format == FXDIB_Rgb) { |
- if (src_format == FXDIB_Rgb32) { |
- for (int row = 0; row < height; row ++) { |
- uint8_t* dest_scan = dest_buf + row * pitch; |
- uint8_t* src_scan = (uint8_t*)pSrcBitmap->GetScanline(src_top + row) + src_left * 4; |
- for (int col = 0; col < width; col ++) { |
- *dest_scan++ = src_scan[2]; |
- *dest_scan++ = src_scan[1]; |
- *dest_scan++ = src_scan[0]; |
- src_scan += 4; |
- } |
- } |
+ } |
+ } else { |
+ ASSERT(FALSE); |
+ } |
+ } else if (dest_format == FXDIB_Argb || dest_format == FXDIB_Rgb32) { |
+ if (src_format == FXDIB_Rgb) { |
+ for (int row = 0; row < height; row++) { |
+ uint8_t* dest_scan = (uint8_t*)(dest_buf + row * pitch); |
+ uint8_t* src_scan = |
+ (uint8_t*)pSrcBitmap->GetScanline(src_top + row) + src_left * 3; |
+ if (src_format == FXDIB_Argb) { |
+ for (int col = 0; col < width; col++) { |
+ FXARGB_SETDIB(dest_scan, FXARGB_MAKE(0xff, FX_GAMMA(src_scan[0]), |
+ FX_GAMMA(src_scan[1]), |
+ FX_GAMMA(src_scan[2]))); |
+ dest_scan += 4; |
+ src_scan += 3; |
+ } |
} else { |
- ASSERT(FALSE); |
+ for (int col = 0; col < width; col++) { |
+ FXARGB_SETDIB(dest_scan, FXARGB_MAKE(0xff, src_scan[0], src_scan[1], |
+ src_scan[2])); |
+ dest_scan += 4; |
+ src_scan += 3; |
+ } |
} |
- } else if (dest_format == FXDIB_Argb || dest_format == FXDIB_Rgb32) { |
- if (src_format == FXDIB_Rgb) { |
- for (int row = 0; row < height; row ++) { |
- uint8_t* dest_scan = (uint8_t*)(dest_buf + row * pitch); |
- uint8_t* src_scan = (uint8_t*)pSrcBitmap->GetScanline(src_top + row) + src_left * 3; |
- if (src_format == FXDIB_Argb) { |
- for (int col = 0; col < width; col ++) { |
- FXARGB_SETDIB(dest_scan, FXARGB_MAKE(0xff, FX_GAMMA(src_scan[0]), FX_GAMMA(src_scan[1]), FX_GAMMA(src_scan[2]))); |
- dest_scan += 4; |
- src_scan += 3; |
- } |
- } else { |
- for (int col = 0; col < width; col ++) { |
- FXARGB_SETDIB(dest_scan, FXARGB_MAKE(0xff, src_scan[0], src_scan[1], src_scan[2])); |
- dest_scan += 4; |
- src_scan += 3; |
- } |
- } |
- } |
- } else if (src_format == FXDIB_Rgb32) { |
- ASSERT(dest_format == FXDIB_Argb); |
- for (int row = 0; row < height; row ++) { |
- uint8_t* dest_scan = dest_buf + row * pitch; |
- uint8_t* src_scan = (uint8_t*)(pSrcBitmap->GetScanline(src_top + row) + src_left * 4); |
- for (int col = 0; col < width; col++) { |
- FXARGB_SETDIB(dest_scan, FXARGB_MAKE(0xff, src_scan[0], src_scan[1], src_scan[2])); |
- src_scan += 4; |
- dest_scan += 4; |
- } |
- } |
+ } |
+ } else if (src_format == FXDIB_Rgb32) { |
+ ASSERT(dest_format == FXDIB_Argb); |
+ for (int row = 0; row < height; row++) { |
+ uint8_t* dest_scan = dest_buf + row * pitch; |
+ uint8_t* src_scan = |
+ (uint8_t*)(pSrcBitmap->GetScanline(src_top + row) + src_left * 4); |
+ for (int col = 0; col < width; col++) { |
+ FXARGB_SETDIB(dest_scan, FXARGB_MAKE(0xff, src_scan[0], src_scan[1], |
+ src_scan[2])); |
+ src_scan += 4; |
+ dest_scan += 4; |
} |
- } else { |
- ASSERT(FALSE); |
+ } |
} |
+ } else { |
+ ASSERT(FALSE); |
+ } |
} |
-FX_ARGB _DefaultCMYK2ARGB(FX_CMYK cmyk, uint8_t alpha) |
-{ |
- uint8_t r, g, b; |
- AdobeCMYK_to_sRGB1(FXSYS_GetCValue(cmyk), FXSYS_GetMValue(cmyk), FXSYS_GetYValue(cmyk), FXSYS_GetKValue(cmyk), |
- r, g, b); |
- return ArgbEncode(alpha, r, g, b); |
+FX_ARGB _DefaultCMYK2ARGB(FX_CMYK cmyk, uint8_t alpha) { |
+ uint8_t r, g, b; |
+ AdobeCMYK_to_sRGB1(FXSYS_GetCValue(cmyk), FXSYS_GetMValue(cmyk), |
+ FXSYS_GetYValue(cmyk), FXSYS_GetKValue(cmyk), r, g, b); |
+ return ArgbEncode(alpha, r, g, b); |
} |
-FX_BOOL _DibSetPixel(CFX_DIBitmap* pDevice, int x, int y, FX_DWORD color, int alpha_flag, void* pIccTransform) |
-{ |
- FX_BOOL bObjCMYK = FXGETFLAG_COLORTYPE(alpha_flag); |
- int alpha = bObjCMYK ? FXGETFLAG_ALPHA_FILL(alpha_flag) : FXARGB_A(color); |
- if (pIccTransform) { |
- ICodec_IccModule* pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule(); |
- color = bObjCMYK ? FXCMYK_TODIB(color) : FXARGB_TODIB(color); |
- pIccModule->TranslateScanline(pIccTransform, (uint8_t*)&color, (uint8_t*)&color, 1); |
- color = bObjCMYK ? FXCMYK_TODIB(color) : FXARGB_TODIB(color); |
- if (!pDevice->IsCmykImage()) { |
- color = (color & 0xffffff) | (alpha << 24); |
- } |
+FX_BOOL _DibSetPixel(CFX_DIBitmap* pDevice, |
+ int x, |
+ int y, |
+ FX_DWORD color, |
+ int alpha_flag, |
+ void* pIccTransform) { |
+ FX_BOOL bObjCMYK = FXGETFLAG_COLORTYPE(alpha_flag); |
+ int alpha = bObjCMYK ? FXGETFLAG_ALPHA_FILL(alpha_flag) : FXARGB_A(color); |
+ if (pIccTransform) { |
+ ICodec_IccModule* pIccModule = |
+ CFX_GEModule::Get()->GetCodecModule()->GetIccModule(); |
+ color = bObjCMYK ? FXCMYK_TODIB(color) : FXARGB_TODIB(color); |
+ pIccModule->TranslateScanline(pIccTransform, (uint8_t*)&color, |
+ (uint8_t*)&color, 1); |
+ color = bObjCMYK ? FXCMYK_TODIB(color) : FXARGB_TODIB(color); |
+ if (!pDevice->IsCmykImage()) { |
+ color = (color & 0xffffff) | (alpha << 24); |
+ } |
+ } else { |
+ if (pDevice->IsCmykImage()) { |
+ if (!bObjCMYK) { |
+ return FALSE; |
+ } |
} else { |
- if (pDevice->IsCmykImage()) { |
- if (!bObjCMYK) { |
- return FALSE; |
- } |
- } else { |
- if (bObjCMYK) { |
- color = _DefaultCMYK2ARGB(color, alpha); |
- } |
- } |
- } |
- pDevice->SetPixel(x, y, color); |
- if (pDevice->m_pAlphaMask) { |
- pDevice->m_pAlphaMask->SetPixel(x, y, alpha << 24); |
- } |
- return TRUE; |
+ if (bObjCMYK) { |
+ color = _DefaultCMYK2ARGB(color, alpha); |
+ } |
+ } |
+ } |
+ pDevice->SetPixel(x, y, color); |
+ if (pDevice->m_pAlphaMask) { |
+ pDevice->m_pAlphaMask->SetPixel(x, y, alpha << 24); |
+ } |
+ return TRUE; |
} |
-FX_BOOL CFX_AggDeviceDriver::SetPixel(int x, int y, FX_DWORD color, int alpha_flag, void* pIccTransform) |
-{ |
- if (m_pBitmap->GetBuffer() == NULL) { |
- return TRUE; |
- } |
- if (!CFX_GEModule::Get()->GetCodecModule() || !CFX_GEModule::Get()->GetCodecModule()->GetIccModule()) { |
- pIccTransform = NULL; |
- } |
- if (m_pClipRgn == NULL) { |
- if (m_bRgbByteOrder) { |
- RgbByteOrderSetPixel(m_pBitmap, x, y, color); |
- } else { |
- return _DibSetPixel(m_pBitmap, x, y, color, alpha_flag, pIccTransform); |
- } |
- } else if (m_pClipRgn->GetBox().Contains(x, y)) { |
- if (m_pClipRgn->GetType() == CFX_ClipRgn::RectI) { |
- if (m_bRgbByteOrder) { |
- RgbByteOrderSetPixel(m_pBitmap, x, y, color); |
- } else { |
- return _DibSetPixel(m_pBitmap, x, y, color, alpha_flag, pIccTransform); |
- } |
- } else if (m_pClipRgn->GetType() == CFX_ClipRgn::MaskF) { |
- const CFX_DIBitmap* pMask = m_pClipRgn->GetMask(); |
- FX_BOOL bCMYK = FXGETFLAG_COLORTYPE(alpha_flag); |
- int new_alpha = bCMYK ? FXGETFLAG_ALPHA_FILL(alpha_flag) : FXARGB_A(color); |
- new_alpha = new_alpha * pMask->GetScanline(y)[x] / 255; |
- if (m_bRgbByteOrder) { |
- RgbByteOrderSetPixel(m_pBitmap, x, y, (color & 0xffffff) | (new_alpha << 24)); |
- return TRUE; |
- } |
- if (bCMYK) { |
- FXSETFLAG_ALPHA_FILL(alpha_flag, new_alpha); |
- } else { |
- color = (color & 0xffffff) | (new_alpha << 24); |
- } |
- return _DibSetPixel(m_pBitmap, x, y, color, alpha_flag, pIccTransform); |
- } |
- } |
+FX_BOOL CFX_AggDeviceDriver::SetPixel(int x, |
+ int y, |
+ FX_DWORD color, |
+ int alpha_flag, |
+ void* pIccTransform) { |
+ if (m_pBitmap->GetBuffer() == NULL) { |
return TRUE; |
-} |
-FX_BOOL CFX_AggDeviceDriver::FillRect(const FX_RECT* pRect, FX_DWORD fill_color, int alpha_flag, void* pIccTransform, int blend_type) |
-{ |
- if (blend_type != FXDIB_BLEND_NORMAL) { |
- return FALSE; |
- } |
- if (m_pBitmap->GetBuffer() == NULL) { |
- return TRUE; |
- } |
- FX_RECT clip_rect; |
- GetClipBox(&clip_rect); |
- FX_RECT draw_rect = clip_rect; |
- if (pRect) { |
- draw_rect.Intersect(*pRect); |
- } |
- if (draw_rect.IsEmpty()) { |
- return TRUE; |
- } |
- if (m_pClipRgn == NULL || m_pClipRgn->GetType() == CFX_ClipRgn::RectI) { |
- if (m_bRgbByteOrder) { |
- RgbByteOrderCompositeRect(m_pBitmap, draw_rect.left, draw_rect.top, draw_rect.Width(), draw_rect.Height(), fill_color); |
- } else { |
- m_pBitmap->CompositeRect(draw_rect.left, draw_rect.top, draw_rect.Width(), draw_rect.Height(), fill_color, alpha_flag, pIccTransform); |
- } |
+ } |
+ if (!CFX_GEModule::Get()->GetCodecModule() || |
+ !CFX_GEModule::Get()->GetCodecModule()->GetIccModule()) { |
+ pIccTransform = NULL; |
+ } |
+ if (m_pClipRgn == NULL) { |
+ if (m_bRgbByteOrder) { |
+ RgbByteOrderSetPixel(m_pBitmap, x, y, color); |
+ } else { |
+ return _DibSetPixel(m_pBitmap, x, y, color, alpha_flag, pIccTransform); |
+ } |
+ } else if (m_pClipRgn->GetBox().Contains(x, y)) { |
+ if (m_pClipRgn->GetType() == CFX_ClipRgn::RectI) { |
+ if (m_bRgbByteOrder) { |
+ RgbByteOrderSetPixel(m_pBitmap, x, y, color); |
+ } else { |
+ return _DibSetPixel(m_pBitmap, x, y, color, alpha_flag, pIccTransform); |
+ } |
+ } else if (m_pClipRgn->GetType() == CFX_ClipRgn::MaskF) { |
+ const CFX_DIBitmap* pMask = m_pClipRgn->GetMask(); |
+ FX_BOOL bCMYK = FXGETFLAG_COLORTYPE(alpha_flag); |
+ int new_alpha = |
+ bCMYK ? FXGETFLAG_ALPHA_FILL(alpha_flag) : FXARGB_A(color); |
+ new_alpha = new_alpha * pMask->GetScanline(y)[x] / 255; |
+ if (m_bRgbByteOrder) { |
+ RgbByteOrderSetPixel(m_pBitmap, x, y, |
+ (color & 0xffffff) | (new_alpha << 24)); |
return TRUE; |
+ } |
+ if (bCMYK) { |
+ FXSETFLAG_ALPHA_FILL(alpha_flag, new_alpha); |
+ } else { |
+ color = (color & 0xffffff) | (new_alpha << 24); |
+ } |
+ return _DibSetPixel(m_pBitmap, x, y, color, alpha_flag, pIccTransform); |
+ } |
+ } |
+ return TRUE; |
+} |
+FX_BOOL CFX_AggDeviceDriver::FillRect(const FX_RECT* pRect, |
+ FX_DWORD fill_color, |
+ int alpha_flag, |
+ void* pIccTransform, |
+ int blend_type) { |
+ if (blend_type != FXDIB_BLEND_NORMAL) { |
+ return FALSE; |
+ } |
+ if (m_pBitmap->GetBuffer() == NULL) { |
+ return TRUE; |
+ } |
+ FX_RECT clip_rect; |
+ GetClipBox(&clip_rect); |
+ FX_RECT draw_rect = clip_rect; |
+ if (pRect) { |
+ draw_rect.Intersect(*pRect); |
+ } |
+ if (draw_rect.IsEmpty()) { |
+ return TRUE; |
+ } |
+ if (m_pClipRgn == NULL || m_pClipRgn->GetType() == CFX_ClipRgn::RectI) { |
+ if (m_bRgbByteOrder) { |
+ RgbByteOrderCompositeRect(m_pBitmap, draw_rect.left, draw_rect.top, |
+ draw_rect.Width(), draw_rect.Height(), |
+ fill_color); |
+ } else { |
+ m_pBitmap->CompositeRect(draw_rect.left, draw_rect.top, draw_rect.Width(), |
+ draw_rect.Height(), fill_color, alpha_flag, |
+ pIccTransform); |
} |
- m_pBitmap->CompositeMask(draw_rect.left, draw_rect.top, draw_rect.Width(), draw_rect.Height(), (const CFX_DIBitmap*)m_pClipRgn->GetMask(), |
- fill_color, draw_rect.left - clip_rect.left, draw_rect.top - clip_rect.top, FXDIB_BLEND_NORMAL, NULL, m_bRgbByteOrder, alpha_flag, pIccTransform); |
return TRUE; |
+ } |
+ m_pBitmap->CompositeMask( |
+ draw_rect.left, draw_rect.top, draw_rect.Width(), draw_rect.Height(), |
+ (const CFX_DIBitmap*)m_pClipRgn->GetMask(), fill_color, |
+ draw_rect.left - clip_rect.left, draw_rect.top - clip_rect.top, |
+ FXDIB_BLEND_NORMAL, NULL, m_bRgbByteOrder, alpha_flag, pIccTransform); |
+ return TRUE; |
} |
-FX_BOOL CFX_AggDeviceDriver::GetClipBox(FX_RECT* pRect) |
-{ |
- if (m_pClipRgn == NULL) { |
- pRect->left = pRect->top = 0; |
- pRect->right = GetDeviceCaps(FXDC_PIXEL_WIDTH); |
- pRect->bottom = GetDeviceCaps(FXDC_PIXEL_HEIGHT); |
- return TRUE; |
- } |
- *pRect = m_pClipRgn->GetBox(); |
+FX_BOOL CFX_AggDeviceDriver::GetClipBox(FX_RECT* pRect) { |
+ if (m_pClipRgn == NULL) { |
+ pRect->left = pRect->top = 0; |
+ pRect->right = GetDeviceCaps(FXDC_PIXEL_WIDTH); |
+ pRect->bottom = GetDeviceCaps(FXDC_PIXEL_HEIGHT); |
return TRUE; |
+ } |
+ *pRect = m_pClipRgn->GetBox(); |
+ return TRUE; |
} |
-FX_BOOL CFX_AggDeviceDriver::GetDIBits(CFX_DIBitmap* pBitmap, int left, int top, void* pIccTransform, FX_BOOL bDEdge) |
-{ |
- if (m_pBitmap->GetBuffer() == NULL) { |
- return TRUE; |
- } |
- if (bDEdge) { |
- if (m_bRgbByteOrder) { |
- RgbByteOrderTransferBitmap(pBitmap, 0, 0, pBitmap->GetWidth(), pBitmap->GetHeight(), m_pBitmap, left, top); |
- } else { |
- return pBitmap->TransferBitmap(0, 0, pBitmap->GetWidth(), pBitmap->GetHeight(), m_pBitmap, left, top, pIccTransform); |
- } |
- return TRUE; |
- } |
- FX_RECT rect(left, top, left + pBitmap->GetWidth(), top + pBitmap->GetHeight()); |
- CFX_DIBitmap *pBack = NULL; |
- if (m_pOriDevice) { |
- pBack = m_pOriDevice->Clone(&rect); |
- if (!pBack) { |
- return TRUE; |
- } |
- pBack->CompositeBitmap(0, 0, pBack->GetWidth(), pBack->GetHeight(), m_pBitmap, 0, 0); |
- } else { |
- pBack = m_pBitmap->Clone(&rect); |
- } |
- if (!pBack) { |
- return TRUE; |
- } |
- FX_BOOL bRet = TRUE; |
- left = left >= 0 ? 0 : left; |
- top = top >= 0 ? 0 : top; |
+FX_BOOL CFX_AggDeviceDriver::GetDIBits(CFX_DIBitmap* pBitmap, |
+ int left, |
+ int top, |
+ void* pIccTransform, |
+ FX_BOOL bDEdge) { |
+ if (m_pBitmap->GetBuffer() == NULL) { |
+ return TRUE; |
+ } |
+ if (bDEdge) { |
if (m_bRgbByteOrder) { |
- RgbByteOrderTransferBitmap(pBitmap, 0, 0, rect.Width(), rect.Height(), pBack, left, top); |
+ RgbByteOrderTransferBitmap(pBitmap, 0, 0, pBitmap->GetWidth(), |
+ pBitmap->GetHeight(), m_pBitmap, left, top); |
} else { |
- bRet = pBitmap->TransferBitmap(0, 0, rect.Width(), rect.Height(), pBack, left, top, pIccTransform); |
+ return pBitmap->TransferBitmap(0, 0, pBitmap->GetWidth(), |
+ pBitmap->GetHeight(), m_pBitmap, left, top, |
+ pIccTransform); |
} |
- delete pBack; |
- return bRet; |
+ return TRUE; |
+ } |
+ FX_RECT rect(left, top, left + pBitmap->GetWidth(), |
+ top + pBitmap->GetHeight()); |
+ CFX_DIBitmap* pBack = NULL; |
+ if (m_pOriDevice) { |
+ pBack = m_pOriDevice->Clone(&rect); |
+ if (!pBack) { |
+ return TRUE; |
+ } |
+ pBack->CompositeBitmap(0, 0, pBack->GetWidth(), pBack->GetHeight(), |
+ m_pBitmap, 0, 0); |
+ } else { |
+ pBack = m_pBitmap->Clone(&rect); |
+ } |
+ if (!pBack) { |
+ return TRUE; |
+ } |
+ FX_BOOL bRet = TRUE; |
+ left = left >= 0 ? 0 : left; |
+ top = top >= 0 ? 0 : top; |
+ if (m_bRgbByteOrder) { |
+ RgbByteOrderTransferBitmap(pBitmap, 0, 0, rect.Width(), rect.Height(), |
+ pBack, left, top); |
+ } else { |
+ bRet = pBitmap->TransferBitmap(0, 0, rect.Width(), rect.Height(), pBack, |
+ left, top, pIccTransform); |
+ } |
+ delete pBack; |
+ return bRet; |
} |
-FX_BOOL CFX_AggDeviceDriver::SetDIBits(const CFX_DIBSource* pBitmap, FX_DWORD argb, const FX_RECT* pSrcRect, int left, int top, int blend_type, |
- int alpha_flag, void* pIccTransform) |
-{ |
- if (m_pBitmap->GetBuffer() == NULL) { |
- return TRUE; |
- } |
- if (pBitmap->IsAlphaMask()) |
- return m_pBitmap->CompositeMask(left, top, pSrcRect->Width(), pSrcRect->Height(), pBitmap, argb, |
- pSrcRect->left, pSrcRect->top, blend_type, m_pClipRgn, m_bRgbByteOrder, alpha_flag, pIccTransform); |
- return m_pBitmap->CompositeBitmap(left, top, pSrcRect->Width(), pSrcRect->Height(), pBitmap, |
- pSrcRect->left, pSrcRect->top, blend_type, m_pClipRgn, m_bRgbByteOrder, pIccTransform); |
+FX_BOOL CFX_AggDeviceDriver::SetDIBits(const CFX_DIBSource* pBitmap, |
+ FX_DWORD argb, |
+ const FX_RECT* pSrcRect, |
+ int left, |
+ int top, |
+ int blend_type, |
+ int alpha_flag, |
+ void* pIccTransform) { |
+ if (m_pBitmap->GetBuffer() == NULL) { |
+ return TRUE; |
+ } |
+ if (pBitmap->IsAlphaMask()) |
+ return m_pBitmap->CompositeMask( |
+ left, top, pSrcRect->Width(), pSrcRect->Height(), pBitmap, argb, |
+ pSrcRect->left, pSrcRect->top, blend_type, m_pClipRgn, m_bRgbByteOrder, |
+ alpha_flag, pIccTransform); |
+ return m_pBitmap->CompositeBitmap( |
+ left, top, pSrcRect->Width(), pSrcRect->Height(), pBitmap, pSrcRect->left, |
+ pSrcRect->top, blend_type, m_pClipRgn, m_bRgbByteOrder, pIccTransform); |
} |
-FX_BOOL CFX_AggDeviceDriver::StretchDIBits(const CFX_DIBSource* pSource, FX_DWORD argb, int dest_left, int dest_top, |
- int dest_width, int dest_height, const FX_RECT* pClipRect, FX_DWORD flags, |
- int alpha_flag, void* pIccTransform, int blend_type) |
-{ |
- if (m_pBitmap->GetBuffer() == NULL) { |
- return TRUE; |
- } |
- if (dest_width == pSource->GetWidth() && dest_height == pSource->GetHeight()) { |
- FX_RECT rect(0, 0, dest_width, dest_height); |
- return SetDIBits(pSource, argb, &rect, dest_left, dest_top, blend_type, alpha_flag, pIccTransform); |
- } |
- FX_RECT dest_rect(dest_left, dest_top, dest_left + dest_width, dest_top + dest_height); |
- dest_rect.Normalize(); |
- FX_RECT dest_clip = dest_rect; |
- dest_clip.Intersect(*pClipRect); |
- CFX_BitmapComposer composer; |
- composer.Compose(m_pBitmap, m_pClipRgn, 255, argb, dest_clip, FALSE, FALSE, FALSE, m_bRgbByteOrder, alpha_flag, pIccTransform, blend_type); |
- dest_clip.Offset(-dest_rect.left, -dest_rect.top); |
- CFX_ImageStretcher stretcher; |
- if (stretcher.Start(&composer, pSource, dest_width, dest_height, dest_clip, flags)) { |
- stretcher.Continue(NULL); |
- } |
+FX_BOOL CFX_AggDeviceDriver::StretchDIBits(const CFX_DIBSource* pSource, |
+ FX_DWORD argb, |
+ int dest_left, |
+ int dest_top, |
+ int dest_width, |
+ int dest_height, |
+ const FX_RECT* pClipRect, |
+ FX_DWORD flags, |
+ int alpha_flag, |
+ void* pIccTransform, |
+ int blend_type) { |
+ if (m_pBitmap->GetBuffer() == NULL) { |
return TRUE; |
+ } |
+ if (dest_width == pSource->GetWidth() && |
+ dest_height == pSource->GetHeight()) { |
+ FX_RECT rect(0, 0, dest_width, dest_height); |
+ return SetDIBits(pSource, argb, &rect, dest_left, dest_top, blend_type, |
+ alpha_flag, pIccTransform); |
+ } |
+ FX_RECT dest_rect(dest_left, dest_top, dest_left + dest_width, |
+ dest_top + dest_height); |
+ dest_rect.Normalize(); |
+ FX_RECT dest_clip = dest_rect; |
+ dest_clip.Intersect(*pClipRect); |
+ CFX_BitmapComposer composer; |
+ composer.Compose(m_pBitmap, m_pClipRgn, 255, argb, dest_clip, FALSE, FALSE, |
+ FALSE, m_bRgbByteOrder, alpha_flag, pIccTransform, |
+ blend_type); |
+ dest_clip.Offset(-dest_rect.left, -dest_rect.top); |
+ CFX_ImageStretcher stretcher; |
+ if (stretcher.Start(&composer, pSource, dest_width, dest_height, dest_clip, |
+ flags)) { |
+ stretcher.Continue(NULL); |
+ } |
+ return TRUE; |
} |
-FX_BOOL CFX_AggDeviceDriver::StartDIBits(const CFX_DIBSource* pSource, int bitmap_alpha, FX_DWORD argb, |
- const CFX_AffineMatrix* pMatrix, FX_DWORD render_flags, void*& handle, |
- int alpha_flag, void* pIccTransform, int blend_type) |
-{ |
- if (m_pBitmap->GetBuffer() == NULL) { |
- return TRUE; |
- } |
- CFX_ImageRenderer* pRenderer = new CFX_ImageRenderer; |
- pRenderer->Start(m_pBitmap, m_pClipRgn, pSource, bitmap_alpha, argb, pMatrix, render_flags, m_bRgbByteOrder, alpha_flag, pIccTransform); |
- handle = pRenderer; |
+FX_BOOL CFX_AggDeviceDriver::StartDIBits(const CFX_DIBSource* pSource, |
+ int bitmap_alpha, |
+ FX_DWORD argb, |
+ const CFX_AffineMatrix* pMatrix, |
+ FX_DWORD render_flags, |
+ void*& handle, |
+ int alpha_flag, |
+ void* pIccTransform, |
+ int blend_type) { |
+ if (m_pBitmap->GetBuffer() == NULL) { |
return TRUE; |
+ } |
+ CFX_ImageRenderer* pRenderer = new CFX_ImageRenderer; |
+ pRenderer->Start(m_pBitmap, m_pClipRgn, pSource, bitmap_alpha, argb, pMatrix, |
+ render_flags, m_bRgbByteOrder, alpha_flag, pIccTransform); |
+ handle = pRenderer; |
+ return TRUE; |
} |
-FX_BOOL CFX_AggDeviceDriver::ContinueDIBits(void* pHandle, IFX_Pause* pPause) |
-{ |
- if (m_pBitmap->GetBuffer() == NULL) { |
- return TRUE; |
- } |
- return ((CFX_ImageRenderer*)pHandle)->Continue(pPause); |
+FX_BOOL CFX_AggDeviceDriver::ContinueDIBits(void* pHandle, IFX_Pause* pPause) { |
+ if (m_pBitmap->GetBuffer() == NULL) { |
+ return TRUE; |
+ } |
+ return ((CFX_ImageRenderer*)pHandle)->Continue(pPause); |
} |
-void CFX_AggDeviceDriver::CancelDIBits(void* pHandle) |
-{ |
- if (m_pBitmap->GetBuffer() == NULL) { |
- return; |
- } |
- delete (CFX_ImageRenderer*)pHandle; |
+void CFX_AggDeviceDriver::CancelDIBits(void* pHandle) { |
+ if (m_pBitmap->GetBuffer() == NULL) { |
+ return; |
+ } |
+ delete (CFX_ImageRenderer*)pHandle; |
} |
-CFX_FxgeDevice::CFX_FxgeDevice() |
-{ |
- m_bOwnedBitmap = FALSE; |
+CFX_FxgeDevice::CFX_FxgeDevice() { |
+ m_bOwnedBitmap = FALSE; |
} |
-FX_BOOL CFX_FxgeDevice::Attach(CFX_DIBitmap* pBitmap, int dither_bits, FX_BOOL bRgbByteOrder, CFX_DIBitmap* pOriDevice, FX_BOOL bGroupKnockout) |
-{ |
- if (pBitmap == NULL) { |
- return FALSE; |
- } |
- SetBitmap(pBitmap); |
- IFX_RenderDeviceDriver* pDriver = new CFX_AggDeviceDriver(pBitmap, dither_bits, bRgbByteOrder, pOriDevice, bGroupKnockout); |
- SetDeviceDriver(pDriver); |
- return TRUE; |
+FX_BOOL CFX_FxgeDevice::Attach(CFX_DIBitmap* pBitmap, |
+ int dither_bits, |
+ FX_BOOL bRgbByteOrder, |
+ CFX_DIBitmap* pOriDevice, |
+ FX_BOOL bGroupKnockout) { |
+ if (pBitmap == NULL) { |
+ return FALSE; |
+ } |
+ SetBitmap(pBitmap); |
+ IFX_RenderDeviceDriver* pDriver = new CFX_AggDeviceDriver( |
+ pBitmap, dither_bits, bRgbByteOrder, pOriDevice, bGroupKnockout); |
+ SetDeviceDriver(pDriver); |
+ return TRUE; |
} |
-FX_BOOL CFX_FxgeDevice::Create(int width, int height, FXDIB_Format format, int dither_bits, CFX_DIBitmap* pOriDevice) |
-{ |
- m_bOwnedBitmap = TRUE; |
- CFX_DIBitmap* pBitmap = new CFX_DIBitmap; |
- if (!pBitmap->Create(width, height, format)) { |
- delete pBitmap; |
- return FALSE; |
- } |
- SetBitmap(pBitmap); |
- IFX_RenderDeviceDriver* pDriver = new CFX_AggDeviceDriver(pBitmap, dither_bits, FALSE, pOriDevice, FALSE); |
- SetDeviceDriver(pDriver); |
- return TRUE; |
+FX_BOOL CFX_FxgeDevice::Create(int width, |
+ int height, |
+ FXDIB_Format format, |
+ int dither_bits, |
+ CFX_DIBitmap* pOriDevice) { |
+ m_bOwnedBitmap = TRUE; |
+ CFX_DIBitmap* pBitmap = new CFX_DIBitmap; |
+ if (!pBitmap->Create(width, height, format)) { |
+ delete pBitmap; |
+ return FALSE; |
+ } |
+ SetBitmap(pBitmap); |
+ IFX_RenderDeviceDriver* pDriver = |
+ new CFX_AggDeviceDriver(pBitmap, dither_bits, FALSE, pOriDevice, FALSE); |
+ SetDeviceDriver(pDriver); |
+ return TRUE; |
} |
-CFX_FxgeDevice::~CFX_FxgeDevice() |
-{ |
- if (m_bOwnedBitmap) { |
- delete GetBitmap(); |
- } |
+CFX_FxgeDevice::~CFX_FxgeDevice() { |
+ if (m_bOwnedBitmap) { |
+ delete GetBitmap(); |
+ } |
} |