summaryrefslogtreecommitdiff
path: root/core/src/fxge/skia
diff options
context:
space:
mode:
Diffstat (limited to 'core/src/fxge/skia')
-rw-r--r--core/src/fxge/skia/fx_skia_blitter_new.cpp3217
-rw-r--r--core/src/fxge/skia/fx_skia_blitter_new.h726
-rw-r--r--core/src/fxge/skia/fx_skia_device.cpp984
-rw-r--r--core/src/fxge/skia/fx_skia_device.h214
4 files changed, 2913 insertions, 2228 deletions
diff --git a/core/src/fxge/skia/fx_skia_blitter_new.cpp b/core/src/fxge/skia/fx_skia_blitter_new.cpp
index 3437eb497d..a3ed75b9cb 100644
--- a/core/src/fxge/skia/fx_skia_blitter_new.cpp
+++ b/core/src/fxge/skia/fx_skia_blitter_new.cpp
@@ -8,308 +8,385 @@
#include "../../../include/fxcodec/fx_codec.h"
#include "SkBlitter.h"
#include "fx_skia_blitter_new.h"
- // We use our own renderer here to make it simple
- void CFX_SkiaRenderer::blitAntiH(int x, int y, const SkAlpha antialias[], const int16_t runs[])
- {
- FXSYS_assert(m_Alpha);
- if (m_pOriDevice == NULL && composite_span == NULL) return;
- if (y < m_ClipBox.top || y >= m_ClipBox.bottom) return;
- while (1)
- {
- int width = runs[0];
- SkASSERT(width >= 0);
- if (width <= 0)
- return;
- unsigned aa = antialias[0];
- if (aa)
- (*composite_span)(m_pDestScan, m_pOriScan, 0, x, width, y, aa, m_ClipBox.top, m_ClipBox.left, m_ClipBox.right, m_pClipScan, m_pDestExtraAlphaScan);
- runs += width;
- antialias += width;
- x += width;
- }
- }
+// We use our own renderer here to make it simple
+void CFX_SkiaRenderer::blitAntiH(int x,
+ int y,
+ const SkAlpha antialias[],
+ const int16_t runs[]) {
+ FXSYS_assert(m_Alpha);
+ if (m_pOriDevice == NULL && composite_span == NULL)
+ return;
+ if (y < m_ClipBox.top || y >= m_ClipBox.bottom)
+ return;
+ while (1) {
+ int width = runs[0];
+ SkASSERT(width >= 0);
+ if (width <= 0)
+ return;
+ unsigned aa = antialias[0];
+ if (aa)
+ (*composite_span)(m_pDestScan, m_pOriScan, 0, x, width, y, aa,
+ m_ClipBox.top, m_ClipBox.left, m_ClipBox.right,
+ m_pClipScan, m_pDestExtraAlphaScan);
+ runs += width;
+ antialias += width;
+ x += width;
+ }
+}
- void CFX_SkiaRenderer::blitH(int x, int y, int width)
- {
- FXSYS_assert(m_Alpha && width);
- if (y < m_ClipBox.top || y >= m_ClipBox.bottom) return;
- (*composite_span)(m_pDestScan, m_pOriScan, 0, x, width, y, 255, m_ClipBox.top, m_ClipBox.left, m_ClipBox.right, m_pClipScan, m_pDestExtraAlphaScan);
- }
+void CFX_SkiaRenderer::blitH(int x, int y, int width) {
+ FXSYS_assert(m_Alpha && width);
+ if (y < m_ClipBox.top || y >= m_ClipBox.bottom)
+ return;
+ (*composite_span)(m_pDestScan, m_pOriScan, 0, x, width, y, 255, m_ClipBox.top,
+ m_ClipBox.left, m_ClipBox.right, m_pClipScan,
+ m_pDestExtraAlphaScan);
+}
- void CFX_SkiaRenderer::blitV(int x, int y, int height, SkAlpha alpha)
- {
- FXSYS_assert(m_Alpha && alpha);
- if (alpha == 255) {
- blitRect(x, y, 1, height);
- } else {
- int16_t runs[2];
- runs[0] = 1;
- runs[1] = 0;
- while (--height >= 0) {
- if (y >= m_ClipBox.bottom)
- return;
- blitAntiH(x, y ++, &alpha, runs);
- }
- }
- }
- void CFX_SkiaRenderer::blitRect(int x, int y, int width, int height)
- {
- FXSYS_assert(m_Alpha && width);
- while (--height >= 0){
- if (y >= m_ClipBox.bottom)
- return;
- blitH(x, y ++, width);
- }
+void CFX_SkiaRenderer::blitV(int x, int y, int height, SkAlpha alpha) {
+ FXSYS_assert(m_Alpha && alpha);
+ if (alpha == 255) {
+ blitRect(x, y, 1, height);
+ } else {
+ int16_t runs[2];
+ runs[0] = 1;
+ runs[1] = 0;
+ while (--height >= 0) {
+ if (y >= m_ClipBox.bottom)
+ return;
+ blitAntiH(x, y++, &alpha, runs);
}
+ }
+}
+void CFX_SkiaRenderer::blitRect(int x, int y, int width, int height) {
+ FXSYS_assert(m_Alpha && width);
+ while (--height >= 0) {
+ if (y >= m_ClipBox.bottom)
+ return;
+ blitH(x, y++, width);
+ }
+}
- void CFX_SkiaRenderer::blitAntiRect(int x, int y, int width, int height,
- SkAlpha leftAlpha, SkAlpha rightAlpha)
- {
- blitV(x++, y, height, leftAlpha);
- if (width > 0) {
- blitRect(x, y, width, height);
- x += width;
- }
- blitV(x, y, height, rightAlpha);
- }
- /*---------------------------------------------------------------------------------------------------*/
- void CFX_SkiaRenderer::CompositeSpan1bpp_0(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan)
- {
- ASSERT(!m_bRgbByteOrder);
- ASSERT(!m_pDevice->IsCmykImage());
- dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + span_left/8;
- 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 (col_end < col_start) return; // do nothing.
- dest_scan += col_start/8;
+void CFX_SkiaRenderer::blitAntiRect(int x,
+ int y,
+ int width,
+ int height,
+ SkAlpha leftAlpha,
+ SkAlpha rightAlpha) {
+ blitV(x++, y, height, leftAlpha);
+ if (width > 0) {
+ blitRect(x, y, width, height);
+ x += width;
+ }
+ blitV(x, y, height, rightAlpha);
+}
+/*---------------------------------------------------------------------------------------------------*/
+void CFX_SkiaRenderer::CompositeSpan1bpp_0(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan) {
+ ASSERT(!m_bRgbByteOrder);
+ ASSERT(!m_pDevice->IsCmykImage());
+ dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + span_left / 8;
+ 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 (col_end < col_start)
+ return; // do nothing.
+ 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;
- }
- uint8_t* dest_scan1 = dest_scan;
- int src_alpha = m_Alpha * cover_scan / 255;
- for (int col = col_start; col < col_end; col ++) {
- 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;
- }
+ 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;
+ int src_alpha = m_Alpha * cover_scan / 255;
+ for (int col = col_start; col < col_end; col++) {
+ if (src_alpha) {
+ if (!index)
+ *dest_scan1 &= ~(1 << (7 - (col + span_left) % 8));
+ else
+ *dest_scan1 |= 1 << (7 - (col + span_left) % 8);
}
- void CFX_SkiaRenderer::CompositeSpan1bpp_4(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan)
- {
- ASSERT(!m_bRgbByteOrder);
- ASSERT(!m_pDevice->IsCmykImage());
- dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + span_left/8;
- clip_scan = (uint8_t*)m_pClipMask->GetScanline(span_top-clip_top) - clip_left + span_left;
- 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 (col_end < col_start) return; // do nothing.
- dest_scan += col_start/8;
+ dest_scan1 = dest_scan + (span_left % 8 + col - col_start + 1) / 8;
+ }
+}
+void CFX_SkiaRenderer::CompositeSpan1bpp_4(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan) {
+ ASSERT(!m_bRgbByteOrder);
+ ASSERT(!m_pDevice->IsCmykImage());
+ dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + span_left / 8;
+ clip_scan = (uint8_t*)m_pClipMask->GetScanline(span_top - clip_top) -
+ clip_left + span_left;
+ 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 (col_end < col_start)
+ return; // do nothing.
+ 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;
- }
- uint8_t* dest_scan1 = dest_scan;
- int src_alpha = m_Alpha * cover_scan / 255;
- for (int col = col_start; col < col_end; col ++) {
- int src_alpha1 = src_alpha * clip_scan[col] / 255;
- if (src_alpha1) {
- 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 CFX_SkiaRenderer::CompositeSpanGray_2(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan)
- {
- ASSERT(!m_pDevice->IsCmykImage());
- ASSERT(!m_bRgbByteOrder);
- dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + span_left;
- 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 (col_end < col_start) return; // do nothing.
- dest_scan += col_start;
- if (cover_scan == 255 && m_Alpha == 255) {
- FXSYS_memset(dest_scan, FXARGB_MAKE(m_Gray, m_Gray, m_Gray, m_Gray), col_end - col_start);
- return;
- }
- int src_alpha = m_Alpha * cover_scan / 255;
- for (int col = col_start; col < col_end; col ++) {
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Gray, src_alpha);
- dest_scan++;
- }
+ 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;
+ int src_alpha = m_Alpha * cover_scan / 255;
+ for (int col = col_start; col < col_end; col++) {
+ int src_alpha1 = src_alpha * clip_scan[col] / 255;
+ if (src_alpha1) {
+ if (!index)
+ *dest_scan1 &= ~(1 << (7 - (col + span_left) % 8));
+ else
+ *dest_scan1 |= 1 << (7 - (col + span_left) % 8);
}
- void CFX_SkiaRenderer::CompositeSpanGray_3(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan)
- {
- ASSERT(!m_pDevice->IsCmykImage());
- ASSERT(!m_bRgbByteOrder);
- dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + span_left;
- ori_scan = (uint8_t*)m_pOriDevice->GetScanline(span_top) + span_left;
- 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 (col_end < col_start) return; // do nothing.
- dest_scan += col_start;
- ori_scan += col_start;
- if (m_Alpha == 255 && cover_scan == 255) {
- FXSYS_memset(dest_scan, FXARGB_MAKE(m_Gray, m_Gray, m_Gray, m_Gray), col_end - col_start);
- } else {
- int src_alpha = m_Alpha;
+ dest_scan1 = dest_scan + (span_left % 8 + col - col_start + 1) / 8;
+ }
+}
+/*-----------------------------------------------------------------------------------------------------*/
+void CFX_SkiaRenderer::CompositeSpanGray_2(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan) {
+ ASSERT(!m_pDevice->IsCmykImage());
+ ASSERT(!m_bRgbByteOrder);
+ dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + span_left;
+ 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 (col_end < col_start)
+ return; // do nothing.
+ dest_scan += col_start;
+ if (cover_scan == 255 && m_Alpha == 255) {
+ FXSYS_memset(dest_scan, FXARGB_MAKE(m_Gray, m_Gray, m_Gray, m_Gray),
+ col_end - col_start);
+ return;
+ }
+ int src_alpha = m_Alpha * cover_scan / 255;
+ for (int col = col_start; col < col_end; col++) {
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Gray, src_alpha);
+ dest_scan++;
+ }
+}
+void CFX_SkiaRenderer::CompositeSpanGray_3(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan) {
+ ASSERT(!m_pDevice->IsCmykImage());
+ ASSERT(!m_bRgbByteOrder);
+ dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + span_left;
+ ori_scan = (uint8_t*)m_pOriDevice->GetScanline(span_top) + span_left;
+ 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 (col_end < col_start)
+ return; // do nothing.
+ dest_scan += col_start;
+ ori_scan += col_start;
+ if (m_Alpha == 255 && cover_scan == 255) {
+ FXSYS_memset(dest_scan, FXARGB_MAKE(m_Gray, m_Gray, m_Gray, m_Gray),
+ col_end - col_start);
+ } else {
+ int src_alpha = m_Alpha;
#if 1
- for (int col = col_start; col < col_end; col ++) {
- int gray = FXDIB_ALPHA_MERGE(*ori_scan++, m_Gray, src_alpha);
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, cover_scan);
- dest_scan ++;
- }
+ for (int col = col_start; col < col_end; col++) {
+ int gray = FXDIB_ALPHA_MERGE(*ori_scan++, m_Gray, src_alpha);
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, cover_scan);
+ dest_scan++;
+ }
#else
- if (m_bFullCover) {
- if (src_alpha == 255) {
- FXSYS_memset(dest_scan, FXARGB_MAKE(m_Gray, m_Gray, m_Gray, m_Gray), col_end - col_start);
- return;
- }
- for (int col = col_start; col < col_end; col ++)
- *dest_scan = FXDIB_ALPHA_MERGE(*ori_scan++, m_Gray, src_alpha);
- } else {
- for (int col = col_start; col < col_end; col ++) {
- int gray = FXDIB_ALPHA_MERGE(*ori_scan++, m_Gray, src_alpha);
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, cover_scan);
- dest_scan++;
- }
- }
-#endif
- }
+ if (m_bFullCover) {
+ if (src_alpha == 255) {
+ FXSYS_memset(dest_scan, FXARGB_MAKE(m_Gray, m_Gray, m_Gray, m_Gray),
+ col_end - col_start);
+ return;
+ }
+ for (int col = col_start; col < col_end; col++)
+ *dest_scan = FXDIB_ALPHA_MERGE(*ori_scan++, m_Gray, src_alpha);
+ } else {
+ for (int col = col_start; col < col_end; col++) {
+ int gray = FXDIB_ALPHA_MERGE(*ori_scan++, m_Gray, src_alpha);
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, cover_scan);
+ dest_scan++;
+ }
}
+#endif
+ }
+}
- void CFX_SkiaRenderer::CompositeSpanGray_6(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan)
- {
- ASSERT(!m_bRgbByteOrder);
- dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + span_left;
- clip_scan = (uint8_t*)m_pClipMask->GetScanline(span_top-clip_top) - clip_left + span_left;
- 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 (col_end < col_start) return; // do nothing.
- dest_scan += col_start;
- int src_alpha = m_Alpha * cover_scan / 255;
- for (int col = col_start; col < col_end; col ++) {
- int src_alpha1 = src_alpha * clip_scan[col] / 255;
- if (!src_alpha1) {
- dest_scan ++;
- continue;
- }
- if (src_alpha1 == 255)
- *dest_scan++ = m_Gray;
- else {
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Gray, src_alpha1);
- dest_scan ++;
- }
- }
+void CFX_SkiaRenderer::CompositeSpanGray_6(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan) {
+ ASSERT(!m_bRgbByteOrder);
+ dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + span_left;
+ clip_scan = (uint8_t*)m_pClipMask->GetScanline(span_top - clip_top) -
+ clip_left + span_left;
+ 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 (col_end < col_start)
+ return; // do nothing.
+ dest_scan += col_start;
+ int src_alpha = m_Alpha * cover_scan / 255;
+ for (int col = col_start; col < col_end; col++) {
+ int src_alpha1 = src_alpha * clip_scan[col] / 255;
+ if (!src_alpha1) {
+ dest_scan++;
+ continue;
+ }
+ if (src_alpha1 == 255)
+ *dest_scan++ = m_Gray;
+ else {
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Gray, src_alpha1);
+ dest_scan++;
}
+ }
+}
- void CFX_SkiaRenderer::CompositeSpanGray_7(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan)
- {
- ASSERT(!m_pDevice->IsCmykImage());
- dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + span_left;
- ori_scan = (uint8_t*)m_pOriDevice->GetScanline(span_top) + span_left;
- clip_scan = (uint8_t*)m_pClipMask->GetScanline(span_top-clip_top) - clip_left + span_left;
- 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 (col_end < col_start) return; // do nothing.
- dest_scan += col_start;
- ori_scan += col_start;
+void CFX_SkiaRenderer::CompositeSpanGray_7(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan) {
+ ASSERT(!m_pDevice->IsCmykImage());
+ dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + span_left;
+ ori_scan = (uint8_t*)m_pOriDevice->GetScanline(span_top) + span_left;
+ clip_scan = (uint8_t*)m_pClipMask->GetScanline(span_top - clip_top) -
+ clip_left + span_left;
+ 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 (col_end < col_start)
+ return; // do nothing.
+ dest_scan += col_start;
+ ori_scan += col_start;
#if 1
- for (int col = col_start; col < col_end; col ++) {
- int src_alpha = m_Alpha * clip_scan[col] / 255;
- if (src_alpha == 255 && cover_scan == 255) {
- *dest_scan++ = m_Gray;
- ori_scan++;
- continue;
- }
- int gray = FXDIB_ALPHA_MERGE(*ori_scan++, m_Gray, src_alpha);
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, cover_scan);
- dest_scan++;
- }
+ for (int col = col_start; col < col_end; col++) {
+ int src_alpha = m_Alpha * clip_scan[col] / 255;
+ if (src_alpha == 255 && cover_scan == 255) {
+ *dest_scan++ = m_Gray;
+ ori_scan++;
+ continue;
+ }
+ int gray = FXDIB_ALPHA_MERGE(*ori_scan++, m_Gray, src_alpha);
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, cover_scan);
+ dest_scan++;
+ }
#else
- if (m_bFullCover) {
- for (int col = col_start; col < col_end; col ++) {
- int src_alpha = m_Alpha * clip_scan[col] / 255;
- if (!src_alpha) {
- dest_scan++;
- ori_scan++;
- continue;
- }
- if (src_alpha == 255){
- *dest_scan++ = m_Gray;
- ori_scan++;
- continue;
- }
- *dest_scan++ = FXDIB_ALPHA_MERGE(*ori_scan++, m_Gray, src_alpha);
- }
- } else {
- for (int col = col_start; col < col_end; col ++) {
- int src_alpha = m_Alpha * clip_scan[col] / 255;
- if (src_alpha == 255 && cover_scan == 255) {
- *dest_scan++ = m_Gray;
- ori_scan++;
- continue;
- }
- int gray = FXDIB_ALPHA_MERGE(*ori_scan++, m_Gray, src_alpha);
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, cover_scan);
- dest_scan++;
- }
- }
-#endif
+ if (m_bFullCover) {
+ for (int col = col_start; col < col_end; col++) {
+ int src_alpha = m_Alpha * clip_scan[col] / 255;
+ if (!src_alpha) {
+ dest_scan++;
+ ori_scan++;
+ continue;
+ }
+ if (src_alpha == 255) {
+ *dest_scan++ = m_Gray;
+ ori_scan++;
+ continue;
+ }
+ *dest_scan++ = FXDIB_ALPHA_MERGE(*ori_scan++, m_Gray, src_alpha);
}
- /*--------------------------------------------------------------------------------------------------*/
+ } else {
+ for (int col = col_start; col < col_end; col++) {
+ int src_alpha = m_Alpha * clip_scan[col] / 255;
+ if (src_alpha == 255 && cover_scan == 255) {
+ *dest_scan++ = m_Gray;
+ ori_scan++;
+ continue;
+ }
+ int gray = FXDIB_ALPHA_MERGE(*ori_scan++, m_Gray, src_alpha);
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, cover_scan);
+ dest_scan++;
+ }
+ }
+#endif
+}
+/*--------------------------------------------------------------------------------------------------*/
- void CFX_SkiaRenderer::CompositeSpanARGB_2(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan)
- {
- dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + (span_left<<2);
- 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 (col_end < col_start) return; // do nothing.
- dest_scan += col_start<<2;
- if (m_Alpha == 255 && cover_scan == 255) {
- FXSYS_memset(dest_scan, m_Color, (col_end - col_start)<<2);
- return;
- }
- int src_alpha;
+void CFX_SkiaRenderer::CompositeSpanARGB_2(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan) {
+ dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + (span_left << 2);
+ 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 (col_end < col_start)
+ return; // do nothing.
+ dest_scan += col_start << 2;
+ if (m_Alpha == 255 && cover_scan == 255) {
+ FXSYS_memset(dest_scan, m_Color, (col_end - col_start) << 2);
+ return;
+ }
+ int src_alpha;
#if 0
if (m_bFullCover) {
if (m_Alpha == 255) {
@@ -319,293 +396,341 @@
}
else
#endif
- src_alpha = m_Alpha * cover_scan / 255;
- for (int col = col_start; col < col_end; col ++) {
- // Dest format: Argb
- // calculate destination alpha (it's union of source and dest alpha)
- 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;
- }
+ src_alpha = m_Alpha * cover_scan / 255;
+ for (int col = col_start; col < col_end; col++) {
+ // Dest format: Argb
+ // calculate destination alpha (it's union of source and dest alpha)
+ 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;
+ }
+}
- void CFX_SkiaRenderer::CompositeSpanARGB_3(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan)
- {
- ASSERT(!m_pDevice->IsCmykImage());
- dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + (span_left<<2);
- //ori_scan = (uint8_t*)m_pOriDevice->GetScanline(span_top) + (span_left<<2);
- 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 (col_end < col_start) return; // do nothing.
- dest_scan += col_start << 2;
- //ori_scan += col_start << 2;
+void CFX_SkiaRenderer::CompositeSpanARGB_3(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan) {
+ ASSERT(!m_pDevice->IsCmykImage());
+ dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + (span_left << 2);
+ // ori_scan = (uint8_t*)m_pOriDevice->GetScanline(span_top) + (span_left<<2);
+ 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 (col_end < col_start)
+ return; // do nothing.
+ dest_scan += col_start << 2;
+ // ori_scan += col_start << 2;
- if (m_Alpha == 255 && cover_scan == 255){
- FXSYS_memset(dest_scan, m_Color, (col_end - col_start)<<2);
- return;
- }
- if (cover_scan == 255) {
- int dst_color = (0x00ffffff&m_Color)|(m_Alpha<<24);
- FXSYS_memset(dest_scan, dst_color, (col_end - col_start)<<2);
- return;
- }
- // Do not need origin bitmap, because of merge in pure transparent background
- int src_alpha_covered = m_Alpha * cover_scan / 255;
- for (int col = col_start; col < col_end; col ++)
- {
- // shortcut
- 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;
- }
- // We should do alpha transition and color transition
- // alpha fg color fg
- // alpha bg color bg
- // alpha cover color cover
- dest_scan[3] = FXDIB_ALPHA_MERGE(dest_scan[3], m_Alpha, cover_scan);
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, cover_scan);
- dest_scan ++;
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, cover_scan);
- dest_scan ++;
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, cover_scan);
- dest_scan += 2;
- }
+ if (m_Alpha == 255 && cover_scan == 255) {
+ FXSYS_memset(dest_scan, m_Color, (col_end - col_start) << 2);
+ return;
+ }
+ if (cover_scan == 255) {
+ int dst_color = (0x00ffffff & m_Color) | (m_Alpha << 24);
+ FXSYS_memset(dest_scan, dst_color, (col_end - col_start) << 2);
+ return;
+ }
+ // Do not need origin bitmap, because of merge in pure transparent background
+ int src_alpha_covered = m_Alpha * cover_scan / 255;
+ for (int col = col_start; col < col_end; col++) {
+ // shortcut
+ 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;
}
- void CFX_SkiaRenderer::CompositeSpanARGB_6(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan)
- {
- dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + (span_left<<2);
- clip_scan = (uint8_t*)m_pClipMask->GetScanline(span_top-clip_top) - clip_left + span_left;
- 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 (col_end < col_start) return; // do nothing.
- dest_scan += col_start << 2;
+ // We should do alpha transition and color transition
+ // alpha fg color fg
+ // alpha bg color bg
+ // alpha cover color cover
+ dest_scan[3] = FXDIB_ALPHA_MERGE(dest_scan[3], m_Alpha, cover_scan);
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, cover_scan);
+ dest_scan++;
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, cover_scan);
+ dest_scan++;
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, cover_scan);
+ dest_scan += 2;
+ }
+}
+void CFX_SkiaRenderer::CompositeSpanARGB_6(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan) {
+ dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + (span_left << 2);
+ clip_scan = (uint8_t*)m_pClipMask->GetScanline(span_top - clip_top) -
+ clip_left + span_left;
+ 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 (col_end < col_start)
+ return; // do nothing.
+ dest_scan += col_start << 2;
#if 1
- int src_alpha = m_Alpha * cover_scan / 255;
- for (int col = col_start; col < col_end; col ++) {
- int src_alpha1 = src_alpha* clip_scan[col] / 255;
- if (!src_alpha1) {
- dest_scan += 4;
- continue;
- }
- if (src_alpha1 == 255) {
- *(FX_DWORD*)dest_scan = m_Color;
- dest_scan += 4;
- } else {
- // Dest format: Argb
- // calculate destination alpha (it's union of source and dest alpha)
- if (dest_scan[3] == 0) {
- dest_scan[3] = src_alpha1;
- *dest_scan++ = m_Blue;
- *dest_scan++ = m_Green;
- *dest_scan = m_Red;
- dest_scan += 2;
- continue;
- }
- uint8_t dest_alpha = dest_scan[3] + src_alpha1 - dest_scan[3] * src_alpha1 / 255;
- dest_scan[3] = dest_alpha;
- int alpha_ratio = src_alpha1*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;
- }
- }
+ int src_alpha = m_Alpha * cover_scan / 255;
+ for (int col = col_start; col < col_end; col++) {
+ int src_alpha1 = src_alpha * clip_scan[col] / 255;
+ if (!src_alpha1) {
+ dest_scan += 4;
+ continue;
+ }
+ if (src_alpha1 == 255) {
+ *(FX_DWORD*)dest_scan = m_Color;
+ dest_scan += 4;
+ } else {
+ // Dest format: Argb
+ // calculate destination alpha (it's union of source and dest alpha)
+ if (dest_scan[3] == 0) {
+ dest_scan[3] = src_alpha1;
+ *dest_scan++ = m_Blue;
+ *dest_scan++ = m_Green;
+ *dest_scan = m_Red;
+ dest_scan += 2;
+ continue;
+ }
+ uint8_t dest_alpha =
+ dest_scan[3] + src_alpha1 - dest_scan[3] * src_alpha1 / 255;
+ dest_scan[3] = dest_alpha;
+ int alpha_ratio = src_alpha1 * 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;
+ }
+ }
#else
- if (m_bFullCover) {
- for (int col = col_start; col < col_end; col ++) {
- int src_alpha = m_Alpha * clip_scan[col] / 255;
- if (!src_alpha) {
- dest_scan += 4;
- continue;
- }
- if (src_alpha == 255){
- *(FX_DWORD*)dest_scan = m_Color;
- dest_scan += 4;
- continue;
- } else {
- // Dest format: Argb
- // calculate destination alpha (it's union of source and dest alpha)
- 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;
- }
- }
- } else {
- int src_alpha = m_Alpha * cover_scan / 255;
- for (int col = col_start; col < col_end; col ++) {
- int src_alpha1 = src_alpha* clip_scan[col] / 255;
- if (!src_alpha1) {
- dest_scan += 4;
- continue;
- }
- if (src_alpha1 == 255) {
- *(FX_DWORD*)dest_scan = m_Color;
- dest_scan += 4;
- } else {
- // Dest format: Argb
- // calculate destination alpha (it's union of source and dest alpha)
- if (dest_scan[3] == 0) {
- dest_scan[3] = src_alpha1;
- *dest_scan++ = m_Blue;
- *dest_scan++ = m_Green;
- *dest_scan = m_Red;
- dest_scan += 2;
- continue;
- }
- uint8_t dest_alpha = dest_scan[3] + src_alpha1 - dest_scan[3] * src_alpha1 / 255;
- dest_scan[3] = dest_alpha;
- int alpha_ratio = src_alpha1*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;
- }
- }
+ if (m_bFullCover) {
+ for (int col = col_start; col < col_end; col++) {
+ int src_alpha = m_Alpha * clip_scan[col] / 255;
+ if (!src_alpha) {
+ dest_scan += 4;
+ continue;
+ }
+ if (src_alpha == 255) {
+ *(FX_DWORD*)dest_scan = m_Color;
+ dest_scan += 4;
+ continue;
+ } else {
+ // Dest format: Argb
+ // calculate destination alpha (it's union of source and dest alpha)
+ 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;
}
-#endif
+ 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;
+ }
}
-
- void CFX_SkiaRenderer::CompositeSpanARGB_7(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan)
- {
- ASSERT(!m_pDevice->IsCmykImage());
- dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + (span_left<<2);
- //ori_scan = (uint8_t*)m_pOriDevice->GetScanline(span_top) + (span_left<<2);
- clip_scan = (uint8_t*)m_pClipMask->GetScanline(span_top-clip_top) - clip_left + span_left;
- 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 (col_end < col_start) return; // do nothing.
- dest_scan += col_start << 2;
- //ori_scan += col_start << 2;
- // Do not need origin bitmap, because of merge in pure transparent background
- for (int col = col_start; col < col_end; col ++)
- {
- int src_alpha = m_Alpha * clip_scan[col] / 255;
- int src_alpha_covered = src_alpha * cover_scan / 255;
- // shortcut
- if (src_alpha_covered == 0){
- dest_scan += 4;
- continue;
- }
- // shortcut
- if (cover_scan == 255 || dest_scan[3] == 0)
- {
- // origin alpha always zero, just get src alpha
- dest_scan[3] = src_alpha_covered;
- *dest_scan ++ = m_Blue;
- *dest_scan ++ = m_Green;
- *dest_scan = m_Red;
- dest_scan += 2;
- continue;
- }
- // We should do alpha transition and color transition
- // alpha fg color fg
- // alpha bg color bg
- // alpha cover color cover
- dest_scan[3] = FXDIB_ALPHA_MERGE(dest_scan[3], src_alpha, cover_scan);
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, cover_scan);
- dest_scan ++;
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, cover_scan);
- dest_scan ++;
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, cover_scan);
- dest_scan += 2;
+ } else {
+ int src_alpha = m_Alpha * cover_scan / 255;
+ for (int col = col_start; col < col_end; col++) {
+ int src_alpha1 = src_alpha * clip_scan[col] / 255;
+ if (!src_alpha1) {
+ dest_scan += 4;
+ continue;
+ }
+ if (src_alpha1 == 255) {
+ *(FX_DWORD*)dest_scan = m_Color;
+ dest_scan += 4;
+ } else {
+ // Dest format: Argb
+ // calculate destination alpha (it's union of source and dest alpha)
+ if (dest_scan[3] == 0) {
+ dest_scan[3] = src_alpha1;
+ *dest_scan++ = m_Blue;
+ *dest_scan++ = m_Green;
+ *dest_scan = m_Red;
+ dest_scan += 2;
+ continue;
}
+ uint8_t dest_alpha =
+ dest_scan[3] + src_alpha1 - dest_scan[3] * src_alpha1 / 255;
+ dest_scan[3] = dest_alpha;
+ int alpha_ratio = src_alpha1 * 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;
+ }
}
+ }
+#endif
+}
- /*-----------------------------------------------------------------------------------------------------------*/
- void CFX_SkiaRenderer::CompositeSpanRGB32_2(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan)
- {
- dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + (span_left<<2);
- 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 (col_end < col_start) return; // do nothing.
- dest_scan += (col_start << 2);
- if (m_Alpha == 255 && cover_scan == 255) {
- FXSYS_memset(dest_scan, m_Color, (col_end - col_start)<<2);
- return;
- }
- int src_alpha;
+void CFX_SkiaRenderer::CompositeSpanARGB_7(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan) {
+ ASSERT(!m_pDevice->IsCmykImage());
+ dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + (span_left << 2);
+ // ori_scan = (uint8_t*)m_pOriDevice->GetScanline(span_top) + (span_left<<2);
+ clip_scan = (uint8_t*)m_pClipMask->GetScanline(span_top - clip_top) -
+ clip_left + span_left;
+ 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 (col_end < col_start)
+ return; // do nothing.
+ dest_scan += col_start << 2;
+ // ori_scan += col_start << 2;
+ // Do not need origin bitmap, because of merge in pure transparent background
+ for (int col = col_start; col < col_end; col++) {
+ int src_alpha = m_Alpha * clip_scan[col] / 255;
+ int src_alpha_covered = src_alpha * cover_scan / 255;
+ // shortcut
+ if (src_alpha_covered == 0) {
+ dest_scan += 4;
+ continue;
+ }
+ // shortcut
+ if (cover_scan == 255 || dest_scan[3] == 0) {
+ // origin alpha always zero, just get src alpha
+ dest_scan[3] = src_alpha_covered;
+ *dest_scan++ = m_Blue;
+ *dest_scan++ = m_Green;
+ *dest_scan = m_Red;
+ dest_scan += 2;
+ continue;
+ }
+ // We should do alpha transition and color transition
+ // alpha fg color fg
+ // alpha bg color bg
+ // alpha cover color cover
+ dest_scan[3] = FXDIB_ALPHA_MERGE(dest_scan[3], src_alpha, cover_scan);
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, cover_scan);
+ dest_scan++;
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, cover_scan);
+ dest_scan++;
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, cover_scan);
+ dest_scan += 2;
+ }
+}
+
+/*-----------------------------------------------------------------------------------------------------------*/
+void CFX_SkiaRenderer::CompositeSpanRGB32_2(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan) {
+ dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + (span_left << 2);
+ 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 (col_end < col_start)
+ return; // do nothing.
+ dest_scan += (col_start << 2);
+ if (m_Alpha == 255 && cover_scan == 255) {
+ FXSYS_memset(dest_scan, m_Color, (col_end - col_start) << 2);
+ return;
+ }
+ int src_alpha;
#if 0
if (m_bFullCover)
src_alpha = m_Alpha;
else
#endif
- src_alpha = m_Alpha * cover_scan / 255;
- for (int col = col_start; col < col_end; col ++) {
- // Dest format: Rgb32
- *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 += 2;
- }
- }
- void CFX_SkiaRenderer::CompositeSpanRGB32_3(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan)
- {
- dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + (span_left<<2);
- ori_scan = (uint8_t*)m_pOriDevice->GetScanline(span_top) + (span_left<<2);
- 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 (col_end < col_start) return; // do nothing.
- dest_scan += col_start << 2;
- ori_scan += col_start << 2;
- if (m_Alpha == 255 && cover_scan == 255) {
- FXSYS_memset(dest_scan, m_Color, (col_end - col_start)<<2);
- return;
- }
- int src_alpha = m_Alpha;
- for (int col = col_start; col < col_end; col ++) {
+ src_alpha = m_Alpha * cover_scan / 255;
+ for (int col = col_start; col < col_end; col++) {
+ // Dest format: Rgb32
+ *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 += 2;
+ }
+}
+void CFX_SkiaRenderer::CompositeSpanRGB32_3(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan) {
+ dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + (span_left << 2);
+ ori_scan = (uint8_t*)m_pOriDevice->GetScanline(span_top) + (span_left << 2);
+ 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 (col_end < col_start)
+ return; // do nothing.
+ dest_scan += col_start << 2;
+ ori_scan += col_start << 2;
+ if (m_Alpha == 255 && cover_scan == 255) {
+ FXSYS_memset(dest_scan, m_Color, (col_end - col_start) << 2);
+ return;
+ }
+ int src_alpha = m_Alpha;
+ for (int col = col_start; col < col_end; col++) {
#if 0
if (m_bFullCover) {
*dest_scan++ = FXDIB_ALPHA_MERGE(*ori_scan++, m_Blue, src_alpha);
@@ -615,231 +740,273 @@
continue;
}
#endif
- 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 += 2;
- *dest_scan = FXDIB_ALPHA_MERGE( *dest_scan, b, cover_scan);
- dest_scan ++;
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, g, cover_scan);
- dest_scan ++;
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, r, cover_scan);
- dest_scan += 2;
- }
- }
- void CFX_SkiaRenderer::CompositeSpanRGB32_6(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan)
- {
- dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + (span_left<<2);
- clip_scan = (uint8_t*)m_pClipMask->GetScanline(span_top-clip_top) - clip_left + span_left;
- 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 (col_end < col_start) return; // do nothing.
- dest_scan += col_start << 2;
+ 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 += 2;
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, b, cover_scan);
+ dest_scan++;
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, g, cover_scan);
+ dest_scan++;
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, r, cover_scan);
+ dest_scan += 2;
+ }
+}
+void CFX_SkiaRenderer::CompositeSpanRGB32_6(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan) {
+ dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + (span_left << 2);
+ clip_scan = (uint8_t*)m_pClipMask->GetScanline(span_top - clip_top) -
+ clip_left + span_left;
+ 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 (col_end < col_start)
+ return; // do nothing.
+ dest_scan += col_start << 2;
#if 1
- int src_alpha = m_Alpha * cover_scan / 255;
- for (int col = col_start; col < col_end; col ++) {
- int src_alpha1 = src_alpha * clip_scan[col] / 255;
- if (!src_alpha1) {
- dest_scan += 4;
- continue;
- }
- if (src_alpha1 == 255) {
- *(FX_DWORD*)dest_scan = m_Color;
- dest_scan += 4;
- } else {
- // Dest format: Rgb or Rgb32
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, src_alpha1);
- dest_scan ++;
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, src_alpha1);
- dest_scan ++;
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, src_alpha1);
- dest_scan += 2;
- }
- }
+ int src_alpha = m_Alpha * cover_scan / 255;
+ for (int col = col_start; col < col_end; col++) {
+ int src_alpha1 = src_alpha * clip_scan[col] / 255;
+ if (!src_alpha1) {
+ dest_scan += 4;
+ continue;
+ }
+ if (src_alpha1 == 255) {
+ *(FX_DWORD*)dest_scan = m_Color;
+ dest_scan += 4;
+ } else {
+ // Dest format: Rgb or Rgb32
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, src_alpha1);
+ dest_scan++;
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, src_alpha1);
+ dest_scan++;
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, src_alpha1);
+ dest_scan += 2;
+ }
+ }
#else
- if (m_bFullCover) {
- for (int col = col_start; col < col_end; col ++) {
- int src_alpha = m_Alpha * clip_scan[col] / 255;
- if (!src_alpha) {
- dest_scan += 4;
- continue;
- }
- if (src_alpha == 255) {
- *(FX_DWORD*)dest_scan = m_Color;
- dest_scan += 4;
- } else {
- // Dest format: Rgb or Rgb32
- *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 += 2;
- }
- }
- } else {
- // Rgb32
- int src_alpha = m_Alpha * cover_scan / 255;
- for (int col = col_start; col < col_end; col ++) {
- int src_alpha1 = src_alpha * clip_scan[col] / 255;
- if (!src_alpha1) {
- dest_scan += 4;
- continue;
- }
- if (src_alpha1 == 255) {
- *(FX_DWORD*)dest_scan = m_Color;
- dest_scan += 4;
- } else {
- // Dest format: Rgb or Rgb32
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, src_alpha1);
- dest_scan ++;
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, src_alpha1);
- dest_scan ++;
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, src_alpha1);
- dest_scan += 2;
- }
- }
- }
-#endif
+ if (m_bFullCover) {
+ for (int col = col_start; col < col_end; col++) {
+ int src_alpha = m_Alpha * clip_scan[col] / 255;
+ if (!src_alpha) {
+ dest_scan += 4;
+ continue;
+ }
+ if (src_alpha == 255) {
+ *(FX_DWORD*)dest_scan = m_Color;
+ dest_scan += 4;
+ } else {
+ // Dest format: Rgb or Rgb32
+ *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 += 2;
+ }
}
- void CFX_SkiaRenderer::CompositeSpanRGB32_7(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan)
- {
- ASSERT(!m_pDevice->IsCmykImage());
- dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + (span_left<<2);
- ori_scan = (uint8_t*)m_pOriDevice->GetScanline(span_top) + (span_left<<2);
- clip_scan = (uint8_t*)m_pClipMask->GetScanline(span_top-clip_top) - clip_left + span_left;
- 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 (col_end < col_start) return; // do nothing.
- dest_scan += col_start << 2;
- ori_scan += col_start << 2;
+ } else {
+ // Rgb32
+ int src_alpha = m_Alpha * cover_scan / 255;
+ for (int col = col_start; col < col_end; col++) {
+ int src_alpha1 = src_alpha * clip_scan[col] / 255;
+ if (!src_alpha1) {
+ dest_scan += 4;
+ continue;
+ }
+ if (src_alpha1 == 255) {
+ *(FX_DWORD*)dest_scan = m_Color;
+ dest_scan += 4;
+ } else {
+ // Dest format: Rgb or Rgb32
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, src_alpha1);
+ dest_scan++;
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, src_alpha1);
+ dest_scan++;
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, src_alpha1);
+ dest_scan += 2;
+ }
+ }
+ }
+#endif
+}
+void CFX_SkiaRenderer::CompositeSpanRGB32_7(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan) {
+ ASSERT(!m_pDevice->IsCmykImage());
+ dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + (span_left << 2);
+ ori_scan = (uint8_t*)m_pOriDevice->GetScanline(span_top) + (span_left << 2);
+ clip_scan = (uint8_t*)m_pClipMask->GetScanline(span_top - clip_top) -
+ clip_left + span_left;
+ 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 (col_end < col_start)
+ return; // do nothing.
+ dest_scan += col_start << 2;
+ ori_scan += col_start << 2;
#if 1
- for (int col = col_start; col < col_end; col ++) {
- int src_alpha = m_Alpha * clip_scan[col] / 255;
- if (src_alpha == 255 && cover_scan == 255) {
- *(FX_DWORD*)dest_scan = m_Color;
- dest_scan += 4;
- ori_scan += 4;
- 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 += 2;
- *dest_scan = FXDIB_ALPHA_MERGE( *dest_scan, b, cover_scan);
- dest_scan ++;
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, g, cover_scan);
- dest_scan ++;
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, r, cover_scan);
- dest_scan += 2;
- }
+ for (int col = col_start; col < col_end; col++) {
+ int src_alpha = m_Alpha * clip_scan[col] / 255;
+ if (src_alpha == 255 && cover_scan == 255) {
+ *(FX_DWORD*)dest_scan = m_Color;
+ dest_scan += 4;
+ ori_scan += 4;
+ 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 += 2;
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, b, cover_scan);
+ dest_scan++;
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, g, cover_scan);
+ dest_scan++;
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, r, cover_scan);
+ dest_scan += 2;
+ }
#else
- if (m_bFullCover) {
- for (int col = col_start; col < col_end; col ++) {
- int src_alpha = m_Alpha * clip_scan[col] / 255;
- if (!src_alpha) {
- *(FX_DWORD*)dest_scan = *(FX_DWORD*)ori_scan;
- dest_scan += 4;
- ori_scan += 4;
- continue;
- }
- if (src_alpha == 255) {
- *(FX_DWORD*)dest_scan = m_Color;
- dest_scan += 4;
- ori_scan += 4;
- continue;
- }
- *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 += 2; ori_scan += 2;
- }
- } else {
- for (int col = col_start; col < col_end; col ++) {
- int src_alpha = m_Alpha * clip_scan[col] / 255;
- if (src_alpha == 255 && cover_scan == 255) {
- *(FX_DWORD*)dest_scan = m_Color;
- dest_scan += 4;
- ori_scan += 4;
- 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 += 2;
- *dest_scan = FXDIB_ALPHA_MERGE( *dest_scan, b, cover_scan);
- dest_scan ++;
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, g, cover_scan);
- dest_scan ++;
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, r, cover_scan);
- dest_scan += 2;
- }
- }
-#endif
+ if (m_bFullCover) {
+ for (int col = col_start; col < col_end; col++) {
+ int src_alpha = m_Alpha * clip_scan[col] / 255;
+ if (!src_alpha) {
+ *(FX_DWORD*)dest_scan = *(FX_DWORD*)ori_scan;
+ dest_scan += 4;
+ ori_scan += 4;
+ continue;
+ }
+ if (src_alpha == 255) {
+ *(FX_DWORD*)dest_scan = m_Color;
+ dest_scan += 4;
+ ori_scan += 4;
+ continue;
+ }
+ *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 += 2;
+ ori_scan += 2;
}
- /*-----------------------------------------------------------------------------------------------------*/
- void CFX_SkiaRenderer::CompositeSpanRGB24_2(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan)
- {
- dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + span_left + (span_left<<1);
- 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 (col_end < col_start) return; // do nothing.
- dest_scan += (col_start<<1)+col_start;
- int src_alpha;
+ } else {
+ for (int col = col_start; col < col_end; col++) {
+ int src_alpha = m_Alpha * clip_scan[col] / 255;
+ if (src_alpha == 255 && cover_scan == 255) {
+ *(FX_DWORD*)dest_scan = m_Color;
+ dest_scan += 4;
+ ori_scan += 4;
+ 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 += 2;
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, b, cover_scan);
+ dest_scan++;
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, g, cover_scan);
+ dest_scan++;
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, r, cover_scan);
+ dest_scan += 2;
+ }
+ }
+#endif
+}
+/*-----------------------------------------------------------------------------------------------------*/
+void CFX_SkiaRenderer::CompositeSpanRGB24_2(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan) {
+ dest_scan =
+ (uint8_t*)m_pDevice->GetScanline(span_top) + span_left + (span_left << 1);
+ 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 (col_end < col_start)
+ return; // do nothing.
+ dest_scan += (col_start << 1) + col_start;
+ int src_alpha;
#if 0
if (m_bFullCover)
src_alpha = m_Alpha;
else
#endif
- src_alpha = m_Alpha * cover_scan / 255;
- if (src_alpha == 255) {
- for (int col = col_start; col < col_end; col ++) {
- *dest_scan++ = m_Blue;
- *dest_scan++ = m_Green;
- *dest_scan++ = m_Red;
- }
- return;
- }
- for (int col = col_start; col < col_end; col ++) {
- *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 ++;
- }
+ src_alpha = m_Alpha * cover_scan / 255;
+ if (src_alpha == 255) {
+ for (int col = col_start; col < col_end; col++) {
+ *dest_scan++ = m_Blue;
+ *dest_scan++ = m_Green;
+ *dest_scan++ = m_Red;
}
- void CFX_SkiaRenderer::CompositeSpanRGB24_3(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan)
- {
- ASSERT(!m_pDevice->IsCmykImage());
- dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + span_left + (span_left<<1);
- ori_scan = (uint8_t*)m_pOriDevice->GetScanline(span_top) + span_left + (span_left<<1);
- 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 (col_end < col_start) return; // do nothing.
- dest_scan += (col_start<<1) + col_start;
- ori_scan += (col_start<<1) + col_start;
- if (m_Alpha == 255&&cover_scan == 255) {
- for (int col = col_start; col < col_end; col ++) {
- *dest_scan ++ = m_Blue;
- *dest_scan ++ = m_Green;
- *dest_scan ++ = m_Red;
- }
- return;
- }
- for (int col = col_start; col < col_end; col ++) {
+ return;
+ }
+ for (int col = col_start; col < col_end; col++) {
+ *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++;
+ }
+}
+void CFX_SkiaRenderer::CompositeSpanRGB24_3(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan) {
+ ASSERT(!m_pDevice->IsCmykImage());
+ dest_scan =
+ (uint8_t*)m_pDevice->GetScanline(span_top) + span_left + (span_left << 1);
+ ori_scan = (uint8_t*)m_pOriDevice->GetScanline(span_top) + span_left +
+ (span_left << 1);
+ 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 (col_end < col_start)
+ return; // do nothing.
+ dest_scan += (col_start << 1) + col_start;
+ ori_scan += (col_start << 1) + col_start;
+ if (m_Alpha == 255 && cover_scan == 255) {
+ for (int col = col_start; col < col_end; col++) {
+ *dest_scan++ = m_Blue;
+ *dest_scan++ = m_Green;
+ *dest_scan++ = m_Red;
+ }
+ return;
+ }
+ for (int col = col_start; col < col_end; col++) {
#if 0
if (m_bFullCover) {
*dest_scan++ = FXDIB_ALPHA_MERGE(*ori_scan++, m_Blue, m_Alpha);
@@ -848,762 +1015,834 @@
continue;
}
#endif
- int b = FXDIB_ALPHA_MERGE(*ori_scan++, m_Blue, m_Alpha);
- int g = FXDIB_ALPHA_MERGE(*ori_scan++, m_Green, m_Alpha);
- int r = FXDIB_ALPHA_MERGE(*ori_scan++, m_Red, m_Alpha);
- *dest_scan = FXDIB_ALPHA_MERGE( *dest_scan, b, cover_scan);
- dest_scan ++;
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, g, cover_scan);
- dest_scan ++;
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, r, cover_scan);
- dest_scan ++;
- }
- }
- void CFX_SkiaRenderer::CompositeSpanRGB24_6(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan)
- {
- dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + span_left+(span_left<<1);
- clip_scan = (uint8_t*)m_pClipMask->GetScanline(span_top-clip_top) - clip_left + span_left;
- 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 (col_end < col_start) return; // do nothing.
- dest_scan += col_start + (col_start << 1);
+ int b = FXDIB_ALPHA_MERGE(*ori_scan++, m_Blue, m_Alpha);
+ int g = FXDIB_ALPHA_MERGE(*ori_scan++, m_Green, m_Alpha);
+ int r = FXDIB_ALPHA_MERGE(*ori_scan++, m_Red, m_Alpha);
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, b, cover_scan);
+ dest_scan++;
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, g, cover_scan);
+ dest_scan++;
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, r, cover_scan);
+ dest_scan++;
+ }
+}
+void CFX_SkiaRenderer::CompositeSpanRGB24_6(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan) {
+ dest_scan =
+ (uint8_t*)m_pDevice->GetScanline(span_top) + span_left + (span_left << 1);
+ clip_scan = (uint8_t*)m_pClipMask->GetScanline(span_top - clip_top) -
+ clip_left + span_left;
+ 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 (col_end < col_start)
+ return; // do nothing.
+ dest_scan += col_start + (col_start << 1);
#if 1
- int src_alpha = m_Alpha * cover_scan /255;
- for (int col = col_start; col < col_end; col ++) {
- int src_alpha1 = src_alpha * clip_scan[col] / 255;
- if (!src_alpha1) {
- dest_scan += 3;
- continue;
- }
- if (src_alpha1 == 255) {
- *dest_scan++ = m_Blue;
- *dest_scan++ = m_Green;
- *dest_scan++ = m_Red;
- } else {
- // Dest format: Rgb
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, src_alpha1);
- dest_scan ++;
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, src_alpha1);
- dest_scan ++;
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, src_alpha1);
- dest_scan ++;
- }
- }
+ int src_alpha = m_Alpha * cover_scan / 255;
+ for (int col = col_start; col < col_end; col++) {
+ int src_alpha1 = src_alpha * clip_scan[col] / 255;
+ if (!src_alpha1) {
+ dest_scan += 3;
+ continue;
+ }
+ if (src_alpha1 == 255) {
+ *dest_scan++ = m_Blue;
+ *dest_scan++ = m_Green;
+ *dest_scan++ = m_Red;
+ } else {
+ // Dest format: Rgb
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, src_alpha1);
+ dest_scan++;
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, src_alpha1);
+ dest_scan++;
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, src_alpha1);
+ dest_scan++;
+ }
+ }
#else
- if (m_bFullCover) {
- for (int col = col_start; col < col_end; col ++) {
- int src_alpha = m_Alpha * clip_scan[col] / 255;
- if (!src_alpha) {
- dest_scan += 3;
- continue;
- }
- if (src_alpha == 255) {
- *dest_scan++ = m_Blue;
- *dest_scan++ = m_Green;
- *dest_scan++ = m_Red;
- } else {
- // Dest format: Rgb
- *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 ++;
- }
- }
- } else {
- int src_alpha = m_Alpha * cover_scan /255;
- for (int col = col_start; col < col_end; col ++) {
- int src_alpha1 = src_alpha * clip_scan[col] / 255;
- if (!src_alpha1) {
- dest_scan += 3;
- continue;
- }
- if (src_alpha1 == 255) {
- *dest_scan++ = m_Blue;
- *dest_scan++ = m_Green;
- *dest_scan++ = m_Red;
- } else {
- // Dest format: Rgb
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, src_alpha1);
- dest_scan ++;
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, src_alpha1);
- dest_scan ++;
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, src_alpha1);
- dest_scan ++;
- }
- }
- }
-#endif
+ if (m_bFullCover) {
+ for (int col = col_start; col < col_end; col++) {
+ int src_alpha = m_Alpha * clip_scan[col] / 255;
+ if (!src_alpha) {
+ dest_scan += 3;
+ continue;
+ }
+ if (src_alpha == 255) {
+ *dest_scan++ = m_Blue;
+ *dest_scan++ = m_Green;
+ *dest_scan++ = m_Red;
+ } else {
+ // Dest format: Rgb
+ *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++;
+ }
}
- void CFX_SkiaRenderer::CompositeSpanRGB24_7(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan)
- {
- ASSERT(!m_pDevice->IsCmykImage());
- dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + span_left+(span_left<<1);
- ori_scan = (uint8_t*)m_pOriDevice->GetScanline(span_top) + span_left+(span_left<<1);
- clip_scan = (uint8_t*)m_pClipMask->GetScanline(span_top-clip_top) - clip_left + span_left;
- 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 (col_end < col_start) return; // do nothing.
- dest_scan += col_start + (col_start<<1);
- ori_scan += col_start + (col_start<<1);
+ } else {
+ int src_alpha = m_Alpha * cover_scan / 255;
+ for (int col = col_start; col < col_end; col++) {
+ int src_alpha1 = src_alpha * clip_scan[col] / 255;
+ if (!src_alpha1) {
+ dest_scan += 3;
+ continue;
+ }
+ if (src_alpha1 == 255) {
+ *dest_scan++ = m_Blue;
+ *dest_scan++ = m_Green;
+ *dest_scan++ = m_Red;
+ } else {
+ // Dest format: Rgb
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, src_alpha1);
+ dest_scan++;
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, src_alpha1);
+ dest_scan++;
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, src_alpha1);
+ dest_scan++;
+ }
+ }
+ }
+#endif
+}
+void CFX_SkiaRenderer::CompositeSpanRGB24_7(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan) {
+ ASSERT(!m_pDevice->IsCmykImage());
+ dest_scan =
+ (uint8_t*)m_pDevice->GetScanline(span_top) + span_left + (span_left << 1);
+ ori_scan = (uint8_t*)m_pOriDevice->GetScanline(span_top) + span_left +
+ (span_left << 1);
+ clip_scan = (uint8_t*)m_pClipMask->GetScanline(span_top - clip_top) -
+ clip_left + span_left;
+ 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 (col_end < col_start)
+ return; // do nothing.
+ dest_scan += col_start + (col_start << 1);
+ ori_scan += col_start + (col_start << 1);
#if 1
- for (int col = col_start; col < col_end; col ++) {
- int src_alpha = m_Alpha * clip_scan[col] / 255;
- if (src_alpha == 255 && cover_scan == 255) {
- *dest_scan++ = m_Blue;
- *dest_scan++ = m_Green;
- *dest_scan++ = m_Red;
- ori_scan += 3;
- 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);
- *dest_scan = FXDIB_ALPHA_MERGE( *dest_scan, b, cover_scan);
- dest_scan ++;
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, g, cover_scan);
- dest_scan ++;
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, r, cover_scan);
- dest_scan ++;
- }
+ for (int col = col_start; col < col_end; col++) {
+ int src_alpha = m_Alpha * clip_scan[col] / 255;
+ if (src_alpha == 255 && cover_scan == 255) {
+ *dest_scan++ = m_Blue;
+ *dest_scan++ = m_Green;
+ *dest_scan++ = m_Red;
+ ori_scan += 3;
+ 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);
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, b, cover_scan);
+ dest_scan++;
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, g, cover_scan);
+ dest_scan++;
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, r, cover_scan);
+ dest_scan++;
+ }
#else
- if (m_bFullCover) {
- for (int col = col_start; col < col_end; col ++) {
- int src_alpha = m_Alpha * clip_scan[col] / 255;
- if (!src_alpha){
- *dest_scan++ = *ori_scan++;
- *dest_scan++ = *ori_scan++;
- *dest_scan++ = *ori_scan++;
- continue;
- }
- if (src_alpha == 255){
- *dest_scan++ = m_Blue;
- *dest_scan++ = m_Green;
- *dest_scan++ = m_Red;
- ori_scan += 3;
- continue;
- }
- *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);
- }
- } else {
- for (int col = col_start; col < col_end; col ++) {
- int src_alpha = m_Alpha * clip_scan[col] / 255;
- if (src_alpha == 255 && cover_scan == 255) {
- *dest_scan++ = m_Blue;
- *dest_scan++ = m_Green;
- *dest_scan++ = m_Red;
- ori_scan += 3;
- 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);
- *dest_scan = FXDIB_ALPHA_MERGE( *dest_scan, b, cover_scan);
- dest_scan ++;
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, g, cover_scan);
- dest_scan ++;
- *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, r, cover_scan);
- dest_scan ++;
- }
- }
-#endif
+ if (m_bFullCover) {
+ for (int col = col_start; col < col_end; col++) {
+ int src_alpha = m_Alpha * clip_scan[col] / 255;
+ if (!src_alpha) {
+ *dest_scan++ = *ori_scan++;
+ *dest_scan++ = *ori_scan++;
+ *dest_scan++ = *ori_scan++;
+ continue;
+ }
+ if (src_alpha == 255) {
+ *dest_scan++ = m_Blue;
+ *dest_scan++ = m_Green;
+ *dest_scan++ = m_Red;
+ ori_scan += 3;
+ continue;
+ }
+ *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);
}
- void CFX_SkiaRenderer::CompositeSpanRGB24_10(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan)
- {
- dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + span_left+(span_left<<1);
- dest_extra_alpha_scan = (uint8_t*)m_pDevice->m_pAlphaMask->GetScanline(span_top)+span_left;
- 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 (col_end < col_start) return; // do nothing.
- dest_scan += col_start+(col_start<<1);
+ } else {
+ for (int col = col_start; col < col_end; col++) {
+ int src_alpha = m_Alpha * clip_scan[col] / 255;
+ if (src_alpha == 255 && cover_scan == 255) {
+ *dest_scan++ = m_Blue;
+ *dest_scan++ = m_Green;
+ *dest_scan++ = m_Red;
+ ori_scan += 3;
+ 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);
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, b, cover_scan);
+ dest_scan++;
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, g, cover_scan);
+ dest_scan++;
+ *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, r, cover_scan);
+ dest_scan++;
+ }
+ }
+#endif
+}
+void CFX_SkiaRenderer::CompositeSpanRGB24_10(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan) {
+ dest_scan =
+ (uint8_t*)m_pDevice->GetScanline(span_top) + span_left + (span_left << 1);
+ dest_extra_alpha_scan =
+ (uint8_t*)m_pDevice->m_pAlphaMask->GetScanline(span_top) + span_left;
+ 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 (col_end < col_start)
+ return; // do nothing.
+ dest_scan += col_start + (col_start << 1);
#if 1
- if (m_Alpha == 255 && cover_scan == 255) {
- for (int col = col_start; col < col_end; col ++) {
- *dest_scan++ = (uint8_t)m_Blue;
- *dest_scan++ = (uint8_t)m_Green;
- *dest_scan++ = (uint8_t)m_Red;
- *dest_extra_alpha_scan++ = 255;
- }
- return;
- }
- int src_alpha = m_Alpha * cover_scan / 255;
- for (int col = col_start; col < col_end; col ++) {
- // Dest format: Rgba
- // calculate destination alpha (it's union of source and dest alpha)
- 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 ++;
- }
+ if (m_Alpha == 255 && cover_scan == 255) {
+ for (int col = col_start; col < col_end; col++) {
+ *dest_scan++ = (uint8_t)m_Blue;
+ *dest_scan++ = (uint8_t)m_Green;
+ *dest_scan++ = (uint8_t)m_Red;
+ *dest_extra_alpha_scan++ = 255;
+ }
+ return;
+ }
+ int src_alpha = m_Alpha * cover_scan / 255;
+ for (int col = col_start; col < col_end; col++) {
+ // Dest format: Rgba
+ // calculate destination alpha (it's union of source and dest alpha)
+ 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++;
+ }
#else
- if (m_bFullCover) {
- if (m_Alpha == 255) {
- for (int col = col_start; col < col_end; col ++) {
- *dest_scan++ = (uint8_t)m_Blue;
- *dest_scan++ = (uint8_t)m_Green;
- *dest_scan++ = (uint8_t)m_Red;
- *dest_extra_alpha_scan++ = 255;
- }
- return;
- }
- for (int col = col_start; col < col_end; col ++) {
- // Dest format: Rgba
- // calculate destination alpha (it's union of source and dest alpha)
- uint8_t dest_alpha = (*dest_extra_alpha_scan) + m_Alpha -
- (*dest_extra_alpha_scan) * m_Alpha / 255;
- *dest_extra_alpha_scan++ = dest_alpha;
- int alpha_ratio = m_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 ++;
- }
- } else {
- if (m_Alpha == 255 && cover_scan == 255) {
- for (int col = col_start; col < col_end; col ++) {
- *dest_scan++ = (uint8_t)m_Blue;
- *dest_scan++ = (uint8_t)m_Green;
- *dest_scan++ = (uint8_t)m_Red;
- *dest_extra_alpha_scan++ = 255;
- }
- return;
- }
- int src_alpha = m_Alpha * cover_scan / 255;
- for (int col = col_start; col < col_end; col ++) {
- // Dest format: Rgba
- // calculate destination alpha (it's union of source and dest alpha)
- 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 ++;
- }
- }
-#endif
+ if (m_bFullCover) {
+ if (m_Alpha == 255) {
+ for (int col = col_start; col < col_end; col++) {
+ *dest_scan++ = (uint8_t)m_Blue;
+ *dest_scan++ = (uint8_t)m_Green;
+ *dest_scan++ = (uint8_t)m_Red;
+ *dest_extra_alpha_scan++ = 255;
+ }
+ return;
+ }
+ for (int col = col_start; col < col_end; col++) {
+ // Dest format: Rgba
+ // calculate destination alpha (it's union of source and dest alpha)
+ uint8_t dest_alpha = (*dest_extra_alpha_scan) + m_Alpha -
+ (*dest_extra_alpha_scan) * m_Alpha / 255;
+ *dest_extra_alpha_scan++ = dest_alpha;
+ int alpha_ratio = m_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++;
}
- void CFX_SkiaRenderer::CompositeSpanRGB24_14(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan)
- {
- dest_scan = (uint8_t*)m_pDevice->GetScanline(span_top) + span_left+(span_left<<1);
- dest_extra_alpha_scan = (uint8_t*)m_pDevice->m_pAlphaMask->GetScanline(span_top)+span_left;
- clip_scan = (uint8_t*)m_pClipMask->GetScanline(span_top-clip_top) - clip_left + span_left;
- 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 (col_end < col_start) return; // do nothing.
- dest_scan += col_start + (col_start << 1);
+ } else {
+ if (m_Alpha == 255 && cover_scan == 255) {
+ for (int col = col_start; col < col_end; col++) {
+ *dest_scan++ = (uint8_t)m_Blue;
+ *dest_scan++ = (uint8_t)m_Green;
+ *dest_scan++ = (uint8_t)m_Red;
+ *dest_extra_alpha_scan++ = 255;
+ }
+ return;
+ }
+ int src_alpha = m_Alpha * cover_scan / 255;
+ for (int col = col_start; col < col_end; col++) {
+ // Dest format: Rgba
+ // calculate destination alpha (it's union of source and dest alpha)
+ 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++;
+ }
+ }
+#endif
+}
+void CFX_SkiaRenderer::CompositeSpanRGB24_14(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan) {
+ dest_scan =
+ (uint8_t*)m_pDevice->GetScanline(span_top) + span_left + (span_left << 1);
+ dest_extra_alpha_scan =
+ (uint8_t*)m_pDevice->m_pAlphaMask->GetScanline(span_top) + span_left;
+ clip_scan = (uint8_t*)m_pClipMask->GetScanline(span_top - clip_top) -
+ clip_left + span_left;
+ 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 (col_end < col_start)
+ return; // do nothing.
+ dest_scan += col_start + (col_start << 1);
#if 1
- int src_alpha = m_Alpha * cover_scan / 255;
- for (int col = col_start; col < col_end; col ++) {
- int src_alpha1 = src_alpha * clip_scan[col] / 255;
- if (!src_alpha1) {
- dest_extra_alpha_scan++;
- dest_scan += 3;
- continue;
- }
- if (src_alpha1 == 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;
- } else {
- // Dest format: Rgba
- // calculate destination alpha (it's union of source and dest alpha)
- uint8_t dest_alpha = (*dest_extra_alpha_scan) + src_alpha1 -
- (*dest_extra_alpha_scan) * src_alpha1 / 255;
- *dest_extra_alpha_scan++ = dest_alpha;
- int alpha_ratio = src_alpha1*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 ++;
- }
- }
+ int src_alpha = m_Alpha * cover_scan / 255;
+ for (int col = col_start; col < col_end; col++) {
+ int src_alpha1 = src_alpha * clip_scan[col] / 255;
+ if (!src_alpha1) {
+ dest_extra_alpha_scan++;
+ dest_scan += 3;
+ continue;
+ }
+ if (src_alpha1 == 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;
+ } else {
+ // Dest format: Rgba
+ // calculate destination alpha (it's union of source and dest alpha)
+ uint8_t dest_alpha = (*dest_extra_alpha_scan) + src_alpha1 -
+ (*dest_extra_alpha_scan) * src_alpha1 / 255;
+ *dest_extra_alpha_scan++ = dest_alpha;
+ int alpha_ratio = src_alpha1 * 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++;
+ }
+ }
#else
- if (m_bFullCover) {
- for (int col = col_start; col < col_end; col ++) {
- int src_alpha = m_Alpha * clip_scan[col] / 255;
- if (!src_alpha) {
- dest_extra_alpha_scan++;
- dest_scan += 3;
- continue;
- }
- 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;
- } else {
- // Dest format: Rgba
- // calculate destination alpha (it's union of source and dest alpha)
- 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 ++;
- }
- }
- } else {
- int src_alpha = m_Alpha * cover_scan / 255;
- for (int col = col_start; col < col_end; col ++) {
- int src_alpha1 = m_Alpha * cover_scan * clip_scan[col] / 255;
- if (!src_alpha1) {
- dest_extra_alpha_scan++;
- dest_scan += 3;
- continue;
- }
- if (src_alpha1 == 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;
- } else {
- // Dest format: Rgba
- // calculate destination alpha (it's union of source and dest alpha)
- uint8_t dest_alpha = (*dest_extra_alpha_scan) + src_alpha1 -
- (*dest_extra_alpha_scan) * src_alpha1 / 255;
- *dest_extra_alpha_scan++ = dest_alpha;
- int alpha_ratio = src_alpha1*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 ++;
- }
- }
- }
-#endif
+ if (m_bFullCover) {
+ for (int col = col_start; col < col_end; col++) {
+ int src_alpha = m_Alpha * clip_scan[col] / 255;
+ if (!src_alpha) {
+ dest_extra_alpha_scan++;
+ dest_scan += 3;
+ continue;
+ }
+ 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;
+ } else {
+ // Dest format: Rgba
+ // calculate destination alpha (it's union of source and dest alpha)
+ 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++;
+ }
+ }
+ } else {
+ int src_alpha = m_Alpha * cover_scan / 255;
+ for (int col = col_start; col < col_end; col++) {
+ int src_alpha1 = m_Alpha * cover_scan * clip_scan[col] / 255;
+ if (!src_alpha1) {
+ dest_extra_alpha_scan++;
+ dest_scan += 3;
+ continue;
+ }
+ if (src_alpha1 == 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;
+ } else {
+ // Dest format: Rgba
+ // calculate destination alpha (it's union of source and dest alpha)
+ uint8_t dest_alpha = (*dest_extra_alpha_scan) + src_alpha1 -
+ (*dest_extra_alpha_scan) * src_alpha1 / 255;
+ *dest_extra_alpha_scan++ = dest_alpha;
+ int alpha_ratio = src_alpha1 * 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++;
+ }
}
- /*-----------------------------------------------------------------------------------------------------*/
+ }
+#endif
+}
+/*-----------------------------------------------------------------------------------------------------*/
- // A general alpha merge function (with clipping mask). Cmyka/Cmyk device.
- void CFX_SkiaRenderer::CompositeSpanCMYK(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan)
- {
- ASSERT(!m_bRgbByteOrder);
- // Cmyk(a)
- 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 (col_end < col_start) return; // do nothing.
- dest_scan += col_start * 4;
- Bpp; // for avoid compile warning.
+// A general alpha merge function (with clipping mask). Cmyka/Cmyk device.
+void CFX_SkiaRenderer::CompositeSpanCMYK(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan) {
+ ASSERT(!m_bRgbByteOrder);
+ // Cmyk(a)
+ 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 (col_end < col_start)
+ return; // do nothing.
+ dest_scan += col_start * 4;
+ Bpp; // for avoid compile warning.
- if (dest_extra_alpha_scan) {
- // CMYKa
- 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 * clip_scan[col] / 255 / 255;
- else
- src_alpha = m_Alpha * cover_scan / 255;
- }
+ if (dest_extra_alpha_scan) {
+ // CMYKa
+ 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 * clip_scan[col] / 255 / 255;
+ else
+ src_alpha = m_Alpha * cover_scan / 255;
+ }
- if (src_alpha) {
- if (src_alpha == 255) {
- *(FX_CMYK*)dest_scan = m_Color;
- *dest_extra_alpha_scan = (uint8_t)m_Alpha;
- } else {
- // Dest format: Cmyka
- // calculate destination alpha (it's union of source and dest alpha)
- 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) {
+ *(FX_CMYK*)dest_scan = m_Color;
+ *dest_extra_alpha_scan = (uint8_t)m_Alpha;
} else {
- // CMYK
- for (int col = col_start; col < col_end; col ++) {
- int src_alpha;
- if (clip_scan)
- src_alpha = m_Alpha * cover_scan * clip_scan[col] / 255 / 255;
- else
- src_alpha = m_Alpha * cover_scan / 255;
-
- if (src_alpha) {
- if (src_alpha == 255) {
- *(FX_CMYK*)dest_scan = m_Color;
- } else {
- // Dest format: cmyk
- *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;
- }
+ // Dest format: Cmyka
+ // calculate destination alpha (it's union of source and dest alpha)
+ 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;
}
+ } else {
+ // CMYK
+ for (int col = col_start; col < col_end; col++) {
+ int src_alpha;
+ if (clip_scan)
+ src_alpha = m_Alpha * cover_scan * clip_scan[col] / 255 / 255;
+ else
+ src_alpha = m_Alpha * cover_scan / 255;
-
-
- //--------------------------------------------------------------------
- FX_BOOL CFX_SkiaRenderer::Init(CFX_DIBitmap* pDevice, CFX_DIBitmap* pOriDevice, const CFX_ClipRgn* pClipRgn, FX_DWORD color, FX_BOOL bFullCover, FX_BOOL bRgbByteOrder,
- int alpha_flag, void* pIccTransform) //The alpha flag must be fill_flag if exist.
- {
- m_pDevice = pDevice;
- m_pClipRgn = pClipRgn;
- m_bRgbByteOrder = bRgbByteOrder;
- m_pOriDevice = pOriDevice;
- m_pDestScan = NULL;
- m_pDestExtraAlphaScan = NULL;
- m_pOriScan = NULL;
- m_pClipScan = NULL;
- composite_span = NULL;
- 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_pClipScan = m_pClipMask->GetBuffer();
+ if (src_alpha) {
+ if (src_alpha == 255) {
+ *(FX_CMYK*)dest_scan = m_Color;
+ } else {
+ // Dest format: cmyk
+ *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;
}
- if (m_pDevice->m_pAlphaMask)
- m_pDestExtraAlphaScan = m_pDevice->m_pAlphaMask->GetBuffer();
- if (m_pOriDevice)
- m_pOriScan = m_pOriDevice->GetBuffer();
- m_pDestScan = m_pDevice->GetBuffer();
-
- m_bFullCover = bFullCover;
+ }
+ dest_scan += 4;
+ }
+ }
+}
- FX_BOOL bObjectCMYK = FXGETFLAG_COLORTYPE(alpha_flag);
- FX_BOOL bDeviceCMYK = pDevice->IsCmykImage();
+//--------------------------------------------------------------------
+FX_BOOL CFX_SkiaRenderer::Init(
+ CFX_DIBitmap* pDevice,
+ CFX_DIBitmap* pOriDevice,
+ const CFX_ClipRgn* pClipRgn,
+ FX_DWORD color,
+ FX_BOOL bFullCover,
+ FX_BOOL bRgbByteOrder,
+ int alpha_flag,
+ void* pIccTransform) // The alpha flag must be fill_flag if exist.
+{
+ m_pDevice = pDevice;
+ m_pClipRgn = pClipRgn;
+ m_bRgbByteOrder = bRgbByteOrder;
+ m_pOriDevice = pOriDevice;
+ m_pDestScan = NULL;
+ m_pDestExtraAlphaScan = NULL;
+ m_pOriScan = NULL;
+ m_pClipScan = NULL;
+ composite_span = NULL;
+ 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_pClipScan = m_pClipMask->GetBuffer();
+ }
+ if (m_pDevice->m_pAlphaMask)
+ m_pDestExtraAlphaScan = m_pDevice->m_pAlphaMask->GetBuffer();
+ if (m_pOriDevice)
+ m_pOriScan = m_pOriDevice->GetBuffer();
+ m_pDestScan = m_pDevice->GetBuffer();
- m_Alpha = bObjectCMYK ? FXGETFLAG_ALPHA_FILL(alpha_flag) : FXARGB_A(color);
+ m_bFullCover = bFullCover;
- ICodec_IccModule* pIccModule = NULL;
- // No lcms engine, we skip the transform
- if (!CFX_GEModule::Get()->GetCodecModule() || !CFX_GEModule::Get()->GetCodecModule()->GetIccModule())
- pIccTransform = NULL;
- else
- pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
+ FX_BOOL bObjectCMYK = FXGETFLAG_COLORTYPE(alpha_flag);
+ FX_BOOL bDeviceCMYK = pDevice->IsCmykImage();
- if (m_pDevice->GetBPP() == 8) { // Gray(a) device
- ASSERT(!m_bRgbByteOrder);
- if (m_pDevice->IsAlphaMask()) {
- //Alpha Mask
- m_Gray = 255;
- } else {
- //Gray(a) device
- 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));
- }
- }
- }
- } else {
- if (bDeviceCMYK) { // Cmyk(a) Device
- ASSERT(!m_bRgbByteOrder);
- //TODO... opt for cmyk
- composite_span = &CFX_SkiaRenderer::CompositeSpanCMYK;
- if (bObjectCMYK) {
- m_Color = FXCMYK_TODIB(color);
- if (pIccTransform)
- pIccModule->TranslateScanline(pIccTransform, (uint8_t*)&m_Color, (const uint8_t*)&m_Color, 1);
- } else { // Object RGB
- 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];
- return TRUE;
- }
- 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];
- // Need Johnson to improvement it.
- if (m_bRgbByteOrder) {
- // swap
- m_Red = ((uint8_t*)&m_Color)[0];
- m_Blue = ((uint8_t*)&m_Color)[2];
- 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);
- m_Red = b; m_Green = g; m_Blue = r;//
- }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);
- ArgbDecode(color, m_Alpha, m_Blue, m_Green, m_Red); //
- }else {
- m_Color = FXARGB_TODIB(color);
- ArgbDecode(color, m_Alpha, m_Red, m_Green, m_Blue);
- }
- }
- }
- }
- // Get palette transparency selector
- m_ProcessFilter = (m_pOriDevice? 1 : 0) /* has Ori Device flag */
- + (m_pDevice->GetBPP() >= 8 ? 2 : 0) /* bpp flag */
- + (m_pClipMask? 4 : 0) /* has clip region flag */
- + (m_pDevice->m_pAlphaMask? 8 : 0); /* has Alpha Mask chanel flag */
- switch(m_ProcessFilter) {
- case 0:
- composite_span = &CFX_SkiaRenderer::CompositeSpan1bpp_0;
- break;
- case 2:
- {
- if (m_pDevice->GetBPP() == 8)
- composite_span = &CFX_SkiaRenderer::CompositeSpanGray_2;
- else if (m_pDevice->GetBPP() == 24)
- composite_span = &CFX_SkiaRenderer::CompositeSpanRGB24_2;
- else
- composite_span = m_pDevice->HasAlpha()?&CFX_SkiaRenderer::CompositeSpanARGB_2 : &CFX_SkiaRenderer::CompositeSpanRGB32_2;
- }
- break;
- case 3:
- {
- if (m_pDevice->GetBPP() == 8)
- composite_span = &CFX_SkiaRenderer::CompositeSpanGray_3;
- else if (m_pDevice->GetBPP() == 24)
- composite_span = &CFX_SkiaRenderer::CompositeSpanRGB24_3;
- else
- composite_span = m_pDevice->HasAlpha()?&CFX_SkiaRenderer::CompositeSpanARGB_3 : &CFX_SkiaRenderer::CompositeSpanRGB32_3;
- }
- break;
- case 4:
- composite_span = &CFX_SkiaRenderer::CompositeSpan1bpp_4;
- break;
- case 6:
- {
- if (m_pDevice->GetBPP() == 8)
- composite_span = &CFX_SkiaRenderer::CompositeSpanGray_6;
- else if (m_pDevice->GetBPP() == 24)
- composite_span = &CFX_SkiaRenderer::CompositeSpanRGB24_6;
- else
- composite_span = m_pDevice->HasAlpha()?&CFX_SkiaRenderer::CompositeSpanARGB_6 : &CFX_SkiaRenderer::CompositeSpanRGB32_6;
- }
- break;
- case 7:
- {
- if (m_pDevice->GetBPP() == 8)
- composite_span = &CFX_SkiaRenderer::CompositeSpanGray_7;
- else if (m_pDevice->GetBPP() == 24)
- composite_span = &CFX_SkiaRenderer::CompositeSpanRGB24_7;
- else
- composite_span = m_pDevice->HasAlpha()?&CFX_SkiaRenderer::CompositeSpanARGB_7 : &CFX_SkiaRenderer::CompositeSpanRGB32_7;
- }
- break;
- case 1:
- case 5:
- case 8:
- case 9:
- case 11:
- case 12:
- case 13:
- case 15:
- //TODO...
- break;
- case 10:
- composite_span = &CFX_SkiaRenderer::CompositeSpanRGB24_10;
- break;
- case 14:
- composite_span = &CFX_SkiaRenderer::CompositeSpanRGB24_14;
- break;
- }
- if (composite_span == NULL)
- return FALSE;
- return TRUE;
- }
+ m_Alpha = bObjectCMYK ? FXGETFLAG_ALPHA_FILL(alpha_flag) : FXARGB_A(color);
- /*----------------------------------------------------------------------------------------------------*/
- void CFX_SkiaA8Renderer::blitAntiH(int x, int y, const SkAlpha antialias[], const int16_t runs[])
- {
- FXSYS_assert(m_pDevice);
- int dst_y = y - m_Top;
- if (dst_y < 0 || dst_y >= m_pDevice->GetHeight())
- return;
+ ICodec_IccModule* pIccModule = NULL;
+ // No lcms engine, we skip the transform
+ if (!CFX_GEModule::Get()->GetCodecModule() ||
+ !CFX_GEModule::Get()->GetCodecModule()->GetIccModule())
+ pIccTransform = NULL;
+ else
+ pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
- uint8_t* dest_scan = m_pDevice->GetBuffer() + m_pDevice->GetPitch() * dst_y;
- uint8_t* dest_pos = dest_scan;
- while (1)
- {
- if (x >= m_dstWidth)
- return;
- int width = runs[0];
- SkASSERT(width >= 0);
- if (width <= 0)
- return;
- unsigned aa = antialias[0];
- if (aa) {
- int col_start = x < m_Left ? 0 : x - m_Left;
- int col_end = x + width;
- col_end = col_end < m_dstWidth ? col_end - m_Left: m_pDevice->GetWidth();
- int result = col_end - col_start;
- if (result > 0) {
- dest_pos = dest_scan + col_start;
- if (result >= 4)
- FXSYS_memset(dest_pos, FXARGB_MAKE(aa, aa, aa, aa),result);
- else
- FXSYS_memset(dest_pos,aa,result);
- }
- }
- runs += width;
- antialias += width;
- x += width;
+ if (m_pDevice->GetBPP() == 8) { // Gray(a) device
+ ASSERT(!m_bRgbByteOrder);
+ if (m_pDevice->IsAlphaMask()) {
+ // Alpha Mask
+ m_Gray = 255;
+ } else {
+ // Gray(a) device
+ 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));
}
+ }
}
- void CFX_SkiaA8Renderer::blitH(int x, int y, int width)
- {
- FXSYS_assert(m_pDevice);
- int dst_y = y - m_Top;
- if (dst_y < 0 || dst_y >= m_pDevice->GetHeight())
- return;
- if (x >= m_dstWidth)
- return;
- uint8_t* dest_scan = m_pDevice->GetBuffer() + m_pDevice->GetPitch() * dst_y;
- int col_start = x < m_Left ? 0 : x - m_Left;
- int col_end = x + width;
- col_end = col_end < m_dstWidth ? col_end - m_Left: m_pDevice->GetWidth();
- int result = col_end - col_start;
- if (result > 0) {
- uint8_t* dest_pos = dest_scan + col_start;
- if (result >= 4)
- FXSYS_memset(dest_pos, 0xffffffff,result);
- else
- FXSYS_memset(dest_pos,255,result);
- }
+ } else {
+ if (bDeviceCMYK) { // Cmyk(a) Device
+ ASSERT(!m_bRgbByteOrder);
+ // TODO... opt for cmyk
+ composite_span = &CFX_SkiaRenderer::CompositeSpanCMYK;
+ if (bObjectCMYK) {
+ m_Color = FXCMYK_TODIB(color);
+ if (pIccTransform)
+ pIccModule->TranslateScanline(pIccTransform, (uint8_t*)&m_Color,
+ (const uint8_t*)&m_Color, 1);
+ } else { // Object RGB
+ 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];
+ return TRUE;
}
- void CFX_SkiaA8Renderer::blitV(int x, int y, int height, SkAlpha alpha)
- {
- FXSYS_assert(alpha);
- if (alpha == 255) {
- blitRect(x, y, 1, height);
+ 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];
+ // Need Johnson to improvement it.
+ if (m_bRgbByteOrder) {
+ // swap
+ m_Red = ((uint8_t*)&m_Color)[0];
+ m_Blue = ((uint8_t*)&m_Color)[2];
+ 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);
+ m_Red = b;
+ m_Green = g;
+ m_Blue = r; //
} else {
- int16_t runs[2];
- runs[0] = 1;
- runs[1] = 0;
- while (--height >= 0) {
- if (y >= m_dstHeight)
- return;
- blitAntiH(x, y ++, &alpha, runs);
- }
+ m_Color = FXARGB_TODIB(m_Color);
+ m_Red = r;
+ m_Green = g;
+ m_Blue = b; //
}
- }
- void CFX_SkiaA8Renderer::blitRect(int x, int y, int width, int height)
- {
- FXSYS_assert(m_pDevice);
- while (--height >= 0) {
- if (y >= m_dstHeight)
- return;
- blitH(x , y ++, width);
+ } else {
+ if (m_bRgbByteOrder) {
+ m_Color = FXARGB_TOBGRORDERDIB(color);
+ ArgbDecode(color, m_Alpha, m_Blue, m_Green, m_Red); //
+ } else {
+ m_Color = FXARGB_TODIB(color);
+ ArgbDecode(color, m_Alpha, m_Red, m_Green, m_Blue);
}
+ }
}
+ }
+ // Get palette transparency selector
+ m_ProcessFilter =
+ (m_pOriDevice ? 1 : 0) /* has Ori Device flag */
+ + (m_pDevice->GetBPP() >= 8 ? 2 : 0) /* bpp flag */
+ + (m_pClipMask ? 4 : 0) /* has clip region flag */
+ + (m_pDevice->m_pAlphaMask ? 8 : 0); /* has Alpha Mask chanel flag */
+ switch (m_ProcessFilter) {
+ case 0:
+ composite_span = &CFX_SkiaRenderer::CompositeSpan1bpp_0;
+ break;
+ case 2: {
+ if (m_pDevice->GetBPP() == 8)
+ composite_span = &CFX_SkiaRenderer::CompositeSpanGray_2;
+ else if (m_pDevice->GetBPP() == 24)
+ composite_span = &CFX_SkiaRenderer::CompositeSpanRGB24_2;
+ else
+ composite_span = m_pDevice->HasAlpha()
+ ? &CFX_SkiaRenderer::CompositeSpanARGB_2
+ : &CFX_SkiaRenderer::CompositeSpanRGB32_2;
+ } break;
+ case 3: {
+ if (m_pDevice->GetBPP() == 8)
+ composite_span = &CFX_SkiaRenderer::CompositeSpanGray_3;
+ else if (m_pDevice->GetBPP() == 24)
+ composite_span = &CFX_SkiaRenderer::CompositeSpanRGB24_3;
+ else
+ composite_span = m_pDevice->HasAlpha()
+ ? &CFX_SkiaRenderer::CompositeSpanARGB_3
+ : &CFX_SkiaRenderer::CompositeSpanRGB32_3;
+ } break;
+ case 4:
+ composite_span = &CFX_SkiaRenderer::CompositeSpan1bpp_4;
+ break;
+ case 6: {
+ if (m_pDevice->GetBPP() == 8)
+ composite_span = &CFX_SkiaRenderer::CompositeSpanGray_6;
+ else if (m_pDevice->GetBPP() == 24)
+ composite_span = &CFX_SkiaRenderer::CompositeSpanRGB24_6;
+ else
+ composite_span = m_pDevice->HasAlpha()
+ ? &CFX_SkiaRenderer::CompositeSpanARGB_6
+ : &CFX_SkiaRenderer::CompositeSpanRGB32_6;
+ } break;
+ case 7: {
+ if (m_pDevice->GetBPP() == 8)
+ composite_span = &CFX_SkiaRenderer::CompositeSpanGray_7;
+ else if (m_pDevice->GetBPP() == 24)
+ composite_span = &CFX_SkiaRenderer::CompositeSpanRGB24_7;
+ else
+ composite_span = m_pDevice->HasAlpha()
+ ? &CFX_SkiaRenderer::CompositeSpanARGB_7
+ : &CFX_SkiaRenderer::CompositeSpanRGB32_7;
+ } break;
+ case 1:
+ case 5:
+ case 8:
+ case 9:
+ case 11:
+ case 12:
+ case 13:
+ case 15:
+ // TODO...
+ break;
+ case 10:
+ composite_span = &CFX_SkiaRenderer::CompositeSpanRGB24_10;
+ break;
+ case 14:
+ composite_span = &CFX_SkiaRenderer::CompositeSpanRGB24_14;
+ break;
+ }
+ if (composite_span == NULL)
+ return FALSE;
+ return TRUE;
+}
- void CFX_SkiaA8Renderer::blitAntiRect(int x, int y, int width, int height,
- SkAlpha leftAlpha, SkAlpha rightAlpha)
- {
- blitV(x++, y, height, leftAlpha);
- if (width > 0) {
- blitRect(x, y, width, height);
- x += width;
- }
- blitV(x, y, height, rightAlpha);
- }
+/*----------------------------------------------------------------------------------------------------*/
+void CFX_SkiaA8Renderer::blitAntiH(int x,
+ int y,
+ const SkAlpha antialias[],
+ const int16_t runs[]) {
+ FXSYS_assert(m_pDevice);
+ int dst_y = y - m_Top;
+ if (dst_y < 0 || dst_y >= m_pDevice->GetHeight())
+ return;
- FX_BOOL CFX_SkiaA8Renderer::Init(CFX_DIBitmap* pDevice, int Left, int Top)
- {
- m_pDevice = pDevice;
- m_Left = Left;
- m_Top = Top;
- if (pDevice){
- m_dstWidth = m_Left + pDevice->GetWidth();
- m_dstHeight = m_Top + pDevice->GetHeight();
- }
- return TRUE;
+ uint8_t* dest_scan = m_pDevice->GetBuffer() + m_pDevice->GetPitch() * dst_y;
+ uint8_t* dest_pos = dest_scan;
+ while (1) {
+ if (x >= m_dstWidth)
+ return;
+ int width = runs[0];
+ SkASSERT(width >= 0);
+ if (width <= 0)
+ return;
+ unsigned aa = antialias[0];
+ if (aa) {
+ int col_start = x < m_Left ? 0 : x - m_Left;
+ int col_end = x + width;
+ col_end = col_end < m_dstWidth ? col_end - m_Left : m_pDevice->GetWidth();
+ int result = col_end - col_start;
+ if (result > 0) {
+ dest_pos = dest_scan + col_start;
+ if (result >= 4)
+ FXSYS_memset(dest_pos, FXARGB_MAKE(aa, aa, aa, aa), result);
+ else
+ FXSYS_memset(dest_pos, aa, result);
+ }
}
+ runs += width;
+ antialias += width;
+ x += width;
+ }
+}
+void CFX_SkiaA8Renderer::blitH(int x, int y, int width) {
+ FXSYS_assert(m_pDevice);
+ int dst_y = y - m_Top;
+ if (dst_y < 0 || dst_y >= m_pDevice->GetHeight())
+ return;
+ if (x >= m_dstWidth)
+ return;
+ uint8_t* dest_scan = m_pDevice->GetBuffer() + m_pDevice->GetPitch() * dst_y;
+ int col_start = x < m_Left ? 0 : x - m_Left;
+ int col_end = x + width;
+ col_end = col_end < m_dstWidth ? col_end - m_Left : m_pDevice->GetWidth();
+ int result = col_end - col_start;
+ if (result > 0) {
+ uint8_t* dest_pos = dest_scan + col_start;
+ if (result >= 4)
+ FXSYS_memset(dest_pos, 0xffffffff, result);
+ else
+ FXSYS_memset(dest_pos, 255, result);
+ }
+}
+void CFX_SkiaA8Renderer::blitV(int x, int y, int height, SkAlpha alpha) {
+ FXSYS_assert(alpha);
+ if (alpha == 255) {
+ blitRect(x, y, 1, height);
+ } else {
+ int16_t runs[2];
+ runs[0] = 1;
+ runs[1] = 0;
+ while (--height >= 0) {
+ if (y >= m_dstHeight)
+ return;
+ blitAntiH(x, y++, &alpha, runs);
+ }
+ }
+}
+void CFX_SkiaA8Renderer::blitRect(int x, int y, int width, int height) {
+ FXSYS_assert(m_pDevice);
+ while (--height >= 0) {
+ if (y >= m_dstHeight)
+ return;
+ blitH(x, y++, width);
+ }
+}
+
+void CFX_SkiaA8Renderer::blitAntiRect(int x,
+ int y,
+ int width,
+ int height,
+ SkAlpha leftAlpha,
+ SkAlpha rightAlpha) {
+ blitV(x++, y, height, leftAlpha);
+ if (width > 0) {
+ blitRect(x, y, width, height);
+ x += width;
+ }
+ blitV(x, y, height, rightAlpha);
+}
+
+FX_BOOL CFX_SkiaA8Renderer::Init(CFX_DIBitmap* pDevice, int Left, int Top) {
+ m_pDevice = pDevice;
+ m_Left = Left;
+ m_Top = Top;
+ if (pDevice) {
+ m_dstWidth = m_Left + pDevice->GetWidth();
+ m_dstHeight = m_Top + pDevice->GetHeight();
+ }
+ return TRUE;
+}
#endif
diff --git a/core/src/fxge/skia/fx_skia_blitter_new.h b/core/src/fxge/skia/fx_skia_blitter_new.h
index e60c6398d2..36a6b438f1 100644
--- a/core/src/fxge/skia/fx_skia_blitter_new.h
+++ b/core/src/fxge/skia/fx_skia_blitter_new.h
@@ -6,224 +6,516 @@
#define CORE_SRC_FXGE_SKIA_FX_SKIA_BLITTER_NEW_H_
#if defined(_SKIA_SUPPORT_)
-class CFX_SkiaRenderer : public SkBlitter
-{
-protected:
- int m_Alpha,
- m_Red, // Or the complementary-color, Cyan
- m_Green, // Magenta
- m_Blue, // Yellow
- m_Gray; // Black
- FX_DWORD m_Color; // FX_ARGB or FX_CMYK
- FX_BOOL m_bFullCover;
- int m_ProcessFilter;
- FX_BOOL m_bRgbByteOrder;
-
- FX_RECT m_ClipBox;
- CFX_DIBitmap* m_pDevice;
- CFX_DIBitmap* m_pOriDevice;
- const CFX_ClipRgn* m_pClipRgn;
- const CFX_DIBitmap* m_pClipMask;
-
- uint8_t* m_pDestScan;
- uint8_t* m_pDestExtraAlphaScan;
- uint8_t* m_pOriScan;
- uint8_t* m_pClipScan;
-
- void (CFX_SkiaRenderer::*composite_span)(uint8_t*,uint8_t*,int,int,int,int,uint8_t,int,int,int,uint8_t*,uint8_t*);
-public:
-
- //--------------------------------------------------------------------
- virtual void blitAntiH(int x, int y, const SkAlpha antialias[], const int16_t runs[]);
- virtual void blitH(int x, int y, int width);
- virtual void blitV(int x, int y, int height, SkAlpha alpha);
- virtual void blitRect(int x, int y, int width, int height);
- virtual void blitAntiRect(int x, int y, int width, int height, SkAlpha leftAlpha, SkAlpha rightAlpha);
-
- /*------------------------------------------------------------------------------------------------------*/
- // A general alpha merge function (with clipping mask). Gray device.
- void CompositeSpan1bpp_0(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan);
- void CompositeSpan1bpp_1(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan);
- void CompositeSpan1bpp_4(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan);
- void CompositeSpan1bpp_5(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan);
- void CompositeSpan1bpp_8(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan);
- void CompositeSpan1bpp_9(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan);
- void CompositeSpan1bpp_12(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan);
- void CompositeSpan1bpp_13(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan);
-
- /*--------------------------------------------------------------------------------------------------------*/
-
- // A general alpha merge function (with clipping mask). Gray device.
- void CompositeSpanGray_2(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan);
-
- void CompositeSpanGray_3(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan);
-
- void CompositeSpanGray_6(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan);
-
- void CompositeSpanGray_7(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan);
-
- void CompositeSpanGray_10(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan);
-
-
- void CompositeSpanGray_11(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan);
-
- void CompositeSpanGray_14(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan);
-
- void CompositeSpanGray_15(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan);
-
- /*--------------------------------------------------------------------------------------------------------*/
- void CompositeSpanARGB_2(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan);
-
- void CompositeSpanARGB_3(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan);
-
-
- void CompositeSpanARGB_6(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan);
-
-
- void CompositeSpanARGB_7(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan);
- // ...
- /*--------------------------------------------------------------------------------------------------------*/
- void CompositeSpanRGB32_2(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan);
- void CompositeSpanRGB32_3(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan);
- void CompositeSpanRGB32_6(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan);
- void CompositeSpanRGB32_7(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan);
-
- /*---------------------------------------------------------------------------------------------------------*/
-
- void CompositeSpanRGB24_2(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan);
- void CompositeSpanRGB24_3(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan);
- void CompositeSpanRGB24_6(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan);
- void CompositeSpanRGB24_7(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan);
- void CompositeSpanRGB24_10(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan);
- void CompositeSpanRGB24_11(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan);
- void CompositeSpanRGB24_14(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan);
- void CompositeSpanRGB24_15(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan);
-
- /*----------------------------------------------------------------------------------------------------------*/
-
- // A general alpha merge function (with clipping mask). Cmyka/Cmyk device.
- void CompositeSpanCMYK(uint8_t* dest_scan, uint8_t* ori_scan,int Bpp,
- int span_left, int span_len, int span_top, uint8_t cover_scan,
- int clip_top, int clip_left, int clip_right, uint8_t* clip_scan,
- uint8_t* dest_extra_alpha_scan);
-
-
- //--------------------------------------------------------------------
- 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); //The alpha flag must be fill_flag if exist.
+class CFX_SkiaRenderer : public SkBlitter {
+ protected:
+ int m_Alpha,
+ m_Red, // Or the complementary-color, Cyan
+ m_Green, // Magenta
+ m_Blue, // Yellow
+ m_Gray; // Black
+ FX_DWORD m_Color; // FX_ARGB or FX_CMYK
+ FX_BOOL m_bFullCover;
+ int m_ProcessFilter;
+ FX_BOOL m_bRgbByteOrder;
+
+ FX_RECT m_ClipBox;
+ CFX_DIBitmap* m_pDevice;
+ CFX_DIBitmap* m_pOriDevice;
+ const CFX_ClipRgn* m_pClipRgn;
+ const CFX_DIBitmap* m_pClipMask;
+
+ uint8_t* m_pDestScan;
+ uint8_t* m_pDestExtraAlphaScan;
+ uint8_t* m_pOriScan;
+ uint8_t* m_pClipScan;
+
+ void (CFX_SkiaRenderer::*composite_span)(uint8_t*,
+ uint8_t*,
+ int,
+ int,
+ int,
+ int,
+ uint8_t,
+ int,
+ int,
+ int,
+ uint8_t*,
+ uint8_t*);
+
+ public:
+ //--------------------------------------------------------------------
+ virtual void blitAntiH(int x,
+ int y,
+ const SkAlpha antialias[],
+ const int16_t runs[]);
+ virtual void blitH(int x, int y, int width);
+ virtual void blitV(int x, int y, int height, SkAlpha alpha);
+ virtual void blitRect(int x, int y, int width, int height);
+ virtual void blitAntiRect(int x,
+ int y,
+ int width,
+ int height,
+ SkAlpha leftAlpha,
+ SkAlpha rightAlpha);
+
+ /*------------------------------------------------------------------------------------------------------*/
+ // A general alpha merge function (with clipping mask). Gray device.
+ void CompositeSpan1bpp_0(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan);
+ void CompositeSpan1bpp_1(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan);
+ void CompositeSpan1bpp_4(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan);
+ void CompositeSpan1bpp_5(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan);
+ void CompositeSpan1bpp_8(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan);
+ void CompositeSpan1bpp_9(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan);
+ void CompositeSpan1bpp_12(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan);
+ void CompositeSpan1bpp_13(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan);
+
+ /*--------------------------------------------------------------------------------------------------------*/
+
+ // A general alpha merge function (with clipping mask). Gray device.
+ void CompositeSpanGray_2(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan);
+
+ void CompositeSpanGray_3(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan);
+
+ void CompositeSpanGray_6(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan);
+
+ void CompositeSpanGray_7(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan);
+
+ void CompositeSpanGray_10(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan);
+
+ void CompositeSpanGray_11(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan);
+
+ void CompositeSpanGray_14(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan);
+
+ void CompositeSpanGray_15(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan);
+
+ /*--------------------------------------------------------------------------------------------------------*/
+ void CompositeSpanARGB_2(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan);
+
+ void CompositeSpanARGB_3(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan);
+
+ void CompositeSpanARGB_6(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan);
+
+ void CompositeSpanARGB_7(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan);
+ // ...
+ /*--------------------------------------------------------------------------------------------------------*/
+ void CompositeSpanRGB32_2(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan);
+ void CompositeSpanRGB32_3(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan);
+ void CompositeSpanRGB32_6(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan);
+ void CompositeSpanRGB32_7(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan);
+
+ /*---------------------------------------------------------------------------------------------------------*/
+
+ void CompositeSpanRGB24_2(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan);
+ void CompositeSpanRGB24_3(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan);
+ void CompositeSpanRGB24_6(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan);
+ void CompositeSpanRGB24_7(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan);
+ void CompositeSpanRGB24_10(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan);
+ void CompositeSpanRGB24_11(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan);
+ void CompositeSpanRGB24_14(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan);
+ void CompositeSpanRGB24_15(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan);
+
+ /*----------------------------------------------------------------------------------------------------------*/
+
+ // A general alpha merge function (with clipping mask). Cmyka/Cmyk device.
+ void CompositeSpanCMYK(uint8_t* dest_scan,
+ uint8_t* ori_scan,
+ int Bpp,
+ int span_left,
+ int span_len,
+ int span_top,
+ uint8_t cover_scan,
+ int clip_top,
+ int clip_left,
+ int clip_right,
+ uint8_t* clip_scan,
+ uint8_t* dest_extra_alpha_scan);
+
+ //--------------------------------------------------------------------
+ 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); // The alpha flag must be fill_flag if exist.
};
-class CFX_SkiaA8Renderer : public SkBlitter
-{
-public:
- //--------------------------------------------------------------------
- virtual void blitAntiH(int x, int y, const SkAlpha antialias[], const int16_t runs[]);
- virtual void blitH(int x, int y, int width);
- virtual void blitV(int x, int y, int height, SkAlpha alpha);
- virtual void blitRect(int x, int y, int width, int height);
- virtual void blitAntiRect(int x, int y, int width, int height, SkAlpha leftAlpha, SkAlpha rightAlpha);
- //--------------------------------------------------------------------
- FX_BOOL Init(CFX_DIBitmap* pDevice, int Left, int Top);
- CFX_DIBitmap* m_pDevice;
- int m_Left;
- int m_Top;
- int m_dstWidth;
- int m_dstHeight;
+class CFX_SkiaA8Renderer : public SkBlitter {
+ public:
+ //--------------------------------------------------------------------
+ virtual void blitAntiH(int x,
+ int y,
+ const SkAlpha antialias[],
+ const int16_t runs[]);
+ virtual void blitH(int x, int y, int width);
+ virtual void blitV(int x, int y, int height, SkAlpha alpha);
+ virtual void blitRect(int x, int y, int width, int height);
+ virtual void blitAntiRect(int x,
+ int y,
+ int width,
+ int height,
+ SkAlpha leftAlpha,
+ SkAlpha rightAlpha);
+ //--------------------------------------------------------------------
+ FX_BOOL Init(CFX_DIBitmap* pDevice, int Left, int Top);
+ CFX_DIBitmap* m_pDevice;
+ int m_Left;
+ int m_Top;
+ int m_dstWidth;
+ int m_dstHeight;
};
#endif
diff --git a/core/src/fxge/skia/fx_skia_device.cpp b/core/src/fxge/skia/fx_skia_device.cpp
index ae6b79b686..8f98293673 100644
--- a/core/src/fxge/skia/fx_skia_device.cpp
+++ b/core/src/fxge/skia/fx_skia_device.cpp
@@ -7,27 +7,28 @@
#if defined(_SKIA_SUPPORT_)
#include "../../../include/fxcodec/fx_codec.h"
-
//#define _FOXIT_DEBUG_
//#define _FOXIT_BENCHMARK_
extern "C" {
- extern void FX_OUTPUT_LOG_FUNC(const char*, ...);
- extern int FX_GET_TICK_FUNC();
+extern void FX_OUTPUT_LOG_FUNC(const char*, ...);
+extern int FX_GET_TICK_FUNC();
};
#ifdef _FOXIT_DEBUG_
#define FOXIT_DEBUG1(msg) FX_OUTPUT_LOG_FUNC(msg)
-#define FOXIT_DEBUG2(msg,para) FX_OUTPUT_LOG_FUNC(msg,para)
-#define FOXIT_DEBUG3(msg,para1,para2) FX_OUTPUT_LOG_FUNC(msg,para1,para2)
-#define FOXIT_DEBUG4(msg,para1,para2,para3) FX_OUTPUT_LOG_FUNC(msg,para1,para2,para3)
-#define FOXIT_DEBUG5(msg,para1,para2,para3,param4) FX_OUTPUT_LOG_FUNC(msg,para1,para2,para3,param4)
+#define FOXIT_DEBUG2(msg, para) FX_OUTPUT_LOG_FUNC(msg, para)
+#define FOXIT_DEBUG3(msg, para1, para2) FX_OUTPUT_LOG_FUNC(msg, para1, para2)
+#define FOXIT_DEBUG4(msg, para1, para2, para3) \
+ FX_OUTPUT_LOG_FUNC(msg, para1, para2, para3)
+#define FOXIT_DEBUG5(msg, para1, para2, para3, param4) \
+ FX_OUTPUT_LOG_FUNC(msg, para1, para2, para3, param4)
#else
#define FOXIT_DEBUG1(msg)
-#define FOXIT_DEBUG2(msg,para)
-#define FOXIT_DEBUG3(msg,para1,para2)
-#define FOXIT_DEBUG4(msg,para1,para2,para3)
-#define FOXIT_DEBUG5(msg,para1,para2,para3,param4)
+#define FOXIT_DEBUG2(msg, para)
+#define FOXIT_DEBUG3(msg, para1, para2)
+#define FOXIT_DEBUG4(msg, para1, para2, para3)
+#define FOXIT_DEBUG5(msg, para1, para2, para3, param4)
#endif
#include "SkDashPathEffect.h"
@@ -36,496 +37,593 @@ extern "C" {
#include "SkRasterClip.h"
#include "SkStroke.h"
-
#include "fx_skia_blitter_new.h"
#include "../agg/fx_agg_driver.h"
#include "fx_skia_device.h"
/// Run-length-encoded supersampling antialiased blitter.
-class SuperBlitter_skia
-{
-public:
- static void DrawPath(const SkPath& srcPath, SkBlitter* blitter, const SkRasterClip& rect, const SkPaint& origPaint);
+class SuperBlitter_skia {
+ public:
+ static void DrawPath(const SkPath& srcPath,
+ SkBlitter* blitter,
+ const SkRasterClip& rect,
+ const SkPaint& origPaint);
};
FX_BOOL FxSkDrawTreatAsHairline(const SkPaint& paint, SkScalar* coverage) {
- if (SkPaint::kStroke_Style != paint.getStyle())
- return FALSE;
- FXSYS_assert(coverage);
- SkScalar strokeWidth = paint.getStrokeWidth();
- if (0 == strokeWidth) {
- *coverage = SK_Scalar1;
- return TRUE;
- }
- // if we get here, we need to try to fake a thick-stroke with a modulated
- // hairline
- if (!paint.isAntiAlias())
- return FALSE;
- if (strokeWidth <= SK_Scalar1) {
- *coverage = strokeWidth;
- return TRUE;
- }
- return FALSE;
+ if (SkPaint::kStroke_Style != paint.getStyle())
+ return FALSE;
+ FXSYS_assert(coverage);
+ SkScalar strokeWidth = paint.getStrokeWidth();
+ if (0 == strokeWidth) {
+ *coverage = SK_Scalar1;
+ return TRUE;
+ }
+ // if we get here, we need to try to fake a thick-stroke with a modulated
+ // hairline
+ if (!paint.isAntiAlias())
+ return FALSE;
+ if (strokeWidth <= SK_Scalar1) {
+ *coverage = strokeWidth;
+ return TRUE;
+ }
+ return FALSE;
}
-void SuperBlitter_skia::DrawPath(const SkPath& srcPath, SkBlitter* blitter, const SkRasterClip& rect, const SkPaint& origPaint)
-{
- SkPath* pathPtr = (SkPath*)&srcPath;
- bool doFill = true;
- SkPath tmpPath;
- SkTCopyOnFirstWrite<SkPaint> paint(origPaint);
- {
- SkScalar coverage;
- if (FxSkDrawTreatAsHairline(origPaint, &coverage)) {
- if (SK_Scalar1 == coverage) {
- paint.writable()->setStrokeWidth(0);
- } else if (1) {//xfermodeSupportsCoverageAsAlpha(xfer), we not use blend mode here, xfer aways NULL.
- U8CPU newAlpha;
- // this is the old technique, which we preserve for now so
- // we don't change previous results (testing)
- // the new way seems fine, its just (a tiny bit) different
- int scale = (int)SkScalarMul(coverage, 256);
- newAlpha = origPaint.getAlpha() * scale >> 8;
- SkPaint* writablePaint = paint.writable();
- writablePaint->setStrokeWidth(0);
- writablePaint->setAlpha(newAlpha);
- }
- }
- }
- if (paint->getPathEffect() || paint->getStyle() != SkPaint::kFill_Style) {
- SkIRect devBounds = rect.getBounds();
- // outset to have slop for antialasing and hairlines
- devBounds.outset(1, 1);
- SkRect cullRect = SkRect::Make(devBounds);
- doFill = paint->getFillPath(*pathPtr, &tmpPath, &cullRect);
- pathPtr = &tmpPath;
- }
- // avoid possibly allocating a new path in transform if we can
- SkPath* devPathPtr = pathPtr;
- void (*proc)(const SkPath&, const SkRasterClip&, SkBlitter*);
- if (doFill) {
- if (paint->isAntiAlias()) {
- proc = SkScan::AntiFillPath;
- } else {
- proc = SkScan::FillPath;
- }
- } else { // hairline
- if (paint->isAntiAlias()) {
- proc = SkScan::AntiHairPath;
- } else {
- proc = SkScan::HairPath;
- }
- }
- proc(*devPathPtr, rect, blitter);
+void SuperBlitter_skia::DrawPath(const SkPath& srcPath,
+ SkBlitter* blitter,
+ const SkRasterClip& rect,
+ const SkPaint& origPaint) {
+ SkPath* pathPtr = (SkPath*)&srcPath;
+ bool doFill = true;
+ SkPath tmpPath;
+ SkTCopyOnFirstWrite<SkPaint> paint(origPaint);
+ {
+ SkScalar coverage;
+ if (FxSkDrawTreatAsHairline(origPaint, &coverage)) {
+ if (SK_Scalar1 == coverage) {
+ paint.writable()->setStrokeWidth(0);
+ } else if (1) { // xfermodeSupportsCoverageAsAlpha(xfer), we not use
+ // blend mode here, xfer aways NULL.
+ U8CPU newAlpha;
+ // this is the old technique, which we preserve for now so
+ // we don't change previous results (testing)
+ // the new way seems fine, its just (a tiny bit) different
+ int scale = (int)SkScalarMul(coverage, 256);
+ newAlpha = origPaint.getAlpha() * scale >> 8;
+ SkPaint* writablePaint = paint.writable();
+ writablePaint->setStrokeWidth(0);
+ writablePaint->setAlpha(newAlpha);
+ }
+ }
+ }
+ if (paint->getPathEffect() || paint->getStyle() != SkPaint::kFill_Style) {
+ SkIRect devBounds = rect.getBounds();
+ // outset to have slop for antialasing and hairlines
+ devBounds.outset(1, 1);
+ SkRect cullRect = SkRect::Make(devBounds);
+ doFill = paint->getFillPath(*pathPtr, &tmpPath, &cullRect);
+ pathPtr = &tmpPath;
+ }
+ // avoid possibly allocating a new path in transform if we can
+ SkPath* devPathPtr = pathPtr;
+ void (*proc)(const SkPath&, const SkRasterClip&, SkBlitter*);
+ if (doFill) {
+ if (paint->isAntiAlias()) {
+ proc = SkScan::AntiFillPath;
+ } else {
+ proc = SkScan::FillPath;
+ }
+ } else { // hairline
+ if (paint->isAntiAlias()) {
+ proc = SkScan::AntiHairPath;
+ } else {
+ proc = SkScan::HairPath;
+ }
+ }
+ proc(*devPathPtr, rect, blitter);
}
-class CSkia_PathData
-{
-public:
- CSkia_PathData() {}
- ~CSkia_PathData() {}
- SkPath m_PathData;
+class CSkia_PathData {
+ public:
+ CSkia_PathData() {}
+ ~CSkia_PathData() {}
+ SkPath m_PathData;
- void BuildPath(const CFX_PathData* pPathData, const CFX_AffineMatrix* pObject2Device);
+ void BuildPath(const CFX_PathData* pPathData,
+ const CFX_AffineMatrix* pObject2Device);
};
-void CSkia_PathData::BuildPath(const CFX_PathData* pPathData, const CFX_AffineMatrix* pObject2Device)
-{
- const CFX_PathData* pFPath = pPathData;
- int nPoints = pFPath->GetPointCount();
- FX_PATHPOINT* pPoints = pFPath->GetPoints();
- for (int i = 0; i < nPoints; i ++) {
- FX_FIXFLOAT x = pPoints[i].m_PointX, y = pPoints[i].m_PointY;
- if (pObject2Device) pObject2Device->Transform(x, y);
- int point_type = pPoints[i].m_Flag & FXPT_TYPE;
- if (point_type == FXPT_MOVETO) {
- m_PathData.moveTo(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) &&
- FXSYS_abs(pPoints[i].m_PointX - pPoints[i-1].m_PointX) < 0.4f && FXSYS_abs(pPoints[i].m_PointY - pPoints[i-1].m_PointY)< 0.4f)
- // PDF line includes the destination point, unlike Windows line.
- // We received some PDF which actually draws zero length lines. TESTDOC: summer cha show.pdf
- // Therefore, we have to extend the line by 0.4 pixel here.
- // But only for standalone segment. TESTDOC: bug #1434 - maze.pdf; TESTDOC: bug#1508 di704P_QIG_111.pdf
- x += 0.4;
- // TODO: we should actually tell skia vertex generator to process zero length stroked line
- // (only butts are drawn)
- m_PathData.lineTo(x, y);
- } else if (point_type == FXPT_BEZIERTO) {
- FX_FIXFLOAT x2 = pPoints[i+1].m_PointX, y2 = pPoints[i+1].m_PointY;
- FX_FIXFLOAT x3 = pPoints[i+2].m_PointX, y3 = pPoints[i+2].m_PointY;
- if (pObject2Device){
- pObject2Device->Transform(x2, y2);
- pObject2Device->Transform(x3, y3);
- }
- m_PathData.cubicTo(x, y, x2, y2, x3, y3);
- i += 2;
- }
- if (pPoints[i].m_Flag & FXPT_CLOSEFIGURE) m_PathData.close();
- }
+void CSkia_PathData::BuildPath(const CFX_PathData* pPathData,
+ const CFX_AffineMatrix* pObject2Device) {
+ const CFX_PathData* pFPath = pPathData;
+ int nPoints = pFPath->GetPointCount();
+ FX_PATHPOINT* pPoints = pFPath->GetPoints();
+ for (int i = 0; i < nPoints; i++) {
+ FX_FIXFLOAT x = pPoints[i].m_PointX, y = pPoints[i].m_PointY;
+ if (pObject2Device)
+ pObject2Device->Transform(x, y);
+ int point_type = pPoints[i].m_Flag & FXPT_TYPE;
+ if (point_type == FXPT_MOVETO) {
+ m_PathData.moveTo(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) &&
+ FXSYS_abs(pPoints[i].m_PointX - pPoints[i - 1].m_PointX) < 0.4f &&
+ FXSYS_abs(pPoints[i].m_PointY - pPoints[i - 1].m_PointY) < 0.4f)
+ // PDF line includes the destination point, unlike Windows line.
+ // We received some PDF which actually draws zero length lines. TESTDOC:
+ // summer cha show.pdf
+ // Therefore, we have to extend the line by 0.4 pixel here.
+ // But only for standalone segment. TESTDOC: bug #1434 - maze.pdf;
+ // TESTDOC: bug#1508 di704P_QIG_111.pdf
+ x += 0.4;
+ // TODO: we should actually tell skia vertex generator to process zero
+ // length stroked line
+ // (only butts are drawn)
+ m_PathData.lineTo(x, y);
+ } else if (point_type == FXPT_BEZIERTO) {
+ FX_FIXFLOAT x2 = pPoints[i + 1].m_PointX, y2 = pPoints[i + 1].m_PointY;
+ FX_FIXFLOAT x3 = pPoints[i + 2].m_PointX, y3 = pPoints[i + 2].m_PointY;
+ if (pObject2Device) {
+ pObject2Device->Transform(x2, y2);
+ pObject2Device->Transform(x3, y3);
+ }
+ m_PathData.cubicTo(x, y, x2, y2, x3, y3);
+ i += 2;
+ }
+ if (pPoints[i].m_Flag & FXPT_CLOSEFIGURE)
+ m_PathData.close();
+ }
}
// convert a stroking path to scanlines
-static void SkRasterizeStroke(SkPaint& spaint, SkPath* dstPathData, SkPath& path_data,
- const CFX_AffineMatrix* pObject2Device,
- const CFX_GraphStateData* pGraphState, FX_FIXFLOAT scale = FIX8_ONE,
- FX_BOOL bStrokeAdjust = FALSE, FX_BOOL bTextMode = FALSE)
-{
- SkPaint::Cap cap;
- switch (pGraphState->m_LineCap) {
- case CFX_GraphStateData::LineCapRound:
- cap = SkPaint::kRound_Cap;
- break;
- case CFX_GraphStateData::LineCapSquare:
- cap = SkPaint::kSquare_Cap;
- break;
- default:
- cap = SkPaint::kButt_Cap;
- break;
- }
- SkPaint::Join join;
- switch (pGraphState->m_LineJoin) {
- case CFX_GraphStateData::LineJoinRound:
- join = SkPaint::kRound_Join;
- break;
- case CFX_GraphStateData::LineJoinBevel:
- join = SkPaint::kBevel_Join;
- break;
- default:
- join = SkPaint::kMiter_Join;
- break;
- }
- FX_FIXFLOAT width = pGraphState->m_LineWidth*scale;
- FX_FIXFLOAT unit = fix32_to_8(fixdiv_8_8_to_32(FIX8_ONE, (pObject2Device->GetXUnit() + pObject2Device->GetYUnit()) / 2));
- if (width <= unit) width = unit;
-
- if (pGraphState->m_DashArray == NULL) {
- SkStroke stroker;
- stroker.setCap(cap);
- stroker.setJoin(join);
- stroker.setMiterLimit(pGraphState->m_MiterLimit);
- stroker.setWidth(width);
- stroker.setDoFill(FALSE);
- stroker.strokePath(path_data, dstPathData);
- SkMatrix smatrix;
- smatrix.setAll(pObject2Device->a, pObject2Device->c, pObject2Device->e, pObject2Device->b, pObject2Device->d, pObject2Device->f, 0, 0, 1);
- dstPathData->transform(smatrix);
- } else {
- int count = (pGraphState->m_DashCount+1)/2;
- SkScalar* intervals = FX_Alloc2D(SkScalar, count, sizeof(SkScalar));
- // Set dash pattern
- for (int i = 0; i < count; i ++) {
- FX_FIXFLOAT on = pGraphState->m_DashArray[i*2];
- if (on <= 0.000001f) on = FIX8_ONE/10;
- FX_FIXFLOAT off = i*2+1 == pGraphState->m_DashCount ? on :
- pGraphState->m_DashArray[i*2+1];
- if (off < 0) off = 0;
- intervals[i*2]=on*scale;
- intervals[i*2+1]=off*scale;
- }
- SkDashPathEffect* pEffect = new SkDashPathEffect(intervals,count*2, pGraphState->m_DashPhase*scale);
- spaint.setPathEffect(pEffect)->unref();
- spaint.setStrokeWidth(width);
- spaint.setStrokeMiter(pGraphState->m_MiterLimit);
- spaint.setStrokeCap(cap);
- spaint.setStrokeJoin(join);
- spaint.getFillPath(path_data, dstPathData);
- SkMatrix smatrix;
- smatrix.setAll(pObject2Device->a, pObject2Device->c, pObject2Device->e, pObject2Device->b, pObject2Device->d, pObject2Device->f, 0, 0, 1);
- dstPathData->transform(smatrix);
- FX_Free(intervals);
- }
+static void SkRasterizeStroke(SkPaint& spaint,
+ SkPath* dstPathData,
+ SkPath& path_data,
+ const CFX_AffineMatrix* pObject2Device,
+ const CFX_GraphStateData* pGraphState,
+ FX_FIXFLOAT scale = FIX8_ONE,
+ FX_BOOL bStrokeAdjust = FALSE,
+ FX_BOOL bTextMode = FALSE) {
+ SkPaint::Cap cap;
+ switch (pGraphState->m_LineCap) {
+ case CFX_GraphStateData::LineCapRound:
+ cap = SkPaint::kRound_Cap;
+ break;
+ case CFX_GraphStateData::LineCapSquare:
+ cap = SkPaint::kSquare_Cap;
+ break;
+ default:
+ cap = SkPaint::kButt_Cap;
+ break;
+ }
+ SkPaint::Join join;
+ switch (pGraphState->m_LineJoin) {
+ case CFX_GraphStateData::LineJoinRound:
+ join = SkPaint::kRound_Join;
+ break;
+ case CFX_GraphStateData::LineJoinBevel:
+ join = SkPaint::kBevel_Join;
+ break;
+ default:
+ join = SkPaint::kMiter_Join;
+ break;
+ }
+ FX_FIXFLOAT width = pGraphState->m_LineWidth * scale;
+ FX_FIXFLOAT unit = fix32_to_8(fixdiv_8_8_to_32(
+ FIX8_ONE, (pObject2Device->GetXUnit() + pObject2Device->GetYUnit()) / 2));
+ if (width <= unit)
+ width = unit;
+
+ if (pGraphState->m_DashArray == NULL) {
+ SkStroke stroker;
+ stroker.setCap(cap);
+ stroker.setJoin(join);
+ stroker.setMiterLimit(pGraphState->m_MiterLimit);
+ stroker.setWidth(width);
+ stroker.setDoFill(FALSE);
+ stroker.strokePath(path_data, dstPathData);
+ SkMatrix smatrix;
+ smatrix.setAll(pObject2Device->a, pObject2Device->c, pObject2Device->e,
+ pObject2Device->b, pObject2Device->d, pObject2Device->f, 0,
+ 0, 1);
+ dstPathData->transform(smatrix);
+ } else {
+ int count = (pGraphState->m_DashCount + 1) / 2;
+ SkScalar* intervals = FX_Alloc2D(SkScalar, count, sizeof(SkScalar));
+ // Set dash pattern
+ for (int i = 0; i < count; i++) {
+ FX_FIXFLOAT on = pGraphState->m_DashArray[i * 2];
+ if (on <= 0.000001f)
+ on = FIX8_ONE / 10;
+ FX_FIXFLOAT off = i * 2 + 1 == pGraphState->m_DashCount
+ ? on
+ : pGraphState->m_DashArray[i * 2 + 1];
+ if (off < 0)
+ off = 0;
+ intervals[i * 2] = on * scale;
+ intervals[i * 2 + 1] = off * scale;
+ }
+ SkDashPathEffect* pEffect = new SkDashPathEffect(
+ intervals, count * 2, pGraphState->m_DashPhase * scale);
+ spaint.setPathEffect(pEffect)->unref();
+ spaint.setStrokeWidth(width);
+ spaint.setStrokeMiter(pGraphState->m_MiterLimit);
+ spaint.setStrokeCap(cap);
+ spaint.setStrokeJoin(join);
+ spaint.getFillPath(path_data, dstPathData);
+ SkMatrix smatrix;
+ smatrix.setAll(pObject2Device->a, pObject2Device->c, pObject2Device->e,
+ pObject2Device->b, pObject2Device->d, pObject2Device->f, 0,
+ 0, 1);
+ dstPathData->transform(smatrix);
+ FX_Free(intervals);
+ }
}
-CFX_SkiaDeviceDriver::CFX_SkiaDeviceDriver(CFX_DIBitmap* pBitmap, int dither_bits, FX_BOOL bRgbByteOrder, CFX_DIBitmap* pOriDevice, FX_BOOL bGroupKnockout)
-{
- m_pAggDriver = FX_NEW CFX_AggDeviceDriver(pBitmap, dither_bits, bRgbByteOrder, pOriDevice, bGroupKnockout);
+CFX_SkiaDeviceDriver::CFX_SkiaDeviceDriver(CFX_DIBitmap* pBitmap,
+ int dither_bits,
+ FX_BOOL bRgbByteOrder,
+ CFX_DIBitmap* pOriDevice,
+ FX_BOOL bGroupKnockout) {
+ m_pAggDriver = FX_NEW CFX_AggDeviceDriver(pBitmap, dither_bits, bRgbByteOrder,
+ pOriDevice, bGroupKnockout);
}
-CFX_SkiaDeviceDriver::~CFX_SkiaDeviceDriver()
-{
- delete m_pAggDriver;
+CFX_SkiaDeviceDriver::~CFX_SkiaDeviceDriver() {
+ delete m_pAggDriver;
}
-FX_BOOL CFX_SkiaDeviceDriver::DrawDeviceText(int nChars, const FXTEXT_CHARPOS* pCharPos, CFX_Font* pFont,
- CFX_FontCache* pCache, const CFX_AffineMatrix* pObject2Device, FX_FIXFLOAT font_size, FX_DWORD color,
- int alpha_flag, void* pIccTransform)
-{
- return m_pAggDriver->DrawDeviceText(nChars, pCharPos, pFont,pCache, pObject2Device, font_size, color,
- alpha_flag, pIccTransform);
+FX_BOOL CFX_SkiaDeviceDriver::DrawDeviceText(
+ int nChars,
+ const FXTEXT_CHARPOS* pCharPos,
+ CFX_Font* pFont,
+ CFX_FontCache* pCache,
+ const CFX_AffineMatrix* pObject2Device,
+ FX_FIXFLOAT font_size,
+ FX_DWORD color,
+ int alpha_flag,
+ void* pIccTransform) {
+ return m_pAggDriver->DrawDeviceText(nChars, pCharPos, pFont, pCache,
+ pObject2Device, font_size, color,
+ alpha_flag, pIccTransform);
}
-int CFX_SkiaDeviceDriver::GetDeviceCaps(int caps_id)
-{
- return m_pAggDriver->GetDeviceCaps(caps_id);
+int CFX_SkiaDeviceDriver::GetDeviceCaps(int caps_id) {
+ return m_pAggDriver->GetDeviceCaps(caps_id);
}
-void CFX_SkiaDeviceDriver::SaveState()
-{
- m_pAggDriver->SaveState();
+void CFX_SkiaDeviceDriver::SaveState() {
+ m_pAggDriver->SaveState();
}
-void CFX_SkiaDeviceDriver::RestoreState(FX_BOOL bKeepSaved)
-{
- m_pAggDriver->RestoreState(bKeepSaved);
+void CFX_SkiaDeviceDriver::RestoreState(FX_BOOL bKeepSaved) {
+ m_pAggDriver->RestoreState(bKeepSaved);
}
-void CFX_SkiaDeviceDriver::SetClipMask(rasterizer_scanline_aa& rasterizer)
-{
- m_pAggDriver->SetClipMask(rasterizer);
+void CFX_SkiaDeviceDriver::SetClipMask(rasterizer_scanline_aa& rasterizer) {
+ m_pAggDriver->SetClipMask(rasterizer);
}
-void CFX_SkiaDeviceDriver::SetClipMask(SkPath& skPath, SkPaint* spaint)
-{
- SkIRect clip_box;
- clip_box.set(0, 0, fix0_to_8(GetDeviceCaps(FXDC_PIXEL_WIDTH)), fix0_to_8(GetDeviceCaps(FXDC_PIXEL_HEIGHT)));
- clip_box.intersect(m_pAggDriver->m_pClipRgn->GetBox().left, m_pAggDriver->m_pClipRgn->GetBox().top,
- m_pAggDriver->m_pClipRgn->GetBox().right, m_pAggDriver->m_pClipRgn->GetBox().bottom);
-
- SkPath* pathPtr = &skPath;
-
- SkRect path_rect = skPath.getBounds();
-
- clip_box.intersect(FXSYS_floor(path_rect.fLeft), FXSYS_floor(path_rect.fTop), FXSYS_floor(path_rect.fRight)+1, FXSYS_floor(path_rect.fBottom)+1);
- CFX_DIBitmapRef mask;
- CFX_DIBitmap* pThisLayer = mask.New();
- pThisLayer->Create(clip_box.width(), clip_box.height(), FXDIB_8bppMask);
- pThisLayer->Clear(0);
-
- CFX_SkiaA8Renderer render;
- render.Init(pThisLayer, clip_box.fLeft, clip_box.fTop);
-
- SkRasterClip rasterClip(clip_box);
- SuperBlitter_skia::DrawPath(skPath, (SkBlitter*)&render, rasterClip, *spaint);
-
- // Finally, we have got the mask that we need, intersect with current clip region
- m_pAggDriver->m_pClipRgn->IntersectMaskF(clip_box.fLeft, clip_box.fTop, mask);
-
+void CFX_SkiaDeviceDriver::SetClipMask(SkPath& skPath, SkPaint* spaint) {
+ SkIRect clip_box;
+ clip_box.set(0, 0, fix0_to_8(GetDeviceCaps(FXDC_PIXEL_WIDTH)),
+ fix0_to_8(GetDeviceCaps(FXDC_PIXEL_HEIGHT)));
+ clip_box.intersect(m_pAggDriver->m_pClipRgn->GetBox().left,
+ m_pAggDriver->m_pClipRgn->GetBox().top,
+ m_pAggDriver->m_pClipRgn->GetBox().right,
+ m_pAggDriver->m_pClipRgn->GetBox().bottom);
+
+ SkPath* pathPtr = &skPath;
+
+ SkRect path_rect = skPath.getBounds();
+
+ clip_box.intersect(FXSYS_floor(path_rect.fLeft), FXSYS_floor(path_rect.fTop),
+ FXSYS_floor(path_rect.fRight) + 1,
+ FXSYS_floor(path_rect.fBottom) + 1);
+ CFX_DIBitmapRef mask;
+ CFX_DIBitmap* pThisLayer = mask.New();
+ pThisLayer->Create(clip_box.width(), clip_box.height(), FXDIB_8bppMask);
+ pThisLayer->Clear(0);
+
+ CFX_SkiaA8Renderer render;
+ render.Init(pThisLayer, clip_box.fLeft, clip_box.fTop);
+
+ SkRasterClip rasterClip(clip_box);
+ SuperBlitter_skia::DrawPath(skPath, (SkBlitter*)&render, rasterClip, *spaint);
+
+ // Finally, we have got the mask that we need, intersect with current clip
+ // region
+ m_pAggDriver->m_pClipRgn->IntersectMaskF(clip_box.fLeft, clip_box.fTop, mask);
}
-FX_BOOL CFX_SkiaDeviceDriver::SetClip_PathFill(const CFX_PathData* pPathData, // path info
- const CFX_AffineMatrix* pObject2Device, // optional transformation
- int fill_mode // fill mode, WINDING or ALTERNATE
- )
-{
- if (m_pAggDriver->m_pClipRgn == NULL)
- m_pAggDriver->m_pClipRgn = FX_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_FIXFLOAT)GetDeviceCaps(FXDC_PIXEL_WIDTH), (FX_FIXFLOAT)GetDeviceCaps(FXDC_PIXEL_HEIGHT)));
- FX_RECT rect = rectf.GetOutterRect();
- m_pAggDriver->m_pClipRgn->IntersectRect(rect);
- return TRUE;
- }
- }
- CSkia_PathData path_data;
- path_data.BuildPath(pPathData, pObject2Device);
- path_data.m_PathData.close();
- path_data.m_PathData.setFillType((fill_mode&3) == FXFILL_WINDING? SkPath::kWinding_FillType:SkPath::kEvenOdd_FillType);
-
- SkPaint spaint;
- spaint.setColor(0xffffffff);
- spaint.setAntiAlias(TRUE);
- spaint.setStyle(SkPaint::kFill_Style);
-
- SetClipMask(path_data.m_PathData, &spaint);
-
- return TRUE;
+FX_BOOL CFX_SkiaDeviceDriver::SetClip_PathFill(
+ const CFX_PathData* pPathData, // path info
+ const CFX_AffineMatrix* pObject2Device, // optional transformation
+ int fill_mode // fill mode, WINDING or ALTERNATE
+ ) {
+ if (m_pAggDriver->m_pClipRgn == NULL)
+ m_pAggDriver->m_pClipRgn = FX_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_FIXFLOAT)GetDeviceCaps(FXDC_PIXEL_WIDTH),
+ (FX_FIXFLOAT)GetDeviceCaps(FXDC_PIXEL_HEIGHT)));
+ FX_RECT rect = rectf.GetOutterRect();
+ m_pAggDriver->m_pClipRgn->IntersectRect(rect);
+ return TRUE;
+ }
+ }
+ CSkia_PathData path_data;
+ path_data.BuildPath(pPathData, pObject2Device);
+ path_data.m_PathData.close();
+ path_data.m_PathData.setFillType((fill_mode & 3) == FXFILL_WINDING
+ ? SkPath::kWinding_FillType
+ : SkPath::kEvenOdd_FillType);
+
+ SkPaint spaint;
+ spaint.setColor(0xffffffff);
+ spaint.setAntiAlias(TRUE);
+ spaint.setStyle(SkPaint::kFill_Style);
+
+ SetClipMask(path_data.m_PathData, &spaint);
+
+ return TRUE;
}
-FX_BOOL CFX_SkiaDeviceDriver::SetClip_PathStroke(const CFX_PathData* pPathData, // path info
- const CFX_AffineMatrix* pObject2Device, // optional transformation
- const CFX_GraphStateData* pGraphState // graphic state, for pen attributes
- )
-{
- if (m_pAggDriver->m_pClipRgn == NULL)
- m_pAggDriver->m_pClipRgn = FX_NEW CFX_ClipRgn(GetDeviceCaps(FXDC_PIXEL_WIDTH), GetDeviceCaps(FXDC_PIXEL_HEIGHT));
-
- // build path data
- CSkia_PathData path_data;
- path_data.BuildPath(pPathData, NULL);
- path_data.m_PathData.setFillType(SkPath::kWinding_FillType);
-
- SkPaint spaint;
- spaint.setColor(0xffffffff);
- spaint.setStyle(SkPaint::kStroke_Style);
- spaint.setAntiAlias(TRUE);
-
- SkPath dst_path;
- SkRasterizeStroke(spaint, &dst_path, path_data.m_PathData, pObject2Device, pGraphState, 1, FALSE, 0);
- spaint.setStyle(SkPaint::kFill_Style);
- SetClipMask(dst_path, &spaint);
-
- return TRUE;
+FX_BOOL CFX_SkiaDeviceDriver::SetClip_PathStroke(
+ const CFX_PathData* pPathData, // path info
+ const CFX_AffineMatrix* pObject2Device, // optional transformation
+ const CFX_GraphStateData* pGraphState // graphic state, for pen attributes
+ ) {
+ if (m_pAggDriver->m_pClipRgn == NULL)
+ m_pAggDriver->m_pClipRgn = FX_NEW CFX_ClipRgn(
+ GetDeviceCaps(FXDC_PIXEL_WIDTH), GetDeviceCaps(FXDC_PIXEL_HEIGHT));
+
+ // build path data
+ CSkia_PathData path_data;
+ path_data.BuildPath(pPathData, NULL);
+ path_data.m_PathData.setFillType(SkPath::kWinding_FillType);
+
+ SkPaint spaint;
+ spaint.setColor(0xffffffff);
+ spaint.setStyle(SkPaint::kStroke_Style);
+ spaint.setAntiAlias(TRUE);
+
+ SkPath dst_path;
+ SkRasterizeStroke(spaint, &dst_path, path_data.m_PathData, pObject2Device,
+ pGraphState, 1, FALSE, 0);
+ spaint.setStyle(SkPaint::kFill_Style);
+ SetClipMask(dst_path, &spaint);
+
+ return TRUE;
}
-FX_BOOL CFX_SkiaDeviceDriver::RenderRasterizer(rasterizer_scanline_aa& rasterizer, FX_DWORD color, FX_BOOL bFullCover, FX_BOOL bGroupKnockout,
- int alpha_flag, void* pIccTransform)
-{
- return m_pAggDriver->RenderRasterizer(rasterizer, color, bFullCover, bGroupKnockout,alpha_flag, pIccTransform);
+FX_BOOL CFX_SkiaDeviceDriver::RenderRasterizer(
+ rasterizer_scanline_aa& rasterizer,
+ FX_DWORD color,
+ FX_BOOL bFullCover,
+ FX_BOOL bGroupKnockout,
+ int alpha_flag,
+ void* pIccTransform) {
+ return m_pAggDriver->RenderRasterizer(
+ rasterizer, color, bFullCover, bGroupKnockout, alpha_flag, pIccTransform);
}
-FX_BOOL CFX_SkiaDeviceDriver::RenderRasterizerSkia(SkPath& skPath, const SkPaint& origPaint, SkIRect& rect, FX_DWORD color, FX_BOOL bFullCover, FX_BOOL bGroupKnockout,
- int alpha_flag, void* pIccTransform, FX_BOOL bFill)
-{
- CFX_DIBitmap* pt = bGroupKnockout?m_pAggDriver->GetBackDrop():NULL;
- CFX_SkiaRenderer render;
- if (!render.Init(m_pAggDriver->m_pBitmap, pt, m_pAggDriver->m_pClipRgn, color, bFullCover, m_pAggDriver->m_bRgbByteOrder, alpha_flag, pIccTransform))
- return FALSE;
-
- SkRasterClip rasterClip(rect);
- SuperBlitter_skia::DrawPath(skPath, (SkBlitter*)&render, rasterClip, origPaint);
-
- return TRUE;
-
+FX_BOOL CFX_SkiaDeviceDriver::RenderRasterizerSkia(SkPath& skPath,
+ const SkPaint& origPaint,
+ SkIRect& rect,
+ FX_DWORD color,
+ FX_BOOL bFullCover,
+ FX_BOOL bGroupKnockout,
+ int alpha_flag,
+ void* pIccTransform,
+ FX_BOOL bFill) {
+ CFX_DIBitmap* pt = bGroupKnockout ? m_pAggDriver->GetBackDrop() : NULL;
+ CFX_SkiaRenderer render;
+ if (!render.Init(m_pAggDriver->m_pBitmap, pt, m_pAggDriver->m_pClipRgn, color,
+ bFullCover, m_pAggDriver->m_bRgbByteOrder, alpha_flag,
+ pIccTransform))
+ return FALSE;
+
+ SkRasterClip rasterClip(rect);
+ SuperBlitter_skia::DrawPath(skPath, (SkBlitter*)&render, rasterClip,
+ origPaint);
+
+ return TRUE;
}
-FX_BOOL CFX_SkiaDeviceDriver::DrawPath(const CFX_PathData* pPathData, // path info
- const CFX_AffineMatrix* pObject2Device, // optional transformation
- const CFX_GraphStateData* pGraphState, // graphic state, for pen attributes
- FX_DWORD fill_color, // fill color
- FX_DWORD stroke_color, // stroke color
- int fill_mode, // fill mode, WINDING or ALTERNATE. 0 for not filled
- int alpha_flag,
- void* pIccTransform
- )
-{
- if (GetBuffer() == NULL) return TRUE;
- FOXIT_DEBUG1("CFX_SkiaDeviceDriver::DrawPath: entering");
- SkIRect rect;
- rect.set(0, 0, GetDeviceCaps(FXDC_PIXEL_WIDTH), GetDeviceCaps(FXDC_PIXEL_HEIGHT));
- if ((fill_mode & 3) && fill_color) {
- // We have to transform before building path data, otherwise we'll have flatting problem
- // when we enlarge a small path (flatten before transformed)
- // TESTDOC: Bug #5115 - DS_S1Dimpact_lr.pdf
- // build path data
- CSkia_PathData path_data;
- path_data.BuildPath(pPathData, pObject2Device);
- //path_data.m_PathData.close();
- path_data.m_PathData.setFillType((fill_mode&3) == FXFILL_WINDING? SkPath::kWinding_FillType:SkPath::kEvenOdd_FillType);
-
- SkPaint spaint;
- spaint.setAntiAlias(TRUE);
- spaint.setStyle(SkPaint::kFill_Style);
- spaint.setColor(fill_color);
- if (!RenderRasterizerSkia(path_data.m_PathData, spaint, rect, 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) {
- // We split the matrix into two parts: first part doing the scaling, so we won't have the
- // flatness problem, second part doing the transformation, so we don't have stroking geo problem.
- // TESTDOC: Bug #5253 - test[1].pdf
- CFX_AffineMatrix matrix1, matrix2;
- if (pObject2Device) {
- matrix1.a = FXSYS_fabs(pObject2Device->a) > FXSYS_fabs(pObject2Device->b) ?
- FXSYS_fabs(pObject2Device->a) : FXSYS_fabs(pObject2Device->b);
- matrix1.d = matrix1.a;//FXSYS_fabs(pObject2Device->c) > FXSYS_fabs(pObject2Device->d) ?
- //pObject2Device->c : pObject2Device->d;
- matrix2.Set(pObject2Device->a/matrix1.a, pObject2Device->b/matrix1.a,
- pObject2Device->c/matrix1.d, pObject2Device->d/matrix1.d,
- pObject2Device->e, pObject2Device->f);
- }
- // build path data
- CSkia_PathData path_data;
- path_data.BuildPath(pPathData, &matrix1);
- path_data.m_PathData.setFillType(SkPath::kWinding_FillType);
-
- SkPaint spaint;
- spaint.setColor(stroke_color);
- spaint.setStyle(SkPaint::kStroke_Style);
- spaint.setAntiAlias(TRUE);
- SkPath dst_path;
- SkRasterizeStroke(spaint, &dst_path, path_data.m_PathData, &matrix2, pGraphState, matrix1.a, FALSE, 0);
- spaint.setStyle(SkPaint::kFill_Style);
- int fill_flag = FXGETFLAG_COLORTYPE(alpha_flag)<<8 | FXGETFLAG_ALPHA_STROKE(alpha_flag);
-
- if (!RenderRasterizerSkia(dst_path, spaint, rect, stroke_color, fill_mode & FXFILL_FULLCOVER, FALSE, fill_flag, pIccTransform, FALSE))
- return FALSE;
-
- }
-
- return TRUE;
+FX_BOOL CFX_SkiaDeviceDriver::DrawPath(
+ const CFX_PathData* pPathData, // path info
+ const CFX_AffineMatrix* pObject2Device, // optional transformation
+ const CFX_GraphStateData* pGraphState, // graphic state, for pen attributes
+ FX_DWORD fill_color, // fill color
+ FX_DWORD stroke_color, // stroke color
+ int fill_mode, // fill mode, WINDING or ALTERNATE. 0 for not filled
+ int alpha_flag,
+ void* pIccTransform) {
+ if (GetBuffer() == NULL)
+ return TRUE;
+ FOXIT_DEBUG1("CFX_SkiaDeviceDriver::DrawPath: entering");
+ SkIRect rect;
+ rect.set(0, 0, GetDeviceCaps(FXDC_PIXEL_WIDTH),
+ GetDeviceCaps(FXDC_PIXEL_HEIGHT));
+ if ((fill_mode & 3) && fill_color) {
+ // We have to transform before building path data, otherwise we'll have
+ // flatting problem
+ // when we enlarge a small path (flatten before transformed)
+ // TESTDOC: Bug #5115 - DS_S1Dimpact_lr.pdf
+ // build path data
+ CSkia_PathData path_data;
+ path_data.BuildPath(pPathData, pObject2Device);
+ // path_data.m_PathData.close();
+ path_data.m_PathData.setFillType((fill_mode & 3) == FXFILL_WINDING
+ ? SkPath::kWinding_FillType
+ : SkPath::kEvenOdd_FillType);
+
+ SkPaint spaint;
+ spaint.setAntiAlias(TRUE);
+ spaint.setStyle(SkPaint::kFill_Style);
+ spaint.setColor(fill_color);
+ if (!RenderRasterizerSkia(path_data.m_PathData, spaint, rect, 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) {
+ // We split the matrix into two parts: first part doing the scaling, so we
+ // won't have the
+ // flatness problem, second part doing the transformation, so we don't have
+ // stroking geo problem.
+ // TESTDOC: Bug #5253 - test[1].pdf
+ CFX_AffineMatrix matrix1, matrix2;
+ if (pObject2Device) {
+ matrix1.a = FXSYS_fabs(pObject2Device->a) > FXSYS_fabs(pObject2Device->b)
+ ? FXSYS_fabs(pObject2Device->a)
+ : FXSYS_fabs(pObject2Device->b);
+ matrix1.d = matrix1.a; // FXSYS_fabs(pObject2Device->c) >
+ // FXSYS_fabs(pObject2Device->d) ?
+ // pObject2Device->c : pObject2Device->d;
+ matrix2.Set(pObject2Device->a / matrix1.a, pObject2Device->b / matrix1.a,
+ pObject2Device->c / matrix1.d, pObject2Device->d / matrix1.d,
+ pObject2Device->e, pObject2Device->f);
+ }
+ // build path data
+ CSkia_PathData path_data;
+ path_data.BuildPath(pPathData, &matrix1);
+ path_data.m_PathData.setFillType(SkPath::kWinding_FillType);
+
+ SkPaint spaint;
+ spaint.setColor(stroke_color);
+ spaint.setStyle(SkPaint::kStroke_Style);
+ spaint.setAntiAlias(TRUE);
+ SkPath dst_path;
+ SkRasterizeStroke(spaint, &dst_path, path_data.m_PathData, &matrix2,
+ pGraphState, matrix1.a, FALSE, 0);
+ spaint.setStyle(SkPaint::kFill_Style);
+ int fill_flag = FXGETFLAG_COLORTYPE(alpha_flag) << 8 |
+ FXGETFLAG_ALPHA_STROKE(alpha_flag);
+
+ if (!RenderRasterizerSkia(dst_path, spaint, rect, stroke_color,
+ fill_mode & FXFILL_FULLCOVER, FALSE, fill_flag,
+ pIccTransform, FALSE))
+ return FALSE;
+ }
+
+ return TRUE;
}
-FX_BOOL CFX_SkiaDeviceDriver::SetPixel(int x, int y, FX_DWORD color,
- int alpha_flag, void* pIccTransform)
-{
- return m_pAggDriver->SetPixel(x, y, color, alpha_flag, pIccTransform);
+FX_BOOL CFX_SkiaDeviceDriver::SetPixel(int x,
+ int y,
+ FX_DWORD color,
+ int alpha_flag,
+ void* pIccTransform) {
+ return m_pAggDriver->SetPixel(x, y, color, alpha_flag, pIccTransform);
}
-FX_BOOL CFX_SkiaDeviceDriver::FillRect(const FX_RECT* pRect, FX_DWORD fill_color, int alpha_flag, void* pIccTransform)
-{
- return m_pAggDriver->FillRect(pRect, fill_color, alpha_flag, pIccTransform);
+FX_BOOL CFX_SkiaDeviceDriver::FillRect(const FX_RECT* pRect,
+ FX_DWORD fill_color,
+ int alpha_flag,
+ void* pIccTransform) {
+ return m_pAggDriver->FillRect(pRect, fill_color, alpha_flag, pIccTransform);
}
-FX_BOOL CFX_SkiaDeviceDriver::GetClipBox(FX_RECT* pRect)
-{
- return m_pAggDriver->GetClipBox(pRect);
+FX_BOOL CFX_SkiaDeviceDriver::GetClipBox(FX_RECT* pRect) {
+ return m_pAggDriver->GetClipBox(pRect);
}
-FX_BOOL CFX_SkiaDeviceDriver::GetDIBits(CFX_DIBitmap* pBitmap, int left, int top, void* pIccTransform, FX_BOOL bDEdge)
-{
- return m_pAggDriver->GetDIBits(pBitmap, left, top, pIccTransform, bDEdge);
+FX_BOOL CFX_SkiaDeviceDriver::GetDIBits(CFX_DIBitmap* pBitmap,
+ int left,
+ int top,
+ void* pIccTransform,
+ FX_BOOL bDEdge) {
+ return m_pAggDriver->GetDIBits(pBitmap, left, top, pIccTransform, bDEdge);
}
-FX_BOOL CFX_SkiaDeviceDriver::SetDIBits(const CFX_DIBSource* pBitmap, FX_DWORD argb, const FX_RECT* pSrcRect, int left, int top, int blend_type,
- int alpha_flag, void* pIccTransform)
-{
- return m_pAggDriver->SetDIBits(pBitmap, argb, pSrcRect, left, top, blend_type, alpha_flag, pIccTransform);
+FX_BOOL CFX_SkiaDeviceDriver::SetDIBits(const CFX_DIBSource* pBitmap,
+ FX_DWORD argb,
+ const FX_RECT* pSrcRect,
+ int left,
+ int top,
+ int blend_type,
+ int alpha_flag,
+ void* pIccTransform) {
+ return m_pAggDriver->SetDIBits(pBitmap, argb, pSrcRect, left, top, blend_type,
+ alpha_flag, pIccTransform);
}
-FX_BOOL CFX_SkiaDeviceDriver::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)
-{
- return m_pAggDriver->StretchDIBits(pSource, argb, dest_left, dest_top,
- dest_width, dest_height, pClipRect, flags,
- alpha_flag, pIccTransform);
+FX_BOOL CFX_SkiaDeviceDriver::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) {
+ return m_pAggDriver->StretchDIBits(pSource, argb, dest_left, dest_top,
+ dest_width, dest_height, pClipRect, flags,
+ alpha_flag, pIccTransform);
}
-FX_BOOL CFX_SkiaDeviceDriver::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)
-{
- return m_pAggDriver->StartDIBits(pSource, bitmap_alpha, argb,
- pMatrix, render_flags, handle, alpha_flag, pIccTransform);
+FX_BOOL CFX_SkiaDeviceDriver::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) {
+ return m_pAggDriver->StartDIBits(pSource, bitmap_alpha, argb, pMatrix,
+ render_flags, handle, alpha_flag,
+ pIccTransform);
}
-FX_BOOL CFX_SkiaDeviceDriver::ContinueDIBits(void* pHandle, IFX_Pause* pPause)
-{
- return m_pAggDriver->ContinueDIBits(pHandle, pPause);
+FX_BOOL CFX_SkiaDeviceDriver::ContinueDIBits(void* pHandle, IFX_Pause* pPause) {
+ return m_pAggDriver->ContinueDIBits(pHandle, pPause);
}
-void CFX_SkiaDeviceDriver::CancelDIBits(void* pHandle)
-{
- m_pAggDriver->CancelDIBits(pHandle);
+void CFX_SkiaDeviceDriver::CancelDIBits(void* pHandle) {
+ m_pAggDriver->CancelDIBits(pHandle);
}
-CFX_SkiaDevice::CFX_SkiaDevice()
-{
- m_bOwnedBitmap = FALSE;
+CFX_SkiaDevice::CFX_SkiaDevice() {
+ m_bOwnedBitmap = FALSE;
}
-FX_BOOL CFX_SkiaDevice::Attach(CFX_DIBitmap* pBitmap, int dither_bits, FX_BOOL bRgbByteOrder, CFX_DIBitmap* pOriDevice, FX_BOOL bGroupKnockout)
-{
- if (pBitmap == NULL)
- return FALSE;
- SetBitmap(pBitmap);
- CFX_SkiaDeviceDriver* pDriver = FX_NEW CFX_SkiaDeviceDriver(pBitmap, dither_bits, bRgbByteOrder, pOriDevice, bGroupKnockout);
- SetDeviceDriver(pDriver);
- return TRUE;
+FX_BOOL CFX_SkiaDevice::Attach(CFX_DIBitmap* pBitmap,
+ int dither_bits,
+ FX_BOOL bRgbByteOrder,
+ CFX_DIBitmap* pOriDevice,
+ FX_BOOL bGroupKnockout) {
+ if (pBitmap == NULL)
+ return FALSE;
+ SetBitmap(pBitmap);
+ CFX_SkiaDeviceDriver* pDriver = FX_NEW CFX_SkiaDeviceDriver(
+ pBitmap, dither_bits, bRgbByteOrder, pOriDevice, bGroupKnockout);
+ SetDeviceDriver(pDriver);
+ return TRUE;
}
-FX_BOOL CFX_SkiaDevice::Create(int width, int height, FXDIB_Format format, int dither_bits, CFX_DIBitmap* pOriDevice)
-{
- m_bOwnedBitmap = TRUE;
- CFX_DIBitmap* pBitmap = FX_NEW CFX_DIBitmap;
- if (!pBitmap->Create(width, height, format)) {
- delete pBitmap;
- return FALSE;
- }
- SetBitmap(pBitmap);
- CFX_SkiaDeviceDriver* pDriver = FX_NEW CFX_SkiaDeviceDriver(pBitmap, dither_bits, FALSE, pOriDevice, FALSE);
- SetDeviceDriver(pDriver);
- return TRUE;
+FX_BOOL CFX_SkiaDevice::Create(int width,
+ int height,
+ FXDIB_Format format,
+ int dither_bits,
+ CFX_DIBitmap* pOriDevice) {
+ m_bOwnedBitmap = TRUE;
+ CFX_DIBitmap* pBitmap = FX_NEW CFX_DIBitmap;
+ if (!pBitmap->Create(width, height, format)) {
+ delete pBitmap;
+ return FALSE;
+ }
+ SetBitmap(pBitmap);
+ CFX_SkiaDeviceDriver* pDriver = FX_NEW CFX_SkiaDeviceDriver(
+ pBitmap, dither_bits, FALSE, pOriDevice, FALSE);
+ SetDeviceDriver(pDriver);
+ return TRUE;
}
-CFX_SkiaDevice::~CFX_SkiaDevice()
-{
- if (m_bOwnedBitmap && GetBitmap()) delete GetBitmap();
+CFX_SkiaDevice::~CFX_SkiaDevice() {
+ if (m_bOwnedBitmap && GetBitmap())
+ delete GetBitmap();
}
#endif \ No newline at end of file
diff --git a/core/src/fxge/skia/fx_skia_device.h b/core/src/fxge/skia/fx_skia_device.h
index ab51e51a33..1de829b783 100644
--- a/core/src/fxge/skia/fx_skia_device.h
+++ b/core/src/fxge/skia/fx_skia_device.h
@@ -6,85 +6,141 @@
#define CORE_SRC_FXGE_SKIA_FX_SKIA_DEVICE_H_
#if defined(_SKIA_SUPPORT_)
-class CFX_SkiaDeviceDriver : public IFX_RenderDeviceDriver
-{
-public:
- CFX_SkiaDeviceDriver(CFX_DIBitmap* pBitmap, int dither_bits, FX_BOOL bRgbByteOrder, CFX_DIBitmap* pOriDevice, FX_BOOL bGroupKnockout);
- virtual ~CFX_SkiaDeviceDriver();
-
- /** Options */
- virtual int GetDeviceCaps(int caps_id);
-
- /** Save and restore all graphic states */
- virtual void SaveState();
- virtual void RestoreState(FX_BOOL bKeepSaved);
-
- /** Set clipping path using filled region */
- virtual FX_BOOL SetClip_PathFill(const CFX_PathData* pPathData, // path info
- const CFX_AffineMatrix* pObject2Device, // optional transformation
- int fill_mode // fill mode, WINDING or ALTERNATE
- );
-
- /** Set clipping path using stroked region */
- virtual FX_BOOL SetClip_PathStroke(const CFX_PathData* pPathData, // path info
- const CFX_AffineMatrix* pObject2Device, // optional transformation
- const CFX_GraphStateData* pGraphState // graphic state, for pen attributes
- );
-
- /** Draw a path */
- virtual FX_BOOL DrawPath(const CFX_PathData* pPathData,
- const CFX_AffineMatrix* pObject2Device,
- const CFX_GraphStateData* pGraphState,
- FX_DWORD fill_color,
- FX_DWORD stroke_color,
- int fill_mode,
- int alpha_flag = 0,
- void* pIccTransform = NULL
- );
-
- virtual FX_BOOL SetPixel(int x, int y, FX_DWORD color,
- int alpha_flag = 0, void* pIccTransform = NULL);
-
- virtual FX_BOOL FillRect(const FX_RECT* pRect, FX_DWORD fill_color,
- int alpha_flag = 0, void* pIccTransform = NULL);
-
- /** Draw a single pixel (device dependant) line */
- virtual FX_BOOL DrawCosmeticLine(FX_FIXFLOAT x1, FX_FIXFLOAT y1, FX_FIXFLOAT x2, FX_FIXFLOAT y2, FX_DWORD color,
- int alpha_flag, void* pIccTransform, int blend_type) { return FALSE; }
-
- virtual FX_BOOL GetClipBox(FX_RECT* pRect);
-
- /** Load device buffer into a DIB */
- virtual FX_BOOL GetDIBits(CFX_DIBitmap* pBitmap, int left, int top, void* pIccTransform = NULL, FX_BOOL bDEdge = FALSE);
-
- virtual CFX_DIBitmap* GetBackDrop() { return m_pAggDriver->GetBackDrop(); }
-
- virtual FX_BOOL SetDIBits(const CFX_DIBSource* pBitmap, FX_DWORD color, const FX_RECT* pSrcRect,
- int dest_left, int dest_top, int blend_type,
- int alpha_flag = 0, void* pIccTransform = NULL);
- virtual FX_BOOL StretchDIBits(const CFX_DIBSource* pBitmap, FX_DWORD color, int dest_left, int dest_top,
- int dest_width, int dest_height, const FX_RECT* pClipRect, FX_DWORD flags,
- int alpha_flag = 0, void* pIccTransform = NULL);
-
- virtual FX_BOOL StartDIBits(const CFX_DIBSource* pBitmap, int bitmap_alpha, FX_DWORD color,
- const CFX_AffineMatrix* pMatrix, FX_DWORD flags, void*& handle,
- int alpha_flag = 0, void* pIccTransform = NULL);
- virtual FX_BOOL ContinueDIBits(void* handle, IFX_Pause* pPause);
- virtual void CancelDIBits(void* handle);
-
- virtual FX_BOOL DrawDeviceText(int nChars, const FXTEXT_CHARPOS* pCharPos, CFX_Font* pFont,
- CFX_FontCache* pCache, const CFX_AffineMatrix* pObject2Device, FX_FIXFLOAT font_size, FX_DWORD color,
- int alpha_flag = 0, void* pIccTransform = NULL);
-
- virtual FX_BOOL RenderRasterizer(rasterizer_scanline_aa& rasterizer, FX_DWORD color, FX_BOOL bFullCover, FX_BOOL bGroupKnockout,
- int alpha_flag, void* pIccTransform);
- virtual FX_BOOL RenderRasterizerSkia(SkPath& skPath, const SkPaint& origPaint, SkIRect& rect, FX_DWORD color, FX_BOOL bFullCover, FX_BOOL bGroupKnockout,
- int alpha_flag, void* pIccTransform, FX_BOOL bFill = TRUE);
- void SetClipMask(rasterizer_scanline_aa& rasterizer);
- void SetClipMask(SkPath& skPath, SkPaint* spaint);
- virtual uint8_t* GetBuffer() const {return m_pAggDriver->GetBuffer();}
-
- CFX_AggDeviceDriver* m_pAggDriver;
+class CFX_SkiaDeviceDriver : public IFX_RenderDeviceDriver {
+ public:
+ CFX_SkiaDeviceDriver(CFX_DIBitmap* pBitmap,
+ int dither_bits,
+ FX_BOOL bRgbByteOrder,
+ CFX_DIBitmap* pOriDevice,
+ FX_BOOL bGroupKnockout);
+ virtual ~CFX_SkiaDeviceDriver();
+
+ /** Options */
+ virtual int GetDeviceCaps(int caps_id);
+
+ /** Save and restore all graphic states */
+ virtual void SaveState();
+ virtual void RestoreState(FX_BOOL bKeepSaved);
+
+ /** Set clipping path using filled region */
+ virtual FX_BOOL SetClip_PathFill(
+ const CFX_PathData* pPathData, // path info
+ const CFX_AffineMatrix* pObject2Device, // optional transformation
+ int fill_mode // fill mode, WINDING or ALTERNATE
+ );
+
+ /** Set clipping path using stroked region */
+ virtual FX_BOOL SetClip_PathStroke(
+ const CFX_PathData* pPathData, // path info
+ const CFX_AffineMatrix* pObject2Device, // optional transformation
+ const CFX_GraphStateData*
+ pGraphState // graphic state, for pen attributes
+ );
+
+ /** Draw a path */
+ virtual FX_BOOL DrawPath(const CFX_PathData* pPathData,
+ const CFX_AffineMatrix* pObject2Device,
+ const CFX_GraphStateData* pGraphState,
+ FX_DWORD fill_color,
+ FX_DWORD stroke_color,
+ int fill_mode,
+ int alpha_flag = 0,
+ void* pIccTransform = NULL);
+
+ virtual FX_BOOL SetPixel(int x,
+ int y,
+ FX_DWORD color,
+ int alpha_flag = 0,
+ void* pIccTransform = NULL);
+
+ virtual FX_BOOL FillRect(const FX_RECT* pRect,
+ FX_DWORD fill_color,
+ int alpha_flag = 0,
+ void* pIccTransform = NULL);
+
+ /** Draw a single pixel (device dependant) line */
+ virtual FX_BOOL DrawCosmeticLine(FX_FIXFLOAT x1,
+ FX_FIXFLOAT y1,
+ FX_FIXFLOAT x2,
+ FX_FIXFLOAT y2,
+ FX_DWORD color,
+ int alpha_flag,
+ void* pIccTransform,
+ int blend_type) {
+ return FALSE;
+ }
+
+ virtual FX_BOOL GetClipBox(FX_RECT* pRect);
+
+ /** Load device buffer into a DIB */
+ virtual FX_BOOL GetDIBits(CFX_DIBitmap* pBitmap,
+ int left,
+ int top,
+ void* pIccTransform = NULL,
+ FX_BOOL bDEdge = FALSE);
+
+ virtual CFX_DIBitmap* GetBackDrop() { return m_pAggDriver->GetBackDrop(); }
+
+ virtual FX_BOOL SetDIBits(const CFX_DIBSource* pBitmap,
+ FX_DWORD color,
+ const FX_RECT* pSrcRect,
+ int dest_left,
+ int dest_top,
+ int blend_type,
+ int alpha_flag = 0,
+ void* pIccTransform = NULL);
+ virtual FX_BOOL StretchDIBits(const CFX_DIBSource* pBitmap,
+ FX_DWORD color,
+ int dest_left,
+ int dest_top,
+ int dest_width,
+ int dest_height,
+ const FX_RECT* pClipRect,
+ FX_DWORD flags,
+ int alpha_flag = 0,
+ void* pIccTransform = NULL);
+
+ virtual FX_BOOL StartDIBits(const CFX_DIBSource* pBitmap,
+ int bitmap_alpha,
+ FX_DWORD color,
+ const CFX_AffineMatrix* pMatrix,
+ FX_DWORD flags,
+ void*& handle,
+ int alpha_flag = 0,
+ void* pIccTransform = NULL);
+ virtual FX_BOOL ContinueDIBits(void* handle, IFX_Pause* pPause);
+ virtual void CancelDIBits(void* handle);
+
+ virtual FX_BOOL DrawDeviceText(int nChars,
+ const FXTEXT_CHARPOS* pCharPos,
+ CFX_Font* pFont,
+ CFX_FontCache* pCache,
+ const CFX_AffineMatrix* pObject2Device,
+ FX_FIXFLOAT font_size,
+ FX_DWORD color,
+ int alpha_flag = 0,
+ void* pIccTransform = NULL);
+
+ virtual FX_BOOL RenderRasterizer(rasterizer_scanline_aa& rasterizer,
+ FX_DWORD color,
+ FX_BOOL bFullCover,
+ FX_BOOL bGroupKnockout,
+ int alpha_flag,
+ void* pIccTransform);
+ virtual FX_BOOL RenderRasterizerSkia(SkPath& skPath,
+ const SkPaint& origPaint,
+ SkIRect& rect,
+ FX_DWORD color,
+ FX_BOOL bFullCover,
+ FX_BOOL bGroupKnockout,
+ int alpha_flag,
+ void* pIccTransform,
+ FX_BOOL bFill = TRUE);
+ void SetClipMask(rasterizer_scanline_aa& rasterizer);
+ void SetClipMask(SkPath& skPath, SkPaint* spaint);
+ virtual uint8_t* GetBuffer() const { return m_pAggDriver->GetBuffer(); }
+
+ CFX_AggDeviceDriver* m_pAggDriver;
};
#endif // defined(_SKIA_SUPPORT_)