Google Git
Sign in
pdfium / pdfium / 72c93731969695eb0e11aab170e980555c54a74a / . / core / src / fxge / skia / fx_skia_blitter_new.cpp
blob: a107485d72164060f65ec52f0ab8e48f5ce7e6e2 [file] [log] [blame]
// Copyright 2014 PDFium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "../../../include/fxge/fx_ge.h"
//#define _SKIA_SUPPORT_
#if defined(_SKIA_SUPPORT_)
#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)
(this->*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;
(this->*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) {
this->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;
this->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(FX_LPBYTE dest_scan, FX_LPBYTE ori_scan,int Bpp,
int span_left, int span_len, int span_top, FX_BYTE cover_scan,
int clip_top, int clip_left, int clip_right, FX_LPBYTE clip_scan,
FX_LPBYTE dest_extra_alpha_scan)
{
ASSERT(!m_bRgbByteOrder);
ASSERT(!m_pDevice->IsCmykImage());
dest_scan = (FX_BYTE*)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 = ((FX_BYTE)m_Color == 0xff) ? 1 : 0;
else {
for (int i = 0; i < 2; i ++)
if (FXARGB_TODIB(m_pDevice->GetPalette()[i]) == m_Color)
index = i;
}
FX_LPBYTE 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;
}
}
void CFX_SkiaRenderer::CompositeSpan1bpp_4(FX_LPBYTE dest_scan, FX_LPBYTE ori_scan,int Bpp,
int span_left, int span_len, int span_top, FX_BYTE cover_scan,
int clip_top, int clip_left, int clip_right, FX_LPBYTE clip_scan,
FX_LPBYTE dest_extra_alpha_scan)
{
ASSERT(!m_bRgbByteOrder);
ASSERT(!m_pDevice->IsCmykImage());
dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + span_left/8;
clip_scan = (FX_BYTE*)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 = ((FX_BYTE)m_Color == 0xff) ? 1 : 0;
else {
for (int i = 0; i < 2; i ++)
if (FXARGB_TODIB(m_pDevice->GetPalette()[i]) == m_Color)
index = i;
}
FX_LPBYTE 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(FX_LPBYTE dest_scan, FX_LPBYTE ori_scan,int Bpp,
int span_left, int span_len, int span_top, FX_BYTE cover_scan,
int clip_top, int clip_left, int clip_right, FX_LPBYTE clip_scan,
FX_LPBYTE dest_extra_alpha_scan)
{
ASSERT(!m_pDevice->IsCmykImage());
ASSERT(!m_bRgbByteOrder);
dest_scan = (FX_BYTE*)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_memset32(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(FX_LPBYTE dest_scan, FX_LPBYTE ori_scan,int Bpp,
int span_left, int span_len, int span_top, FX_BYTE cover_scan,
int clip_top, int clip_left, int clip_right, FX_LPBYTE clip_scan,
FX_LPBYTE dest_extra_alpha_scan)
{
ASSERT(!m_pDevice->IsCmykImage());
ASSERT(!m_bRgbByteOrder);
dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + span_left;
ori_scan = (FX_BYTE*)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_memset32(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 ++;
}
#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
}
}
void CFX_SkiaRenderer::CompositeSpanGray_6(FX_LPBYTE dest_scan, FX_LPBYTE ori_scan,int Bpp,
int span_left, int span_len, int span_top, FX_BYTE cover_scan,
int clip_top, int clip_left, int clip_right, FX_LPBYTE clip_scan,
FX_LPBYTE dest_extra_alpha_scan)
{
ASSERT(!m_bRgbByteOrder);
dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + span_left;
clip_scan = (FX_BYTE*)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(FX_LPBYTE dest_scan, FX_LPBYTE ori_scan,int Bpp,
int span_left, int span_len, int span_top, FX_BYTE cover_scan,
int clip_top, int clip_left, int clip_right, FX_LPBYTE clip_scan,
FX_LPBYTE dest_extra_alpha_scan)
{
ASSERT(!m_pDevice->IsCmykImage());
dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + span_left;
ori_scan = (FX_BYTE*)m_pOriDevice->GetScanline(span_top) + span_left;
clip_scan = (FX_BYTE*)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++;
}
#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
}
/*--------------------------------------------------------------------------------------------------*/
void CFX_SkiaRenderer::CompositeSpanARGB_2(FX_LPBYTE dest_scan, FX_LPBYTE ori_scan,int Bpp,
int span_left, int span_len, int span_top, FX_BYTE cover_scan,
int clip_top, int clip_left, int clip_right, FX_LPBYTE clip_scan,
FX_LPBYTE dest_extra_alpha_scan)
{
dest_scan = (FX_BYTE*)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_memset32(dest_scan, m_Color, (col_end - col_start)<<2);
return;
}
int src_alpha;
#if 0
if (m_bFullCover) {
if (m_Alpha == 255) {
FXSYS_memset32(dest_scan, m_Color, (col_end - col_start)<<2);
return;
}
}
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;
}
FX_BYTE 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(FX_LPBYTE dest_scan, FX_LPBYTE ori_scan,int Bpp,
int span_left, int span_len, int span_top, FX_BYTE cover_scan,
int clip_top, int clip_left, int clip_right, FX_LPBYTE clip_scan,
FX_LPBYTE dest_extra_alpha_scan)
{
ASSERT(!m_pDevice->IsCmykImage());
dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + (span_left<<2);
//ori_scan = (FX_BYTE*)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_memset32(dest_scan, m_Color, (col_end - col_start)<<2);
return;
}
if (cover_scan == 255) {
int dst_color = (0x00ffffff&m_Color)|(m_Alpha<<24);
FXSYS_memset32(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;
}
}
void CFX_SkiaRenderer::CompositeSpanARGB_6(FX_LPBYTE dest_scan, FX_LPBYTE ori_scan,int Bpp,
int span_left, int span_len, int span_top, FX_BYTE cover_scan,
int clip_top, int clip_left, int clip_right, FX_LPBYTE clip_scan,
FX_LPBYTE dest_extra_alpha_scan)
{
dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + (span_left<<2);
clip_scan = (FX_BYTE*)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;
}
FX_BYTE 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;
}
FX_BYTE 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;
}
FX_BYTE 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::CompositeSpanARGB_7(FX_LPBYTE dest_scan, FX_LPBYTE ori_scan,int Bpp,
int span_left, int span_len, int span_top, FX_BYTE cover_scan,
int clip_top, int clip_left, int clip_right, FX_LPBYTE clip_scan,
FX_LPBYTE dest_extra_alpha_scan)
{
ASSERT(!m_pDevice->IsCmykImage());
dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + (span_left<<2);
//ori_scan = (FX_BYTE*)m_pOriDevice->GetScanline(span_top) + (span_left<<2);
clip_scan = (FX_BYTE*)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(FX_LPBYTE dest_scan, FX_LPBYTE ori_scan,int Bpp,
int span_left, int span_len, int span_top, FX_BYTE cover_scan,
int clip_top, int clip_left, int clip_right, FX_LPBYTE clip_scan,
FX_LPBYTE dest_extra_alpha_scan)
{
dest_scan = (FX_BYTE*)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_memset32(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(FX_LPBYTE dest_scan, FX_LPBYTE ori_scan,int Bpp,
int span_left, int span_len, int span_top, FX_BYTE cover_scan,
int clip_top, int clip_left, int clip_right, FX_LPBYTE clip_scan,
FX_LPBYTE dest_extra_alpha_scan)
{
dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + (span_left<<2);
ori_scan = (FX_BYTE*)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_memset32(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);
*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;
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(FX_LPBYTE dest_scan, FX_LPBYTE ori_scan,int Bpp,
int span_left, int span_len, int span_top, FX_BYTE cover_scan,
int clip_top, int clip_left, int clip_right, FX_LPBYTE clip_scan,
FX_LPBYTE dest_extra_alpha_scan)
{
dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + (span_left<<2);
clip_scan = (FX_BYTE*)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;
}
}
#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
}
void CFX_SkiaRenderer::CompositeSpanRGB32_7(FX_LPBYTE dest_scan, FX_LPBYTE ori_scan,int Bpp,
int span_left, int span_len, int span_top, FX_BYTE cover_scan,
int clip_top, int clip_left, int clip_right, FX_LPBYTE clip_scan,
FX_LPBYTE dest_extra_alpha_scan)
{
ASSERT(!m_pDevice->IsCmykImage());
dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + (span_left<<2);
ori_scan = (FX_BYTE*)m_pOriDevice->GetScanline(span_top) + (span_left<<2);
clip_scan = (FX_BYTE*)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;
}
#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
}
/*-----------------------------------------------------------------------------------------------------*/
void CFX_SkiaRenderer::CompositeSpanRGB24_2(FX_LPBYTE dest_scan, FX_LPBYTE ori_scan,int Bpp,
int span_left, int span_len, int span_top, FX_BYTE cover_scan,
int clip_top, int clip_left, int clip_right, FX_LPBYTE clip_scan,
FX_LPBYTE dest_extra_alpha_scan)
{
dest_scan = (FX_BYTE*)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 ++;
}
}
void CFX_SkiaRenderer::CompositeSpanRGB24_3(FX_LPBYTE dest_scan, FX_LPBYTE ori_scan,int Bpp,
int span_left, int span_len, int span_top, FX_BYTE cover_scan,
int clip_top, int clip_left, int clip_right, FX_LPBYTE clip_scan,
FX_LPBYTE dest_extra_alpha_scan)
{
ASSERT(!m_pDevice->IsCmykImage());
dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + span_left + (span_left<<1);
ori_scan = (FX_BYTE*)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);
*dest_scan++ = FXDIB_ALPHA_MERGE(*ori_scan++, m_Green, m_Alpha);
*dest_scan++ = FXDIB_ALPHA_MERGE(*ori_scan++, m_Red, m_Alpha);
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(FX_LPBYTE dest_scan, FX_LPBYTE ori_scan,int Bpp,
int span_left, int span_len, int span_top, FX_BYTE cover_scan,
int clip_top, int clip_left, int clip_right, FX_LPBYTE clip_scan,
FX_LPBYTE dest_extra_alpha_scan)
{
dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + span_left+(span_left<<1);
clip_scan = (FX_BYTE*)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 ++;
}
}
#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
}
void CFX_SkiaRenderer::CompositeSpanRGB24_7(FX_LPBYTE dest_scan, FX_LPBYTE ori_scan,int Bpp,
int span_left, int span_len, int span_top, FX_BYTE cover_scan,
int clip_top, int clip_left, int clip_right, FX_LPBYTE clip_scan,
FX_LPBYTE dest_extra_alpha_scan)
{
ASSERT(!m_pDevice->IsCmykImage());
dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + span_left+(span_left<<1);
ori_scan = (FX_BYTE*)m_pOriDevice->GetScanline(span_top) + span_left+(span_left<<1);
clip_scan = (FX_BYTE*)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 ++;
}
#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
}
void CFX_SkiaRenderer::CompositeSpanRGB24_10(FX_LPBYTE dest_scan, FX_LPBYTE ori_scan,int Bpp,
int span_left, int span_len, int span_top, FX_BYTE cover_scan,
int clip_top, int clip_left, int clip_right, FX_LPBYTE clip_scan,
FX_LPBYTE dest_extra_alpha_scan)
{
dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + span_left+(span_left<<1);
dest_extra_alpha_scan = (FX_BYTE*)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++ = (FX_BYTE)m_Blue;
*dest_scan++ = (FX_BYTE)m_Green;
*dest_scan++ = (FX_BYTE)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)
FX_BYTE 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++ = (FX_BYTE)m_Blue;
*dest_scan++ = (FX_BYTE)m_Green;
*dest_scan++ = (FX_BYTE)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)
FX_BYTE 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++ = (FX_BYTE)m_Blue;
*dest_scan++ = (FX_BYTE)m_Green;
*dest_scan++ = (FX_BYTE)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)
FX_BYTE 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(FX_LPBYTE dest_scan, FX_LPBYTE ori_scan,int Bpp,
int span_left, int span_len, int span_top, FX_BYTE cover_scan,
int clip_top, int clip_left, int clip_right, FX_LPBYTE clip_scan,
FX_LPBYTE dest_extra_alpha_scan)
{
dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + span_left+(span_left<<1);
dest_extra_alpha_scan = (FX_BYTE*)m_pDevice->m_pAlphaMask->GetScanline(span_top)+span_left;
clip_scan = (FX_BYTE*)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++ = (FX_BYTE)m_Blue;
*dest_scan++ = (FX_BYTE)m_Green;
*dest_scan++ = (FX_BYTE)m_Red;
*dest_extra_alpha_scan++ = (FX_BYTE)m_Alpha;
} else {
// Dest format: Rgba
// calculate destination alpha (it's union of source and dest alpha)
FX_BYTE 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++ = (FX_BYTE)m_Blue;
*dest_scan++ = (FX_BYTE)m_Green;
*dest_scan++ = (FX_BYTE)m_Red;
*dest_extra_alpha_scan++ = (FX_BYTE)m_Alpha;
} else {
// Dest format: Rgba
// calculate destination alpha (it's union of source and dest alpha)
FX_BYTE 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++ = (FX_BYTE)m_Blue;
*dest_scan++ = (FX_BYTE)m_Green;
*dest_scan++ = (FX_BYTE)m_Red;
*dest_extra_alpha_scan++ = (FX_BYTE)m_Alpha;
} else {
// Dest format: Rgba
// calculate destination alpha (it's union of source and dest alpha)
FX_BYTE 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(FX_LPBYTE dest_scan, FX_LPBYTE ori_scan,int Bpp,
int span_left, int span_len, int span_top, FX_BYTE cover_scan,
int clip_top, int clip_left, int clip_right, FX_LPBYTE clip_scan,
FX_LPBYTE 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 (src_alpha) {
if (src_alpha == 255) {
*(FX_CMYK*)dest_scan = m_Color;
*dest_extra_alpha_scan = (FX_BYTE)m_Alpha;
} else {
// Dest format: Cmyka
// calculate destination alpha (it's union of source and dest alpha)
FX_BYTE 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;
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;
}
}
}
//--------------------------------------------------------------------
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_bFullCover = bFullCover;
FX_BOOL bObjectCMYK = FXGETFLAG_COLORTYPE(alpha_flag);
FX_BOOL bDeviceCMYK = pDevice->IsCmykImage();
m_Alpha = bObjectCMYK ? FXGETFLAG_ALPHA_FILL(alpha_flag) : FXARGB_A(color);
ICodec_IccModule* pIccModule = NULL;
// 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();
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) {
FX_BYTE gray;
color = bObjectCMYK ? FXCMYK_TODIB(color) : FXARGB_TODIB(color);
pIccModule->TranslateScanline(pIccTransform, &gray, (FX_LPCBYTE)&color, 1);
m_Gray = gray;
} else {
if (bObjectCMYK) {
FX_BYTE 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, (FX_LPBYTE)&m_Color, (FX_LPCBYTE)&m_Color, 1);
} else { // Object RGB
if (!pIccTransform)
return FALSE;
color = FXARGB_TODIB(color);
pIccModule->TranslateScanline(pIccTransform, (FX_LPBYTE)&m_Color, (FX_LPCBYTE)&color, 1);
}
m_Red = ((FX_LPBYTE)&m_Color)[0];
m_Green = ((FX_LPBYTE)&m_Color)[1];
m_Blue = ((FX_LPBYTE)&m_Color)[2];
m_Gray = ((FX_LPBYTE)&m_Color)[3];
return TRUE;
} else {
if (pIccTransform) {
color = bObjectCMYK ? FXCMYK_TODIB(color) : FXARGB_TODIB(color);
pIccModule->TranslateScanline(pIccTransform, (FX_LPBYTE)&m_Color, (FX_LPCBYTE)&color, 1);
((FX_LPBYTE)&m_Color)[3] = m_Alpha;
m_Red = ((FX_LPBYTE)&m_Color)[2];
m_Green = ((FX_LPBYTE)&m_Color)[1];
m_Blue = ((FX_LPBYTE)&m_Color)[0];
// Need Johnson to improvement it.
if (m_bRgbByteOrder) {
// swap
m_Red = ((FX_LPBYTE)&m_Color)[0];
m_Blue = ((FX_LPBYTE)&m_Color)[2];
m_Color = FXARGB_TODIB(m_Color);
m_Color = FXARGB_TOBGRORDERDIB(m_Color);
}
} else {
if (bObjectCMYK) {
FX_BYTE 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;
}
/*----------------------------------------------------------------------------------------------------*/
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_LPBYTE dest_scan = m_pDevice->GetBuffer() + m_pDevice->GetPitch() * dst_y;
FX_LPBYTE 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_memset32(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;
FX_LPBYTE 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) {
FX_BYTE* dest_pos = dest_scan + col_start;
if (result >= 4)
FXSYS_memset32(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) {
this->blitRect(x, y, 1, height);
} else {
int16_t runs[2];
runs[0] = 1;
runs[1] = 0;
while (--height >= 0) {
if (y >= m_dstHeight)
return;
this->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