OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2015 Google Inc. | 2 * Copyright 2015 Google Inc. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license that can be | 4 * Use of this source code is governed by a BSD-style license that can be |
5 * found in the LICENSE file. | 5 * found in the LICENSE file. |
6 */ | 6 */ |
7 | 7 |
8 #include "SkCodecPriv.h" | |
9 #include "SkColorPriv.h" | 8 #include "SkColorPriv.h" |
10 #include "SkSwizzler.h" | 9 #include "SkSwizzler.h" |
11 #include "SkTemplates.h" | 10 #include "SkTemplates.h" |
12 | 11 |
13 SkSwizzler::ResultAlpha SkSwizzler::GetResult(uint8_t zeroAlpha, | 12 // index |
14 uint8_t maxAlpha) { | 13 |
15 // In the transparent case, this returns 0x0000 | 14 #define A32_MASK_IN_PLACE (SkPMColor)(SK_A32_MASK << SK_A32_SHIFT) |
16 // In the opaque case, this returns 0xFFFF | 15 |
17 // If the row is neither transparent nor opaque, returns something else | 16 static bool swizzle_index_to_n32(void* SK_RESTRICT dstRow, |
18 return (((uint16_t) maxAlpha) << 8) | zeroAlpha; | 17 const uint8_t* SK_RESTRICT src, |
| 18 int width, int deltaSrc, int, const SkPMColor c
table[]) { |
| 19 |
| 20 SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow; |
| 21 SkPMColor cc = A32_MASK_IN_PLACE; |
| 22 for (int x = 0; x < width; x++) { |
| 23 SkPMColor c = ctable[*src]; |
| 24 cc &= c; |
| 25 dst[x] = c; |
| 26 src += deltaSrc; |
| 27 } |
| 28 return cc != A32_MASK_IN_PLACE; |
19 } | 29 } |
20 | 30 |
21 // kIndex1, kIndex2, kIndex4 | 31 static bool swizzle_index_to_n32_skipZ(void* SK_RESTRICT dstRow, |
22 | 32 const uint8_t* SK_RESTRICT src, |
23 static SkSwizzler::ResultAlpha swizzle_small_index_to_n32( | 33 int width, int deltaSrc, int, |
24 void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width, | 34 const SkPMColor ctable[]) { |
25 int bitsPerPixel, int y, const SkPMColor ctable[]) { | |
26 | |
27 SkPMColor* SK_RESTRICT dst = (SkPMColor*) dstRow; | |
28 INIT_RESULT_ALPHA; | |
29 const uint32_t pixelsPerByte = 8 / bitsPerPixel; | |
30 const size_t rowBytes = compute_row_bytes_ppb(width, pixelsPerByte); | |
31 const uint8_t mask = (1 << bitsPerPixel) - 1; | |
32 int x = 0; | |
33 for (uint32_t byte = 0; byte < rowBytes; byte++) { | |
34 uint8_t pixelData = src[byte]; | |
35 for (uint32_t p = 0; p < pixelsPerByte && x < width; p++) { | |
36 uint8_t index = (pixelData >> (8 - bitsPerPixel)) & mask; | |
37 SkPMColor c = ctable[index]; | |
38 UPDATE_RESULT_ALPHA(c >> SK_A32_SHIFT); | |
39 dst[x] = c; | |
40 pixelData <<= bitsPerPixel; | |
41 x++; | |
42 } | |
43 } | |
44 return COMPUTE_RESULT_ALPHA; | |
45 } | |
46 | |
47 // kIndex | |
48 | |
49 static SkSwizzler::ResultAlpha swizzle_index_to_n32( | |
50 void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width, | |
51 int bytesPerPixel, int y, const SkPMColor ctable[]) { | |
52 | 35 |
53 SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow; | 36 SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow; |
54 INIT_RESULT_ALPHA; | 37 SkPMColor cc = A32_MASK_IN_PLACE; |
55 for (int x = 0; x < width; x++) { | 38 for (int x = 0; x < width; x++) { |
56 SkPMColor c = ctable[*src]; | 39 SkPMColor c = ctable[*src]; |
57 UPDATE_RESULT_ALPHA(c >> SK_A32_SHIFT); | 40 cc &= c; |
58 dst[x] = c; | |
59 src++; | |
60 } | |
61 return COMPUTE_RESULT_ALPHA; | |
62 } | |
63 | |
64 static SkSwizzler::ResultAlpha swizzle_index_to_n32_skipZ( | |
65 void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width, | |
66 int bytesPerPixel, int y, const SkPMColor ctable[]) { | |
67 | |
68 SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow; | |
69 INIT_RESULT_ALPHA; | |
70 for (int x = 0; x < width; x++) { | |
71 SkPMColor c = ctable[*src]; | |
72 UPDATE_RESULT_ALPHA(c >> SK_A32_SHIFT); | |
73 if (c != 0) { | 41 if (c != 0) { |
74 dst[x] = c; | 42 dst[x] = c; |
75 } | 43 } |
76 src++; | 44 src += deltaSrc; |
77 } | 45 } |
78 return COMPUTE_RESULT_ALPHA; | 46 return cc != A32_MASK_IN_PLACE; |
79 } | 47 } |
80 | 48 |
81 #undef A32_MASK_IN_PLACE | 49 #undef A32_MASK_IN_PLACE |
82 | 50 |
83 static SkSwizzler::ResultAlpha swizzle_bgrx_to_n32( | |
84 void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width, | |
85 int bytesPerPixel, int y, const SkPMColor ctable[]) { | |
86 | |
87 SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow; | |
88 for (int x = 0; x < width; x++) { | |
89 dst[x] = SkPackARGB32NoCheck(0xFF, src[2], src[1], src[0]); | |
90 src += bytesPerPixel; | |
91 } | |
92 return SkSwizzler::kOpaque_ResultAlpha; | |
93 } | |
94 | |
95 // kBGRA | |
96 | |
97 static SkSwizzler::ResultAlpha swizzle_bgra_to_n32( | |
98 void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width, | |
99 int bytesPerPixel, int y, const SkPMColor ctable[]) { | |
100 | |
101 SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow; | |
102 INIT_RESULT_ALPHA; | |
103 for (int x = 0; x < width; x++) { | |
104 uint8_t alpha = src[3]; | |
105 UPDATE_RESULT_ALPHA(alpha); | |
106 dst[x] = SkPackARGB32NoCheck(alpha, src[2], src[1], src[0]); | |
107 src += bytesPerPixel; | |
108 } | |
109 return COMPUTE_RESULT_ALPHA; | |
110 } | |
111 | |
112 // n32 | 51 // n32 |
113 static SkSwizzler::ResultAlpha swizzle_rgbx_to_n32( | 52 static bool swizzle_rgbx_to_n32(void* SK_RESTRICT dstRow, |
114 void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width, | 53 const uint8_t* SK_RESTRICT src, |
115 int bytesPerPixel, int y, const SkPMColor ctable[]) { | 54 int width, int deltaSrc, int, const SkPMColor[])
{ |
116 | |
117 SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow; | 55 SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow; |
118 for (int x = 0; x < width; x++) { | 56 for (int x = 0; x < width; x++) { |
119 dst[x] = SkPackARGB32(0xFF, src[0], src[1], src[2]); | 57 dst[x] = SkPackARGB32(0xFF, src[0], src[1], src[2]); |
120 src += bytesPerPixel; | 58 src += deltaSrc; |
121 } | 59 } |
122 return SkSwizzler::kOpaque_ResultAlpha; | 60 return false; |
123 } | 61 } |
124 | 62 |
125 static SkSwizzler::ResultAlpha swizzle_rgba_to_n32_premul( | 63 static bool swizzle_rgba_to_n32_premul(void* SK_RESTRICT dstRow, |
126 void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width, | 64 const uint8_t* SK_RESTRICT src, |
127 int bytesPerPixel, int y, const SkPMColor ctable[]) { | 65 int width, int deltaSrc, int, const SkPMC
olor[]) { |
128 | |
129 SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow; | 66 SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow; |
130 INIT_RESULT_ALPHA; | 67 unsigned alphaMask = 0xFF; |
131 for (int x = 0; x < width; x++) { | 68 for (int x = 0; x < width; x++) { |
132 unsigned alpha = src[3]; | 69 unsigned alpha = src[3]; |
133 UPDATE_RESULT_ALPHA(alpha); | |
134 dst[x] = SkPreMultiplyARGB(alpha, src[0], src[1], src[2]); | 70 dst[x] = SkPreMultiplyARGB(alpha, src[0], src[1], src[2]); |
135 src += bytesPerPixel; | 71 src += deltaSrc; |
| 72 alphaMask &= alpha; |
136 } | 73 } |
137 return COMPUTE_RESULT_ALPHA; | 74 return alphaMask != 0xFF; |
138 } | 75 } |
139 | 76 |
140 static SkSwizzler::ResultAlpha swizzle_rgba_to_n32_unpremul( | 77 static bool swizzle_rgba_to_n32_unpremul(void* SK_RESTRICT dstRow, |
141 void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width, | 78 const uint8_t* SK_RESTRICT src, |
142 int bytesPerPixel, int y, const SkPMColor ctable[]) { | 79 int width, int deltaSrc, int, |
143 | 80 const SkPMColor[]) { |
144 uint32_t* SK_RESTRICT dst = reinterpret_cast<uint32_t*>(dstRow); | 81 uint32_t* SK_RESTRICT dst = reinterpret_cast<uint32_t*>(dstRow); |
145 INIT_RESULT_ALPHA; | 82 unsigned alphaMask = 0xFF; |
146 for (int x = 0; x < width; x++) { | 83 for (int x = 0; x < width; x++) { |
147 unsigned alpha = src[3]; | 84 unsigned alpha = src[3]; |
148 UPDATE_RESULT_ALPHA(alpha); | |
149 dst[x] = SkPackARGB32NoCheck(alpha, src[0], src[1], src[2]); | 85 dst[x] = SkPackARGB32NoCheck(alpha, src[0], src[1], src[2]); |
150 src += bytesPerPixel; | 86 src += deltaSrc; |
| 87 alphaMask &= alpha; |
151 } | 88 } |
152 return COMPUTE_RESULT_ALPHA; | 89 return alphaMask != 0xFF; |
153 } | 90 } |
154 | 91 |
155 static SkSwizzler::ResultAlpha swizzle_rgba_to_n32_premul_skipZ( | 92 static bool swizzle_rgba_to_n32_premul_skipZ(void* SK_RESTRICT dstRow, |
156 void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width, | 93 const uint8_t* SK_RESTRICT src, |
157 int bytesPerPixel, int y, const SkPMColor ctable[]) { | 94 int width, int deltaSrc, int, |
158 | 95 const SkPMColor[]) { |
159 SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow; | 96 SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow; |
160 INIT_RESULT_ALPHA; | 97 unsigned alphaMask = 0xFF; |
161 for (int x = 0; x < width; x++) { | 98 for (int x = 0; x < width; x++) { |
162 unsigned alpha = src[3]; | 99 unsigned alpha = src[3]; |
163 UPDATE_RESULT_ALPHA(alpha); | |
164 if (0 != alpha) { | 100 if (0 != alpha) { |
165 dst[x] = SkPreMultiplyARGB(alpha, src[0], src[1], src[2]); | 101 dst[x] = SkPreMultiplyARGB(alpha, src[0], src[1], src[2]); |
166 } | 102 } |
167 src += bytesPerPixel; | 103 src += deltaSrc; |
| 104 alphaMask &= alpha; |
168 } | 105 } |
169 return COMPUTE_RESULT_ALPHA; | 106 return alphaMask != 0xFF; |
170 } | 107 } |
171 | 108 |
172 /** | 109 /** |
173 FIXME: This was my idea to cheat in order to continue taking advantage of sk
ipping zeroes. | 110 FIXME: This was my idea to cheat in order to continue taking advantage of sk
ipping zeroes. |
174 This would be fine for drawing normally, but not for drawing with transfer m
odes. Being | 111 This would be fine for drawing normally, but not for drawing with transfer m
odes. Being |
175 honest means we can draw correctly with transfer modes, with the cost of not
being able | 112 honest means we can draw correctly with transfer modes, with the cost of not
being able |
176 to take advantage of Android's free unwritten pages. Something to keep in mi
nd when we | 113 to take advantage of Android's free unwritten pages. Something to keep in mi
nd when we |
177 decide whether to switch to unpremul default. | 114 decide whether to switch to unpremul default. |
178 static bool swizzle_rgba_to_n32_unpremul_skipZ(void* SK_RESTRICT dstRow, | 115 static bool swizzle_rgba_to_n32_unpremul_skipZ(void* SK_RESTRICT dstRow, |
179 const uint8_t* SK_RESTRICT src, | 116 const uint8_t* SK_RESTRICT src, |
180 int width, int bitsPerPixel, | 117 int width, int deltaSrc, int, |
181 const SkPMColor[]) { | 118 const SkPMColor[]) { |
182 SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow; | 119 SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow; |
183 unsigned alphaMask = 0xFF; | 120 unsigned alphaMask = 0xFF; |
184 for (int x = 0; x < width; x++) { | 121 for (int x = 0; x < width; x++) { |
185 unsigned alpha = src[3]; | 122 unsigned alpha = src[3]; |
186 // NOTE: We cheat here. The caller requested unpremul and skip zeroes. I
t's possible | 123 // NOTE: We cheat here. The caller requested unpremul and skip zeroes. I
t's possible |
187 // the color components are not zero, but we skip them anyway, meaning t
hey'll remain | 124 // the color components are not zero, but we skip them anyway, meaning t
hey'll remain |
188 // zero (implied by the request to skip zeroes). | 125 // zero (implied by the request to skip zeroes). |
189 if (0 != alpha) { | 126 if (0 != alpha) { |
190 dst[x] = SkPackARGB32NoCheck(alpha, src[0], src[1], src[2]); | 127 dst[x] = SkPackARGB32NoCheck(alpha, src[0], src[1], src[2]); |
191 } | 128 } |
192 src += deltaSrc; | 129 src += deltaSrc; |
193 alphaMask &= alpha; | 130 alphaMask &= alpha; |
194 } | 131 } |
195 return alphaMask != 0xFF; | 132 return alphaMask != 0xFF; |
196 } | 133 } |
197 */ | 134 */ |
198 | 135 |
199 SkSwizzler* SkSwizzler::CreateSwizzler(SkSwizzler::SrcConfig sc, | 136 SkSwizzler* SkSwizzler::CreateSwizzler(SkSwizzler::SrcConfig sc, const SkPMColor
* ctable, |
200 const SkPMColor* ctable, | |
201 const SkImageInfo& info, void* dst, | 137 const SkImageInfo& info, void* dst, |
202 size_t dstRowBytes, bool skipZeroes) { | 138 size_t dstRowBytes, bool skipZeroes) { |
203 if (kUnknown_SkColorType == info.colorType()) { | 139 if (info.colorType() == kUnknown_SkColorType) { |
204 return NULL; | 140 return NULL; |
205 } | 141 } |
206 if (info.minRowBytes() > dstRowBytes) { | 142 if (info.minRowBytes() > dstRowBytes) { |
207 return NULL; | 143 return NULL; |
208 } | 144 } |
209 if ((kIndex == sc || kIndex4 == sc || kIndex2 == sc || kIndex1 == sc) | 145 if (kIndex == sc && NULL == ctable) { |
210 && NULL == ctable) { | |
211 return NULL; | 146 return NULL; |
212 } | 147 } |
213 RowProc proc = NULL; | 148 RowProc proc = NULL; |
214 switch (sc) { | 149 switch (sc) { |
215 case kIndex1: | |
216 case kIndex2: | |
217 case kIndex4: | |
218 switch (info.colorType()) { | |
219 case kN32_SkColorType: | |
220 proc = &swizzle_small_index_to_n32; | |
221 break; | |
222 default: | |
223 break; | |
224 } | |
225 break; | |
226 case kIndex: | 150 case kIndex: |
227 switch (info.colorType()) { | 151 switch (info.colorType()) { |
228 case kN32_SkColorType: | 152 case kN32_SkColorType: |
| 153 // We assume the color premultiplied ctable (or not) as desi
red. |
229 if (skipZeroes) { | 154 if (skipZeroes) { |
230 proc = &swizzle_index_to_n32_skipZ; | 155 proc = &swizzle_index_to_n32_skipZ; |
231 } else { | 156 } else { |
232 proc = &swizzle_index_to_n32; | 157 proc = &swizzle_index_to_n32; |
233 } | 158 } |
234 break; | 159 break; |
| 160 |
235 default: | 161 default: |
236 break; | 162 break; |
237 } | 163 } |
238 break; | |
239 case kBGR: | |
240 case kBGRX: | |
241 switch (info.colorType()) { | |
242 case kN32_SkColorType: | |
243 proc = &swizzle_bgrx_to_n32; | |
244 break; | |
245 default: | |
246 break; | |
247 } | |
248 break; | |
249 case kBGRA: | |
250 switch (info.colorType()) { | |
251 case kN32_SkColorType: | |
252 proc = &swizzle_bgra_to_n32; | |
253 break; | |
254 default: | |
255 break; | |
256 } | |
257 break; | 164 break; |
258 case kRGBX: | 165 case kRGBX: |
259 // TODO: Support other swizzles. | 166 // TODO: Support other swizzles. |
260 switch (info.colorType()) { | 167 switch (info.colorType()) { |
261 case kN32_SkColorType: | 168 case kN32_SkColorType: |
262 proc = &swizzle_rgbx_to_n32; | 169 proc = &swizzle_rgbx_to_n32; |
263 break; | 170 break; |
264 default: | 171 default: |
265 break; | 172 break; |
266 } | 173 } |
267 break; | 174 break; |
268 case kRGBA: | 175 case kRGBA: |
269 switch (info.colorType()) { | 176 switch (info.colorType()) { |
270 case kN32_SkColorType: | 177 case kN32_SkColorType: |
271 if (info.alphaType() == kUnpremul_SkAlphaType) { | 178 if (info.alphaType() == kUnpremul_SkAlphaType) { |
272 // Respect skipZeroes? | 179 // Respect skipZeroes? |
273 proc = &swizzle_rgba_to_n32_unpremul; | 180 proc = &swizzle_rgba_to_n32_unpremul; |
274 } else { | 181 } else { |
275 if (skipZeroes) { | 182 if (skipZeroes) { |
276 proc = &swizzle_rgba_to_n32_premul_skipZ; | 183 proc = &swizzle_rgba_to_n32_premul_skipZ; |
277 } else { | 184 } else { |
278 proc = &swizzle_rgba_to_n32_premul; | 185 proc = &swizzle_rgba_to_n32_premul; |
279 } | 186 } |
280 } | 187 } |
281 break; | 188 break; |
282 default: | 189 default: |
283 break; | 190 break; |
284 } | 191 } |
285 break; | 192 break; |
286 case kRGB: | |
287 switch (info.colorType()) { | |
288 case kN32_SkColorType: | |
289 proc = &swizzle_rgbx_to_n32; | |
290 break; | |
291 default: | |
292 break; | |
293 } | |
294 break; | |
295 default: | 193 default: |
296 break; | 194 break; |
297 } | 195 } |
298 if (NULL == proc) { | 196 if (NULL == proc) { |
299 return NULL; | 197 return NULL; |
300 } | 198 } |
301 | 199 return SkNEW_ARGS(SkSwizzler, (proc, ctable, BytesPerPixel(sc), info, dst, d
stRowBytes)); |
302 // Store deltaSrc in bytes if it is an even multiple, otherwise use bits | |
303 int deltaSrc = SkIsAlign8(BitsPerPixel(sc)) ? BytesPerPixel(sc) : | |
304 BitsPerPixel(sc); | |
305 return SkNEW_ARGS(SkSwizzler, (proc, ctable, deltaSrc, info, dst, | |
306 dstRowBytes)); | |
307 } | 200 } |
308 | 201 |
309 SkSwizzler::SkSwizzler(RowProc proc, const SkPMColor* ctable, | 202 SkSwizzler::SkSwizzler(RowProc proc, const SkPMColor* ctable, int srcBpp, |
310 int deltaSrc, const SkImageInfo& info, void* dst, | 203 const SkImageInfo& info, void* dst, size_t rowBytes) |
311 size_t rowBytes) | |
312 : fRowProc(proc) | 204 : fRowProc(proc) |
313 , fColorTable(ctable) | 205 , fColorTable(ctable) |
314 , fDeltaSrc(deltaSrc) | 206 , fSrcPixelSize(srcBpp) |
315 , fDstInfo(info) | 207 , fDstInfo(info) |
316 , fDstRow(dst) | 208 , fDstRow(dst) |
317 , fDstRowBytes(rowBytes) | 209 , fDstRowBytes(rowBytes) |
318 , fCurrY(0) | 210 , fCurrY(0) |
319 { | 211 { |
320 SkDEBUGCODE(fNextMode = kUninitialized_NextMode); | |
321 } | 212 } |
322 | 213 |
323 SkSwizzler::ResultAlpha SkSwizzler::next(const uint8_t* SK_RESTRICT src) { | 214 bool SkSwizzler::next(const uint8_t* SK_RESTRICT src) { |
324 SkASSERT(0 <= fCurrY && fCurrY < fDstInfo.height()); | 215 SkASSERT(fCurrY < fDstInfo.height()); |
325 SkASSERT(kDesignateRow_NextMode != fNextMode); | 216 const bool hadAlpha = fRowProc(fDstRow, src, fDstInfo.width(), fSrcPixelSize
, |
326 SkDEBUGCODE(fNextMode = kConsecutive_NextMode); | 217 fCurrY, fColorTable); |
327 | 218 fCurrY++; |
328 // Decode a row | |
329 const ResultAlpha result = fRowProc(fDstRow, src, fDstInfo.width(), | |
330 fDeltaSrc, fCurrY, fColorTable); | |
331 | |
332 // Move to the next row and return the result | |
333 fDstRow = SkTAddOffset<void>(fDstRow, fDstRowBytes); | 219 fDstRow = SkTAddOffset<void>(fDstRow, fDstRowBytes); |
334 return result; | 220 return hadAlpha; |
335 } | 221 } |
336 | |
337 SkSwizzler::ResultAlpha SkSwizzler::next(const uint8_t* SK_RESTRICT src, | |
338 int y) { | |
339 SkASSERT(0 <= y && y < fDstInfo.height()); | |
340 SkASSERT(kConsecutive_NextMode != fNextMode); | |
341 SkDEBUGCODE(fNextMode = kDesignateRow_NextMode); | |
342 | |
343 // Choose the row | |
344 void* row = SkTAddOffset<void>(fDstRow, y*fDstRowBytes); | |
345 | |
346 // Decode the row | |
347 return fRowProc(row, src, fDstInfo.width(), fDeltaSrc, fCurrY, | |
348 fColorTable); | |
349 } | |
OLD | NEW |