| // 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 "core/include/fxge/fx_ge.h" |
| |
| //#define _SKIA_SUPPORT_ |
| #if defined(_SKIA_SUPPORT_) |
| #include "SkBlitter.h" |
| #include "core/include/fxcodec/fx_codec.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 && !composite_span) |
| 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::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; |
| |
| int index = 0; |
| if (m_pDevice->GetPalette()) { |
| for (int i = 0; i < 2; i++) { |
| if (FXARGB_TODIB(m_pDevice->GetPalette()[i]) == m_Color) |
| index = i; |
| } |
| } else { |
| index = ((uint8_t)m_Color == 0xff) ? 1 : 0; |
| } |
| 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; |
| } |
| } |
| 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()) { |
| for (int i = 0; i < 2; i++) { |
| if (FXARGB_TODIB(m_pDevice->GetPalette()[i]) == m_Color) |
| index = i; |
| } |
| } else { |
| index = ((uint8_t)m_Color == 0xff) ? 1 : 0; |
| } |
| 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++; |
| } |
| } |
| 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++; |
| } |
| #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(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; |
| #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(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) { |
| FXSYS_memset(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; |
| } |
| 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; |
| |
| 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; |
| } |
| } |
| 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; |
| } |
| } |
| #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; |
| } |
| } |
| } |
| #endif |
| } |
| |
| 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++) { |
| #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(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; |
| } |
| } |
| #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(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; |
| } |
| #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(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++; |
| } |
| } |
| 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); |
| *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(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++; |
| } |
| } |
| #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(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++; |
| } |
| #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(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++; |
| } |
| #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 |
| } |
| 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++; |
| } |
| } |
| #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 |
| } |
| /*-----------------------------------------------------------------------------------------------------*/ |
| |
| // 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 (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; |
| } |
| } 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) { |
| 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; |
| } |
| return !!composite_span; |
| } |
| |
| /*----------------------------------------------------------------------------------------------------*/ |
| 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; |
| |
| 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 |
