The Tor Browser / file comparison

comparison: gfx/skia/trunk/src/images/SkScaledBitmapSampler.cpp

gfx/skia/trunk/src/images/SkScaledBitmapSampler.cpp

branch
TOR_BUG_3246
changeset 7
129ffea94266
equal deleted inserted replaced
-1:000000000000 0:d342f8421ace
1 /*
2 * Copyright 2007 The Android Open Source Project
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8
9 #include "SkScaledBitmapSampler.h"
10 #include "SkBitmap.h"
11 #include "SkColorPriv.h"
12 #include "SkDither.h"
13 #include "SkTypes.h"
14
15 // 8888
16
17 static bool Sample_Gray_D8888(void* SK_RESTRICT dstRow,
18 const uint8_t* SK_RESTRICT src,
19 int width, int deltaSrc, int, const SkPMColor[]) {
20 SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
21 for (int x = 0; x < width; x++) {
22 dst[x] = SkPackARGB32(0xFF, src[0], src[0], src[0]);
23 src += deltaSrc;
24 }
25 return false;
26 }
27
28 static SkScaledBitmapSampler::RowProc get_gray_to_8888_proc(const SkImageDecoder& decoder) {
29 // Dither, unpremul, and skipZeroes have no effect
30 return Sample_Gray_D8888;
31 }
32
33 static bool Sample_RGBx_D8888(void* SK_RESTRICT dstRow,
34 const uint8_t* SK_RESTRICT src,
35 int width, int deltaSrc, int, const SkPMColor[]) {
36 SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
37 for (int x = 0; x < width; x++) {
38 dst[x] = SkPackARGB32(0xFF, src[0], src[1], src[2]);
39 src += deltaSrc;
40 }
41 return false;
42 }
43
44 static SkScaledBitmapSampler::RowProc get_RGBx_to_8888_proc(const SkImageDecoder& decoder) {
45 // Dither, unpremul, and skipZeroes have no effect
46 return Sample_RGBx_D8888;
47 }
48
49 static bool Sample_RGBA_D8888(void* SK_RESTRICT dstRow,
50 const uint8_t* SK_RESTRICT src,
51 int width, int deltaSrc, int, const SkPMColor[]) {
52 SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
53 unsigned alphaMask = 0xFF;
54 for (int x = 0; x < width; x++) {
55 unsigned alpha = src[3];
56 dst[x] = SkPreMultiplyARGB(alpha, src[0], src[1], src[2]);
57 src += deltaSrc;
58 alphaMask &= alpha;
59 }
60 return alphaMask != 0xFF;
61 }
62
63 static bool Sample_RGBA_D8888_Unpremul(void* SK_RESTRICT dstRow,
64 const uint8_t* SK_RESTRICT src,
65 int width, int deltaSrc, int,
66 const SkPMColor[]) {
67 uint32_t* SK_RESTRICT dst = reinterpret_cast<uint32_t*>(dstRow);
68 unsigned alphaMask = 0xFF;
69 for (int x = 0; x < width; x++) {
70 unsigned alpha = src[3];
71 dst[x] = SkPackARGB32NoCheck(alpha, src[0], src[1], src[2]);
72 src += deltaSrc;
73 alphaMask &= alpha;
74 }
75 return alphaMask != 0xFF;
76 }
77
78 static bool Sample_RGBA_D8888_SkipZ(void* SK_RESTRICT dstRow,
79 const uint8_t* SK_RESTRICT src,
80 int width, int deltaSrc, int,
81 const SkPMColor[]) {
82 SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
83 unsigned alphaMask = 0xFF;
84 for (int x = 0; x < width; x++) {
85 unsigned alpha = src[3];
86 if (0 != alpha) {
87 dst[x] = SkPreMultiplyARGB(alpha, src[0], src[1], src[2]);
88 }
89 src += deltaSrc;
90 alphaMask &= alpha;
91 }
92 return alphaMask != 0xFF;
93 }
94
95 static SkScaledBitmapSampler::RowProc get_RGBA_to_8888_proc(const SkImageDecoder& decoder) {
96 // Dither has no effect.
97 if (decoder.getRequireUnpremultipliedColors()) {
98 // We could check each component for a zero, at the expense of extra checks.
99 // For now, just return unpremul.
100 return Sample_RGBA_D8888_Unpremul;
101 }
102 // Supply the versions that premultiply the colors
103 if (decoder.getSkipWritingZeroes()) {
104 return Sample_RGBA_D8888_SkipZ;
105 }
106 return Sample_RGBA_D8888;
107 }
108
109 // 565
110
111 static bool Sample_Gray_D565(void* SK_RESTRICT dstRow,
112 const uint8_t* SK_RESTRICT src,
113 int width, int deltaSrc, int, const SkPMColor[]) {
114 uint16_t* SK_RESTRICT dst = (uint16_t*)dstRow;
115 for (int x = 0; x < width; x++) {
116 dst[x] = SkPack888ToRGB16(src[0], src[0], src[0]);
117 src += deltaSrc;
118 }
119 return false;
120 }
121
122 static bool Sample_Gray_D565_D(void* SK_RESTRICT dstRow,
123 const uint8_t* SK_RESTRICT src,
124 int width, int deltaSrc, int y, const SkPMColor[]) {
125 uint16_t* SK_RESTRICT dst = (uint16_t*)dstRow;
126 DITHER_565_SCAN(y);
127 for (int x = 0; x < width; x++) {
128 dst[x] = SkDitherRGBTo565(src[0], src[0], src[0], DITHER_VALUE(x));
129 src += deltaSrc;
130 }
131 return false;
132 }
133
134 static SkScaledBitmapSampler::RowProc get_gray_to_565_proc(const SkImageDecoder& decoder) {
135 // Unpremul and skip zeroes make no difference
136 if (decoder.getDitherImage()) {
137 return Sample_Gray_D565_D;
138 }
139 return Sample_Gray_D565;
140 }
141
142 static bool Sample_RGBx_D565(void* SK_RESTRICT dstRow,
143 const uint8_t* SK_RESTRICT src,
144 int width, int deltaSrc, int, const SkPMColor[]) {
145 uint16_t* SK_RESTRICT dst = (uint16_t*)dstRow;
146 for (int x = 0; x < width; x++) {
147 dst[x] = SkPack888ToRGB16(src[0], src[1], src[2]);
148 src += deltaSrc;
149 }
150 return false;
151 }
152
153 static bool Sample_RGBx_D565_D(void* SK_RESTRICT dstRow,
154 const uint8_t* SK_RESTRICT src,
155 int width, int deltaSrc, int y,
156 const SkPMColor[]) {
157 uint16_t* SK_RESTRICT dst = (uint16_t*)dstRow;
158 DITHER_565_SCAN(y);
159 for (int x = 0; x < width; x++) {
160 dst[x] = SkDitherRGBTo565(src[0], src[1], src[2], DITHER_VALUE(x));
161 src += deltaSrc;
162 }
163 return false;
164 }
165
166 static SkScaledBitmapSampler::RowProc get_RGBx_to_565_proc(const SkImageDecoder& decoder) {
167 // Unpremul and skip zeroes make no difference
168 if (decoder.getDitherImage()) {
169 return Sample_RGBx_D565_D;
170 }
171 return Sample_RGBx_D565;
172 }
173
174
175 static bool Sample_D565_D565(void* SK_RESTRICT dstRow,
176 const uint8_t* SK_RESTRICT src,
177 int width, int deltaSrc, int, const SkPMColor[]) {
178 uint16_t* SK_RESTRICT dst = (uint16_t*)dstRow;
179 uint16_t* SK_RESTRICT castedSrc = (uint16_t*) src;
180 for (int x = 0; x < width; x++) {
181 dst[x] = castedSrc[0];
182 castedSrc += deltaSrc >> 1;
183 }
184 return false;
185 }
186
187 static SkScaledBitmapSampler::RowProc get_565_to_565_proc(const SkImageDecoder& decoder) {
188 // Unpremul, dither, and skip zeroes have no effect
189 return Sample_D565_D565;
190 }
191
192 // 4444
193
194 static bool Sample_Gray_D4444(void* SK_RESTRICT dstRow,
195 const uint8_t* SK_RESTRICT src,
196 int width, int deltaSrc, int, const SkPMColor[]) {
197 SkPMColor16* SK_RESTRICT dst = (SkPMColor16*)dstRow;
198 for (int x = 0; x < width; x++) {
199 unsigned gray = src[0] >> 4;
200 dst[x] = SkPackARGB4444(0xF, gray, gray, gray);
201 src += deltaSrc;
202 }
203 return false;
204 }
205
206 static bool Sample_Gray_D4444_D(void* SK_RESTRICT dstRow,
207 const uint8_t* SK_RESTRICT src,
208 int width, int deltaSrc, int y, const SkPMColor[]) {
209 SkPMColor16* SK_RESTRICT dst = (SkPMColor16*)dstRow;
210 DITHER_4444_SCAN(y);
211 for (int x = 0; x < width; x++) {
212 dst[x] = SkDitherARGB32To4444(0xFF, src[0], src[0], src[0],
213 DITHER_VALUE(x));
214 src += deltaSrc;
215 }
216 return false;
217 }
218
219 static SkScaledBitmapSampler::RowProc get_gray_to_4444_proc(const SkImageDecoder& decoder) {
220 // Skip zeroes and unpremul make no difference
221 if (decoder.getDitherImage()) {
222 return Sample_Gray_D4444_D;
223 }
224 return Sample_Gray_D4444;
225 }
226
227 static bool Sample_RGBx_D4444(void* SK_RESTRICT dstRow,
228 const uint8_t* SK_RESTRICT src,
229 int width, int deltaSrc, int, const SkPMColor[]) {
230 SkPMColor16* SK_RESTRICT dst = (SkPMColor16*)dstRow;
231 for (int x = 0; x < width; x++) {
232 dst[x] = SkPackARGB4444(0xF, src[0] >> 4, src[1] >> 4, src[2] >> 4);
233 src += deltaSrc;
234 }
235 return false;
236 }
237
238 static bool Sample_RGBx_D4444_D(void* SK_RESTRICT dstRow,
239 const uint8_t* SK_RESTRICT src,
240 int width, int deltaSrc, int y, const SkPMColor[]) {
241 SkPMColor16* dst = (SkPMColor16*)dstRow;
242 DITHER_4444_SCAN(y);
243
244 for (int x = 0; x < width; x++) {
245 dst[x] = SkDitherARGB32To4444(0xFF, src[0], src[1], src[2],
246 DITHER_VALUE(x));
247 src += deltaSrc;
248 }
249 return false;
250 }
251
252 static SkScaledBitmapSampler::RowProc get_RGBx_to_4444_proc(const SkImageDecoder& decoder) {
253 // Skip zeroes and unpremul make no difference
254 if (decoder.getDitherImage()) {
255 return Sample_RGBx_D4444_D;
256 }
257 return Sample_RGBx_D4444;
258 }
259
260 static bool Sample_RGBA_D4444(void* SK_RESTRICT dstRow,
261 const uint8_t* SK_RESTRICT src,
262 int width, int deltaSrc, int, const SkPMColor[]) {
263 SkPMColor16* SK_RESTRICT dst = (SkPMColor16*)dstRow;
264 unsigned alphaMask = 0xFF;
265
266 for (int x = 0; x < width; x++) {
267 unsigned alpha = src[3];
268 SkPMColor c = SkPreMultiplyARGB(alpha, src[0], src[1], src[2]);
269 dst[x] = SkPixel32ToPixel4444(c);
270 src += deltaSrc;
271 alphaMask &= alpha;
272 }
273 return alphaMask != 0xFF;
274 }
275
276 static bool Sample_RGBA_D4444_SkipZ(void* SK_RESTRICT dstRow,
277 const uint8_t* SK_RESTRICT src,
278 int width, int deltaSrc, int,
279 const SkPMColor[]) {
280 SkPMColor16* SK_RESTRICT dst = (SkPMColor16*)dstRow;
281 unsigned alphaMask = 0xFF;
282
283 for (int x = 0; x < width; x++) {
284 unsigned alpha = src[3];
285 if (alpha != 0) {
286 SkPMColor c = SkPreMultiplyARGB(alpha, src[0], src[1], src[2]);
287 dst[x] = SkPixel32ToPixel4444(c);
288 }
289 src += deltaSrc;
290 alphaMask &= alpha;
291 }
292 return alphaMask != 0xFF;
293 }
294
295
296 static bool Sample_RGBA_D4444_D(void* SK_RESTRICT dstRow,
297 const uint8_t* SK_RESTRICT src,
298 int width, int deltaSrc, int y,
299 const SkPMColor[]) {
300 SkPMColor16* SK_RESTRICT dst = (SkPMColor16*)dstRow;
301 unsigned alphaMask = 0xFF;
302 DITHER_4444_SCAN(y);
303
304 for (int x = 0; x < width; x++) {
305 unsigned alpha = src[3];
306 SkPMColor c = SkPreMultiplyARGB(alpha, src[0], src[1], src[2]);
307 dst[x] = SkDitherARGB32To4444(c, DITHER_VALUE(x));
308 src += deltaSrc;
309 alphaMask &= alpha;
310 }
311 return alphaMask != 0xFF;
312 }
313
314 static bool Sample_RGBA_D4444_D_SkipZ(void* SK_RESTRICT dstRow,
315 const uint8_t* SK_RESTRICT src,
316 int width, int deltaSrc, int y,
317 const SkPMColor[]) {
318 SkPMColor16* SK_RESTRICT dst = (SkPMColor16*)dstRow;
319 unsigned alphaMask = 0xFF;
320 DITHER_4444_SCAN(y);
321
322 for (int x = 0; x < width; x++) {
323 unsigned alpha = src[3];
324 if (alpha != 0) {
325 SkPMColor c = SkPreMultiplyARGB(alpha, src[0], src[1], src[2]);
326 dst[x] = SkDitherARGB32To4444(c, DITHER_VALUE(x));
327 }
328 src += deltaSrc;
329 alphaMask &= alpha;
330 }
331 return alphaMask != 0xFF;
332 }
333
334 static SkScaledBitmapSampler::RowProc get_RGBA_to_4444_proc(const SkImageDecoder& decoder) {
335 if (decoder.getRequireUnpremultipliedColors()) {
336 // Unpremultiplied is not supported for 4444
337 return NULL;
338 }
339 const bool dither = decoder.getDitherImage();
340 if (decoder.getSkipWritingZeroes()) {
341 if (dither) {
342 return Sample_RGBA_D4444_D_SkipZ;
343 }
344 return Sample_RGBA_D4444_SkipZ;
345 }
346 if (dither) {
347 return Sample_RGBA_D4444_D;
348 }
349 return Sample_RGBA_D4444;
350 }
351
352 // Index
353
354 #define A32_MASK_IN_PLACE (SkPMColor)(SK_A32_MASK << SK_A32_SHIFT)
355
356 static bool Sample_Index_D8888(void* SK_RESTRICT dstRow,
357 const uint8_t* SK_RESTRICT src,
358 int width, int deltaSrc, int, const SkPMColor ctable[]) {
359
360 SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
361 SkPMColor cc = A32_MASK_IN_PLACE;
362 for (int x = 0; x < width; x++) {
363 SkPMColor c = ctable[*src];
364 cc &= c;
365 dst[x] = c;
366 src += deltaSrc;
367 }
368 return cc != A32_MASK_IN_PLACE;
369 }
370
371 static bool Sample_Index_D8888_SkipZ(void* SK_RESTRICT dstRow,
372 const uint8_t* SK_RESTRICT src,
373 int width, int deltaSrc, int,
374 const SkPMColor ctable[]) {
375
376 SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
377 SkPMColor cc = A32_MASK_IN_PLACE;
378 for (int x = 0; x < width; x++) {
379 SkPMColor c = ctable[*src];
380 cc &= c;
381 if (c != 0) {
382 dst[x] = c;
383 }
384 src += deltaSrc;
385 }
386 return cc != A32_MASK_IN_PLACE;
387 }
388
389 static SkScaledBitmapSampler::RowProc get_index_to_8888_proc(const SkImageDecoder& decoder) {
390 if (decoder.getRequireUnpremultipliedColors()) {
391 // Unpremultiplied is not supported for an index source.
392 return NULL;
393 }
394 // Dither makes no difference
395 if (decoder.getSkipWritingZeroes()) {
396 return Sample_Index_D8888_SkipZ;
397 }
398 return Sample_Index_D8888;
399 }
400
401 static bool Sample_Index_D565(void* SK_RESTRICT dstRow,
402 const uint8_t* SK_RESTRICT src,
403 int width, int deltaSrc, int, const SkPMColor ctable[]) {
404
405 uint16_t* SK_RESTRICT dst = (uint16_t*)dstRow;
406 for (int x = 0; x < width; x++) {
407 dst[x] = SkPixel32ToPixel16(ctable[*src]);
408 src += deltaSrc;
409 }
410 return false;
411 }
412
413 static bool Sample_Index_D565_D(void* SK_RESTRICT dstRow,
414 const uint8_t* SK_RESTRICT src, int width,
415 int deltaSrc, int y, const SkPMColor ctable[]) {
416
417 uint16_t* SK_RESTRICT dst = (uint16_t*)dstRow;
418 DITHER_565_SCAN(y);
419
420 for (int x = 0; x < width; x++) {
421 SkPMColor c = ctable[*src];
422 dst[x] = SkDitherRGBTo565(SkGetPackedR32(c), SkGetPackedG32(c),
423 SkGetPackedB32(c), DITHER_VALUE(x));
424 src += deltaSrc;
425 }
426 return false;
427 }
428
429 static SkScaledBitmapSampler::RowProc get_index_to_565_proc(const SkImageDecoder& decoder) {
430 // Unpremultiplied and skip zeroes make no difference
431 if (decoder.getDitherImage()) {
432 return Sample_Index_D565_D;
433 }
434 return Sample_Index_D565;
435 }
436
437 static bool Sample_Index_D4444(void* SK_RESTRICT dstRow,
438 const uint8_t* SK_RESTRICT src, int width,
439 int deltaSrc, int y, const SkPMColor ctable[]) {
440
441 SkPMColor16* SK_RESTRICT dst = (SkPMColor16*)dstRow;
442 SkPMColor cc = A32_MASK_IN_PLACE;
443 for (int x = 0; x < width; x++) {
444 SkPMColor c = ctable[*src];
445 cc &= c;
446 dst[x] = SkPixel32ToPixel4444(c);
447 src += deltaSrc;
448 }
449 return cc != A32_MASK_IN_PLACE;
450 }
451
452 static bool Sample_Index_D4444_D(void* SK_RESTRICT dstRow,
453 const uint8_t* SK_RESTRICT src, int width,
454 int deltaSrc, int y, const SkPMColor ctable[]) {
455
456 SkPMColor16* SK_RESTRICT dst = (SkPMColor16*)dstRow;
457 SkPMColor cc = A32_MASK_IN_PLACE;
458 DITHER_4444_SCAN(y);
459
460 for (int x = 0; x < width; x++) {
461 SkPMColor c = ctable[*src];
462 cc &= c;
463 dst[x] = SkDitherARGB32To4444(c, DITHER_VALUE(x));
464 src += deltaSrc;
465 }
466 return cc != A32_MASK_IN_PLACE;
467 }
468
469 static bool Sample_Index_D4444_SkipZ(void* SK_RESTRICT dstRow,
470 const uint8_t* SK_RESTRICT src, int width,
471 int deltaSrc, int y, const SkPMColor ctable[]) {
472
473 SkPMColor16* SK_RESTRICT dst = (SkPMColor16*)dstRow;
474 SkPMColor cc = A32_MASK_IN_PLACE;
475 for (int x = 0; x < width; x++) {
476 SkPMColor c = ctable[*src];
477 cc &= c;
478 if (c != 0) {
479 dst[x] = SkPixel32ToPixel4444(c);
480 }
481 src += deltaSrc;
482 }
483 return cc != A32_MASK_IN_PLACE;
484 }
485
486 static bool Sample_Index_D4444_D_SkipZ(void* SK_RESTRICT dstRow,
487 const uint8_t* SK_RESTRICT src, int width,
488 int deltaSrc, int y, const SkPMColor ctable[]) {
489
490 SkPMColor16* SK_RESTRICT dst = (SkPMColor16*)dstRow;
491 SkPMColor cc = A32_MASK_IN_PLACE;
492 DITHER_4444_SCAN(y);
493
494 for (int x = 0; x < width; x++) {
495 SkPMColor c = ctable[*src];
496 cc &= c;
497 if (c != 0) {
498 dst[x] = SkDitherARGB32To4444(c, DITHER_VALUE(x));
499 }
500 src += deltaSrc;
501 }
502 return cc != A32_MASK_IN_PLACE;
503 }
504
505 static SkScaledBitmapSampler::RowProc get_index_to_4444_proc(const SkImageDecoder& decoder) {
506 // Unpremul not allowed
507 if (decoder.getRequireUnpremultipliedColors()) {
508 return NULL;
509 }
510 const bool dither = decoder.getDitherImage();
511 if (decoder.getSkipWritingZeroes()) {
512 if (dither) {
513 return Sample_Index_D4444_D_SkipZ;
514 }
515 return Sample_Index_D4444_SkipZ;
516 }
517 if (dither) {
518 return Sample_Index_D4444_D;
519 }
520 return Sample_Index_D4444;
521 }
522
523 static bool Sample_Index_DI(void* SK_RESTRICT dstRow,
524 const uint8_t* SK_RESTRICT src,
525 int width, int deltaSrc, int, const SkPMColor[]) {
526 if (1 == deltaSrc) {
527 memcpy(dstRow, src, width);
528 } else {
529 uint8_t* SK_RESTRICT dst = (uint8_t*)dstRow;
530 for (int x = 0; x < width; x++) {
531 dst[x] = src[0];
532 src += deltaSrc;
533 }
534 }
535 return false;
536 }
537
538 static SkScaledBitmapSampler::RowProc get_index_to_index_proc(const SkImageDecoder& decoder) {
539 // Unpremul not allowed
540 if (decoder.getRequireUnpremultipliedColors()) {
541 return NULL;
542 }
543 // Ignore dither and skip zeroes
544 return Sample_Index_DI;
545 }
546
547 // A8
548 static bool Sample_Gray_DA8(void* SK_RESTRICT dstRow,
549 const uint8_t* SK_RESTRICT src,
550 int width, int deltaSrc, int,
551 const SkPMColor[]) {
552 // Sampling Gray to A8 uses the same function as Index to Index8,
553 // except we assume that there is alpha for speed, since an A8
554 // bitmap with no alpha is not interesting.
555 (void) Sample_Index_DI(dstRow, src, width, deltaSrc, /* y unused */ 0,
556 /* ctable unused */ NULL);
557 return true;
558 }
559
560 static SkScaledBitmapSampler::RowProc get_gray_to_A8_proc(const SkImageDecoder& decoder) {
561 if (decoder.getRequireUnpremultipliedColors()) {
562 return NULL;
563 }
564 // Ignore skip and dither.
565 return Sample_Gray_DA8;
566 }
567
568 typedef SkScaledBitmapSampler::RowProc (*RowProcChooser)(const SkImageDecoder& decoder);
569 ///////////////////////////////////////////////////////////////////////////////
570
571 #include "SkScaledBitmapSampler.h"
572
573 SkScaledBitmapSampler::SkScaledBitmapSampler(int width, int height,
574 int sampleSize) {
575 fCTable = NULL;
576 fDstRow = NULL;
577 fRowProc = NULL;
578
579 if (width <= 0 || height <= 0) {
580 sk_throw();
581 }
582
583 SkDEBUGCODE(fSampleMode = kUninitialized_SampleMode);
584
585 if (sampleSize <= 1) {
586 fScaledWidth = width;
587 fScaledHeight = height;
588 fX0 = fY0 = 0;
589 fDX = fDY = 1;
590 return;
591 }
592
593 int dx = SkMin32(sampleSize, width);
594 int dy = SkMin32(sampleSize, height);
595
596 fScaledWidth = width / dx;
597 fScaledHeight = height / dy;
598
599 SkASSERT(fScaledWidth > 0);
600 SkASSERT(fScaledHeight > 0);
601
602 fX0 = dx >> 1;
603 fY0 = dy >> 1;
604
605 SkASSERT(fX0 >= 0 && fX0 < width);
606 SkASSERT(fY0 >= 0 && fY0 < height);
607
608 fDX = dx;
609 fDY = dy;
610
611 SkASSERT(fDX > 0 && (fX0 + fDX * (fScaledWidth - 1)) < width);
612 SkASSERT(fDY > 0 && (fY0 + fDY * (fScaledHeight - 1)) < height);
613 }
614
615 bool SkScaledBitmapSampler::begin(SkBitmap* dst, SrcConfig sc,
616 const SkImageDecoder& decoder,
617 const SkPMColor ctable[]) {
618 static const RowProcChooser gProcChoosers[] = {
619 get_gray_to_8888_proc,
620 get_RGBx_to_8888_proc,
621 get_RGBA_to_8888_proc,
622 get_index_to_8888_proc,
623 NULL, // 565 to 8888
624
625 get_gray_to_565_proc,
626 get_RGBx_to_565_proc,
627 get_RGBx_to_565_proc, // The source alpha will be ignored.
628 get_index_to_565_proc,
629 get_565_to_565_proc,
630
631 get_gray_to_4444_proc,
632 get_RGBx_to_4444_proc,
633 get_RGBA_to_4444_proc,
634 get_index_to_4444_proc,
635 NULL, // 565 to 4444
636
637 NULL, // gray to index
638 NULL, // rgbx to index
639 NULL, // rgba to index
640 get_index_to_index_proc,
641 NULL, // 565 to index
642
643 get_gray_to_A8_proc,
644 NULL, // rgbx to a8
645 NULL, // rgba to a8
646 NULL, // index to a8
647 NULL, // 565 to a8
648 };
649
650 // The jump between dst configs in the table
651 static const int gProcDstConfigSpan = 5;
652 SK_COMPILE_ASSERT(SK_ARRAY_COUNT(gProcChoosers) == 5 * gProcDstConfigSpan,
653 gProcs_has_the_wrong_number_of_entries);
654
655 fCTable = ctable;
656
657 int index = 0;
658 switch (sc) {
659 case SkScaledBitmapSampler::kGray:
660 fSrcPixelSize = 1;
661 index += 0;
662 break;
663 case SkScaledBitmapSampler::kRGB:
664 fSrcPixelSize = 3;
665 index += 1;
666 break;
667 case SkScaledBitmapSampler::kRGBX:
668 fSrcPixelSize = 4;
669 index += 1;
670 break;
671 case SkScaledBitmapSampler::kRGBA:
672 fSrcPixelSize = 4;
673 index += 2;
674 break;
675 case SkScaledBitmapSampler::kIndex:
676 fSrcPixelSize = 1;
677 index += 3;
678 break;
679 case SkScaledBitmapSampler::kRGB_565:
680 fSrcPixelSize = 2;
681 index += 4;
682 break;
683 default:
684 return false;
685 }
686
687 switch (dst->config()) {
688 case SkBitmap::kARGB_8888_Config:
689 index += 0 * gProcDstConfigSpan;
690 break;
691 case SkBitmap::kRGB_565_Config:
692 index += 1 * gProcDstConfigSpan;
693 break;
694 case SkBitmap::kARGB_4444_Config:
695 index += 2 * gProcDstConfigSpan;
696 break;
697 case SkBitmap::kIndex8_Config:
698 index += 3 * gProcDstConfigSpan;
699 break;
700 case SkBitmap::kA8_Config:
701 index += 4 * gProcDstConfigSpan;
702 break;
703 default:
704 return false;
705 }
706
707 RowProcChooser chooser = gProcChoosers[index];
708 if (NULL == chooser) {
709 fRowProc = NULL;
710 } else {
711 fRowProc = chooser(decoder);
712 }
713 fDstRow = (char*)dst->getPixels();
714 fDstRowBytes = dst->rowBytes();
715 fCurrY = 0;
716 return fRowProc != NULL;
717 }
718
719 bool SkScaledBitmapSampler::next(const uint8_t* SK_RESTRICT src) {
720 SkASSERT(kInterlaced_SampleMode != fSampleMode);
721 SkDEBUGCODE(fSampleMode = kConsecutive_SampleMode);
722 SkASSERT((unsigned)fCurrY < (unsigned)fScaledHeight);
723
724 bool hadAlpha = fRowProc(fDstRow, src + fX0 * fSrcPixelSize, fScaledWidth,
725 fDX * fSrcPixelSize, fCurrY, fCTable);
726 fDstRow += fDstRowBytes;
727 fCurrY += 1;
728 return hadAlpha;
729 }
730
731 bool SkScaledBitmapSampler::sampleInterlaced(const uint8_t* SK_RESTRICT src, int srcY) {
732 SkASSERT(kConsecutive_SampleMode != fSampleMode);
733 SkDEBUGCODE(fSampleMode = kInterlaced_SampleMode);
734 // Any line that should be a part of the destination can be created by the formula:
735 // fY0 + (some multiplier) * fDY
736 // so if srcY - fY0 is not an integer multiple of fDY that srcY will be skipped.
737 const int srcYMinusY0 = srcY - fY0;
738 if (srcYMinusY0 % fDY != 0) {
739 // This line is not part of the output, so return false for alpha, since we have
740 // not added an alpha to the output.
741 return false;
742 }
743 // Unlike in next(), where the data is used sequentially, this function skips around,
744 // so fDstRow and fCurrY are never updated. fDstRow must always be the starting point
745 // of the destination bitmap's pixels, which is used to calculate the destination row
746 // each time this function is called.
747 const int dstY = srcYMinusY0 / fDY;
748 SkASSERT(dstY < fScaledHeight);
749 char* dstRow = fDstRow + dstY * fDstRowBytes;
750 return fRowProc(dstRow, src + fX0 * fSrcPixelSize, fScaledWidth,
751 fDX * fSrcPixelSize, dstY, fCTable);
752 }
753
754 #ifdef SK_DEBUG
755 // The following code is for a test to ensure that changing the method to get the right row proc
756 // did not change the row proc unintentionally. Tested by ImageDecodingTest.cpp
757
758 // friend of SkScaledBitmapSampler solely for the purpose of accessing fRowProc.
759 class RowProcTester {
760 public:
761 static SkScaledBitmapSampler::RowProc getRowProc(const SkScaledBitmapSampler& sampler) {
762 return sampler.fRowProc;
763 }
764 };
765
766
767 // Table showing the expected RowProc for each combination of inputs.
768 // Table formated as follows:
769 // Each group of 5 consecutive rows represents sampling from a single
770 // SkScaledBitmapSampler::SrcConfig.
771 // Within each set, each row represents a different destination SkBitmap::Config
772 // Each column represents a different combination of dither and unpremul.
773 // D = dither ~D = no dither
774 // U = unpremul ~U = no unpremul
775 // ~D~U D~U ~DU DU
776 SkScaledBitmapSampler::RowProc gTestProcs[] = {
777 // Gray
778 Sample_Gray_DA8, Sample_Gray_DA8, NULL, NULL, // to A8
779 NULL, NULL, NULL, NULL, // to Index8
780 Sample_Gray_D565, Sample_Gray_D565_D, Sample_Gray_D565, Sample_Gray_D565_D, // to 565
781 Sample_Gray_D4444, Sample_Gray_D4444_D, Sample_Gray_D4444, Sample_Gray_D4444_D, // to 4444
782 Sample_Gray_D8888, Sample_Gray_D8888, Sample_Gray_D8888, Sample_Gray_D8888, // to 8888
783 // Index
784 NULL, NULL, NULL, NULL, // to A8
785 Sample_Index_DI, Sample_Index_DI, NULL, NULL, // to Index8
786 Sample_Index_D565, Sample_Index_D565_D, Sample_Index_D565, Sample_Index_D565_D, // to 565
787 Sample_Index_D4444, Sample_Index_D4444_D, NULL, NULL, // to 4444
788 Sample_Index_D8888, Sample_Index_D8888, NULL, NULL, // to 8888
789 // RGB
790 NULL, NULL, NULL, NULL, // to A8
791 NULL, NULL, NULL, NULL, // to Index8
792 Sample_RGBx_D565, Sample_RGBx_D565_D, Sample_RGBx_D565, Sample_RGBx_D565_D, // to 565
793 Sample_RGBx_D4444, Sample_RGBx_D4444_D, Sample_RGBx_D4444, Sample_RGBx_D4444_D, // to 4444
794 Sample_RGBx_D8888, Sample_RGBx_D8888, Sample_RGBx_D8888, Sample_RGBx_D8888, // to 8888
795 // RGBx is the same as RGB
796 NULL, NULL, NULL, NULL, // to A8
797 NULL, NULL, NULL, NULL, // to Index8
798 Sample_RGBx_D565, Sample_RGBx_D565_D, Sample_RGBx_D565, Sample_RGBx_D565_D, // to 565
799 Sample_RGBx_D4444, Sample_RGBx_D4444_D, Sample_RGBx_D4444, Sample_RGBx_D4444_D, // to 4444
800 Sample_RGBx_D8888, Sample_RGBx_D8888, Sample_RGBx_D8888, Sample_RGBx_D8888, // to 8888
801 // RGBA
802 NULL, NULL, NULL, NULL, // to A8
803 NULL, NULL, NULL, NULL, // to Index8
804 Sample_RGBx_D565, Sample_RGBx_D565_D, Sample_RGBx_D565, Sample_RGBx_D565_D, // to 565
805 Sample_RGBA_D4444, Sample_RGBA_D4444_D, NULL, NULL, // to 4444
806 Sample_RGBA_D8888, Sample_RGBA_D8888, Sample_RGBA_D8888_Unpremul, Sample_RGBA_D8888_Unpremul, // to 8888
807 // RGB_565
808 NULL, NULL, NULL, NULL, // to A8
809 NULL, NULL, NULL, NULL, // to Index8
810 Sample_D565_D565, Sample_D565_D565, Sample_D565_D565, Sample_D565_D565, // to 565
811 NULL, NULL, NULL, NULL, // to 4444
812 NULL, NULL, NULL, NULL, // to 8888
813 };
814
815 // Dummy class that allows instantiation of an ImageDecoder, so begin can query its fields.
816 class DummyDecoder : public SkImageDecoder {
817 public:
818 DummyDecoder() {}
819 protected:
820 virtual bool onDecode(SkStream*, SkBitmap*, SkImageDecoder::Mode) SK_OVERRIDE {
821 return false;
822 }
823 };
824
825 void test_row_proc_choice();
826 void test_row_proc_choice() {
827 SkBitmap dummyBitmap;
828 DummyDecoder dummyDecoder;
829 size_t procCounter = 0;
830 for (int sc = SkScaledBitmapSampler::kGray; sc <= SkScaledBitmapSampler::kRGB_565; ++sc) {
831 for (int c = SkBitmap::kA8_Config; c <= SkBitmap::kARGB_8888_Config; ++c) {
832 for (int unpremul = 0; unpremul <= 1; ++unpremul) {
833 for (int dither = 0; dither <= 1; ++dither) {
834 // Arbitrary width/height/sampleSize to allow SkScaledBitmapSampler to
835 // be considered valid.
836 SkScaledBitmapSampler sampler(10, 10, 1);
837 dummyBitmap.setConfig((SkBitmap::Config) c, 10, 10);
838 dummyDecoder.setDitherImage(SkToBool(dither));
839 dummyDecoder.setRequireUnpremultipliedColors(SkToBool(unpremul));
840 sampler.begin(&dummyBitmap, (SkScaledBitmapSampler::SrcConfig) sc,
841 dummyDecoder);
842 SkScaledBitmapSampler::RowProc expected = gTestProcs[procCounter];
843 SkScaledBitmapSampler::RowProc actual = RowProcTester::getRowProc(sampler);
844 SkASSERT(expected == actual);
845 procCounter++;
846 }
847 }
848 }
849 }
850 SkASSERT(SK_ARRAY_COUNT(gTestProcs) == procCounter);
851 }
852 #endif // SK_DEBUG

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial