Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(131)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: core/src/fxge/skia/fx_skia_blitter_new.cpp

Issue 453133004: clang-format all code (Closed) Base URL: https://pdfium.googlesource.com/pdfium.git@master
Patch Set: Created 6 years, 4 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« core/src/fdrm/crypto/fx_crypt_aes.cpp ('K') | « core/src/fxge/skia/fx_skia_blitter_new.h ('k') | core/src/fxge/skia/fx_skia_device.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 // Copyright 2014 PDFium Authors. All rights reserved. 1 // Copyright 2014 PDFium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include "../../../include/fxge/fx_ge.h" 5 #include "../../../include/fxge/fx_ge.h"
6 //#define _SKIA_SUPPORT_ 6 //#define _SKIA_SUPPORT_
7 #if defined(_SKIA_SUPPORT_) 7 #if defined(_SKIA_SUPPORT_)
8 #include "../../../include/fxcodec/fx_codec.h" 8 #include "../../../include/fxcodec/fx_codec.h"
9 #include "SkBlitter.h" 9 #include "SkBlitter.h"
10 #include "fx_skia_blitter_new.h" 10 #include "fx_skia_blitter_new.h"
11 // We use our own renderer here to make it simple 11 // We use our own renderer here to make it simple
12 void CFX_SkiaRenderer::blitAntiH(int x, int y, const SkAlpha antialias[] , const int16_t runs[]) 12 void CFX_SkiaRenderer::blitAntiH(int x,
13 { 13 int y,
14 FXSYS_assert(m_Alpha); 14 const SkAlpha antialias[],
15 if (m_pOriDevice == NULL && composite_span == NULL) return; 15 const int16_t runs[]) {
16 if (y < m_ClipBox.top || y >= m_ClipBox.bottom) return; 16 FXSYS_assert(m_Alpha);
17 while (1) 17 if (m_pOriDevice == NULL && composite_span == NULL)
18 { 18 return;
19 int width = runs[0]; 19 if (y < m_ClipBox.top || y >= m_ClipBox.bottom)
20 SkASSERT(width >= 0); 20 return;
21 if (width <= 0) 21 while (1) {
22 return; 22 int width = runs[0];
23 unsigned aa = antialias[0]; 23 SkASSERT(width >= 0);
24 if (aa) 24 if (width <= 0)
25 (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); 25 return;
26 runs += width; 26 unsigned aa = antialias[0];
27 antialias += width; 27 if (aa)
28 x += width; 28 (this->*composite_span)(m_pDestScan,
29 } 29 m_pOriScan,
30 } 30 0,
31 31 x,
32 void CFX_SkiaRenderer::blitH(int x, int y, int width) 32 width,
33 { 33 y,
34 FXSYS_assert(m_Alpha && width); 34 aa,
35 if (y < m_ClipBox.top || y >= m_ClipBox.bottom) return; 35 m_ClipBox.top,
36 (this->*composite_span)(m_pDestScan, m_pOriScan, 0, x, width, y, 255, m_ClipBox.top, m_ClipBox.left, m_ClipBox.right, m_pClipScan, m_pDestExtraA lphaScan); 36 m_ClipBox.left,
37 } 37 m_ClipBox.right,
38 38 m_pClipScan,
39 void CFX_SkiaRenderer::blitV(int x, int y, int height, SkAlpha alpha) 39 m_pDestExtraAlphaScan);
40 { 40 runs += width;
41 FXSYS_assert(m_Alpha && alpha); 41 antialias += width;
42 if (alpha == 255) { 42 x += width;
43 this->blitRect(x, y, 1, height); 43 }
44 } else { 44 }
45 int16_t runs[2]; 45
46 runs[0] = 1; 46 void CFX_SkiaRenderer::blitH(int x, int y, int width) {
47 runs[1] = 0; 47 FXSYS_assert(m_Alpha && width);
48 while (--height >= 0) { 48 if (y < m_ClipBox.top || y >= m_ClipBox.bottom)
49 if (y >= m_ClipBox.bottom) 49 return;
50 return; 50 (this->*composite_span)(m_pDestScan,
51 this->blitAntiH(x, y ++, &alpha, runs); 51 m_pOriScan,
52 } 52 0,
53 } 53 x,
54 } 54 width,
55 void CFX_SkiaRenderer::blitRect(int x, int y, int width, int height) 55 y,
56 { 56 255,
57 FXSYS_assert(m_Alpha && width); 57 m_ClipBox.top,
58 while (--height >= 0){ 58 m_ClipBox.left,
59 if (y >= m_ClipBox.bottom) 59 m_ClipBox.right,
60 return; 60 m_pClipScan,
61 blitH(x, y ++, width); 61 m_pDestExtraAlphaScan);
62 } 62 }
63 } 63
64 64 void CFX_SkiaRenderer::blitV(int x, int y, int height, SkAlpha alpha) {
65 void CFX_SkiaRenderer::blitAntiRect(int x, int y, int width, int height, 65 FXSYS_assert(m_Alpha && alpha);
66 SkAlpha leftAlpha, SkAlpha rightAlpha) 66 if (alpha == 255) {
67 { 67 this->blitRect(x, y, 1, height);
68 blitV(x++, y, height, leftAlpha); 68 } else {
69 if (width > 0) { 69 int16_t runs[2];
70 blitRect(x, y, width, height); 70 runs[0] = 1;
71 x += width; 71 runs[1] = 0;
72 } 72 while (--height >= 0) {
73 blitV(x, y, height, rightAlpha); 73 if (y >= m_ClipBox.bottom)
74 } 74 return;
75 /*---------------------------------------------------------------------- -----------------------------*/ 75 this->blitAntiH(x, y++, &alpha, runs);
76 void CFX_SkiaRenderer::CompositeSpan1bpp_0(FX_LPBYTE dest_scan, FX_LPBYT E ori_scan,int Bpp, 76 }
77 int span_left, int span_len, int span_top, FX_BYTE cover _scan, 77 }
78 int clip_top, int clip_left, int clip_right, FX_LPBYTE c lip_scan, 78 }
79 FX_LPBYTE dest_extra_alpha_scan) 79 void CFX_SkiaRenderer::blitRect(int x, int y, int width, int height) {
80 { 80 FXSYS_assert(m_Alpha && width);
81 ASSERT(!m_bRgbByteOrder); 81 while (--height >= 0) {
82 ASSERT(!m_pDevice->IsCmykImage()); 82 if (y >= m_ClipBox.bottom)
83 dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + span_le ft/8; 83 return;
84 int col_start = span_left < clip_left ? clip_left - span_left : 0; 84 blitH(x, y++, width);
85 int col_end = (span_left + span_len) < clip_right ? span_len : ( clip_right - span_left); 85 }
86 if (col_end < col_start) return; // do nothing. 86 }
87 dest_scan += col_start/8; 87
88 88 void CFX_SkiaRenderer::blitAntiRect(int x,
89 int index = 0; 89 int y,
90 if (m_pDevice->GetPalette() == NULL) 90 int width,
91 index = ((FX_BYTE)m_Color == 0xff) ? 1 : 0; 91 int height,
92 else { 92 SkAlpha leftAlpha,
93 for (int i = 0; i < 2; i ++) 93 SkAlpha rightAlpha) {
94 if (FXARGB_TODIB(m_pDevice->GetPalette()[i]) == m_Color) 94 blitV(x++, y, height, leftAlpha);
95 index = i; 95 if (width > 0) {
96 } 96 blitRect(x, y, width, height);
97 FX_LPBYTE dest_scan1 = dest_scan; 97 x += width;
98 int src_alpha = m_Alpha * cover_scan / 255; 98 }
99 for (int col = col_start; col < col_end; col ++) { 99 blitV(x, y, height, rightAlpha);
100 if (src_alpha) { 100 }
101 if (!index) 101 /*------------------------------------------------------------------------------ ---------------------*/
102 *dest_scan1 &= ~(1 << (7 - (col+span_lef t)%8)); 102 void CFX_SkiaRenderer::CompositeSpan1bpp_0(FX_LPBYTE dest_scan,
103 else 103 FX_LPBYTE ori_scan,
104 *dest_scan1|= 1 << (7 - (col+span_left)% 8); 104 int Bpp,
105 } 105 int span_left,
106 dest_scan1 = dest_scan+(span_left%8+col-col_start+1)/8; 106 int span_len,
107 } 107 int span_top,
108 } 108 FX_BYTE cover_scan,
109 void CFX_SkiaRenderer::CompositeSpan1bpp_4(FX_LPBYTE dest_scan, FX_LPBYT E ori_scan,int Bpp, 109 int clip_top,
110 int span_left, int span_len, int span_top, FX_BYTE cover _scan, 110 int clip_left,
111 int clip_top, int clip_left, int clip_right, FX_LPBYTE c lip_scan, 111 int clip_right,
112 FX_LPBYTE dest_extra_alpha_scan) 112 FX_LPBYTE clip_scan,
113 { 113 FX_LPBYTE dest_extra_alpha_scan) {
114 ASSERT(!m_bRgbByteOrder); 114 ASSERT(!m_bRgbByteOrder);
115 ASSERT(!m_pDevice->IsCmykImage()); 115 ASSERT(!m_pDevice->IsCmykImage());
116 dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + span_le ft/8; 116 dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + span_left / 8;
117 clip_scan = (FX_BYTE*)m_pClipMask->GetScanline(span_top-clip_top ) - clip_left + span_left; 117 int col_start = span_left < clip_left ? clip_left - span_left : 0;
118 int col_start = span_left < clip_left ? clip_left - span_left : 0; 118 int col_end =
119 int col_end = (span_left + span_len) < clip_right ? span_len : ( clip_right - span_left); 119 (span_left + span_len) < clip_right ? span_len : (clip_right - span_left);
120 if (col_end < col_start) return; // do nothing. 120 if (col_end < col_start)
121 dest_scan += col_start/8; 121 return; // do nothing.
122 122 dest_scan += col_start / 8;
123 int index = 0; 123
124 if (m_pDevice->GetPalette() == NULL) 124 int index = 0;
125 index = ((FX_BYTE)m_Color == 0xff) ? 1 : 0; 125 if (m_pDevice->GetPalette() == NULL)
126 else { 126 index = ((FX_BYTE)m_Color == 0xff) ? 1 : 0;
127 for (int i = 0; i < 2; i ++) 127 else {
128 if (FXARGB_TODIB(m_pDevice->GetPalette()[i]) == m_Color) 128 for (int i = 0; i < 2; i++)
129 index = i; 129 if (FXARGB_TODIB(m_pDevice->GetPalette()[i]) == m_Color)
130 } 130 index = i;
131 FX_LPBYTE dest_scan1 = dest_scan; 131 }
132 int src_alpha = m_Alpha * cover_scan / 255; 132 FX_LPBYTE dest_scan1 = dest_scan;
133 for (int col = col_start; col < col_end; col ++) { 133 int src_alpha = m_Alpha * cover_scan / 255;
134 int src_alpha1 = src_alpha * clip_scan[col] / 255; 134 for (int col = col_start; col < col_end; col++) {
135 if (src_alpha1) { 135 if (src_alpha) {
136 if (!index) 136 if (!index)
137 *dest_scan1 &= ~(1 << (7 - (col+span_lef t)%8)); 137 *dest_scan1 &= ~(1 << (7 - (col + span_left) % 8));
138 else 138 else
139 *dest_scan1|= 1 << (7 - (col+span_left)% 8); 139 *dest_scan1 |= 1 << (7 - (col + span_left) % 8);
140 } 140 }
141 dest_scan1 = dest_scan+(span_left%8+col-col_start+1)/8; 141 dest_scan1 = dest_scan + (span_left % 8 + col - col_start + 1) / 8;
142 } 142 }
143 } 143 }
144 /*---------------------------------------------------------------------- -------------------------------*/ 144 void CFX_SkiaRenderer::CompositeSpan1bpp_4(FX_LPBYTE dest_scan,
145 void CFX_SkiaRenderer::CompositeSpanGray_2(FX_LPBYTE dest_scan, FX_LPBYT E ori_scan,int Bpp, 145 FX_LPBYTE ori_scan,
146 int span_left, int span_len, int span_top, FX_BYTE cover _scan, 146 int Bpp,
147 int clip_top, int clip_left, int clip_right, FX_LPBYTE c lip_scan, 147 int span_left,
148 FX_LPBYTE dest_extra_alpha_scan) 148 int span_len,
149 { 149 int span_top,
150 ASSERT(!m_pDevice->IsCmykImage()); 150 FX_BYTE cover_scan,
151 ASSERT(!m_bRgbByteOrder); 151 int clip_top,
152 dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + span_le ft; 152 int clip_left,
153 int col_start = span_left < clip_left ? clip_left - span_left : 0; 153 int clip_right,
154 int col_end = (span_left + span_len) < clip_right ? span_len : ( clip_right - span_left); 154 FX_LPBYTE clip_scan,
155 if (col_end < col_start) return; // do nothing. 155 FX_LPBYTE dest_extra_alpha_scan) {
156 dest_scan += col_start; 156 ASSERT(!m_bRgbByteOrder);
157 if (cover_scan == 255 && m_Alpha == 255) { 157 ASSERT(!m_pDevice->IsCmykImage());
158 FXSYS_memset32(dest_scan, FXARGB_MAKE(m_Gray, m_Gray, m_ Gray, m_Gray), col_end - col_start); 158 dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + span_left / 8;
159 return; 159 clip_scan = (FX_BYTE*)m_pClipMask->GetScanline(span_top - clip_top) -
160 } 160 clip_left + span_left;
161 int src_alpha = m_Alpha * cover_scan / 255; 161 int col_start = span_left < clip_left ? clip_left - span_left : 0;
162 for (int col = col_start; col < col_end; col ++) { 162 int col_end =
163 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Gray, src_a lpha); 163 (span_left + span_len) < clip_right ? span_len : (clip_right - span_left);
164 dest_scan++; 164 if (col_end < col_start)
165 } 165 return; // do nothing.
166 } 166 dest_scan += col_start / 8;
167 void CFX_SkiaRenderer::CompositeSpanGray_3(FX_LPBYTE dest_scan, FX_LPBYT E ori_scan,int Bpp, 167
168 int span_left, int span_len, int span_top, FX_BYTE cover _scan, 168 int index = 0;
169 int clip_top, int clip_left, int clip_right, FX_LPBYTE c lip_scan, 169 if (m_pDevice->GetPalette() == NULL)
170 FX_LPBYTE dest_extra_alpha_scan) 170 index = ((FX_BYTE)m_Color == 0xff) ? 1 : 0;
171 { 171 else {
172 ASSERT(!m_pDevice->IsCmykImage()); 172 for (int i = 0; i < 2; i++)
173 ASSERT(!m_bRgbByteOrder); 173 if (FXARGB_TODIB(m_pDevice->GetPalette()[i]) == m_Color)
174 dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + span_le ft; 174 index = i;
175 ori_scan = (FX_BYTE*)m_pOriDevice->GetScanline(span_top) + span _left; 175 }
176 int col_start = span_left < clip_left ? clip_left - span_left : 0; 176 FX_LPBYTE dest_scan1 = dest_scan;
177 int col_end = (span_left + span_len) < clip_right ? span_len : ( clip_right - span_left); 177 int src_alpha = m_Alpha * cover_scan / 255;
178 if (col_end < col_start) return; // do nothing. 178 for (int col = col_start; col < col_end; col++) {
179 dest_scan += col_start; 179 int src_alpha1 = src_alpha * clip_scan[col] / 255;
180 ori_scan += col_start; 180 if (src_alpha1) {
181 if (m_Alpha == 255 && cover_scan == 255) { 181 if (!index)
182 FXSYS_memset32(dest_scan, FXARGB_MAKE(m_Gray, m_Gray, m_ Gray, m_Gray), col_end - col_start); 182 *dest_scan1 &= ~(1 << (7 - (col + span_left) % 8));
183 } else { 183 else
184 int src_alpha = m_Alpha; 184 *dest_scan1 |= 1 << (7 - (col + span_left) % 8);
185 }
186 dest_scan1 = dest_scan + (span_left % 8 + col - col_start + 1) / 8;
187 }
188 }
189 /*------------------------------------------------------------------------------ -----------------------*/
190 void CFX_SkiaRenderer::CompositeSpanGray_2(FX_LPBYTE dest_scan,
191 FX_LPBYTE ori_scan,
192 int Bpp,
193 int span_left,
194 int span_len,
195 int span_top,
196 FX_BYTE cover_scan,
197 int clip_top,
198 int clip_left,
199 int clip_right,
200 FX_LPBYTE clip_scan,
201 FX_LPBYTE dest_extra_alpha_scan) {
202 ASSERT(!m_pDevice->IsCmykImage());
203 ASSERT(!m_bRgbByteOrder);
204 dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + span_left;
205 int col_start = span_left < clip_left ? clip_left - span_left : 0;
206 int col_end =
207 (span_left + span_len) < clip_right ? span_len : (clip_right - span_left);
208 if (col_end < col_start)
209 return; // do nothing.
210 dest_scan += col_start;
211 if (cover_scan == 255 && m_Alpha == 255) {
212 FXSYS_memset32(dest_scan,
213 FXARGB_MAKE(m_Gray, m_Gray, m_Gray, m_Gray),
214 col_end - col_start);
215 return;
216 }
217 int src_alpha = m_Alpha * cover_scan / 255;
218 for (int col = col_start; col < col_end; col++) {
219 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Gray, src_alpha);
220 dest_scan++;
221 }
222 }
223 void CFX_SkiaRenderer::CompositeSpanGray_3(FX_LPBYTE dest_scan,
224 FX_LPBYTE ori_scan,
225 int Bpp,
226 int span_left,
227 int span_len,
228 int span_top,
229 FX_BYTE cover_scan,
230 int clip_top,
231 int clip_left,
232 int clip_right,
233 FX_LPBYTE clip_scan,
234 FX_LPBYTE dest_extra_alpha_scan) {
235 ASSERT(!m_pDevice->IsCmykImage());
236 ASSERT(!m_bRgbByteOrder);
237 dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + span_left;
238 ori_scan = (FX_BYTE*)m_pOriDevice->GetScanline(span_top) + span_left;
239 int col_start = span_left < clip_left ? clip_left - span_left : 0;
240 int col_end =
241 (span_left + span_len) < clip_right ? span_len : (clip_right - span_left);
242 if (col_end < col_start)
243 return; // do nothing.
244 dest_scan += col_start;
245 ori_scan += col_start;
246 if (m_Alpha == 255 && cover_scan == 255) {
247 FXSYS_memset32(dest_scan,
248 FXARGB_MAKE(m_Gray, m_Gray, m_Gray, m_Gray),
249 col_end - col_start);
250 } else {
251 int src_alpha = m_Alpha;
185 #if 1 252 #if 1
186 » » » for (int col = col_start; col < col_end; col ++) { 253 for (int col = col_start; col < col_end; col++) {
187 » » » » int gray = FXDIB_ALPHA_MERGE(*ori_scan++, m_Gray , src_alpha); 254 int gray = FXDIB_ALPHA_MERGE(*ori_scan++, m_Gray, src_alpha);
188 » » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, cover_scan); 255 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, cover_scan);
189 » » » » dest_scan ++; 256 dest_scan++;
190 » » » } 257 }
191 #else 258 #else
192 » » » if (m_bFullCover) { 259 if (m_bFullCover) {
193 » » » » if (src_alpha == 255) { 260 if (src_alpha == 255) {
194 » » » » » FXSYS_memset(dest_scan, FXARGB_MAKE(m_Gr ay, m_Gray, m_Gray, m_Gray), col_end - col_start); 261 FXSYS_memset(dest_scan,
195 » » » » » return; 262 FXARGB_MAKE(m_Gray, m_Gray, m_Gray, m_Gray),
196 » » » » } 263 col_end - col_start);
197 » » » » for (int col = col_start; col < col_end; col ++) 264 return;
198 » » » » » *dest_scan = FXDIB_ALPHA_MERGE(*ori_scan ++, m_Gray, src_alpha); 265 }
199 » » » } else { 266 for (int col = col_start; col < col_end; col++)
200 » » » » for (int col = col_start; col < col_end; col ++) { 267 *dest_scan = FXDIB_ALPHA_MERGE(*ori_scan++, m_Gray, src_alpha);
201 » » » » » int gray = FXDIB_ALPHA_MERGE(*ori_scan++ , m_Gray, src_alpha); 268 } else {
202 » » » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_sca n, gray, cover_scan); 269 for (int col = col_start; col < col_end; col++) {
203 » » » » » dest_scan++; 270 int gray = FXDIB_ALPHA_MERGE(*ori_scan++, m_Gray, src_alpha);
204 » » » » } 271 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, cover_scan);
205 » » » } 272 dest_scan++;
273 }
274 }
206 #endif 275 #endif
207 » » } 276 }
208 » } 277 }
209 278
210 » void CFX_SkiaRenderer::CompositeSpanGray_6(FX_LPBYTE dest_scan, FX_LPBYT E ori_scan,int Bpp, 279 void CFX_SkiaRenderer::CompositeSpanGray_6(FX_LPBYTE dest_scan,
211 » » » int span_left, int span_len, int span_top, FX_BYTE cover _scan, 280 FX_LPBYTE ori_scan,
212 » » » int clip_top, int clip_left, int clip_right, FX_LPBYTE c lip_scan, 281 int Bpp,
213 » » » FX_LPBYTE dest_extra_alpha_scan) 282 int span_left,
214 » { 283 int span_len,
215 » » ASSERT(!m_bRgbByteOrder); 284 int span_top,
216 » » dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + span_le ft; 285 FX_BYTE cover_scan,
217 » » clip_scan = (FX_BYTE*)m_pClipMask->GetScanline(span_top-clip_top ) - clip_left + span_left; 286 int clip_top,
218 » » int col_start = span_left < clip_left ? clip_left - span_left : 0; 287 int clip_left,
219 » » int col_end = (span_left + span_len) < clip_right ? span_len : ( clip_right - span_left); 288 int clip_right,
220 » » if (col_end < col_start) return; // do nothing. 289 FX_LPBYTE clip_scan,
221 » » dest_scan += col_start; 290 FX_LPBYTE dest_extra_alpha_scan) {
222 » » int src_alpha = m_Alpha * cover_scan / 255; 291 ASSERT(!m_bRgbByteOrder);
223 » » for (int col = col_start; col < col_end; col ++) { 292 dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + span_left;
224 » » » int src_alpha1 = src_alpha * clip_scan[col] / 255; 293 clip_scan = (FX_BYTE*)m_pClipMask->GetScanline(span_top - clip_top) -
225 » » » if (!src_alpha1) { 294 clip_left + span_left;
226 » » » » dest_scan ++; 295 int col_start = span_left < clip_left ? clip_left - span_left : 0;
227 » » » » continue; 296 int col_end =
228 » » » } 297 (span_left + span_len) < clip_right ? span_len : (clip_right - span_left);
229 » » » if (src_alpha1 == 255) 298 if (col_end < col_start)
230 » » » » *dest_scan++ = m_Gray; 299 return; // do nothing.
231 » » » else { 300 dest_scan += col_start;
232 » » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Gra y, src_alpha1); 301 int src_alpha = m_Alpha * cover_scan / 255;
233 » » » » dest_scan ++; 302 for (int col = col_start; col < col_end; col++) {
234 » » » } 303 int src_alpha1 = src_alpha * clip_scan[col] / 255;
235 » » }» 304 if (!src_alpha1) {
236 » } 305 dest_scan++;
237 306 continue;
238 » void CFX_SkiaRenderer::CompositeSpanGray_7(FX_LPBYTE dest_scan, FX_LPBYT E ori_scan,int Bpp, 307 }
239 » » » int span_left, int span_len, int span_top, FX_BYTE cover _scan, 308 if (src_alpha1 == 255)
240 » » » int clip_top, int clip_left, int clip_right, FX_LPBYTE c lip_scan, 309 *dest_scan++ = m_Gray;
241 » » » FX_LPBYTE dest_extra_alpha_scan) 310 else {
242 » { 311 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Gray, src_alpha1);
243 » » ASSERT(!m_pDevice->IsCmykImage()); 312 dest_scan++;
244 » » dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + span_le ft; 313 }
245 » » ori_scan = (FX_BYTE*)m_pOriDevice->GetScanline(span_top) + span _left; 314 }
246 » » clip_scan = (FX_BYTE*)m_pClipMask->GetScanline(span_top-clip_top ) - clip_left + span_left; 315 }
247 » » int col_start = span_left < clip_left ? clip_left - span_left : 0; 316
248 » » int col_end = (span_left + span_len) < clip_right ? span_len : ( clip_right - span_left); 317 void CFX_SkiaRenderer::CompositeSpanGray_7(FX_LPBYTE dest_scan,
249 » » if (col_end < col_start) return; // do nothing. 318 FX_LPBYTE ori_scan,
250 » » dest_scan += col_start; 319 int Bpp,
251 » » ori_scan += col_start; 320 int span_left,
321 int span_len,
322 int span_top,
323 FX_BYTE cover_scan,
324 int clip_top,
325 int clip_left,
326 int clip_right,
327 FX_LPBYTE clip_scan,
328 FX_LPBYTE dest_extra_alpha_scan) {
329 ASSERT(!m_pDevice->IsCmykImage());
330 dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + span_left;
331 ori_scan = (FX_BYTE*)m_pOriDevice->GetScanline(span_top) + span_left;
332 clip_scan = (FX_BYTE*)m_pClipMask->GetScanline(span_top - clip_top) -
333 clip_left + span_left;
334 int col_start = span_left < clip_left ? clip_left - span_left : 0;
335 int col_end =
336 (span_left + span_len) < clip_right ? span_len : (clip_right - span_left);
337 if (col_end < col_start)
338 return; // do nothing.
339 dest_scan += col_start;
340 ori_scan += col_start;
252 #if 1 341 #if 1
253 » » for (int col = col_start; col < col_end; col ++) { 342 for (int col = col_start; col < col_end; col++) {
254 » » » int src_alpha = m_Alpha * clip_scan[col] / 255; 343 int src_alpha = m_Alpha * clip_scan[col] / 255;
255 » » » if (src_alpha == 255 && cover_scan == 255) { 344 if (src_alpha == 255 && cover_scan == 255) {
256 » » » » *dest_scan++ = m_Gray; 345 *dest_scan++ = m_Gray;
257 » » » » ori_scan++; 346 ori_scan++;
258 » » » » continue; 347 continue;
259 » » » } 348 }
260 » » » int gray = FXDIB_ALPHA_MERGE(*ori_scan++, m_Gray, src_al pha); 349 int gray = FXDIB_ALPHA_MERGE(*ori_scan++, m_Gray, src_alpha);
261 » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, cover_s can); 350 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, cover_scan);
262 » » » dest_scan++; 351 dest_scan++;
263 » » } 352 }
264 353
265 #else 354 #else
266 » » if (m_bFullCover) { 355 if (m_bFullCover) {
267 » » » for (int col = col_start; col < col_end; col ++) { 356 for (int col = col_start; col < col_end; col++) {
268 » » » » int src_alpha = m_Alpha * clip_scan[col] / 255; 357 int src_alpha = m_Alpha * clip_scan[col] / 255;
269 » » » » if (!src_alpha) { 358 if (!src_alpha) {
270 » » » » » dest_scan++; 359 dest_scan++;
271 » » » » » ori_scan++; 360 ori_scan++;
272 » » » » » continue; 361 continue;
273 » » » » } 362 }
274 » » » » if (src_alpha == 255){ 363 if (src_alpha == 255) {
275 » » » » » *dest_scan++ = m_Gray; 364 *dest_scan++ = m_Gray;
276 » » » » » ori_scan++; 365 ori_scan++;
277 » » » » » continue; 366 continue;
278 » » » » } 367 }
279 » » » » *dest_scan++ = FXDIB_ALPHA_MERGE(*ori_scan++, m_ Gray, src_alpha); 368 *dest_scan++ = FXDIB_ALPHA_MERGE(*ori_scan++, m_Gray, src_alpha);
280 » » » } 369 }
281 » » } else { 370 } else {
282 » » » for (int col = col_start; col < col_end; col ++) { 371 for (int col = col_start; col < col_end; col++) {
283 » » » » int src_alpha = m_Alpha * clip_scan[col] / 255; 372 int src_alpha = m_Alpha * clip_scan[col] / 255;
284 » » » » if (src_alpha == 255 && cover_scan == 255) { 373 if (src_alpha == 255 && cover_scan == 255) {
285 » » » » » *dest_scan++ = m_Gray; 374 *dest_scan++ = m_Gray;
286 » » » » » ori_scan++; 375 ori_scan++;
287 » » » » » continue; 376 continue;
288 » » » » } 377 }
289 » » » » int gray = FXDIB_ALPHA_MERGE(*ori_scan++, m_Gray , src_alpha); 378 int gray = FXDIB_ALPHA_MERGE(*ori_scan++, m_Gray, src_alpha);
290 » » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, cover_scan); 379 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, cover_scan);
291 » » » » dest_scan++; 380 dest_scan++;
292 » » » } 381 }
293 » » } 382 }
294 #endif 383 #endif
295 » } 384 }
296 » /*---------------------------------------------------------------------- ----------------------------*/ 385 /*------------------------------------------------------------------------------ --------------------*/
297 386
298 » void CFX_SkiaRenderer::CompositeSpanARGB_2(FX_LPBYTE dest_scan, FX_LPBYT E ori_scan,int Bpp, 387 void CFX_SkiaRenderer::CompositeSpanARGB_2(FX_LPBYTE dest_scan,
299 » » » int span_left, int span_len, int span_top, FX_BYTE cover _scan, 388 FX_LPBYTE ori_scan,
300 » » » int clip_top, int clip_left, int clip_right, FX_LPBYTE c lip_scan, 389 int Bpp,
301 » » » FX_LPBYTE dest_extra_alpha_scan) 390 int span_left,
302 » { 391 int span_len,
303 » » dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + (span_l eft<<2); 392 int span_top,
304 » » int col_start = span_left < clip_left ? clip_left - span_left : 0; 393 FX_BYTE cover_scan,
305 » » int col_end = (span_left + span_len) < clip_right ? span_len : ( clip_right - span_left); 394 int clip_top,
306 » » if (col_end < col_start) return; // do nothing. 395 int clip_left,
307 » » dest_scan += col_start<<2; 396 int clip_right,
308 » » if (m_Alpha == 255 && cover_scan == 255) { 397 FX_LPBYTE clip_scan,
309 » » » FXSYS_memset32(dest_scan, m_Color, (col_end - col_start) <<2); 398 FX_LPBYTE dest_extra_alpha_scan) {
310 » » » return; 399 dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + (span_left << 2);
311 » » } 400 int col_start = span_left < clip_left ? clip_left - span_left : 0;
312 » » int src_alpha; 401 int col_end =
402 (span_left + span_len) < clip_right ? span_len : (clip_right - span_left);
403 if (col_end < col_start)
404 return; // do nothing.
405 dest_scan += col_start << 2;
406 if (m_Alpha == 255 && cover_scan == 255) {
407 FXSYS_memset32(dest_scan, m_Color, (col_end - col_start) << 2);
408 return;
409 }
410 int src_alpha;
313 #if 0 411 #if 0
314 if (m_bFullCover) { 412 if (m_bFullCover) {
315 if (m_Alpha == 255) { 413 if (m_Alpha == 255) {
316 FXSYS_memset32(dest_scan, m_Color, (col_end - co l_start)<<2); 414 FXSYS_memset32(dest_scan, m_Color, (col_end - co l_start)<<2);
317 return; 415 return;
318 } 416 }
319 } 417 }
320 » » else 418 » » else
321 #endif 419 #endif
322 » » » src_alpha = m_Alpha * cover_scan / 255; 420 src_alpha = m_Alpha * cover_scan / 255;
323 » » for (int col = col_start; col < col_end; col ++) { 421 for (int col = col_start; col < col_end; col++) {
324 » » » // Dest format: Argb 422 // Dest format: Argb
325 » » » // calculate destination alpha (it's union of source and dest alpha) 423 // calculate destination alpha (it's union of source and dest alpha)
326 » » » if (dest_scan[3] == 0) { 424 if (dest_scan[3] == 0) {
327 » » » » dest_scan[3] = src_alpha; 425 dest_scan[3] = src_alpha;
328 » » » » *dest_scan++ = m_Blue; 426 *dest_scan++ = m_Blue;
329 » » » » *dest_scan++ = m_Green; 427 *dest_scan++ = m_Green;
330 » » » » *dest_scan = m_Red; 428 *dest_scan = m_Red;
331 » » » » dest_scan += 2; 429 dest_scan += 2;
332 » » » » continue; 430 continue;
333 » » » } 431 }
334 » » » FX_BYTE dest_alpha = dest_scan[3] + src_alpha - dest_sca n[3] * src_alpha / 255; 432 FX_BYTE dest_alpha =
335 » » » dest_scan[3] = dest_alpha; 433 dest_scan[3] + src_alpha - dest_scan[3] * src_alpha / 255;
336 » » » int alpha_ratio = src_alpha*255/dest_alpha; 434 dest_scan[3] = dest_alpha;
337 » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, alpha _ratio); 435 int alpha_ratio = src_alpha * 255 / dest_alpha;
338 » » » dest_scan ++; 436 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, alpha_ratio);
339 » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, alph a_ratio); 437 dest_scan++;
340 » » » dest_scan ++; 438 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, alpha_ratio);
341 » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, alpha_ ratio); 439 dest_scan++;
342 » » » dest_scan += 2; 440 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, alpha_ratio);
343 » » } 441 dest_scan += 2;
344 » } 442 }
443 }
345 444
346 » void CFX_SkiaRenderer::CompositeSpanARGB_3(FX_LPBYTE dest_scan, FX_LPBYT E ori_scan,int Bpp, 445 void CFX_SkiaRenderer::CompositeSpanARGB_3(FX_LPBYTE dest_scan,
347 » » » int span_left, int span_len, int span_top, FX_BYTE cover _scan, 446 FX_LPBYTE ori_scan,
348 » » » int clip_top, int clip_left, int clip_right, FX_LPBYTE c lip_scan, 447 int Bpp,
349 » » » FX_LPBYTE dest_extra_alpha_scan) 448 int span_left,
350 » { 449 int span_len,
351 » » ASSERT(!m_pDevice->IsCmykImage()); 450 int span_top,
352 » » dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + (span_l eft<<2); 451 FX_BYTE cover_scan,
353 » » //ori_scan = (FX_BYTE*)m_pOriDevice->GetScanline(span_top) + (s pan_left<<2); 452 int clip_top,
354 » » int col_start = span_left < clip_left ? clip_left - span_left : 0; 453 int clip_left,
355 » » int col_end = (span_left + span_len) < clip_right ? span_len : ( clip_right - span_left); 454 int clip_right,
356 » » if (col_end < col_start) return; // do nothing. 455 FX_LPBYTE clip_scan,
357 » » dest_scan += col_start << 2; 456 FX_LPBYTE dest_extra_alpha_scan) {
358 » » //ori_scan += col_start << 2; 457 ASSERT(!m_pDevice->IsCmykImage());
458 dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + (span_left << 2);
459 // ori_scan = (FX_BYTE*)m_pOriDevice->GetScanline(span_top) + (span_left<<2);
460 int col_start = span_left < clip_left ? clip_left - span_left : 0;
461 int col_end =
462 (span_left + span_len) < clip_right ? span_len : (clip_right - span_left);
463 if (col_end < col_start)
464 return; // do nothing.
465 dest_scan += col_start << 2;
466 // ori_scan += col_start << 2;
359 467
360 » » if (m_Alpha == 255 && cover_scan == 255){ 468 if (m_Alpha == 255 && cover_scan == 255) {
361 » » » FXSYS_memset32(dest_scan, m_Color, (col_end - col_start) <<2); 469 FXSYS_memset32(dest_scan, m_Color, (col_end - col_start) << 2);
362 » » » return; 470 return;
363 » » }» » 471 }
364 » » if (cover_scan == 255) { 472 if (cover_scan == 255) {
365 » » » int dst_color = (0x00ffffff&m_Color)|(m_Alpha<<24); 473 int dst_color = (0x00ffffff & m_Color) | (m_Alpha << 24);
366 » » » FXSYS_memset32(dest_scan, dst_color, (col_end - col_star t)<<2); 474 FXSYS_memset32(dest_scan, dst_color, (col_end - col_start) << 2);
367 » » » return; 475 return;
368 » » } 476 }
369 » » // Do not need origin bitmap, because of merge in pure transpare nt background 477 // Do not need origin bitmap, because of merge in pure transparent background
370 » » int src_alpha_covered = m_Alpha * cover_scan / 255; 478 int src_alpha_covered = m_Alpha * cover_scan / 255;
371 » » for (int col = col_start; col < col_end; col ++) 479 for (int col = col_start; col < col_end; col++) {
372 » » { 480 // shortcut
373 » » » // shortcut 481 if (dest_scan[3] == 0) {
374 » » » if (dest_scan[3] == 0) { 482 dest_scan[3] = src_alpha_covered;
375 » » » » dest_scan[3] = src_alpha_covered; 483 *dest_scan++ = m_Blue;
376 » » » » *dest_scan ++ = m_Blue; 484 *dest_scan++ = m_Green;
377 » » » » *dest_scan ++ = m_Green; 485 *dest_scan = m_Red;
378 » » » » *dest_scan = m_Red; 486 dest_scan += 2;
379 » » » » dest_scan += 2; 487 continue;
380 » » » » continue; 488 }
381 » » » } 489 // We should do alpha transition and color transition
382 » » » // We should do alpha transition and color transition 490 // alpha fg color fg
383 » » » // alpha fg color fg 491 // alpha bg color bg
384 » » » // alpha bg color bg 492 // alpha cover color cover
385 » » » // alpha cover color cover 493 dest_scan[3] = FXDIB_ALPHA_MERGE(dest_scan[3], m_Alpha, cover_scan);
386 » » » dest_scan[3] = FXDIB_ALPHA_MERGE(dest_scan[3], m_Alpha, cover_scan); 494 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, cover_scan);
387 » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, cover _scan); 495 dest_scan++;
388 » » » dest_scan ++; 496 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, cover_scan);
389 » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, cove r_scan); 497 dest_scan++;
390 » » » dest_scan ++; 498 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, cover_scan);
391 » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, cover_ scan); 499 dest_scan += 2;
392 » » » dest_scan += 2; 500 }
393 » » } 501 }
394 » } 502 void CFX_SkiaRenderer::CompositeSpanARGB_6(FX_LPBYTE dest_scan,
395 » void CFX_SkiaRenderer::CompositeSpanARGB_6(FX_LPBYTE dest_scan, FX_LPBYT E ori_scan,int Bpp, 503 FX_LPBYTE ori_scan,
396 » » » int span_left, int span_len, int span_top, FX_BYTE cover _scan, 504 int Bpp,
397 » » » int clip_top, int clip_left, int clip_right, FX_LPBYTE c lip_scan, 505 int span_left,
398 » » » FX_LPBYTE dest_extra_alpha_scan) 506 int span_len,
399 » { 507 int span_top,
400 » » dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + (span_l eft<<2); 508 FX_BYTE cover_scan,
401 » » clip_scan = (FX_BYTE*)m_pClipMask->GetScanline(span_top-clip_top ) - clip_left + span_left; 509 int clip_top,
402 » » int col_start = span_left < clip_left ? clip_left - span_left : 0; 510 int clip_left,
403 » » int col_end = (span_left + span_len) < clip_right ? span_len : ( clip_right - span_left); 511 int clip_right,
404 » » if (col_end < col_start) return; // do nothing. 512 FX_LPBYTE clip_scan,
405 » » dest_scan += col_start << 2; 513 FX_LPBYTE dest_extra_alpha_scan) {
514 dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + (span_left << 2);
515 clip_scan = (FX_BYTE*)m_pClipMask->GetScanline(span_top - clip_top) -
516 clip_left + span_left;
517 int col_start = span_left < clip_left ? clip_left - span_left : 0;
518 int col_end =
519 (span_left + span_len) < clip_right ? span_len : (clip_right - span_left);
520 if (col_end < col_start)
521 return; // do nothing.
522 dest_scan += col_start << 2;
406 #if 1 523 #if 1
407 » » int src_alpha = m_Alpha * cover_scan / 255; 524 int src_alpha = m_Alpha * cover_scan / 255;
408 » » for (int col = col_start; col < col_end; col ++) { 525 for (int col = col_start; col < col_end; col++) {
409 » » » int src_alpha1 = src_alpha* clip_scan[col] / 255; 526 int src_alpha1 = src_alpha * clip_scan[col] / 255;
410 » » » if (!src_alpha1) { 527 if (!src_alpha1) {
411 » » » » dest_scan += 4; 528 dest_scan += 4;
412 » » » » continue; 529 continue;
413 » » » } 530 }
414 » » » if (src_alpha1 == 255) { 531 if (src_alpha1 == 255) {
415 » » » » *(FX_DWORD*)dest_scan = m_Color; 532 *(FX_DWORD*)dest_scan = m_Color;
416 » » » » dest_scan += 4; 533 dest_scan += 4;
417 » » » } else { 534 } else {
418 » » » » // Dest format: Argb 535 // Dest format: Argb
419 » » » » // calculate destination alpha (it's union of so urce and dest alpha) 536 // calculate destination alpha (it's union of source and dest alpha)
420 » » » » if (dest_scan[3] == 0) { 537 if (dest_scan[3] == 0) {
421 » » » » » dest_scan[3] = src_alpha1; 538 dest_scan[3] = src_alpha1;
422 » » » » » *dest_scan++ = m_Blue; 539 *dest_scan++ = m_Blue;
423 » » » » » *dest_scan++ = m_Green; 540 *dest_scan++ = m_Green;
424 » » » » » *dest_scan = m_Red; 541 *dest_scan = m_Red;
425 » » » » » dest_scan += 2; 542 dest_scan += 2;
426 » » » » » continue; 543 continue;
427 » » » » } 544 }
428 » » » » FX_BYTE dest_alpha = dest_scan[3] + src_alpha1 - dest_scan[3] * src_alpha1 / 255; 545 FX_BYTE dest_alpha =
429 » » » » dest_scan[3] = dest_alpha; 546 dest_scan[3] + src_alpha1 - dest_scan[3] * src_alpha1 / 255;
430 » » » » int alpha_ratio = src_alpha1*255/dest_alpha; 547 dest_scan[3] = dest_alpha;
431 » » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blu e, alpha_ratio); 548 int alpha_ratio = src_alpha1 * 255 / dest_alpha;
432 » » » » dest_scan ++; 549 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, alpha_ratio);
433 » » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Gre en, alpha_ratio); 550 dest_scan++;
434 » » » » dest_scan ++; 551 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, alpha_ratio);
435 » » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red , alpha_ratio); 552 dest_scan++;
436 » » » » dest_scan += 2; 553 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, alpha_ratio);
437 » » » } 554 dest_scan += 2;
438 » » } 555 }
556 }
439 #else 557 #else
440 » » if (m_bFullCover) { 558 if (m_bFullCover) {
441 » » » for (int col = col_start; col < col_end; col ++) { 559 for (int col = col_start; col < col_end; col++) {
442 » » » » int src_alpha = m_Alpha * clip_scan[col] / 255; 560 int src_alpha = m_Alpha * clip_scan[col] / 255;
443 » » » » if (!src_alpha) { 561 if (!src_alpha) {
444 » » » » » dest_scan += 4; 562 dest_scan += 4;
445 » » » » » continue; 563 continue;
446 » » » » } 564 }
447 » » » » if (src_alpha == 255){ 565 if (src_alpha == 255) {
448 » » » » » *(FX_DWORD*)dest_scan = m_Color; 566 *(FX_DWORD*)dest_scan = m_Color;
449 » » » » » dest_scan += 4; 567 dest_scan += 4;
450 » » » » » continue; 568 continue;
451 » » » » } else { 569 } else {
452 » » » » » // Dest format: Argb 570 // Dest format: Argb
453 » » » » » // calculate destination alpha (it's uni on of source and dest alpha) 571 // calculate destination alpha (it's union of source and dest alpha)
454 » » » » » if (dest_scan[3] == 0) { 572 if (dest_scan[3] == 0) {
455 » » » » » » dest_scan[3] = src_alpha; 573 dest_scan[3] = src_alpha;
456 » » » » » » *dest_scan++ = m_Blue; 574 *dest_scan++ = m_Blue;
457 » » » » » » *dest_scan++ = m_Green; 575 *dest_scan++ = m_Green;
458 » » » » » » *dest_scan = m_Red; 576 *dest_scan = m_Red;
459 » » » » » » dest_scan += 2; 577 dest_scan += 2;
460 » » » » » » continue; 578 continue;
461 » » » » » } 579 }
462 » » » » » FX_BYTE dest_alpha = dest_scan[3] + src_ alpha - dest_scan[3] * src_alpha / 255; 580 FX_BYTE dest_alpha =
463 » » » » » dest_scan[3] = dest_alpha; 581 dest_scan[3] + src_alpha - dest_scan[3] * src_alpha / 255;
464 » » » » » int alpha_ratio = src_alpha*255/dest_alp ha; 582 dest_scan[3] = dest_alpha;
465 » » » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_sca n, m_Blue, alpha_ratio); 583 int alpha_ratio = src_alpha * 255 / dest_alpha;
466 » » » » » dest_scan ++; 584 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, alpha_ratio);
467 » » » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_sca n, m_Green, alpha_ratio); 585 dest_scan++;
468 » » » » » dest_scan ++; 586 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, alpha_ratio);
469 » » » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_sca n, m_Red, alpha_ratio); 587 dest_scan++;
470 » » » » » dest_scan += 2; 588 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, alpha_ratio);
471 » » » » } 589 dest_scan += 2;
472 » » » } 590 }
473 » » } else { 591 }
474 » » » int src_alpha = m_Alpha * cover_scan / 255; 592 } else {
475 » » » for (int col = col_start; col < col_end; col ++) { 593 int src_alpha = m_Alpha * cover_scan / 255;
476 » » » » int src_alpha1 = src_alpha* clip_scan[col] / 255 ; 594 for (int col = col_start; col < col_end; col++) {
477 » » » » if (!src_alpha1) { 595 int src_alpha1 = src_alpha * clip_scan[col] / 255;
478 » » » » » dest_scan += 4; 596 if (!src_alpha1) {
479 » » » » » continue; 597 dest_scan += 4;
480 » » » » } 598 continue;
481 » » » » if (src_alpha1 == 255) { 599 }
482 » » » » » *(FX_DWORD*)dest_scan = m_Color; 600 if (src_alpha1 == 255) {
483 » » » » » dest_scan += 4; 601 *(FX_DWORD*)dest_scan = m_Color;
484 » » » » } else { 602 dest_scan += 4;
485 » » » » » // Dest format: Argb 603 } else {
486 » » » » » // calculate destination alpha (it's uni on of source and dest alpha) 604 // Dest format: Argb
487 » » » » » if (dest_scan[3] == 0) { 605 // calculate destination alpha (it's union of source and dest alpha)
488 » » » » » » dest_scan[3] = src_alpha1; 606 if (dest_scan[3] == 0) {
489 » » » » » » *dest_scan++ = m_Blue; 607 dest_scan[3] = src_alpha1;
490 » » » » » » *dest_scan++ = m_Green; 608 *dest_scan++ = m_Blue;
491 » » » » » » *dest_scan = m_Red; 609 *dest_scan++ = m_Green;
492 » » » » » » dest_scan += 2; 610 *dest_scan = m_Red;
493 » » » » » » continue; 611 dest_scan += 2;
494 » » » » » } 612 continue;
495 » » » » » FX_BYTE dest_alpha = dest_scan[3] + src_ alpha1 - dest_scan[3] * src_alpha1 / 255; 613 }
496 » » » » » dest_scan[3] = dest_alpha; 614 FX_BYTE dest_alpha =
497 » » » » » int alpha_ratio = src_alpha1*255/dest_al pha; 615 dest_scan[3] + src_alpha1 - dest_scan[3] * src_alpha1 / 255;
498 » » » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_sca n, m_Blue, alpha_ratio); 616 dest_scan[3] = dest_alpha;
499 » » » » » dest_scan ++; 617 int alpha_ratio = src_alpha1 * 255 / dest_alpha;
500 » » » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_sca n, m_Green, alpha_ratio); 618 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, alpha_ratio);
501 » » » » » dest_scan ++; 619 dest_scan++;
502 » » » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_sca n, m_Red, alpha_ratio); 620 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, alpha_ratio);
503 » » » » » dest_scan += 2; 621 dest_scan++;
504 » » » » } 622 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, alpha_ratio);
505 » » » } 623 dest_scan += 2;
506 » » } 624 }
625 }
626 }
507 #endif 627 #endif
508 » } 628 }
509 629
510 » void CFX_SkiaRenderer::CompositeSpanARGB_7(FX_LPBYTE dest_scan, FX_LPBYT E ori_scan,int Bpp, 630 void CFX_SkiaRenderer::CompositeSpanARGB_7(FX_LPBYTE dest_scan,
511 » » » int span_left, int span_len, int span_top, FX_BYTE cover _scan, 631 FX_LPBYTE ori_scan,
512 » » » int clip_top, int clip_left, int clip_right, FX_LPBYTE c lip_scan, 632 int Bpp,
513 » » » FX_LPBYTE dest_extra_alpha_scan) 633 int span_left,
514 » { 634 int span_len,
515 » » ASSERT(!m_pDevice->IsCmykImage()); 635 int span_top,
516 » » dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + (span_l eft<<2); 636 FX_BYTE cover_scan,
517 » » //ori_scan = (FX_BYTE*)m_pOriDevice->GetScanline(span_top) + (s pan_left<<2); 637 int clip_top,
518 » » clip_scan = (FX_BYTE*)m_pClipMask->GetScanline(span_top-clip_top ) - clip_left + span_left; 638 int clip_left,
519 » » int col_start = span_left < clip_left ? clip_left - span_left : 0; 639 int clip_right,
520 » » int col_end = (span_left + span_len) < clip_right ? span_len : ( clip_right - span_left); 640 FX_LPBYTE clip_scan,
521 » » if (col_end < col_start) return; // do nothing. 641 FX_LPBYTE dest_extra_alpha_scan) {
522 » » dest_scan += col_start << 2; 642 ASSERT(!m_pDevice->IsCmykImage());
523 » » //ori_scan += col_start << 2; 643 dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + (span_left << 2);
524 » » // Do not need origin bitmap, because of merge in pure transpare nt background 644 // ori_scan = (FX_BYTE*)m_pOriDevice->GetScanline(span_top) + (span_left<<2);
525 » » for (int col = col_start; col < col_end; col ++) 645 clip_scan = (FX_BYTE*)m_pClipMask->GetScanline(span_top - clip_top) -
526 » » { 646 clip_left + span_left;
527 » » » int src_alpha = m_Alpha * clip_scan[col] / 255; 647 int col_start = span_left < clip_left ? clip_left - span_left : 0;
528 » » » int src_alpha_covered = src_alpha * cover_scan / 255; 648 int col_end =
529 » » » // shortcut 649 (span_left + span_len) < clip_right ? span_len : (clip_right - span_left);
530 » » » if (src_alpha_covered == 0){ 650 if (col_end < col_start)
531 » » » » dest_scan += 4; 651 return; // do nothing.
532 » » » » continue; 652 dest_scan += col_start << 2;
533 » » » } 653 // ori_scan += col_start << 2;
534 » » » // shortcut 654 // Do not need origin bitmap, because of merge in pure transparent background
535 » » » if (cover_scan == 255 || dest_scan[3] == 0) 655 for (int col = col_start; col < col_end; col++) {
536 » » » { 656 int src_alpha = m_Alpha * clip_scan[col] / 255;
537 » » » » // origin alpha always zero, just get src alpha 657 int src_alpha_covered = src_alpha * cover_scan / 255;
538 » » » » dest_scan[3] = src_alpha_covered; 658 // shortcut
539 » » » » *dest_scan ++ = m_Blue; 659 if (src_alpha_covered == 0) {
540 » » » » *dest_scan ++ = m_Green; 660 dest_scan += 4;
541 » » » » *dest_scan = m_Red; 661 continue;
542 » » » » dest_scan += 2; 662 }
543 » » » » continue; 663 // shortcut
544 » » » } 664 if (cover_scan == 255 || dest_scan[3] == 0) {
545 » » » // We should do alpha transition and color transition 665 // origin alpha always zero, just get src alpha
546 » » » // alpha fg color fg 666 dest_scan[3] = src_alpha_covered;
547 » » » // alpha bg color bg 667 *dest_scan++ = m_Blue;
548 » » » // alpha cover color cover 668 *dest_scan++ = m_Green;
549 » » » dest_scan[3] = FXDIB_ALPHA_MERGE(dest_scan[3], src_alpha , cover_scan); 669 *dest_scan = m_Red;
550 » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, cover _scan); 670 dest_scan += 2;
551 » » » dest_scan ++; 671 continue;
552 » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, cove r_scan); 672 }
553 » » » dest_scan ++; 673 // We should do alpha transition and color transition
554 » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, cover_ scan); 674 // alpha fg color fg
555 » » » dest_scan += 2; 675 // alpha bg color bg
556 » » } 676 // alpha cover color cover
557 » } 677 dest_scan[3] = FXDIB_ALPHA_MERGE(dest_scan[3], src_alpha, cover_scan);
558 » 678 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, cover_scan);
559 » /*---------------------------------------------------------------------- -------------------------------------*/ 679 dest_scan++;
560 » void CFX_SkiaRenderer::CompositeSpanRGB32_2(FX_LPBYTE dest_scan, FX_LPBY TE ori_scan,int Bpp, 680 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, cover_scan);
561 » » » int span_left, int span_len, int span_top, FX_BYTE cover _scan, 681 dest_scan++;
562 » » » int clip_top, int clip_left, int clip_right, FX_LPBYTE c lip_scan, 682 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, cover_scan);
563 » » » FX_LPBYTE dest_extra_alpha_scan) 683 dest_scan += 2;
564 » { 684 }
565 » » dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + (span_l eft<<2); 685 }
566 » » int col_start = span_left < clip_left ? clip_left - span_left : 0; 686
567 » » int col_end = (span_left + span_len) < clip_right ? span_len : ( clip_right - span_left); 687 /*------------------------------------------------------------------------------ -----------------------------*/
568 » » if (col_end < col_start) return; // do nothing. 688 void CFX_SkiaRenderer::CompositeSpanRGB32_2(FX_LPBYTE dest_scan,
569 » » dest_scan += (col_start << 2); 689 FX_LPBYTE ori_scan,
570 » » if (m_Alpha == 255 && cover_scan == 255) { 690 int Bpp,
571 » » » FXSYS_memset32(dest_scan, m_Color, (col_end - col_start) <<2); 691 int span_left,
572 » » » return; 692 int span_len,
573 » » } 693 int span_top,
574 » » int src_alpha; 694 FX_BYTE cover_scan,
695 int clip_top,
696 int clip_left,
697 int clip_right,
698 FX_LPBYTE clip_scan,
699 FX_LPBYTE dest_extra_alpha_scan) {
700 dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + (span_left << 2);
701 int col_start = span_left < clip_left ? clip_left - span_left : 0;
702 int col_end =
703 (span_left + span_len) < clip_right ? span_len : (clip_right - span_left);
704 if (col_end < col_start)
705 return; // do nothing.
706 dest_scan += (col_start << 2);
707 if (m_Alpha == 255 && cover_scan == 255) {
708 FXSYS_memset32(dest_scan, m_Color, (col_end - col_start) << 2);
709 return;
710 }
711 int src_alpha;
575 #if 0 712 #if 0
576 if (m_bFullCover) 713 if (m_bFullCover)
577 src_alpha = m_Alpha; 714 src_alpha = m_Alpha;
578 » » else 715 » » else
579 #endif 716 #endif
580 » » » src_alpha = m_Alpha * cover_scan / 255; 717 src_alpha = m_Alpha * cover_scan / 255;
581 » » for (int col = col_start; col < col_end; col ++) { 718 for (int col = col_start; col < col_end; col++) {
582 » » » // Dest format: Rgb32 719 // Dest format: Rgb32
583 » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, src_a lpha); 720 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, src_alpha);
584 » » » dest_scan ++; 721 dest_scan++;
585 » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, src_ alpha); 722 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, src_alpha);
586 » » » dest_scan ++; 723 dest_scan++;
587 » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, src_al pha); 724 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, src_alpha);
588 » » » dest_scan += 2; 725 dest_scan += 2;
589 » » } 726 }
590 » } 727 }
591 » void CFX_SkiaRenderer::CompositeSpanRGB32_3(FX_LPBYTE dest_scan, FX_LPBY TE ori_scan,int Bpp, 728 void CFX_SkiaRenderer::CompositeSpanRGB32_3(FX_LPBYTE dest_scan,
592 » » » int span_left, int span_len, int span_top, FX_BYTE cover _scan, 729 FX_LPBYTE ori_scan,
593 » » » int clip_top, int clip_left, int clip_right, FX_LPBYTE c lip_scan, 730 int Bpp,
594 » » » FX_LPBYTE dest_extra_alpha_scan) 731 int span_left,
595 » { 732 int span_len,
596 » » dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + (span_l eft<<2); 733 int span_top,
597 » » ori_scan = (FX_BYTE*)m_pOriDevice->GetScanline(span_top) + (spa n_left<<2); 734 FX_BYTE cover_scan,
598 » » int col_start = span_left < clip_left ? clip_left - span_left : 0; 735 int clip_top,
599 » » int col_end = (span_left + span_len) < clip_right ? span_len : ( clip_right - span_left); 736 int clip_left,
600 » » if (col_end < col_start) return; // do nothing. 737 int clip_right,
601 » » dest_scan += col_start << 2; 738 FX_LPBYTE clip_scan,
602 » » ori_scan += col_start << 2; 739 FX_LPBYTE dest_extra_alpha_scan) {
603 » » if (m_Alpha == 255 && cover_scan == 255) { 740 dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + (span_left << 2);
604 » » » FXSYS_memset32(dest_scan, m_Color, (col_end - col_start) <<2); 741 ori_scan = (FX_BYTE*)m_pOriDevice->GetScanline(span_top) + (span_left << 2);
605 » » » return; 742 int col_start = span_left < clip_left ? clip_left - span_left : 0;
606 » » } 743 int col_end =
607 » » int src_alpha = m_Alpha; 744 (span_left + span_len) < clip_right ? span_len : (clip_right - span_left);
608 » » for (int col = col_start; col < col_end; col ++) { 745 if (col_end < col_start)
746 return; // do nothing.
747 dest_scan += col_start << 2;
748 ori_scan += col_start << 2;
749 if (m_Alpha == 255 && cover_scan == 255) {
750 FXSYS_memset32(dest_scan, m_Color, (col_end - col_start) << 2);
751 return;
752 }
753 int src_alpha = m_Alpha;
754 for (int col = col_start; col < col_end; col++) {
609 #if 0 755 #if 0
610 if (m_bFullCover) { 756 if (m_bFullCover) {
611 *dest_scan++ = FXDIB_ALPHA_MERGE(*ori_scan++, m_ Blue, src_alpha); 757 *dest_scan++ = FXDIB_ALPHA_MERGE(*ori_scan++, m_ Blue, src_alpha);
612 *dest_scan++ = FXDIB_ALPHA_MERGE(*ori_scan++, m_ Green, src_alpha); 758 *dest_scan++ = FXDIB_ALPHA_MERGE(*ori_scan++, m_ Green, src_alpha);
613 *dest_scan = FXDIB_ALPHA_MERGE(*ori_scan, m_Red, src_alpha); 759 *dest_scan = FXDIB_ALPHA_MERGE(*ori_scan, m_Red, src_alpha);
614 dest_scan += 2; ori_scan += 2; 760 dest_scan += 2; ori_scan += 2;
615 continue; 761 continue;
616 } 762 }
617 #endif 763 #endif
618 » » » int b = FXDIB_ALPHA_MERGE(*ori_scan++, m_Blue, src_alpha ); 764 int b = FXDIB_ALPHA_MERGE(*ori_scan++, m_Blue, src_alpha);
619 » » » int g = FXDIB_ALPHA_MERGE(*ori_scan++, m_Green, src_alph a); 765 int g = FXDIB_ALPHA_MERGE(*ori_scan++, m_Green, src_alpha);
620 » » » int r = FXDIB_ALPHA_MERGE(*ori_scan, m_Red, src_alpha); 766 int r = FXDIB_ALPHA_MERGE(*ori_scan, m_Red, src_alpha);
621 » » » ori_scan += 2; 767 ori_scan += 2;
622 » » » *dest_scan = FXDIB_ALPHA_MERGE( *dest_scan, b, cover_sca n); 768 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, b, cover_scan);
623 » » » dest_scan ++; 769 dest_scan++;
624 » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, g, cover_scan ); 770 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, g, cover_scan);
625 » » » dest_scan ++; 771 dest_scan++;
626 » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, r, cover_scan ); 772 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, r, cover_scan);
627 » » » dest_scan += 2; 773 dest_scan += 2;
628 » » } 774 }
629 » } 775 }
630 » void CFX_SkiaRenderer::CompositeSpanRGB32_6(FX_LPBYTE dest_scan, FX_LPBY TE ori_scan,int Bpp, 776 void CFX_SkiaRenderer::CompositeSpanRGB32_6(FX_LPBYTE dest_scan,
631 » » » int span_left, int span_len, int span_top, FX_BYTE cover _scan, 777 FX_LPBYTE ori_scan,
632 » » » int clip_top, int clip_left, int clip_right, FX_LPBYTE c lip_scan, 778 int Bpp,
633 » » » FX_LPBYTE dest_extra_alpha_scan) 779 int span_left,
634 » { 780 int span_len,
635 » » dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + (span_l eft<<2); 781 int span_top,
636 » » clip_scan = (FX_BYTE*)m_pClipMask->GetScanline(span_top-clip_top ) - clip_left + span_left; 782 FX_BYTE cover_scan,
637 » » int col_start = span_left < clip_left ? clip_left - span_left : 0; 783 int clip_top,
638 » » int col_end = (span_left + span_len) < clip_right ? span_len : ( clip_right - span_left); 784 int clip_left,
639 » » if (col_end < col_start) return; // do nothing. 785 int clip_right,
640 » » dest_scan += col_start << 2; 786 FX_LPBYTE clip_scan,
787 FX_LPBYTE dest_extra_alpha_scan) {
788 dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + (span_left << 2);
789 clip_scan = (FX_BYTE*)m_pClipMask->GetScanline(span_top - clip_top) -
790 clip_left + span_left;
791 int col_start = span_left < clip_left ? clip_left - span_left : 0;
792 int col_end =
793 (span_left + span_len) < clip_right ? span_len : (clip_right - span_left);
794 if (col_end < col_start)
795 return; // do nothing.
796 dest_scan += col_start << 2;
641 #if 1 797 #if 1
642 » » int src_alpha = m_Alpha * cover_scan / 255; 798 int src_alpha = m_Alpha * cover_scan / 255;
643 » » for (int col = col_start; col < col_end; col ++) { 799 for (int col = col_start; col < col_end; col++) {
644 » » » int src_alpha1 = src_alpha * clip_scan[col] / 255; 800 int src_alpha1 = src_alpha * clip_scan[col] / 255;
645 » » » if (!src_alpha1) { 801 if (!src_alpha1) {
646 » » » » dest_scan += 4; 802 dest_scan += 4;
647 » » » » continue; 803 continue;
648 » » » } 804 }
649 » » » if (src_alpha1 == 255) { 805 if (src_alpha1 == 255) {
650 » » » » *(FX_DWORD*)dest_scan = m_Color; 806 *(FX_DWORD*)dest_scan = m_Color;
651 » » » » dest_scan += 4; 807 dest_scan += 4;
652 » » » } else { 808 } else {
653 » » » » // Dest format: Rgb or Rgb32 809 // Dest format: Rgb or Rgb32
654 » » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blu e, src_alpha1); 810 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, src_alpha1);
655 » » » » dest_scan ++; 811 dest_scan++;
656 » » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Gre en, src_alpha1); 812 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, src_alpha1);
657 » » » » dest_scan ++; 813 dest_scan++;
658 » » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red , src_alpha1); 814 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, src_alpha1);
659 » » » » dest_scan += 2; 815 dest_scan += 2;
660 » » » }» » » » 816 }
661 » » } 817 }
662 #else 818 #else
663 » » if (m_bFullCover) { 819 if (m_bFullCover) {
664 » » » for (int col = col_start; col < col_end; col ++) { 820 for (int col = col_start; col < col_end; col++) {
665 » » » » int src_alpha = m_Alpha * clip_scan[col] / 255; 821 int src_alpha = m_Alpha * clip_scan[col] / 255;
666 » » » » if (!src_alpha) { 822 if (!src_alpha) {
667 » » » » » dest_scan += 4; 823 dest_scan += 4;
668 » » » » » continue; 824 continue;
669 » » » » } 825 }
670 » » » » if (src_alpha == 255) { 826 if (src_alpha == 255) {
671 » » » » » *(FX_DWORD*)dest_scan = m_Color; 827 *(FX_DWORD*)dest_scan = m_Color;
672 » » » » » dest_scan += 4; 828 dest_scan += 4;
673 » » » » } else { 829 } else {
674 » » » » » // Dest format: Rgb or Rgb32 830 // Dest format: Rgb or Rgb32
675 » » » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_sca n, m_Blue, src_alpha); 831 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, src_alpha);
676 » » » » » dest_scan ++; 832 dest_scan++;
677 » » » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_sca n, m_Green, src_alpha); 833 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, src_alpha);
678 » » » » » dest_scan ++; 834 dest_scan++;
679 » » » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_sca n, m_Red, src_alpha); 835 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, src_alpha);
680 » » » » » dest_scan += 2; 836 dest_scan += 2;
681 » » » » } 837 }
682 » » » } 838 }
683 » » } else { 839 } else {
684 » » » // Rgb32 840 // Rgb32
685 » » » int src_alpha = m_Alpha * cover_scan / 255; 841 int src_alpha = m_Alpha * cover_scan / 255;
686 » » » for (int col = col_start; col < col_end; col ++) { 842 for (int col = col_start; col < col_end; col++) {
687 » » » » int src_alpha1 = src_alpha * clip_scan[col] / 25 5; 843 int src_alpha1 = src_alpha * clip_scan[col] / 255;
688 » » » » if (!src_alpha1) { 844 if (!src_alpha1) {
689 » » » » » dest_scan += 4; 845 dest_scan += 4;
690 » » » » » continue; 846 continue;
691 » » » » } 847 }
692 » » » » if (src_alpha1 == 255) { 848 if (src_alpha1 == 255) {
693 » » » » » *(FX_DWORD*)dest_scan = m_Color; 849 *(FX_DWORD*)dest_scan = m_Color;
694 » » » » » dest_scan += 4; 850 dest_scan += 4;
695 » » » » } else { 851 } else {
696 » » » » » // Dest format: Rgb or Rgb32 852 // Dest format: Rgb or Rgb32
697 » » » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_sca n, m_Blue, src_alpha1); 853 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, src_alpha1);
698 » » » » » dest_scan ++; 854 dest_scan++;
699 » » » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_sca n, m_Green, src_alpha1); 855 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, src_alpha1);
700 » » » » » dest_scan ++; 856 dest_scan++;
701 » » » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_sca n, m_Red, src_alpha1); 857 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, src_alpha1);
702 » » » » » dest_scan += 2; 858 dest_scan += 2;
703 » » » » }» » » » 859 }
704 » » » } 860 }
705 » » }» » » 861 }
706 #endif 862 #endif
707 » } 863 }
708 » void CFX_SkiaRenderer::CompositeSpanRGB32_7(FX_LPBYTE dest_scan, FX_LPBY TE ori_scan,int Bpp, 864 void CFX_SkiaRenderer::CompositeSpanRGB32_7(FX_LPBYTE dest_scan,
709 » » » int span_left, int span_len, int span_top, FX_BYTE cover _scan, 865 FX_LPBYTE ori_scan,
710 » » » int clip_top, int clip_left, int clip_right, FX_LPBYTE c lip_scan, 866 int Bpp,
711 » » » FX_LPBYTE dest_extra_alpha_scan) 867 int span_left,
712 » { 868 int span_len,
713 » » ASSERT(!m_pDevice->IsCmykImage()); 869 int span_top,
714 » » dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + (span_l eft<<2); 870 FX_BYTE cover_scan,
715 » » ori_scan = (FX_BYTE*)m_pOriDevice->GetScanline(span_top) + (spa n_left<<2); 871 int clip_top,
716 » » clip_scan = (FX_BYTE*)m_pClipMask->GetScanline(span_top-clip_top ) - clip_left + span_left; 872 int clip_left,
717 » » int col_start = span_left < clip_left ? clip_left - span_left : 0; 873 int clip_right,
718 » » int col_end = (span_left + span_len) < clip_right ? span_len : ( clip_right - span_left); 874 FX_LPBYTE clip_scan,
719 » » if (col_end < col_start) return; // do nothing. 875 FX_LPBYTE dest_extra_alpha_scan) {
720 » » dest_scan += col_start << 2; 876 ASSERT(!m_pDevice->IsCmykImage());
721 » » ori_scan += col_start << 2; 877 dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + (span_left << 2);
878 ori_scan = (FX_BYTE*)m_pOriDevice->GetScanline(span_top) + (span_left << 2);
879 clip_scan = (FX_BYTE*)m_pClipMask->GetScanline(span_top - clip_top) -
880 clip_left + span_left;
881 int col_start = span_left < clip_left ? clip_left - span_left : 0;
882 int col_end =
883 (span_left + span_len) < clip_right ? span_len : (clip_right - span_left);
884 if (col_end < col_start)
885 return; // do nothing.
886 dest_scan += col_start << 2;
887 ori_scan += col_start << 2;
722 #if 1 888 #if 1
723 » » for (int col = col_start; col < col_end; col ++) { 889 for (int col = col_start; col < col_end; col++) {
724 » » » int src_alpha = m_Alpha * clip_scan[col] / 255; 890 int src_alpha = m_Alpha * clip_scan[col] / 255;
725 » » » if (src_alpha == 255 && cover_scan == 255) { 891 if (src_alpha == 255 && cover_scan == 255) {
726 » » » » *(FX_DWORD*)dest_scan = m_Color; 892 *(FX_DWORD*)dest_scan = m_Color;
727 » » » » dest_scan += 4; 893 dest_scan += 4;
728 » » » » ori_scan += 4; 894 ori_scan += 4;
729 » » » » continue; 895 continue;
730 » » » } 896 }
731 » » » int b = FXDIB_ALPHA_MERGE(*ori_scan++, m_Blue, src_alpha ); 897 int b = FXDIB_ALPHA_MERGE(*ori_scan++, m_Blue, src_alpha);
732 » » » int g = FXDIB_ALPHA_MERGE(*ori_scan++, m_Green, src_alph a); 898 int g = FXDIB_ALPHA_MERGE(*ori_scan++, m_Green, src_alpha);
733 » » » int r = FXDIB_ALPHA_MERGE(*ori_scan, m_Red, src_alpha); 899 int r = FXDIB_ALPHA_MERGE(*ori_scan, m_Red, src_alpha);
734 » » » ori_scan += 2; 900 ori_scan += 2;
735 » » » *dest_scan = FXDIB_ALPHA_MERGE( *dest_scan, b, cover_sca n); 901 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, b, cover_scan);
736 » » » dest_scan ++; 902 dest_scan++;
737 » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, g, cover_scan ); 903 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, g, cover_scan);
738 » » » dest_scan ++; 904 dest_scan++;
739 » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, r, cover_scan ); 905 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, r, cover_scan);
740 » » » dest_scan += 2; 906 dest_scan += 2;
741 » » } 907 }
742 #else 908 #else
743 » » if (m_bFullCover) { 909 if (m_bFullCover) {
744 » » » for (int col = col_start; col < col_end; col ++) { 910 for (int col = col_start; col < col_end; col++) {
745 » » » » int src_alpha = m_Alpha * clip_scan[col] / 255; 911 int src_alpha = m_Alpha * clip_scan[col] / 255;
746 » » » » if (!src_alpha) { 912 if (!src_alpha) {
747 » » » » » *(FX_DWORD*)dest_scan = *(FX_DWORD*)ori_ scan; 913 *(FX_DWORD*)dest_scan = *(FX_DWORD*)ori_scan;
748 » » » » » dest_scan += 4; 914 dest_scan += 4;
749 » » » » » ori_scan += 4; 915 ori_scan += 4;
750 » » » » » continue; 916 continue;
751 » » » » } 917 }
752 » » » » if (src_alpha == 255) { 918 if (src_alpha == 255) {
753 » » » » » *(FX_DWORD*)dest_scan = m_Color; 919 *(FX_DWORD*)dest_scan = m_Color;
754 » » » » » dest_scan += 4; 920 dest_scan += 4;
755 » » » » » ori_scan += 4; 921 ori_scan += 4;
756 » » » » » continue; 922 continue;
757 » » » » } 923 }
758 » » » » *dest_scan++ = FXDIB_ALPHA_MERGE(*ori_scan++, m_ Blue, src_alpha); 924 *dest_scan++ = FXDIB_ALPHA_MERGE(*ori_scan++, m_Blue, src_alpha);
759 » » » » *dest_scan++ = FXDIB_ALPHA_MERGE(*ori_scan++, m_ Green, src_alpha); 925 *dest_scan++ = FXDIB_ALPHA_MERGE(*ori_scan++, m_Green, src_alpha);
760 » » » » *dest_scan = FXDIB_ALPHA_MERGE(*ori_scan, m_Red, src_alpha); 926 *dest_scan = FXDIB_ALPHA_MERGE(*ori_scan, m_Red, src_alpha);
761 » » » » dest_scan += 2; ori_scan += 2; 927 dest_scan += 2;
762 » » » }» » » 928 ori_scan += 2;
763 » » } else { 929 }
764 » » » for (int col = col_start; col < col_end; col ++) { 930 } else {
765 » » » » int src_alpha = m_Alpha * clip_scan[col] / 255; 931 for (int col = col_start; col < col_end; col++) {
766 » » » » if (src_alpha == 255 && cover_scan == 255) { 932 int src_alpha = m_Alpha * clip_scan[col] / 255;
767 » » » » » *(FX_DWORD*)dest_scan = m_Color; 933 if (src_alpha == 255 && cover_scan == 255) {
768 » » » » » dest_scan += 4; 934 *(FX_DWORD*)dest_scan = m_Color;
769 » » » » » ori_scan += 4; 935 dest_scan += 4;
770 » » » » » continue; 936 ori_scan += 4;
771 » » » » } 937 continue;
772 » » » » int b = FXDIB_ALPHA_MERGE(*ori_scan++, m_Blue, s rc_alpha); 938 }
773 » » » » int g = FXDIB_ALPHA_MERGE(*ori_scan++, m_Green, src_alpha); 939 int b = FXDIB_ALPHA_MERGE(*ori_scan++, m_Blue, src_alpha);
774 » » » » int r = FXDIB_ALPHA_MERGE(*ori_scan, m_Red, src_ alpha); 940 int g = FXDIB_ALPHA_MERGE(*ori_scan++, m_Green, src_alpha);
775 » » » » ori_scan += 2; 941 int r = FXDIB_ALPHA_MERGE(*ori_scan, m_Red, src_alpha);
776 » » » » *dest_scan = FXDIB_ALPHA_MERGE( *dest_scan, b, c over_scan); 942 ori_scan += 2;
777 » » » » dest_scan ++; 943 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, b, cover_scan);
778 » » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, g, co ver_scan); 944 dest_scan++;
779 » » » » dest_scan ++; 945 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, g, cover_scan);
780 » » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, r, co ver_scan); 946 dest_scan++;
781 » » » » dest_scan += 2; 947 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, r, cover_scan);
782 » » » } 948 dest_scan += 2;
783 » » } 949 }
784 #endif 950 }
785 » } 951 #endif
786 » /*---------------------------------------------------------------------- -------------------------------*/ 952 }
787 » void CFX_SkiaRenderer::CompositeSpanRGB24_2(FX_LPBYTE dest_scan, FX_LPBY TE ori_scan,int Bpp, 953 /*------------------------------------------------------------------------------ -----------------------*/
788 » » » int span_left, int span_len, int span_top, FX_BYTE cover _scan, 954 void CFX_SkiaRenderer::CompositeSpanRGB24_2(FX_LPBYTE dest_scan,
789 » » » int clip_top, int clip_left, int clip_right, FX_LPBYTE c lip_scan, 955 FX_LPBYTE ori_scan,
790 » » » FX_LPBYTE dest_extra_alpha_scan) 956 int Bpp,
791 » { 957 int span_left,
792 » » dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + span_le ft + (span_left<<1); 958 int span_len,
793 » » int col_start = span_left < clip_left ? clip_left - span_left : 0; 959 int span_top,
794 » » int col_end = (span_left + span_len) < clip_right ? span_len : ( clip_right - span_left); 960 FX_BYTE cover_scan,
795 » » if (col_end < col_start) return; // do nothing. 961 int clip_top,
796 » » dest_scan += (col_start<<1)+col_start; 962 int clip_left,
797 » » int src_alpha; 963 int clip_right,
964 FX_LPBYTE clip_scan,
965 FX_LPBYTE dest_extra_alpha_scan) {
966 dest_scan =
967 (FX_BYTE*)m_pDevice->GetScanline(span_top) + span_left + (span_left << 1);
968 int col_start = span_left < clip_left ? clip_left - span_left : 0;
969 int col_end =
970 (span_left + span_len) < clip_right ? span_len : (clip_right - span_left);
971 if (col_end < col_start)
972 return; // do nothing.
973 dest_scan += (col_start << 1) + col_start;
974 int src_alpha;
798 #if 0 975 #if 0
799 if (m_bFullCover) 976 if (m_bFullCover)
800 src_alpha = m_Alpha; 977 src_alpha = m_Alpha;
801 » » else 978 » » else
802 #endif 979 #endif
803 » » » src_alpha = m_Alpha * cover_scan / 255; 980 src_alpha = m_Alpha * cover_scan / 255;
804 » » if (src_alpha == 255) { 981 if (src_alpha == 255) {
805 » » » for (int col = col_start; col < col_end; col ++) { 982 for (int col = col_start; col < col_end; col++) {
806 » » » » *dest_scan++ = m_Blue; 983 *dest_scan++ = m_Blue;
807 » » » » *dest_scan++ = m_Green; 984 *dest_scan++ = m_Green;
808 » » » » *dest_scan++ = m_Red; 985 *dest_scan++ = m_Red;
809 » » » } 986 }
810 » » » return; 987 return;
811 » » } 988 }
812 » » for (int col = col_start; col < col_end; col ++) { 989 for (int col = col_start; col < col_end; col++) {
813 » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, src_a lpha); 990 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, src_alpha);
814 » » » dest_scan ++; 991 dest_scan++;
815 » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, src_ alpha); 992 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, src_alpha);
816 » » » dest_scan ++; 993 dest_scan++;
817 » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, src_al pha); 994 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, src_alpha);
818 » » » dest_scan ++; 995 dest_scan++;
819 » » } 996 }
820 » } 997 }
821 » void CFX_SkiaRenderer::CompositeSpanRGB24_3(FX_LPBYTE dest_scan, FX_LPBY TE ori_scan,int Bpp, 998 void CFX_SkiaRenderer::CompositeSpanRGB24_3(FX_LPBYTE dest_scan,
822 » » » int span_left, int span_len, int span_top, FX_BYTE cover _scan, 999 FX_LPBYTE ori_scan,
823 » » » int clip_top, int clip_left, int clip_right, FX_LPBYTE c lip_scan, 1000 int Bpp,
824 » » » FX_LPBYTE dest_extra_alpha_scan) 1001 int span_left,
825 » { 1002 int span_len,
826 » » ASSERT(!m_pDevice->IsCmykImage()); 1003 int span_top,
827 » » dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + span_le ft + (span_left<<1); 1004 FX_BYTE cover_scan,
828 » » ori_scan = (FX_BYTE*)m_pOriDevice->GetScanline(span_top) + span _left + (span_left<<1); 1005 int clip_top,
829 » » int col_start = span_left < clip_left ? clip_left - span_left : 0; 1006 int clip_left,
830 » » int col_end = (span_left + span_len) < clip_right ? span_len : ( clip_right - span_left); 1007 int clip_right,
831 » » if (col_end < col_start) return; // do nothing. 1008 FX_LPBYTE clip_scan,
832 » » dest_scan += (col_start<<1) + col_start; 1009 FX_LPBYTE dest_extra_alpha_scan) {
833 » » ori_scan += (col_start<<1) + col_start; 1010 ASSERT(!m_pDevice->IsCmykImage());
834 » » if (m_Alpha == 255&&cover_scan == 255) { 1011 dest_scan =
835 » » » for (int col = col_start; col < col_end; col ++) { 1012 (FX_BYTE*)m_pDevice->GetScanline(span_top) + span_left + (span_left << 1);
836 » » » » *dest_scan ++ = m_Blue; 1013 ori_scan = (FX_BYTE*)m_pOriDevice->GetScanline(span_top) + span_left +
837 » » » » *dest_scan ++ = m_Green; 1014 (span_left << 1);
838 » » » » *dest_scan ++ = m_Red; 1015 int col_start = span_left < clip_left ? clip_left - span_left : 0;
839 » » » } 1016 int col_end =
840 » » » return; 1017 (span_left + span_len) < clip_right ? span_len : (clip_right - span_left);
841 » » } 1018 if (col_end < col_start)
842 » » for (int col = col_start; col < col_end; col ++) { 1019 return; // do nothing.
1020 dest_scan += (col_start << 1) + col_start;
1021 ori_scan += (col_start << 1) + col_start;
1022 if (m_Alpha == 255 && cover_scan == 255) {
1023 for (int col = col_start; col < col_end; col++) {
1024 *dest_scan++ = m_Blue;
1025 *dest_scan++ = m_Green;
1026 *dest_scan++ = m_Red;
1027 }
1028 return;
1029 }
1030 for (int col = col_start; col < col_end; col++) {
843 #if 0 1031 #if 0
844 if (m_bFullCover) { 1032 if (m_bFullCover) {
845 *dest_scan++ = FXDIB_ALPHA_MERGE(*ori_scan++, m_ Blue, m_Alpha); 1033 *dest_scan++ = FXDIB_ALPHA_MERGE(*ori_scan++, m_ Blue, m_Alpha);
846 *dest_scan++ = FXDIB_ALPHA_MERGE(*ori_scan++, m_ Green, m_Alpha); 1034 *dest_scan++ = FXDIB_ALPHA_MERGE(*ori_scan++, m_ Green, m_Alpha);
847 *dest_scan++ = FXDIB_ALPHA_MERGE(*ori_scan++, m_ Red, m_Alpha); 1035 *dest_scan++ = FXDIB_ALPHA_MERGE(*ori_scan++, m_ Red, m_Alpha);
848 continue; 1036 continue;
849 } 1037 }
850 #endif 1038 #endif
851 » » » int b = FXDIB_ALPHA_MERGE(*ori_scan++, m_Blue, m_Alpha); 1039 int b = FXDIB_ALPHA_MERGE(*ori_scan++, m_Blue, m_Alpha);
852 » » » int g = FXDIB_ALPHA_MERGE(*ori_scan++, m_Green, m_Alpha) ; 1040 int g = FXDIB_ALPHA_MERGE(*ori_scan++, m_Green, m_Alpha);
853 » » » int r = FXDIB_ALPHA_MERGE(*ori_scan++, m_Red, m_Alpha); 1041 int r = FXDIB_ALPHA_MERGE(*ori_scan++, m_Red, m_Alpha);
854 » » » *dest_scan = FXDIB_ALPHA_MERGE( *dest_scan, b, cover_sca n); 1042 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, b, cover_scan);
855 » » » dest_scan ++; 1043 dest_scan++;
856 » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, g, cover_scan ); 1044 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, g, cover_scan);
857 » » » dest_scan ++; 1045 dest_scan++;
858 » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, r, cover_scan ); 1046 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, r, cover_scan);
859 » » » dest_scan ++; 1047 dest_scan++;
860 » » } 1048 }
861 » } 1049 }
862 » void CFX_SkiaRenderer::CompositeSpanRGB24_6(FX_LPBYTE dest_scan, FX_LPBY TE ori_scan,int Bpp, 1050 void CFX_SkiaRenderer::CompositeSpanRGB24_6(FX_LPBYTE dest_scan,
863 » » » int span_left, int span_len, int span_top, FX_BYTE cover _scan, 1051 FX_LPBYTE ori_scan,
864 » » » int clip_top, int clip_left, int clip_right, FX_LPBYTE c lip_scan, 1052 int Bpp,
865 » » » FX_LPBYTE dest_extra_alpha_scan) 1053 int span_left,
866 » { 1054 int span_len,
867 » » dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + span_le ft+(span_left<<1); 1055 int span_top,
868 » » clip_scan = (FX_BYTE*)m_pClipMask->GetScanline(span_top-clip_top ) - clip_left + span_left; 1056 FX_BYTE cover_scan,
869 » » int col_start = span_left < clip_left ? clip_left - span_left : 0; 1057 int clip_top,
870 » » int col_end = (span_left + span_len) < clip_right ? span_len : ( clip_right - span_left); 1058 int clip_left,
871 » » if (col_end < col_start) return; // do nothing. 1059 int clip_right,
872 » » dest_scan += col_start + (col_start << 1); 1060 FX_LPBYTE clip_scan,
1061 FX_LPBYTE dest_extra_alpha_scan) {
1062 dest_scan =
1063 (FX_BYTE*)m_pDevice->GetScanline(span_top) + span_left + (span_left << 1);
1064 clip_scan = (FX_BYTE*)m_pClipMask->GetScanline(span_top - clip_top) -
1065 clip_left + span_left;
1066 int col_start = span_left < clip_left ? clip_left - span_left : 0;
1067 int col_end =
1068 (span_left + span_len) < clip_right ? span_len : (clip_right - span_left);
1069 if (col_end < col_start)
1070 return; // do nothing.
1071 dest_scan += col_start + (col_start << 1);
873 #if 1 1072 #if 1
874 » » int src_alpha = m_Alpha * cover_scan /255; 1073 int src_alpha = m_Alpha * cover_scan / 255;
875 » » for (int col = col_start; col < col_end; col ++) { 1074 for (int col = col_start; col < col_end; col++) {
876 » » » int src_alpha1 = src_alpha * clip_scan[col] / 255;» 1075 int src_alpha1 = src_alpha * clip_scan[col] / 255;
877 » » » if (!src_alpha1) { 1076 if (!src_alpha1) {
878 » » » » dest_scan += 3; 1077 dest_scan += 3;
879 » » » » continue; 1078 continue;
880 » » » } 1079 }
881 » » » if (src_alpha1 == 255) { 1080 if (src_alpha1 == 255) {
882 » » » » *dest_scan++ = m_Blue; 1081 *dest_scan++ = m_Blue;
883 » » » » *dest_scan++ = m_Green; 1082 *dest_scan++ = m_Green;
884 » » » » *dest_scan++ = m_Red; 1083 *dest_scan++ = m_Red;
885 » » » } else { 1084 } else {
886 » » » » // Dest format: Rgb 1085 // Dest format: Rgb
887 » » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blu e, src_alpha1); 1086 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, src_alpha1);
888 » » » » dest_scan ++; 1087 dest_scan++;
889 » » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Gre en, src_alpha1); 1088 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, src_alpha1);
890 » » » » dest_scan ++; 1089 dest_scan++;
891 » » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red , src_alpha1); 1090 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, src_alpha1);
892 » » » » dest_scan ++; 1091 dest_scan++;
893 » » » } 1092 }
894 » » } 1093 }
895 #else 1094 #else
896 » » if (m_bFullCover) { 1095 if (m_bFullCover) {
897 » » » for (int col = col_start; col < col_end; col ++) { 1096 for (int col = col_start; col < col_end; col++) {
898 » » » » int src_alpha = m_Alpha * clip_scan[col] / 255;» 1097 int src_alpha = m_Alpha * clip_scan[col] / 255;
899 » » » » if (!src_alpha) { 1098 if (!src_alpha) {
900 » » » » » dest_scan += 3; 1099 dest_scan += 3;
901 » » » » » continue; 1100 continue;
902 » » » » } 1101 }
903 » » » » if (src_alpha == 255) { 1102 if (src_alpha == 255) {
904 » » » » » *dest_scan++ = m_Blue; 1103 *dest_scan++ = m_Blue;
905 » » » » » *dest_scan++ = m_Green; 1104 *dest_scan++ = m_Green;
906 » » » » » *dest_scan++ = m_Red; 1105 *dest_scan++ = m_Red;
907 » » » » } else { 1106 } else {
908 » » » » » // Dest format: Rgb 1107 // Dest format: Rgb
909 » » » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_sca n, m_Blue, src_alpha); 1108 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, src_alpha);
910 » » » » » dest_scan ++; 1109 dest_scan++;
911 » » » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_sca n, m_Green, src_alpha); 1110 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, src_alpha);
912 » » » » » dest_scan ++; 1111 dest_scan++;
913 » » » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_sca n, m_Red, src_alpha); 1112 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, src_alpha);
914 » » » » » dest_scan ++; 1113 dest_scan++;
915 » » » » } 1114 }
916 » » » } 1115 }
917 » » } else { 1116 } else {
918 » » » int src_alpha = m_Alpha * cover_scan /255; 1117 int src_alpha = m_Alpha * cover_scan / 255;
919 » » » for (int col = col_start; col < col_end; col ++) { 1118 for (int col = col_start; col < col_end; col++) {
920 » » » » int src_alpha1 = src_alpha * clip_scan[col] / 25 5;» 1119 int src_alpha1 = src_alpha * clip_scan[col] / 255;
921 » » » » if (!src_alpha1) { 1120 if (!src_alpha1) {
922 » » » » » dest_scan += 3; 1121 dest_scan += 3;
923 » » » » » continue; 1122 continue;
924 » » » » } 1123 }
925 » » » » if (src_alpha1 == 255) { 1124 if (src_alpha1 == 255) {
926 » » » » » *dest_scan++ = m_Blue; 1125 *dest_scan++ = m_Blue;
927 » » » » » *dest_scan++ = m_Green; 1126 *dest_scan++ = m_Green;
928 » » » » » *dest_scan++ = m_Red; 1127 *dest_scan++ = m_Red;
929 » » » » } else { 1128 } else {
930 » » » » » // Dest format: Rgb 1129 // Dest format: Rgb
931 » » » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_sca n, m_Blue, src_alpha1); 1130 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, src_alpha1);
932 » » » » » dest_scan ++; 1131 dest_scan++;
933 » » » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_sca n, m_Green, src_alpha1); 1132 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, src_alpha1);
934 » » » » » dest_scan ++; 1133 dest_scan++;
935 » » » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_sca n, m_Red, src_alpha1); 1134 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, src_alpha1);
936 » » » » » dest_scan ++; 1135 dest_scan++;
937 » » » » } 1136 }
938 » » » } 1137 }
939 » » } 1138 }
940 #endif 1139 #endif
941 » } 1140 }
942 » void CFX_SkiaRenderer::CompositeSpanRGB24_7(FX_LPBYTE dest_scan, FX_LPBY TE ori_scan,int Bpp, 1141 void CFX_SkiaRenderer::CompositeSpanRGB24_7(FX_LPBYTE dest_scan,
943 » » » int span_left, int span_len, int span_top, FX_BYTE cover _scan, 1142 FX_LPBYTE ori_scan,
944 » » » int clip_top, int clip_left, int clip_right, FX_LPBYTE c lip_scan, 1143 int Bpp,
945 » » » FX_LPBYTE dest_extra_alpha_scan) 1144 int span_left,
946 » { 1145 int span_len,
947 » » ASSERT(!m_pDevice->IsCmykImage()); 1146 int span_top,
948 » » dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + span_le ft+(span_left<<1); 1147 FX_BYTE cover_scan,
949 » » ori_scan = (FX_BYTE*)m_pOriDevice->GetScanline(span_top) + span _left+(span_left<<1); 1148 int clip_top,
950 » » clip_scan = (FX_BYTE*)m_pClipMask->GetScanline(span_top-clip_top ) - clip_left + span_left; 1149 int clip_left,
951 » » int col_start = span_left < clip_left ? clip_left - span_left : 0; 1150 int clip_right,
952 » » int col_end = (span_left + span_len) < clip_right ? span_len : ( clip_right - span_left); 1151 FX_LPBYTE clip_scan,
953 » » if (col_end < col_start) return; // do nothing. 1152 FX_LPBYTE dest_extra_alpha_scan) {
954 » » dest_scan += col_start + (col_start<<1); 1153 ASSERT(!m_pDevice->IsCmykImage());
955 » » ori_scan += col_start + (col_start<<1); 1154 dest_scan =
1155 (FX_BYTE*)m_pDevice->GetScanline(span_top) + span_left + (span_left << 1);
1156 ori_scan = (FX_BYTE*)m_pOriDevice->GetScanline(span_top) + span_left +
1157 (span_left << 1);
1158 clip_scan = (FX_BYTE*)m_pClipMask->GetScanline(span_top - clip_top) -
1159 clip_left + span_left;
1160 int col_start = span_left < clip_left ? clip_left - span_left : 0;
1161 int col_end =
1162 (span_left + span_len) < clip_right ? span_len : (clip_right - span_left);
1163 if (col_end < col_start)
1164 return; // do nothing.
1165 dest_scan += col_start + (col_start << 1);
1166 ori_scan += col_start + (col_start << 1);
956 #if 1 1167 #if 1
957 » » for (int col = col_start; col < col_end; col ++) { 1168 for (int col = col_start; col < col_end; col++) {
958 » » » int src_alpha = m_Alpha * clip_scan[col] / 255; 1169 int src_alpha = m_Alpha * clip_scan[col] / 255;
959 » » » if (src_alpha == 255 && cover_scan == 255) { 1170 if (src_alpha == 255 && cover_scan == 255) {
960 » » » » *dest_scan++ = m_Blue; 1171 *dest_scan++ = m_Blue;
961 » » » » *dest_scan++ = m_Green; 1172 *dest_scan++ = m_Green;
962 » » » » *dest_scan++ = m_Red; 1173 *dest_scan++ = m_Red;
963 » » » » ori_scan += 3; 1174 ori_scan += 3;
964 » » » » continue; 1175 continue;
965 » » » } 1176 }
966 » » » int b = FXDIB_ALPHA_MERGE(*ori_scan++, m_Blue, src_alpha ); 1177 int b = FXDIB_ALPHA_MERGE(*ori_scan++, m_Blue, src_alpha);
967 » » » int g = FXDIB_ALPHA_MERGE(*ori_scan++, m_Green, src_alph a); 1178 int g = FXDIB_ALPHA_MERGE(*ori_scan++, m_Green, src_alpha);
968 » » » int r = FXDIB_ALPHA_MERGE(*ori_scan++, m_Red, src_alpha) ; 1179 int r = FXDIB_ALPHA_MERGE(*ori_scan++, m_Red, src_alpha);
969 » » » *dest_scan = FXDIB_ALPHA_MERGE( *dest_scan, b, cover_sca n); 1180 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, b, cover_scan);
970 » » » dest_scan ++; 1181 dest_scan++;
971 » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, g, cover_scan ); 1182 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, g, cover_scan);
972 » » » dest_scan ++; 1183 dest_scan++;
973 » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, r, cover_scan ); 1184 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, r, cover_scan);
974 » » » dest_scan ++; 1185 dest_scan++;
975 » » } 1186 }
976 #else 1187 #else
977 » » if (m_bFullCover) { 1188 if (m_bFullCover) {
978 » » » for (int col = col_start; col < col_end; col ++) { 1189 for (int col = col_start; col < col_end; col++) {
979 » » » » int src_alpha = m_Alpha * clip_scan[col] / 255; 1190 int src_alpha = m_Alpha * clip_scan[col] / 255;
980 » » » » if (!src_alpha){ 1191 if (!src_alpha) {
981 » » » » » *dest_scan++ = *ori_scan++; 1192 *dest_scan++ = *ori_scan++;
982 » » » » » *dest_scan++ = *ori_scan++; 1193 *dest_scan++ = *ori_scan++;
983 » » » » » *dest_scan++ = *ori_scan++; 1194 *dest_scan++ = *ori_scan++;
984 » » » » » continue; 1195 continue;
985 » » » » } 1196 }
986 » » » » if (src_alpha == 255){ 1197 if (src_alpha == 255) {
987 » » » » » *dest_scan++ = m_Blue; 1198 *dest_scan++ = m_Blue;
988 » » » » » *dest_scan++ = m_Green; 1199 *dest_scan++ = m_Green;
989 » » » » » *dest_scan++ = m_Red; 1200 *dest_scan++ = m_Red;
990 » » » » » ori_scan += 3; 1201 ori_scan += 3;
991 » » » » » continue; 1202 continue;
992 » » » » } 1203 }
993 » » » » *dest_scan++ = FXDIB_ALPHA_MERGE(*ori_scan++, m_ Blue, src_alpha); 1204 *dest_scan++ = FXDIB_ALPHA_MERGE(*ori_scan++, m_Blue, src_alpha);
994 » » » » *dest_scan++ = FXDIB_ALPHA_MERGE(*ori_scan++, m_ Green, src_alpha); 1205 *dest_scan++ = FXDIB_ALPHA_MERGE(*ori_scan++, m_Green, src_alpha);
995 » » » » *dest_scan++ = FXDIB_ALPHA_MERGE(*ori_scan++, m_ Red, src_alpha); 1206 *dest_scan++ = FXDIB_ALPHA_MERGE(*ori_scan++, m_Red, src_alpha);
996 » » » } 1207 }
997 » » } else { 1208 } else {
998 » » » for (int col = col_start; col < col_end; col ++) { 1209 for (int col = col_start; col < col_end; col++) {
999 » » » » int src_alpha = m_Alpha * clip_scan[col] / 255; 1210 int src_alpha = m_Alpha * clip_scan[col] / 255;
1000 » » » » if (src_alpha == 255 && cover_scan == 255) { 1211 if (src_alpha == 255 && cover_scan == 255) {
1001 » » » » » *dest_scan++ = m_Blue; 1212 *dest_scan++ = m_Blue;
1002 » » » » » *dest_scan++ = m_Green; 1213 *dest_scan++ = m_Green;
1003 » » » » » *dest_scan++ = m_Red; 1214 *dest_scan++ = m_Red;
1004 » » » » » ori_scan += 3; 1215 ori_scan += 3;
1005 » » » » » continue; 1216 continue;
1006 » » » » } 1217 }
1007 » » » » int b = FXDIB_ALPHA_MERGE(*ori_scan++, m_Blue, s rc_alpha); 1218 int b = FXDIB_ALPHA_MERGE(*ori_scan++, m_Blue, src_alpha);
1008 » » » » int g = FXDIB_ALPHA_MERGE(*ori_scan++, m_Green, src_alpha); 1219 int g = FXDIB_ALPHA_MERGE(*ori_scan++, m_Green, src_alpha);
1009 » » » » int r = FXDIB_ALPHA_MERGE(*ori_scan++, m_Red, sr c_alpha); 1220 int r = FXDIB_ALPHA_MERGE(*ori_scan++, m_Red, src_alpha);
1010 » » » » *dest_scan = FXDIB_ALPHA_MERGE( *dest_scan, b, c over_scan); 1221 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, b, cover_scan);
1011 » » » » dest_scan ++; 1222 dest_scan++;
1012 » » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, g, co ver_scan); 1223 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, g, cover_scan);
1013 » » » » dest_scan ++; 1224 dest_scan++;
1014 » » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, r, co ver_scan); 1225 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, r, cover_scan);
1015 » » » » dest_scan ++; 1226 dest_scan++;
1016 » » » } 1227 }
1017 » » } 1228 }
1018 #endif 1229 #endif
1019 » } 1230 }
1020 » void CFX_SkiaRenderer::CompositeSpanRGB24_10(FX_LPBYTE dest_scan, FX_LPB YTE ori_scan,int Bpp, 1231 void CFX_SkiaRenderer::CompositeSpanRGB24_10(FX_LPBYTE dest_scan,
1021 » » » int span_left, int span_len, int span_top, FX_BYTE cover _scan, 1232 FX_LPBYTE ori_scan,
1022 » » » int clip_top, int clip_left, int clip_right, FX_LPBYTE c lip_scan, 1233 int Bpp,
1023 » » » FX_LPBYTE dest_extra_alpha_scan) 1234 int span_left,
1024 » { 1235 int span_len,
1025 » » dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + span_le ft+(span_left<<1); 1236 int span_top,
1026 » » dest_extra_alpha_scan = (FX_BYTE*)m_pDevice->m_pAlphaMask->GetS canline(span_top)+span_left; 1237 FX_BYTE cover_scan,
1027 » » int col_start = span_left < clip_left ? clip_left - span_left : 0; 1238 int clip_top,
1028 » » int col_end = (span_left + span_len) < clip_right ? span_len : ( clip_right - span_left); 1239 int clip_left,
1029 » » if (col_end < col_start) return; // do nothing. 1240 int clip_right,
1030 » » dest_scan += col_start+(col_start<<1); 1241 FX_LPBYTE clip_scan,
1242 FX_LPBYTE dest_extra_alpha_scan) {
1243 dest_scan =
1244 (FX_BYTE*)m_pDevice->GetScanline(span_top) + span_left + (span_left << 1);
1245 dest_extra_alpha_scan =
1246 (FX_BYTE*)m_pDevice->m_pAlphaMask->GetScanline(span_top) + span_left;
1247 int col_start = span_left < clip_left ? clip_left - span_left : 0;
1248 int col_end =
1249 (span_left + span_len) < clip_right ? span_len : (clip_right - span_left);
1250 if (col_end < col_start)
1251 return; // do nothing.
1252 dest_scan += col_start + (col_start << 1);
1031 #if 1 1253 #if 1
1032 » » if (m_Alpha == 255 && cover_scan == 255) { 1254 if (m_Alpha == 255 && cover_scan == 255) {
1033 » » » for (int col = col_start; col < col_end; col ++) { 1255 for (int col = col_start; col < col_end; col++) {
1034 » » » » *dest_scan++ = (FX_BYTE)m_Blue; 1256 *dest_scan++ = (FX_BYTE)m_Blue;
1035 » » » » *dest_scan++ = (FX_BYTE)m_Green; 1257 *dest_scan++ = (FX_BYTE)m_Green;
1036 » » » » *dest_scan++ = (FX_BYTE)m_Red; 1258 *dest_scan++ = (FX_BYTE)m_Red;
1037 » » » » *dest_extra_alpha_scan++ = 255; 1259 *dest_extra_alpha_scan++ = 255;
1038 » » » } 1260 }
1039 » » » return; 1261 return;
1040 » » } 1262 }
1041 » » int src_alpha = m_Alpha * cover_scan / 255; 1263 int src_alpha = m_Alpha * cover_scan / 255;
1042 » » for (int col = col_start; col < col_end; col ++) { 1264 for (int col = col_start; col < col_end; col++) {
1043 » » » // Dest format: Rgba 1265 // Dest format: Rgba
1044 » » » // calculate destination alpha (it's union of source and dest alpha) 1266 // calculate destination alpha (it's union of source and dest alpha)
1045 » » » FX_BYTE dest_alpha = (*dest_extra_alpha_scan) + src_alph a - 1267 FX_BYTE dest_alpha = (*dest_extra_alpha_scan) + src_alpha -
1046 » » » » » » » » (*dest_extra_alp ha_scan) * src_alpha / 255; 1268 (*dest_extra_alpha_scan) * src_alpha / 255;
1047 » » » *dest_extra_alpha_scan++ = dest_alpha; 1269 *dest_extra_alpha_scan++ = dest_alpha;
1048 » » » int alpha_ratio = src_alpha*255/dest_alpha; 1270 int alpha_ratio = src_alpha * 255 / dest_alpha;
1049 » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, alpha _ratio); 1271 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, alpha_ratio);
1050 » » » dest_scan ++; 1272 dest_scan++;
1051 » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, alph a_ratio); 1273 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, alpha_ratio);
1052 » » » dest_scan ++; 1274 dest_scan++;
1053 » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, alpha_ ratio); 1275 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, alpha_ratio);
1054 » » » dest_scan ++;» » » 1276 dest_scan++;
1055 » » } 1277 }
1056 #else 1278 #else
1057 » » if (m_bFullCover) { 1279 if (m_bFullCover) {
1058 » » » if (m_Alpha == 255) { 1280 if (m_Alpha == 255) {
1059 » » » » for (int col = col_start; col < col_end; col ++) { 1281 for (int col = col_start; col < col_end; col++) {
1060 » » » » » *dest_scan++ = (FX_BYTE)m_Blue; 1282 *dest_scan++ = (FX_BYTE)m_Blue;
1061 » » » » » *dest_scan++ = (FX_BYTE)m_Green; 1283 *dest_scan++ = (FX_BYTE)m_Green;
1062 » » » » » *dest_scan++ = (FX_BYTE)m_Red; 1284 *dest_scan++ = (FX_BYTE)m_Red;
1063 » » » » » *dest_extra_alpha_scan++ = 255; 1285 *dest_extra_alpha_scan++ = 255;
1064 » » » » } 1286 }
1065 » » » » return; 1287 return;
1066 » » » } 1288 }
1067 » » » for (int col = col_start; col < col_end; col ++) { 1289 for (int col = col_start; col < col_end; col++) {
1068 » » » » // Dest format: Rgba 1290 // Dest format: Rgba
1069 » » » » // calculate destination alpha (it's union of so urce and dest alpha) 1291 // calculate destination alpha (it's union of source and dest alpha)
1070 » » » » FX_BYTE dest_alpha = (*dest_extra_alpha_scan) + m_Alpha - 1292 FX_BYTE dest_alpha = (*dest_extra_alpha_scan) + m_Alpha -
1071 » » » » » » » » » (*dest_e xtra_alpha_scan) * m_Alpha / 255; 1293 (*dest_extra_alpha_scan) * m_Alpha / 255;
1072 » » » » *dest_extra_alpha_scan++ = dest_alpha; 1294 *dest_extra_alpha_scan++ = dest_alpha;
1073 » » » » int alpha_ratio = m_Alpha*255/dest_alpha; 1295 int alpha_ratio = m_Alpha * 255 / dest_alpha;
1074 » » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blu e, alpha_ratio); 1296 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, alpha_ratio);
1075 » » » » dest_scan ++; 1297 dest_scan++;
1076 » » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Gre en, alpha_ratio); 1298 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, alpha_ratio);
1077 » » » » dest_scan ++; 1299 dest_scan++;
1078 » » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red , alpha_ratio); 1300 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, alpha_ratio);
1079 » » » » dest_scan ++; 1301 dest_scan++;
1080 » » » } 1302 }
1081 » » } else { 1303 } else {
1082 » » » if (m_Alpha == 255 && cover_scan == 255) { 1304 if (m_Alpha == 255 && cover_scan == 255) {
1083 » » » » for (int col = col_start; col < col_end; col ++) { 1305 for (int col = col_start; col < col_end; col++) {
1084 » » » » » *dest_scan++ = (FX_BYTE)m_Blue; 1306 *dest_scan++ = (FX_BYTE)m_Blue;
1085 » » » » » *dest_scan++ = (FX_BYTE)m_Green; 1307 *dest_scan++ = (FX_BYTE)m_Green;
1086 » » » » » *dest_scan++ = (FX_BYTE)m_Red; 1308 *dest_scan++ = (FX_BYTE)m_Red;
1087 » » » » » *dest_extra_alpha_scan++ = 255; 1309 *dest_extra_alpha_scan++ = 255;
1088 » » » » } 1310 }
1089 » » » » return; 1311 return;
1090 » » » } 1312 }
1091 » » » int src_alpha = m_Alpha * cover_scan / 255; 1313 int src_alpha = m_Alpha * cover_scan / 255;
1092 » » » for (int col = col_start; col < col_end; col ++) { 1314 for (int col = col_start; col < col_end; col++) {
1093 » » » » // Dest format: Rgba 1315 // Dest format: Rgba
1094 » » » » // calculate destination alpha (it's union of so urce and dest alpha) 1316 // calculate destination alpha (it's union of source and dest alpha)
1095 » » » » FX_BYTE dest_alpha = (*dest_extra_alpha_scan) + src_alpha - 1317 FX_BYTE dest_alpha = (*dest_extra_alpha_scan) + src_alpha -
1096 » » » » » » » » » (*dest_e xtra_alpha_scan) * src_alpha / 255; 1318 (*dest_extra_alpha_scan) * src_alpha / 255;
1097 » » » » *dest_extra_alpha_scan++ = dest_alpha; 1319 *dest_extra_alpha_scan++ = dest_alpha;
1098 » » » » int alpha_ratio = src_alpha*255/dest_alpha; 1320 int alpha_ratio = src_alpha * 255 / dest_alpha;
1099 » » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blu e, alpha_ratio); 1321 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, alpha_ratio);
1100 » » » » dest_scan ++; 1322 dest_scan++;
1101 » » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Gre en, alpha_ratio); 1323 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, alpha_ratio);
1102 » » » » dest_scan ++; 1324 dest_scan++;
1103 » » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red , alpha_ratio); 1325 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, alpha_ratio);
1104 » » » » dest_scan ++;» » » 1326 dest_scan++;
1105 » » » } 1327 }
1106 » » } 1328 }
1107 #endif 1329 #endif
1108 » } 1330 }
1109 » void CFX_SkiaRenderer::CompositeSpanRGB24_14(FX_LPBYTE dest_scan, FX_LPB YTE ori_scan,int Bpp, 1331 void CFX_SkiaRenderer::CompositeSpanRGB24_14(FX_LPBYTE dest_scan,
1110 » » » int span_left, int span_len, int span_top, FX_BYTE cover _scan, 1332 FX_LPBYTE ori_scan,
1111 » » » int clip_top, int clip_left, int clip_right, FX_LPBYTE c lip_scan, 1333 int Bpp,
1112 » » » FX_LPBYTE dest_extra_alpha_scan) 1334 int span_left,
1113 » { 1335 int span_len,
1114 » » dest_scan = (FX_BYTE*)m_pDevice->GetScanline(span_top) + span_le ft+(span_left<<1); 1336 int span_top,
1115 » » dest_extra_alpha_scan = (FX_BYTE*)m_pDevice->m_pAlphaMask->GetS canline(span_top)+span_left; 1337 FX_BYTE cover_scan,
1116 » » clip_scan = (FX_BYTE*)m_pClipMask->GetScanline(span_top-clip_top ) - clip_left + span_left; 1338 int clip_top,
1117 » » int col_start = span_left < clip_left ? clip_left - span_left : 0; 1339 int clip_left,
1118 » » int col_end = (span_left + span_len) < clip_right ? span_len : ( clip_right - span_left); 1340 int clip_right,
1119 » » if (col_end < col_start) return; // do nothing. 1341 FX_LPBYTE clip_scan,
1120 » » dest_scan += col_start + (col_start << 1); 1342 FX_LPBYTE dest_extra_alpha_scan) {
1343 dest_scan =
1344 (FX_BYTE*)m_pDevice->GetScanline(span_top) + span_left + (span_left << 1);
1345 dest_extra_alpha_scan =
1346 (FX_BYTE*)m_pDevice->m_pAlphaMask->GetScanline(span_top) + span_left;
1347 clip_scan = (FX_BYTE*)m_pClipMask->GetScanline(span_top - clip_top) -
1348 clip_left + span_left;
1349 int col_start = span_left < clip_left ? clip_left - span_left : 0;
1350 int col_end =
1351 (span_left + span_len) < clip_right ? span_len : (clip_right - span_left);
1352 if (col_end < col_start)
1353 return; // do nothing.
1354 dest_scan += col_start + (col_start << 1);
1121 #if 1 1355 #if 1
1122 » » int src_alpha = m_Alpha * cover_scan / 255; 1356 int src_alpha = m_Alpha * cover_scan / 255;
1123 » » for (int col = col_start; col < col_end; col ++) { 1357 for (int col = col_start; col < col_end; col++) {
1124 » » » int src_alpha1 = src_alpha * clip_scan[col] / 255; 1358 int src_alpha1 = src_alpha * clip_scan[col] / 255;
1125 » » » if (!src_alpha1) { 1359 if (!src_alpha1) {
1126 » » » » dest_extra_alpha_scan++; 1360 dest_extra_alpha_scan++;
1127 » » » » dest_scan += 3; 1361 dest_scan += 3;
1128 » » » » continue; 1362 continue;
1129 » » » }» » » » 1363 }
1130 » » » if (src_alpha1 == 255) { 1364 if (src_alpha1 == 255) {
1131 » » » » *dest_scan++ = (FX_BYTE)m_Blue; 1365 *dest_scan++ = (FX_BYTE)m_Blue;
1132 » » » » *dest_scan++ = (FX_BYTE)m_Green; 1366 *dest_scan++ = (FX_BYTE)m_Green;
1133 » » » » *dest_scan++ = (FX_BYTE)m_Red; 1367 *dest_scan++ = (FX_BYTE)m_Red;
1134 » » » » *dest_extra_alpha_scan++ = (FX_BYTE)m_Alpha; 1368 *dest_extra_alpha_scan++ = (FX_BYTE)m_Alpha;
1135 » » » } else { 1369 } else {
1136 » » » » // Dest format: Rgba 1370 // Dest format: Rgba
1137 » » » » // calculate destination alpha (it's union of so urce and dest alpha) 1371 // calculate destination alpha (it's union of source and dest alpha)
1138 » » » » FX_BYTE dest_alpha = (*dest_extra_alpha_scan) + src_alpha1 - 1372 FX_BYTE dest_alpha = (*dest_extra_alpha_scan) + src_alpha1 -
1139 » » » » » » » » » (*dest_e xtra_alpha_scan) * src_alpha1 / 255; 1373 (*dest_extra_alpha_scan) * src_alpha1 / 255;
1140 » » » » *dest_extra_alpha_scan++ = dest_alpha; 1374 *dest_extra_alpha_scan++ = dest_alpha;
1141 » » » » int alpha_ratio = src_alpha1*255/dest_alpha; 1375 int alpha_ratio = src_alpha1 * 255 / dest_alpha;
1142 » » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blu e, alpha_ratio); 1376 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, alpha_ratio);
1143 » » » » dest_scan ++; 1377 dest_scan++;
1144 » » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Gre en, alpha_ratio); 1378 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, alpha_ratio);
1145 » » » » dest_scan ++; 1379 dest_scan++;
1146 » » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red , alpha_ratio); 1380 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, alpha_ratio);
1147 » » » » dest_scan ++; 1381 dest_scan++;
1148 » » » } 1382 }
1149 » » } 1383 }
1150 #else 1384 #else
1151 » » if (m_bFullCover) { 1385 if (m_bFullCover) {
1152 » » » for (int col = col_start; col < col_end; col ++) { 1386 for (int col = col_start; col < col_end; col++) {
1153 » » » » int src_alpha = m_Alpha * clip_scan[col] / 255; 1387 int src_alpha = m_Alpha * clip_scan[col] / 255;
1154 » » » » if (!src_alpha) { 1388 if (!src_alpha) {
1155 » » » » » dest_extra_alpha_scan++; 1389 dest_extra_alpha_scan++;
1156 » » » » » dest_scan += 3; 1390 dest_scan += 3;
1157 » » » » » continue; 1391 continue;
1158 » » » » } 1392 }
1159 » » » » if (src_alpha == 255) { 1393 if (src_alpha == 255) {
1160 » » » » » *dest_scan++ = (FX_BYTE)m_Blue; 1394 *dest_scan++ = (FX_BYTE)m_Blue;
1161 » » » » » *dest_scan++ = (FX_BYTE)m_Green; 1395 *dest_scan++ = (FX_BYTE)m_Green;
1162 » » » » » *dest_scan++ = (FX_BYTE)m_Red; 1396 *dest_scan++ = (FX_BYTE)m_Red;
1163 » » » » » *dest_extra_alpha_scan++ = (FX_BYTE)m_Al pha; 1397 *dest_extra_alpha_scan++ = (FX_BYTE)m_Alpha;
1164 » » » » } else { 1398 } else {
1165 » » » » » // Dest format: Rgba 1399 // Dest format: Rgba
1166 » » » » » // calculate destination alpha (it's uni on of source and dest alpha) 1400 // calculate destination alpha (it's union of source and dest alpha)
1167 » » » » » FX_BYTE dest_alpha = (*dest_extra_alpha_ scan) + src_alpha - 1401 FX_BYTE dest_alpha = (*dest_extra_alpha_scan) + src_alpha -
1168 » » » » » » » » » » (*dest_extra_alpha_scan) * src_alpha / 255; 1402 (*dest_extra_alpha_scan) * src_alpha / 255;
1169 » » » » » *dest_extra_alpha_scan++ = dest_alpha; 1403 *dest_extra_alpha_scan++ = dest_alpha;
1170 » » » » » int alpha_ratio = src_alpha*255/dest_alp ha; 1404 int alpha_ratio = src_alpha * 255 / dest_alpha;
1171 » » » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_sca n, m_Blue, alpha_ratio); 1405 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, alpha_ratio);
1172 » » » » » dest_scan ++; 1406 dest_scan++;
1173 » » » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_sca n, m_Green, alpha_ratio); 1407 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, alpha_ratio);
1174 » » » » » dest_scan ++; 1408 dest_scan++;
1175 » » » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_sca n, m_Red, alpha_ratio); 1409 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, alpha_ratio);
1176 » » » » » dest_scan ++; 1410 dest_scan++;
1177 » » » » } 1411 }
1178 » » » } 1412 }
1179 » » } else { 1413 } else {
1180 » » » int src_alpha = m_Alpha * cover_scan / 255; 1414 int src_alpha = m_Alpha * cover_scan / 255;
1181 » » » for (int col = col_start; col < col_end; col ++) { 1415 for (int col = col_start; col < col_end; col++) {
1182 » » » » int src_alpha1 = m_Alpha * cover_scan * clip_sca n[col] / 255; 1416 int src_alpha1 = m_Alpha * cover_scan * clip_scan[col] / 255;
1183 » » » » if (!src_alpha1) { 1417 if (!src_alpha1) {
1184 » » » » » dest_extra_alpha_scan++; 1418 dest_extra_alpha_scan++;
1185 » » » » » dest_scan += 3; 1419 dest_scan += 3;
1186 » » » » » continue; 1420 continue;
1187 » » » » }» » » » 1421 }
1188 » » » » if (src_alpha1 == 255) { 1422 if (src_alpha1 == 255) {
1189 » » » » » *dest_scan++ = (FX_BYTE)m_Blue; 1423 *dest_scan++ = (FX_BYTE)m_Blue;
1190 » » » » » *dest_scan++ = (FX_BYTE)m_Green; 1424 *dest_scan++ = (FX_BYTE)m_Green;
1191 » » » » » *dest_scan++ = (FX_BYTE)m_Red; 1425 *dest_scan++ = (FX_BYTE)m_Red;
1192 » » » » » *dest_extra_alpha_scan++ = (FX_BYTE)m_Al pha; 1426 *dest_extra_alpha_scan++ = (FX_BYTE)m_Alpha;
1193 » » » » } else { 1427 } else {
1194 » » » » » // Dest format: Rgba 1428 // Dest format: Rgba
1195 » » » » » // calculate destination alpha (it's uni on of source and dest alpha) 1429 // calculate destination alpha (it's union of source and dest alpha)
1196 » » » » » FX_BYTE dest_alpha = (*dest_extra_alpha_ scan) + src_alpha1 - 1430 FX_BYTE dest_alpha = (*dest_extra_alpha_scan) + src_alpha1 -
1197 » » » » » » » » » » (*dest_extra_alpha_scan) * src_alpha1 / 255; 1431 (*dest_extra_alpha_scan) * src_alpha1 / 255;
1198 » » » » » *dest_extra_alpha_scan++ = dest_alpha; 1432 *dest_extra_alpha_scan++ = dest_alpha;
1199 » » » » » int alpha_ratio = src_alpha1*255/dest_al pha; 1433 int alpha_ratio = src_alpha1 * 255 / dest_alpha;
1200 » » » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_sca n, m_Blue, alpha_ratio); 1434 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, alpha_ratio);
1201 » » » » » dest_scan ++; 1435 dest_scan++;
1202 » » » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_sca n, m_Green, alpha_ratio); 1436 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, alpha_ratio);
1203 » » » » » dest_scan ++; 1437 dest_scan++;
1204 » » » » » *dest_scan = FXDIB_ALPHA_MERGE(*dest_sca n, m_Red, alpha_ratio); 1438 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, alpha_ratio);
1205 » » » » » dest_scan ++; 1439 dest_scan++;
1206 » » » » } 1440 }
1207 » » » } 1441 }
1208 » » } 1442 }
1209 #endif 1443 #endif
1210 } 1444 }
1211 /*---------------------------------------------------------------------- -------------------------------*/ 1445 /*------------------------------------------------------------------------------ -----------------------*/
1212 1446
1213 // A general alpha merge function (with clipping mask). Cmyka/Cmyk devic e. 1447 // A general alpha merge function (with clipping mask). Cmyka/Cmyk device.
1214 void CFX_SkiaRenderer::CompositeSpanCMYK(FX_LPBYTE dest_scan, FX_LPBYTE ori_scan,int Bpp, 1448 void CFX_SkiaRenderer::CompositeSpanCMYK(FX_LPBYTE dest_scan,
1215 int span_left, int span_len, int span_top, FX_BYTE cover _scan, 1449 FX_LPBYTE ori_scan,
1216 int clip_top, int clip_left, int clip_right, FX_LPBYTE c lip_scan, 1450 int Bpp,
1217 FX_LPBYTE dest_extra_alpha_scan) 1451 int span_left,
1218 { 1452 int span_len,
1219 ASSERT(!m_bRgbByteOrder); 1453 int span_top,
1220 // Cmyk(a) 1454 FX_BYTE cover_scan,
1221 int col_start = span_left < clip_left ? clip_left - span_left : 0; 1455 int clip_top,
1222 int col_end = (span_left + span_len) < clip_right ? span_len : ( clip_right - span_left); 1456 int clip_left,
1223 if (col_end < col_start) return; // do nothing. 1457 int clip_right,
1224 dest_scan += col_start * 4; 1458 FX_LPBYTE clip_scan,
1225 Bpp; // for avoid compile warning. 1459 FX_LPBYTE dest_extra_alpha_scan) {
1226 1460 ASSERT(!m_bRgbByteOrder);
1227 if (dest_extra_alpha_scan) { 1461 // Cmyk(a)
1228 // CMYKa 1462 int col_start = span_left < clip_left ? clip_left - span_left : 0;
1229 for (int col = col_start; col < col_end; col ++) { 1463 int col_end =
1230 int src_alpha; 1464 (span_left + span_len) < clip_right ? span_len : (clip_right - span_left);
1231 if (m_bFullCover) { 1465 if (col_end < col_start)
1232 if (clip_scan) 1466 return; // do nothing.
1233 src_alpha = m_Alpha * clip_scan[ col] / 255; 1467 dest_scan += col_start * 4;
1234 else 1468 Bpp; // for avoid compile warning.
1235 src_alpha = m_Alpha; 1469
1236 } else { 1470 if (dest_extra_alpha_scan) {
1237 if (clip_scan) 1471 // CMYKa
1238 src_alpha = m_Alpha * cover_scan * clip_scan[col] / 255 / 255; 1472 for (int col = col_start; col < col_end; col++) {
1239 else 1473 int src_alpha;
1240 src_alpha = m_Alpha * cover_scan / 255; 1474 if (m_bFullCover) {
1241 } 1475 if (clip_scan)
1242 1476 src_alpha = m_Alpha * clip_scan[col] / 255;
1243 if (src_alpha) { 1477 else
1244 if (src_alpha == 255) { 1478 src_alpha = m_Alpha;
1245 *(FX_CMYK*)dest_scan = m_Color; 1479 } else {
1246 *dest_extra_alpha_scan = (FX_BYT E)m_Alpha; 1480 if (clip_scan)
1247 } else { 1481 src_alpha = m_Alpha * cover_scan * clip_scan[col] / 255 / 255;
1248 // Dest format: Cmyka 1482 else
1249 // calculate destination alpha ( it's union of source and dest alpha) 1483 src_alpha = m_Alpha * cover_scan / 255;
1250 FX_BYTE dest_alpha = (*dest_extr a_alpha_scan) + src_alpha - 1484 }
1251 (*dest_extra_alpha_scan) * src_alpha / 255; 1485
1252 *dest_extra_alpha_scan++ = dest_ alpha; 1486 if (src_alpha) {
1253 int alpha_ratio = src_alpha*255/ dest_alpha; 1487 if (src_alpha == 255) {
1254 *dest_scan = FXDIB_ALPHA_MERGE(* dest_scan, m_Red, alpha_ratio); 1488 *(FX_CMYK*)dest_scan = m_Color;
1255 dest_scan ++; 1489 *dest_extra_alpha_scan = (FX_BYTE)m_Alpha;
1256 *dest_scan = FXDIB_ALPHA_MERGE(* dest_scan, m_Green, alpha_ratio); 1490 } else {
1257 dest_scan ++; 1491 // Dest format: Cmyka
1258 *dest_scan = FXDIB_ALPHA_MERGE(* dest_scan, m_Blue, alpha_ratio); 1492 // calculate destination alpha (it's union of source and dest alpha)
1259 dest_scan ++; 1493 FX_BYTE dest_alpha = (*dest_extra_alpha_scan) + src_alpha -
1260 *dest_scan = FXDIB_ALPHA_MERGE(* dest_scan, m_Gray, alpha_ratio); 1494 (*dest_extra_alpha_scan) * src_alpha / 255;
1261 dest_scan ++; 1495 *dest_extra_alpha_scan++ = dest_alpha;
1262 continue; 1496 int alpha_ratio = src_alpha * 255 / dest_alpha;
1263 } 1497 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, alpha_ratio);
1264 } 1498 dest_scan++;
1265 dest_extra_alpha_scan++; 1499 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, alpha_ratio);
1266 dest_scan += 4; 1500 dest_scan++;
1267 } 1501 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, alpha_ratio);
1268 } else { 1502 dest_scan++;
1269 // CMYK 1503 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Gray, alpha_ratio);
1270 for (int col = col_start; col < col_end; col ++) { 1504 dest_scan++;
1271 int src_alpha; 1505 continue;
1272 if (clip_scan) 1506 }
1273 src_alpha = m_Alpha * cover_scan * clip_ scan[col] / 255 / 255; 1507 }
1274 else 1508 dest_extra_alpha_scan++;
1275 src_alpha = m_Alpha * cover_scan / 255; 1509 dest_scan += 4;
1276 1510 }
1277 if (src_alpha) { 1511 } else {
1278 if (src_alpha == 255) { 1512 // CMYK
1279 *(FX_CMYK*)dest_scan = m_Color; 1513 for (int col = col_start; col < col_end; col++) {
1280 } else { 1514 int src_alpha;
1281 // Dest format: cmyk 1515 if (clip_scan)
1282 *dest_scan = FXDIB_ALPHA_MERGE(* dest_scan, m_Red, src_alpha); 1516 src_alpha = m_Alpha * cover_scan * clip_scan[col] / 255 / 255;
1283 dest_scan ++; 1517 else
1284 *dest_scan = FXDIB_ALPHA_MERGE(* dest_scan, m_Green, src_alpha); 1518 src_alpha = m_Alpha * cover_scan / 255;
1285 dest_scan ++; 1519
1286 *dest_scan = FXDIB_ALPHA_MERGE(* dest_scan, m_Blue, src_alpha); 1520 if (src_alpha) {
1287 dest_scan ++; 1521 if (src_alpha == 255) {
1288 *dest_scan = FXDIB_ALPHA_MERGE(* dest_scan, m_Gray, src_alpha); 1522 *(FX_CMYK*)dest_scan = m_Color;
1289 dest_scan ++; 1523 } else {
1290 continue; 1524 // Dest format: cmyk
1291 } 1525 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, src_alpha);
1292 } 1526 dest_scan++;
1293 dest_scan += 4; 1527 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, src_alpha);
1294 } 1528 dest_scan++;
1295 } 1529 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, src_alpha);
1296 } 1530 dest_scan++;
1297 1531 *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Gray, src_alpha);
1298 1532 dest_scan++;
1299 1533 continue;
1300 //-------------------------------------------------------------------- 1534 }
1301 FX_BOOL CFX_SkiaRenderer::Init(CFX_DIBitmap* pDevice, CFX_DIBitmap* pOri Device, const CFX_ClipRgn* pClipRgn, FX_DWORD color, FX_BOOL bFullCover, FX_BOOL bRgbByteOrder, 1535 }
1302 int alpha_flag, void* pIccTransform) //The alpha flag must be fi ll_flag if exist. 1536 dest_scan += 4;
1303 { 1537 }
1304 m_pDevice = pDevice; 1538 }
1305 m_pClipRgn = pClipRgn; 1539 }
1306 m_bRgbByteOrder = bRgbByteOrder; 1540
1307 m_pOriDevice = pOriDevice; 1541 //--------------------------------------------------------------------
1308 m_pDestScan = NULL; 1542 FX_BOOL CFX_SkiaRenderer::Init(
1309 m_pDestExtraAlphaScan = NULL; 1543 CFX_DIBitmap* pDevice,
1310 m_pOriScan = NULL; 1544 CFX_DIBitmap* pOriDevice,
1311 m_pClipScan = NULL; 1545 const CFX_ClipRgn* pClipRgn,
1312 composite_span = NULL; 1546 FX_DWORD color,
1313 if (m_pClipRgn) 1547 FX_BOOL bFullCover,
1314 m_ClipBox = m_pClipRgn->GetBox(); 1548 FX_BOOL bRgbByteOrder,
1315 else { 1549 int alpha_flag,
1316 m_ClipBox.left = m_ClipBox.top = 0; 1550 void* pIccTransform) // The alpha flag must be fill_flag if exist.
1317 m_ClipBox.right = m_pDevice->GetWidth(); 1551 {
1318 m_ClipBox.bottom = m_pDevice->GetHeight(); 1552 m_pDevice = pDevice;
1319 } 1553 m_pClipRgn = pClipRgn;
1320 m_pClipMask = NULL; 1554 m_bRgbByteOrder = bRgbByteOrder;
1321 if (m_pClipRgn && m_pClipRgn->GetType() == CFX_ClipRgn::MaskF) 1555 m_pOriDevice = pOriDevice;
1322 { 1556 m_pDestScan = NULL;
1323 m_pClipMask = m_pClipRgn->GetMask(); 1557 m_pDestExtraAlphaScan = NULL;
1324 m_pClipScan = m_pClipMask->GetBuffer(); 1558 m_pOriScan = NULL;
1325 } 1559 m_pClipScan = NULL;
1326 if (m_pDevice->m_pAlphaMask) 1560 composite_span = NULL;
1327 m_pDestExtraAlphaScan = m_pDevice->m_pAlphaMask->GetBuff er(); 1561 if (m_pClipRgn)
1328 if (m_pOriDevice) 1562 m_ClipBox = m_pClipRgn->GetBox();
1329 m_pOriScan = m_pOriDevice->GetBuffer(); 1563 else {
1330 m_pDestScan = m_pDevice->GetBuffer(); 1564 m_ClipBox.left = m_ClipBox.top = 0;
1331 1565 m_ClipBox.right = m_pDevice->GetWidth();
1332 m_bFullCover = bFullCover; 1566 m_ClipBox.bottom = m_pDevice->GetHeight();
1333 1567 }
1334 FX_BOOL bObjectCMYK = FXGETFLAG_COLORTYPE(alpha_flag); 1568 m_pClipMask = NULL;
1335 FX_BOOL bDeviceCMYK = pDevice->IsCmykImage(); 1569 if (m_pClipRgn && m_pClipRgn->GetType() == CFX_ClipRgn::MaskF) {
1336 1570 m_pClipMask = m_pClipRgn->GetMask();
1337 m_Alpha = bObjectCMYK ? FXGETFLAG_ALPHA_FILL(alpha_flag) : FXARG B_A(color); 1571 m_pClipScan = m_pClipMask->GetBuffer();
1338 1572 }
1339 ICodec_IccModule* pIccModule = NULL; 1573 if (m_pDevice->m_pAlphaMask)
1340 // No lcms engine, we skip the transform 1574 m_pDestExtraAlphaScan = m_pDevice->m_pAlphaMask->GetBuffer();
1341 if (!CFX_GEModule::Get()->GetCodecModule() || !CFX_GEModule::Get ()->GetCodecModule()->GetIccModule()) 1575 if (m_pOriDevice)
1342 pIccTransform = NULL; 1576 m_pOriScan = m_pOriDevice->GetBuffer();
1343 else 1577 m_pDestScan = m_pDevice->GetBuffer();
1344 pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetI ccModule(); 1578
1345 1579 m_bFullCover = bFullCover;
1346 if (m_pDevice->GetBPP() == 8) { // Gray(a) device 1580
1347 ASSERT(!m_bRgbByteOrder); 1581 FX_BOOL bObjectCMYK = FXGETFLAG_COLORTYPE(alpha_flag);
1348 if (m_pDevice->IsAlphaMask()) { 1582 FX_BOOL bDeviceCMYK = pDevice->IsCmykImage();
1349 //Alpha Mask 1583
1350 m_Gray = 255; 1584 m_Alpha = bObjectCMYK ? FXGETFLAG_ALPHA_FILL(alpha_flag) : FXARGB_A(color);
1351 } else { 1585
1352 //Gray(a) device 1586 ICodec_IccModule* pIccModule = NULL;
1353 if (pIccTransform) { 1587 // No lcms engine, we skip the transform
1354 FX_BYTE gray; 1588 if (!CFX_GEModule::Get()->GetCodecModule() ||
1355 color = bObjectCMYK ? FXCMYK_TODIB(color ) : FXARGB_TODIB(color); 1589 !CFX_GEModule::Get()->GetCodecModule()->GetIccModule())
1356 pIccModule->TranslateScanline(pIccTransf orm, &gray, (FX_LPCBYTE)&color, 1); 1590 pIccTransform = NULL;
1357 m_Gray = gray; 1591 else
1358 } else { 1592 pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
1359 if (bObjectCMYK) { 1593
1360 FX_BYTE r, g, b; 1594 if (m_pDevice->GetBPP() == 8) { // Gray(a) device
1361 AdobeCMYK_to_sRGB1(FXSYS_GetCVal ue(color), FXSYS_GetMValue(color), FXSYS_GetYValue(color), FXSYS_GetKValue(color ), 1595 ASSERT(!m_bRgbByteOrder);
1362 r, g, b); 1596 if (m_pDevice->IsAlphaMask()) {
1363 m_Gray = FXRGB2GRAY(r, g, b); 1597 // Alpha Mask
1364 } else { 1598 m_Gray = 255;
1365 m_Gray = FXRGB2GRAY(FXARGB_R(col or), FXARGB_G(color), FXARGB_B(color)); 1599 } else {
1366 } 1600 // Gray(a) device
1367 } 1601 if (pIccTransform) {
1368 } 1602 FX_BYTE gray;
1369 } else { 1603 color = bObjectCMYK ? FXCMYK_TODIB(color) : FXARGB_TODIB(color);
1370 if (bDeviceCMYK) { // Cmyk(a) Device 1604 pIccModule->TranslateScanline(
1371 ASSERT(!m_bRgbByteOrder); 1605 pIccTransform, &gray, (FX_LPCBYTE)&color, 1);
1372 //TODO... opt for cmyk 1606 m_Gray = gray;
1373 composite_span = &CFX_SkiaRenderer::CompositeSpa nCMYK; 1607 } else {
1374 if (bObjectCMYK) { 1608 if (bObjectCMYK) {
1375 m_Color = FXCMYK_TODIB(color); 1609 FX_BYTE r, g, b;
1376 if (pIccTransform) 1610 AdobeCMYK_to_sRGB1(FXSYS_GetCValue(color),
1377 pIccModule->TranslateScanline(pI ccTransform, (FX_LPBYTE)&m_Color, (FX_LPCBYTE)&m_Color, 1); 1611 FXSYS_GetMValue(color),
1378 } else { // Object RGB 1612 FXSYS_GetYValue(color),
1379 if (!pIccTransform) 1613 FXSYS_GetKValue(color),
1380 return FALSE; 1614 r,
1381 color = FXARGB_TODIB(color); 1615 g,
1382 pIccModule->TranslateScanline(pIccTransf orm, (FX_LPBYTE)&m_Color, (FX_LPCBYTE)&color, 1); 1616 b);
1383 } 1617 m_Gray = FXRGB2GRAY(r, g, b);
1384 m_Red = ((FX_LPBYTE)&m_Color)[0]; 1618 } else {
1385 m_Green = ((FX_LPBYTE)&m_Color)[1]; 1619 m_Gray =
1386 m_Blue = ((FX_LPBYTE)&m_Color)[2]; 1620 FXRGB2GRAY(FXARGB_R(color), FXARGB_G(color), FXARGB_B(color));
1387 m_Gray = ((FX_LPBYTE)&m_Color)[3]; 1621 }
1388 return TRUE; 1622 }
1389 } else { 1623 }
1390 if (pIccTransform) { 1624 } else {
1391 color = bObjectCMYK ? FXCMYK_TODIB(color ) : FXARGB_TODIB(color); 1625 if (bDeviceCMYK) { // Cmyk(a) Device
1392 pIccModule->TranslateScanline(pIccTransf orm, (FX_LPBYTE)&m_Color, (FX_LPCBYTE)&color, 1); 1626 ASSERT(!m_bRgbByteOrder);
1393 ((FX_LPBYTE)&m_Color)[3] = m_Alpha; 1627 // TODO... opt for cmyk
1394 m_Red = ((FX_LPBYTE)&m_Color)[2]; 1628 composite_span = &CFX_SkiaRenderer::CompositeSpanCMYK;
1395 m_Green = ((FX_LPBYTE)&m_Color)[1]; 1629 if (bObjectCMYK) {
1396 m_Blue = ((FX_LPBYTE)&m_Color)[0]; 1630 m_Color = FXCMYK_TODIB(color);
1397 // Need Johnson to improvement it. 1631 if (pIccTransform)
1398 if (m_bRgbByteOrder) { 1632 pIccModule->TranslateScanline(
1399 // swap 1633 pIccTransform, (FX_LPBYTE)&m_Color, (FX_LPCBYTE)&m_Color, 1);
1400 m_Red = ((FX_LPBYTE)&m_Color)[0] ; 1634 } else { // Object RGB
1401 m_Blue = ((FX_LPBYTE)&m_Color)[2 ]; 1635 if (!pIccTransform)
1402 m_Color = FXARGB_TODIB(m_Color); 1636 return FALSE;
1403 m_Color = FXARGB_TOBGRORDERDIB(m _Color); 1637 color = FXARGB_TODIB(color);
1404 } 1638 pIccModule->TranslateScanline(
1405 } else { 1639 pIccTransform, (FX_LPBYTE)&m_Color, (FX_LPCBYTE)&color, 1);
1406 if (bObjectCMYK) { 1640 }
1407 FX_BYTE r, g, b; 1641 m_Red = ((FX_LPBYTE)&m_Color)[0];
1408 AdobeCMYK_to_sRGB1(FXSYS_GetCVal ue(color), FXSYS_GetMValue(color), FXSYS_GetYValue(color), FXSYS_GetKValue(color ), 1642 m_Green = ((FX_LPBYTE)&m_Color)[1];
1409 r, g, b); 1643 m_Blue = ((FX_LPBYTE)&m_Color)[2];
1410 m_Color = FXARGB_MAKE(m_Alpha, r , g, b); 1644 m_Gray = ((FX_LPBYTE)&m_Color)[3];
1411 if (m_bRgbByteOrder){ 1645 return TRUE;
1412 m_Color = FXARGB_TOBGROR DERDIB(m_Color); 1646 } else {
1413 m_Red = b; m_Green = g; m_Blue = r;// 1647 if (pIccTransform) {
1414 }else { 1648 color = bObjectCMYK ? FXCMYK_TODIB(color) : FXARGB_TODIB(color);
1415 m_Color = FXARGB_TODIB(m _Color); 1649 pIccModule->TranslateScanline(
1416 m_Red = r; m_Green = g; m_Blue = b;// 1650 pIccTransform, (FX_LPBYTE)&m_Color, (FX_LPCBYTE)&color, 1);
1417 } 1651 ((FX_LPBYTE)&m_Color)[3] = m_Alpha;
1418 } else { 1652 m_Red = ((FX_LPBYTE)&m_Color)[2];
1419 if (m_bRgbByteOrder){ 1653 m_Green = ((FX_LPBYTE)&m_Color)[1];
1420 m_Color = FXARGB_TOBGROR DERDIB(color); 1654 m_Blue = ((FX_LPBYTE)&m_Color)[0];
1421 ArgbDecode(color, m_Alph a, m_Blue, m_Green, m_Red); // 1655 // Need Johnson to improvement it.
1422 }else { 1656 if (m_bRgbByteOrder) {
1423 m_Color = FXARGB_TODIB(c olor); 1657 // swap
1424 ArgbDecode(color, m_Alph a, m_Red, m_Green, m_Blue); 1658 m_Red = ((FX_LPBYTE)&m_Color)[0];
1425 } 1659 m_Blue = ((FX_LPBYTE)&m_Color)[2];
1426 } 1660 m_Color = FXARGB_TODIB(m_Color);
1427 } 1661 m_Color = FXARGB_TOBGRORDERDIB(m_Color);
1428 } 1662 }
1429 } 1663 } else {
1430 // Get palette transparency selector 1664 if (bObjectCMYK) {
1431 m_ProcessFilter = (m_pOriDevice? 1 : 0) /* has Ori Device flag * / 1665 FX_BYTE r, g, b;
1432 + (m_pDevice->GetBPP() >= 8 ? 2 : 0) /* bpp flag */ 1666 AdobeCMYK_to_sRGB1(FXSYS_GetCValue(color),
1433 + (m_pClipMask? 4 : 0) /* has clip region flag */ 1667 FXSYS_GetMValue(color),
1434 + (m_pDevice->m_pAlphaMask? 8 : 0); /* has Alpha Mask chanel flag */ 1668 FXSYS_GetYValue(color),
1435 switch(m_ProcessFilter) { 1669 FXSYS_GetKValue(color),
1436 case 0: 1670 r,
1437 composite_span = &CFX_SkiaRenderer::CompositeSpa n1bpp_0; 1671 g,
1438 break; 1672 b);
1439 case 2: 1673 m_Color = FXARGB_MAKE(m_Alpha, r, g, b);
1440 { 1674 if (m_bRgbByteOrder) {
1441 if (m_pDevice->GetBPP() == 8) 1675 m_Color = FXARGB_TOBGRORDERDIB(m_Color);
1442 composite_span = &CFX_SkiaRender er::CompositeSpanGray_2; 1676 m_Red = b;
1443 else if (m_pDevice->GetBPP() == 24) 1677 m_Green = g;
1444 composite_span = &CFX_SkiaRender er::CompositeSpanRGB24_2; 1678 m_Blue = r; //
1445 else 1679 } else {
1446 composite_span = m_pDevice->HasA lpha()?&CFX_SkiaRenderer::CompositeSpanARGB_2 : &CFX_SkiaRenderer::CompositeSpan RGB32_2; 1680 m_Color = FXARGB_TODIB(m_Color);
1447 } 1681 m_Red = r;
1448 break; 1682 m_Green = g;
1449 case 3: 1683 m_Blue = b; //
1450 { 1684 }
1451 if (m_pDevice->GetBPP() == 8) 1685 } else {
1452 composite_span = &CFX_SkiaRender er::CompositeSpanGray_3; 1686 if (m_bRgbByteOrder) {
1453 else if (m_pDevice->GetBPP() == 24) 1687 m_Color = FXARGB_TOBGRORDERDIB(color);
1454 composite_span = &CFX_SkiaRender er::CompositeSpanRGB24_3; 1688 ArgbDecode(color, m_Alpha, m_Blue, m_Green, m_Red); //
1455 else 1689 } else {
1456 composite_span = m_pDevice->HasA lpha()?&CFX_SkiaRenderer::CompositeSpanARGB_3 : &CFX_SkiaRenderer::CompositeSpan RGB32_3; 1690 m_Color = FXARGB_TODIB(color);
1457 } 1691 ArgbDecode(color, m_Alpha, m_Red, m_Green, m_Blue);
1458 break; 1692 }
1459 case 4: 1693 }
1460 composite_span = &CFX_SkiaRenderer::CompositeSpa n1bpp_4; 1694 }
1461 break; 1695 }
1462 case 6: 1696 }
1463 { 1697 // Get palette transparency selector
1464 if (m_pDevice->GetBPP() == 8) 1698 m_ProcessFilter =
1465 composite_span = &CFX_SkiaRender er::CompositeSpanGray_6; 1699 (m_pOriDevice ? 1 : 0) /* has Ori Device flag */
1466 else if (m_pDevice->GetBPP() == 24) 1700 + (m_pDevice->GetBPP() >= 8 ? 2 : 0) /* bpp flag */
1467 composite_span = &CFX_SkiaRender er::CompositeSpanRGB24_6; 1701 + (m_pClipMask ? 4 : 0) /* has clip region flag */
1468 else 1702 + (m_pDevice->m_pAlphaMask ? 8 : 0); /* has Alpha Mask chanel flag */
1469 composite_span = m_pDevice->HasA lpha()?&CFX_SkiaRenderer::CompositeSpanARGB_6 : &CFX_SkiaRenderer::CompositeSpan RGB32_6; 1703 switch (m_ProcessFilter) {
1470 } 1704 case 0:
1471 break; 1705 composite_span = &CFX_SkiaRenderer::CompositeSpan1bpp_0;
1472 case 7: 1706 break;
1473 { 1707 case 2: {
1474 if (m_pDevice->GetBPP() == 8) 1708 if (m_pDevice->GetBPP() == 8)
1475 composite_span = &CFX_SkiaRender er::CompositeSpanGray_7; 1709 composite_span = &CFX_SkiaRenderer::CompositeSpanGray_2;
1476 else if (m_pDevice->GetBPP() == 24) 1710 else if (m_pDevice->GetBPP() == 24)
1477 composite_span = &CFX_SkiaRender er::CompositeSpanRGB24_7; 1711 composite_span = &CFX_SkiaRenderer::CompositeSpanRGB24_2;
1478 else 1712 else
1479 composite_span = m_pDevice->HasA lpha()?&CFX_SkiaRenderer::CompositeSpanARGB_7 : &CFX_SkiaRenderer::CompositeSpan RGB32_7; 1713 composite_span = m_pDevice->HasAlpha()
1480 } 1714 ? &CFX_SkiaRenderer::CompositeSpanARGB_2
1481 break; 1715 : &CFX_SkiaRenderer::CompositeSpanRGB32_2;
1482 case 1: 1716 } break;
1483 case 5: 1717 case 3: {
1484 case 8: 1718 if (m_pDevice->GetBPP() == 8)
1485 case 9: 1719 composite_span = &CFX_SkiaRenderer::CompositeSpanGray_3;
1486 case 11: 1720 else if (m_pDevice->GetBPP() == 24)
1487 case 12: 1721 composite_span = &CFX_SkiaRenderer::CompositeSpanRGB24_3;
1488 case 13: 1722 else
1489 case 15: 1723 composite_span = m_pDevice->HasAlpha()
1490 //TODO... 1724 ? &CFX_SkiaRenderer::CompositeSpanARGB_3
1491 break; 1725 : &CFX_SkiaRenderer::CompositeSpanRGB32_3;
1492 case 10: 1726 } break;
1493 composite_span = &CFX_SkiaRenderer::CompositeSpa nRGB24_10; 1727 case 4:
1494 break; 1728 composite_span = &CFX_SkiaRenderer::CompositeSpan1bpp_4;
1495 case 14: 1729 break;
1496 composite_span = &CFX_SkiaRenderer::CompositeSpa nRGB24_14; 1730 case 6: {
1497 break; 1731 if (m_pDevice->GetBPP() == 8)
1498 } 1732 composite_span = &CFX_SkiaRenderer::CompositeSpanGray_6;
1499 if (composite_span == NULL) 1733 else if (m_pDevice->GetBPP() == 24)
1500 return FALSE; 1734 composite_span = &CFX_SkiaRenderer::CompositeSpanRGB24_6;
1501 return TRUE; 1735 else
1502 } 1736 composite_span = m_pDevice->HasAlpha()
1503 1737 ? &CFX_SkiaRenderer::CompositeSpanARGB_6
1504 /*---------------------------------------------------------------------- ------------------------------*/ 1738 : &CFX_SkiaRenderer::CompositeSpanRGB32_6;
1505 void CFX_SkiaA8Renderer::blitAntiH(int x, int y, const SkAlpha antialias [], const int16_t runs[]) 1739 } break;
1506 { 1740 case 7: {
1507 FXSYS_assert(m_pDevice); 1741 if (m_pDevice->GetBPP() == 8)
1508 int dst_y = y - m_Top; 1742 composite_span = &CFX_SkiaRenderer::CompositeSpanGray_7;
1509 if (dst_y < 0 || dst_y >= m_pDevice->GetHeight()) 1743 else if (m_pDevice->GetBPP() == 24)
1510 return; 1744 composite_span = &CFX_SkiaRenderer::CompositeSpanRGB24_7;
1511 1745 else
1512 FX_LPBYTE dest_scan = m_pDevice->GetBuffer() + m_pDevice->GetPit ch() * dst_y; 1746 composite_span = m_pDevice->HasAlpha()
1513 FX_LPBYTE dest_pos = dest_scan; 1747 ? &CFX_SkiaRenderer::CompositeSpanARGB_7
1514 while (1) 1748 : &CFX_SkiaRenderer::CompositeSpanRGB32_7;
1515 { 1749 } break;
1516 if (x >= m_dstWidth) 1750 case 1:
1517 return; 1751 case 5:
1518 int width = runs[0]; 1752 case 8:
1519 SkASSERT(width >= 0); 1753 case 9:
1520 if (width <= 0) 1754 case 11:
1521 return; 1755 case 12:
1522 unsigned aa = antialias[0]; 1756 case 13:
1523 if (aa) { 1757 case 15:
1524 int col_start = x < m_Left ? 0 : x - m_Left; 1758 // TODO...
1525 int col_end = x + width; 1759 break;
1526 col_end = col_end < m_dstWidth ? col_end - m_Lef t: m_pDevice->GetWidth(); 1760 case 10:
1527 int result = col_end - col_start; 1761 composite_span = &CFX_SkiaRenderer::CompositeSpanRGB24_10;
1528 if (result > 0) { 1762 break;
1529 dest_pos = dest_scan + col_start; 1763 case 14:
1530 if (result >= 4) 1764 composite_span = &CFX_SkiaRenderer::CompositeSpanRGB24_14;
1531 FXSYS_memset32(dest_pos, FXARGB_ MAKE(aa, aa, aa, aa),result); 1765 break;
1532 else 1766 }
1533 FXSYS_memset(dest_pos,aa,result) ; 1767 if (composite_span == NULL)
1534 } 1768 return FALSE;
1535 } 1769 return TRUE;
1536 runs += width; 1770 }
1537 antialias += width; 1771
1538 x += width; 1772 /*------------------------------------------------------------------------------ ----------------------*/
1539 } 1773 void CFX_SkiaA8Renderer::blitAntiH(int x,
1540 } 1774 int y,
1541 void CFX_SkiaA8Renderer::blitH(int x, int y, int width) 1775 const SkAlpha antialias[],
1542 { 1776 const int16_t runs[]) {
1543 FXSYS_assert(m_pDevice); 1777 FXSYS_assert(m_pDevice);
1544 int dst_y = y - m_Top; 1778 int dst_y = y - m_Top;
1545 if (dst_y < 0 || dst_y >= m_pDevice->GetHeight()) 1779 if (dst_y < 0 || dst_y >= m_pDevice->GetHeight())
1546 return; 1780 return;
1547 if (x >= m_dstWidth) 1781
1548 return; 1782 FX_LPBYTE dest_scan = m_pDevice->GetBuffer() + m_pDevice->GetPitch() * dst_y;
1549 FX_LPBYTE dest_scan = m_pDevice->GetBuffer() + m_pDevice->GetPit ch() * dst_y; 1783 FX_LPBYTE dest_pos = dest_scan;
1550 int col_start = x < m_Left ? 0 : x - m_Left; 1784 while (1) {
1551 int col_end = x + width; 1785 if (x >= m_dstWidth)
1552 col_end = col_end < m_dstWidth ? col_end - m_Left: m_pDevice->Ge tWidth(); 1786 return;
1553 int result = col_end - col_start; 1787 int width = runs[0];
1554 if (result > 0) { 1788 SkASSERT(width >= 0);
1555 FX_BYTE* dest_pos = dest_scan + col_start; 1789 if (width <= 0)
1556 if (result >= 4) 1790 return;
1557 FXSYS_memset32(dest_pos, 0xffffffff,result); 1791 unsigned aa = antialias[0];
1558 else 1792 if (aa) {
1559 FXSYS_memset(dest_pos,255,result); 1793 int col_start = x < m_Left ? 0 : x - m_Left;
1560 } 1794 int col_end = x + width;
1561 } 1795 col_end = col_end < m_dstWidth ? col_end - m_Left : m_pDevice->GetWidth();
1562 void CFX_SkiaA8Renderer::blitV(int x, int y, int height, SkAlpha alpha) 1796 int result = col_end - col_start;
1563 { 1797 if (result > 0) {
1564 FXSYS_assert(alpha); 1798 dest_pos = dest_scan + col_start;
1565 if (alpha == 255) { 1799 if (result >= 4)
1566 this->blitRect(x, y, 1, height); 1800 FXSYS_memset32(dest_pos, FXARGB_MAKE(aa, aa, aa, aa), result);
1567 } else { 1801 else
1568 int16_t runs[2]; 1802 FXSYS_memset(dest_pos, aa, result);
1569 runs[0] = 1; 1803 }
1570 runs[1] = 0; 1804 }
1571 while (--height >= 0) { 1805 runs += width;
1572 if (y >= m_dstHeight) 1806 antialias += width;
1573 return; 1807 x += width;
1574 this->blitAntiH(x, y ++, &alpha, runs); 1808 }
1575 } 1809 }
1576 } 1810 void CFX_SkiaA8Renderer::blitH(int x, int y, int width) {
1577 } 1811 FXSYS_assert(m_pDevice);
1578 void CFX_SkiaA8Renderer::blitRect(int x, int y, int width, int height) 1812 int dst_y = y - m_Top;
1579 { 1813 if (dst_y < 0 || dst_y >= m_pDevice->GetHeight())
1580 FXSYS_assert(m_pDevice); 1814 return;
1581 while (--height >= 0) { 1815 if (x >= m_dstWidth)
1582 if (y >= m_dstHeight) 1816 return;
1583 return; 1817 FX_LPBYTE dest_scan = m_pDevice->GetBuffer() + m_pDevice->GetPitch() * dst_y;
1584 blitH(x , y ++, width); 1818 int col_start = x < m_Left ? 0 : x - m_Left;
1585 } 1819 int col_end = x + width;
1586 } 1820 col_end = col_end < m_dstWidth ? col_end - m_Left : m_pDevice->GetWidth();
1587 1821 int result = col_end - col_start;
1588 void CFX_SkiaA8Renderer::blitAntiRect(int x, int y, int width, int heigh t, 1822 if (result > 0) {
1589 SkAlpha leftAlpha, SkAlpha rightAlpha) 1823 FX_BYTE* dest_pos = dest_scan + col_start;
1590 { 1824 if (result >= 4)
1591 blitV(x++, y, height, leftAlpha); 1825 FXSYS_memset32(dest_pos, 0xffffffff, result);
1592 if (width > 0) { 1826 else
1593 blitRect(x, y, width, height); 1827 FXSYS_memset(dest_pos, 255, result);
1594 x += width; 1828 }
1595 } 1829 }
1596 blitV(x, y, height, rightAlpha); 1830 void CFX_SkiaA8Renderer::blitV(int x, int y, int height, SkAlpha alpha) {
1597 } 1831 FXSYS_assert(alpha);
1598 1832 if (alpha == 255) {
1599 FX_BOOL CFX_SkiaA8Renderer::Init(CFX_DIBitmap* pDevice, int Left, int To p) 1833 this->blitRect(x, y, 1, height);
1600 { 1834 } else {
1601 m_pDevice = pDevice; 1835 int16_t runs[2];
1602 m_Left = Left; 1836 runs[0] = 1;
1603 m_Top = Top; 1837 runs[1] = 0;
1604 if (pDevice){ 1838 while (--height >= 0) {
1605 m_dstWidth = m_Left + pDevice->GetWidth(); 1839 if (y >= m_dstHeight)
1606 m_dstHeight = m_Top + pDevice->GetHeight(); 1840 return;
1607 } 1841 this->blitAntiH(x, y++, &alpha, runs);
1608 return TRUE; 1842 }
1609 } 1843 }
1844 }
1845 void CFX_SkiaA8Renderer::blitRect(int x, int y, int width, int height) {
1846 FXSYS_assert(m_pDevice);
1847 while (--height >= 0) {
1848 if (y >= m_dstHeight)
1849 return;
1850 blitH(x, y++, width);
1851 }
1852 }
1853
1854 void CFX_SkiaA8Renderer::blitAntiRect(int x,
1855 int y,
1856 int width,
1857 int height,
1858 SkAlpha leftAlpha,
1859 SkAlpha rightAlpha) {
1860 blitV(x++, y, height, leftAlpha);
1861 if (width > 0) {
1862 blitRect(x, y, width, height);
1863 x += width;
1864 }
1865 blitV(x, y, height, rightAlpha);
1866 }
1867
1868 FX_BOOL CFX_SkiaA8Renderer::Init(CFX_DIBitmap* pDevice, int Left, int Top) {
1869 m_pDevice = pDevice;
1870 m_Left = Left;
1871 m_Top = Top;
1872 if (pDevice) {
1873 m_dstWidth = m_Left + pDevice->GetWidth();
1874 m_dstHeight = m_Top + pDevice->GetHeight();
1875 }
1876 return TRUE;
1877 }
1610 #endif 1878 #endif
OLDNEW
« core/src/fdrm/crypto/fx_crypt_aes.cpp ('K') | « core/src/fxge/skia/fx_skia_blitter_new.h ('k') | core/src/fxge/skia/fx_skia_device.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698