1#include "SkBlitMask.h"
2#include "SkColor.h"
3#include "SkColorPriv.h"
4
5static void D32_A8_Color(void* SK_RESTRICT dst, size_t dstRB,
6                         const void* SK_RESTRICT maskPtr, size_t maskRB,
7                         SkColor color, int width, int height) {
8    SkPMColor pmc = SkPreMultiplyColor(color);
9    size_t dstOffset = dstRB - (width << 2);
10    size_t maskOffset = maskRB - width;
11    SkPMColor* SK_RESTRICT device = (SkPMColor *)dst;
12    const uint8_t* SK_RESTRICT mask = (const uint8_t*)maskPtr;
13
14    do {
15        int w = width;
16        do {
17            unsigned aa = *mask++;
18            *device = SkBlendARGB32(pmc, *device, aa);
19            device += 1;
20        } while (--w != 0);
21        device = (uint32_t*)((char*)device + dstOffset);
22        mask += maskOffset;
23    } while (--height != 0);
24}
25
26static void D32_A8_Opaque(void* SK_RESTRICT dst, size_t dstRB,
27                          const void* SK_RESTRICT maskPtr, size_t maskRB,
28                          SkColor color, int width, int height) {
29    SkPMColor pmc = SkPreMultiplyColor(color);
30    SkPMColor* SK_RESTRICT device = (SkPMColor*)dst;
31    const uint8_t* SK_RESTRICT mask = (const uint8_t*)maskPtr;
32
33    maskRB -= width;
34    dstRB -= (width << 2);
35    do {
36        int w = width;
37        do {
38            unsigned aa = *mask++;
39            *device = SkAlphaMulQ(pmc, SkAlpha255To256(aa)) + SkAlphaMulQ(*device, SkAlpha255To256(255 - aa));
40            device += 1;
41        } while (--w != 0);
42        device = (uint32_t*)((char*)device + dstRB);
43        mask += maskRB;
44    } while (--height != 0);
45}
46
47static void D32_A8_Black(void* SK_RESTRICT dst, size_t dstRB,
48                         const void* SK_RESTRICT maskPtr, size_t maskRB,
49                         SkColor, int width, int height) {
50    SkPMColor* SK_RESTRICT device = (SkPMColor*)dst;
51    const uint8_t* SK_RESTRICT mask = (const uint8_t*)maskPtr;
52
53    maskRB -= width;
54    dstRB -= (width << 2);
55    do {
56        int w = width;
57        do {
58            unsigned aa = *mask++;
59            *device = (aa << SK_A32_SHIFT) + SkAlphaMulQ(*device, SkAlpha255To256(255 - aa));
60            device += 1;
61        } while (--w != 0);
62        device = (uint32_t*)((char*)device + dstRB);
63        mask += maskRB;
64    } while (--height != 0);
65}
66
67SkBlitMask::BlitLCD16RowProc SkBlitMask::BlitLCD16RowFactory(bool isOpaque) {
68    BlitLCD16RowProc proc = PlatformBlitRowProcs16(isOpaque);
69    if (proc) {
70        return proc;
71    }
72
73    if (isOpaque) {
74        return  SkBlitLCD16OpaqueRow;
75    } else {
76        return  SkBlitLCD16Row;
77    }
78}
79
80static void D32_LCD16_Proc(void* SK_RESTRICT dst, size_t dstRB,
81                           const void* SK_RESTRICT mask, size_t maskRB,
82                           SkColor color, int width, int height) {
83
84    SkPMColor*		dstRow = (SkPMColor*)dst;
85    const uint16_t* srcRow = (const uint16_t*)mask;
86    SkPMColor       opaqueDst;
87
88    SkBlitMask::BlitLCD16RowProc proc = NULL;
89    bool isOpaque = (0xFF == SkColorGetA(color));
90    proc = SkBlitMask::BlitLCD16RowFactory(isOpaque);
91    SkASSERT(proc != NULL);
92
93    if (isOpaque) {
94        opaqueDst = SkPreMultiplyColor(color);
95    } else {
96        opaqueDst = 0;  // ignored
97    }
98
99    do {
100        proc(dstRow, srcRow, color, width, opaqueDst);
101        dstRow = (SkPMColor*)((char*)dstRow + dstRB);
102        srcRow = (const uint16_t*)((const char*)srcRow + maskRB);
103    } while (--height != 0);
104}
105
106///////////////////////////////////////////////////////////////////////////////
107
108static void blit_lcd32_opaque_row(SkPMColor* SK_RESTRICT dst,
109                                  const SkPMColor* SK_RESTRICT src,
110                                  SkColor color, int width) {
111    int srcR = SkColorGetR(color);
112    int srcG = SkColorGetG(color);
113    int srcB = SkColorGetB(color);
114
115    for (int i = 0; i < width; i++) {
116        SkPMColor mask = src[i];
117        if (0 == mask) {
118            continue;
119        }
120
121        SkPMColor d = dst[i];
122
123        int maskR = SkGetPackedR32(mask);
124        int maskG = SkGetPackedG32(mask);
125        int maskB = SkGetPackedB32(mask);
126
127        // Now upscale them to 0..256, so we can use SkAlphaBlend
128        maskR = SkAlpha255To256(maskR);
129        maskG = SkAlpha255To256(maskG);
130        maskB = SkAlpha255To256(maskB);
131
132        int dstR = SkGetPackedR32(d);
133        int dstG = SkGetPackedG32(d);
134        int dstB = SkGetPackedB32(d);
135
136        // LCD blitting is only supported if the dst is known/required
137        // to be opaque
138        dst[i] = SkPackARGB32(0xFF,
139                              SkAlphaBlend(srcR, dstR, maskR),
140                              SkAlphaBlend(srcG, dstG, maskG),
141                              SkAlphaBlend(srcB, dstB, maskB));
142    }
143}
144
145static void blit_lcd32_row(SkPMColor* SK_RESTRICT dst,
146                           const SkPMColor* SK_RESTRICT src,
147                           SkColor color, int width) {
148    int srcA = SkColorGetA(color);
149    int srcR = SkColorGetR(color);
150    int srcG = SkColorGetG(color);
151    int srcB = SkColorGetB(color);
152
153    srcA = SkAlpha255To256(srcA);
154
155    for (int i = 0; i < width; i++) {
156        SkPMColor mask = src[i];
157        if (0 == mask) {
158            continue;
159        }
160
161        SkPMColor d = dst[i];
162
163        int maskR = SkGetPackedR32(mask);
164        int maskG = SkGetPackedG32(mask);
165        int maskB = SkGetPackedB32(mask);
166
167        // Now upscale them to 0..256, so we can use SkAlphaBlend
168        maskR = SkAlpha255To256(maskR);
169        maskG = SkAlpha255To256(maskG);
170        maskB = SkAlpha255To256(maskB);
171
172        maskR = maskR * srcA >> 8;
173        maskG = maskG * srcA >> 8;
174        maskB = maskB * srcA >> 8;
175
176        int dstR = SkGetPackedR32(d);
177        int dstG = SkGetPackedG32(d);
178        int dstB = SkGetPackedB32(d);
179
180        // LCD blitting is only supported if the dst is known/required
181        // to be opaque
182        dst[i] = SkPackARGB32(0xFF,
183                              SkAlphaBlend(srcR, dstR, maskR),
184                              SkAlphaBlend(srcG, dstG, maskG),
185                              SkAlphaBlend(srcB, dstB, maskB));
186    }
187}
188
189static void D32_LCD32_Blend(void* SK_RESTRICT dst, size_t dstRB,
190                            const void* SK_RESTRICT mask, size_t maskRB,
191                            SkColor color, int width, int height) {
192    SkASSERT(height > 0);
193    SkPMColor* SK_RESTRICT dstRow = (SkPMColor*)dst;
194    const SkPMColor* SK_RESTRICT srcRow = (const SkPMColor*)mask;
195
196    do {
197        blit_lcd32_row(dstRow, srcRow, color, width);
198        dstRow = (SkPMColor*)((char*)dstRow + dstRB);
199        srcRow = (const SkPMColor*)((const char*)srcRow + maskRB);
200    } while (--height != 0);
201}
202
203static void D32_LCD32_Opaque(void* SK_RESTRICT dst, size_t dstRB,
204                             const void* SK_RESTRICT mask, size_t maskRB,
205                             SkColor color, int width, int height) {
206    SkASSERT(height > 0);
207    SkPMColor* SK_RESTRICT dstRow = (SkPMColor*)dst;
208    const SkPMColor* SK_RESTRICT srcRow = (const SkPMColor*)mask;
209
210    do {
211        blit_lcd32_opaque_row(dstRow, srcRow, color, width);
212        dstRow = (SkPMColor*)((char*)dstRow + dstRB);
213        srcRow = (const SkPMColor*)((const char*)srcRow + maskRB);
214    } while (--height != 0);
215}
216
217///////////////////////////////////////////////////////////////////////////////
218
219static SkBlitMask::ColorProc D32_A8_Factory(SkColor color) {
220    if (SK_ColorBLACK == color) {
221        return D32_A8_Black;
222    } else if (0xFF == SkColorGetA(color)) {
223        return D32_A8_Opaque;
224    } else {
225        return D32_A8_Color;
226    }
227}
228
229static SkBlitMask::ColorProc D32_LCD32_Factory(SkColor color) {
230    return (0xFF == SkColorGetA(color)) ? D32_LCD32_Opaque : D32_LCD32_Blend;
231}
232
233SkBlitMask::ColorProc SkBlitMask::ColorFactory(SkBitmap::Config config,
234                                               SkMask::Format format,
235                                               SkColor color) {
236    ColorProc proc = PlatformColorProcs(config, format, color);
237    if (proc) {
238        return proc;
239    }
240
241    switch (config) {
242        case SkBitmap::kARGB_8888_Config:
243            switch (format) {
244                case SkMask::kA8_Format:
245                    return D32_A8_Factory(color);
246                case SkMask::kLCD16_Format:
247                    return D32_LCD16_Proc;
248                case SkMask::kLCD32_Format:
249                    return D32_LCD32_Factory(color);
250                default:
251                    break;
252            }
253            break;
254        default:
255            break;
256    }
257    return NULL;
258}
259
260bool SkBlitMask::BlitColor(const SkBitmap& device, const SkMask& mask,
261                           const SkIRect& clip, SkColor color) {
262    ColorProc proc = ColorFactory(device.config(), mask.fFormat, color);
263    if (proc) {
264        int x = clip.fLeft;
265        int y = clip.fTop;
266        proc(device.getAddr32(x, y), device.rowBytes(), mask.getAddr(x, y),
267             mask.fRowBytes, color, clip.width(), clip.height());
268        return true;
269    }
270    return false;
271}
272
273///////////////////////////////////////////////////////////////////////////////
274///////////////////////////////////////////////////////////////////////////////
275
276static void BW_RowProc_Blend(SkPMColor* SK_RESTRICT dst,
277                             const uint8_t* SK_RESTRICT mask,
278                             const SkPMColor* SK_RESTRICT src, int count) {
279    int i, octuple = (count + 7) >> 3;
280    for (i = 0; i < octuple; ++i) {
281        int m = *mask++;
282        if (m & 0x80) { dst[0] = SkPMSrcOver(src[0], dst[0]); }
283        if (m & 0x40) { dst[1] = SkPMSrcOver(src[1], dst[1]); }
284        if (m & 0x20) { dst[2] = SkPMSrcOver(src[2], dst[2]); }
285        if (m & 0x10) { dst[3] = SkPMSrcOver(src[3], dst[3]); }
286        if (m & 0x08) { dst[4] = SkPMSrcOver(src[4], dst[4]); }
287        if (m & 0x04) { dst[5] = SkPMSrcOver(src[5], dst[5]); }
288        if (m & 0x02) { dst[6] = SkPMSrcOver(src[6], dst[6]); }
289        if (m & 0x01) { dst[7] = SkPMSrcOver(src[7], dst[7]); }
290        src += 8;
291        dst += 8;
292    }
293    count &= 7;
294    if (count > 0) {
295        int m = *mask;
296        do {
297            if (m & 0x80) { dst[0] = SkPMSrcOver(src[0], dst[0]); }
298            m <<= 1;
299            src += 1;
300            dst += 1;
301        } while (--count > 0);
302    }
303}
304
305static void BW_RowProc_Opaque(SkPMColor* SK_RESTRICT dst,
306                              const uint8_t* SK_RESTRICT mask,
307                              const SkPMColor* SK_RESTRICT src, int count) {
308    int i, octuple = (count + 7) >> 3;
309    for (i = 0; i < octuple; ++i) {
310        int m = *mask++;
311        if (m & 0x80) { dst[0] = src[0]; }
312        if (m & 0x40) { dst[1] = src[1]; }
313        if (m & 0x20) { dst[2] = src[2]; }
314        if (m & 0x10) { dst[3] = src[3]; }
315        if (m & 0x08) { dst[4] = src[4]; }
316        if (m & 0x04) { dst[5] = src[5]; }
317        if (m & 0x02) { dst[6] = src[6]; }
318        if (m & 0x01) { dst[7] = src[7]; }
319        src += 8;
320        dst += 8;
321    }
322    count &= 7;
323    if (count > 0) {
324        int m = *mask;
325        do {
326            if (m & 0x80) { dst[0] = SkPMSrcOver(src[0], dst[0]); }
327            m <<= 1;
328            src += 1;
329            dst += 1;
330        } while (--count > 0);
331    }
332}
333
334static void A8_RowProc_Blend(SkPMColor* SK_RESTRICT dst,
335                             const uint8_t* SK_RESTRICT mask,
336                             const SkPMColor* SK_RESTRICT src, int count) {
337    for (int i = 0; i < count; ++i) {
338        if (mask[i]) {
339            dst[i] = SkBlendARGB32(src[i], dst[i], mask[i]);
340        }
341    }
342}
343
344// expand the steps that SkAlphaMulQ performs, but this way we can
345//  exand.. add.. combine
346// instead of
347// expand..combine add expand..combine
348//
349#define EXPAND0(v, m, s)    ((v) & (m)) * (s)
350#define EXPAND1(v, m, s)    (((v) >> 8) & (m)) * (s)
351#define COMBINE(e0, e1, m)  ((((e0) >> 8) & (m)) | ((e1) & ~(m)))
352
353static void A8_RowProc_Opaque(SkPMColor* SK_RESTRICT dst,
354                              const uint8_t* SK_RESTRICT mask,
355                              const SkPMColor* SK_RESTRICT src, int count) {
356    const uint32_t rbmask = gMask_00FF00FF;
357    for (int i = 0; i < count; ++i) {
358        int m = mask[i];
359        if (m) {
360            m += (m >> 7);
361#if 1
362            // this is slightly slower than the expand/combine version, but it
363            // is much closer to the old results, so we use it for now to reduce
364            // rebaselining.
365            dst[i] = SkAlphaMulQ(src[i], m) + SkAlphaMulQ(dst[i], 256 - m);
366#else
367            uint32_t v = src[i];
368            uint32_t s0 = EXPAND0(v, rbmask, m);
369            uint32_t s1 = EXPAND1(v, rbmask, m);
370            v = dst[i];
371            uint32_t d0 = EXPAND0(v, rbmask, m);
372            uint32_t d1 = EXPAND1(v, rbmask, m);
373            dst[i] = COMBINE(s0 + d0, s1 + d1, rbmask);
374#endif
375        }
376    }
377}
378
379static int upscale31To255(int value) {
380    value = (value << 3) | (value >> 2);
381    return value;
382}
383
384static int mul(int a, int b) {
385    return a * b >> 8;
386}
387
388static int src_alpha_blend(int src, int dst, int srcA, int mask) {
389
390    return dst + mul(src - mul(srcA, dst), mask);
391}
392
393static void LCD16_RowProc_Blend(SkPMColor* SK_RESTRICT dst,
394                                const uint16_t* SK_RESTRICT mask,
395                                const SkPMColor* SK_RESTRICT src, int count) {
396    for (int i = 0; i < count; ++i) {
397        uint16_t m = mask[i];
398        if (0 == m) {
399            continue;
400        }
401
402        SkPMColor s = src[i];
403        SkPMColor d = dst[i];
404
405        int srcA = SkGetPackedA32(s);
406        int srcR = SkGetPackedR32(s);
407        int srcG = SkGetPackedG32(s);
408        int srcB = SkGetPackedB32(s);
409
410        srcA += srcA >> 7;
411
412        /*  We want all of these in 5bits, hence the shifts in case one of them
413         *  (green) is 6bits.
414         */
415        int maskR = SkGetPackedR16(m) >> (SK_R16_BITS - 5);
416        int maskG = SkGetPackedG16(m) >> (SK_G16_BITS - 5);
417        int maskB = SkGetPackedB16(m) >> (SK_B16_BITS - 5);
418
419        maskR = upscale31To255(maskR);
420        maskG = upscale31To255(maskG);
421        maskB = upscale31To255(maskB);
422
423        int dstR = SkGetPackedR32(d);
424        int dstG = SkGetPackedG32(d);
425        int dstB = SkGetPackedB32(d);
426
427        // LCD blitting is only supported if the dst is known/required
428        // to be opaque
429        dst[i] = SkPackARGB32(0xFF,
430                              src_alpha_blend(srcR, dstR, srcA, maskR),
431                              src_alpha_blend(srcG, dstG, srcA, maskG),
432                              src_alpha_blend(srcB, dstB, srcA, maskB));
433    }
434}
435
436static void LCD16_RowProc_Opaque(SkPMColor* SK_RESTRICT dst,
437                                 const uint16_t* SK_RESTRICT mask,
438                                 const SkPMColor* SK_RESTRICT src, int count) {
439    for (int i = 0; i < count; ++i) {
440        uint16_t m = mask[i];
441        if (0 == m) {
442            continue;
443        }
444
445        SkPMColor s = src[i];
446        SkPMColor d = dst[i];
447
448        int srcR = SkGetPackedR32(s);
449        int srcG = SkGetPackedG32(s);
450        int srcB = SkGetPackedB32(s);
451
452        /*  We want all of these in 5bits, hence the shifts in case one of them
453         *  (green) is 6bits.
454         */
455        int maskR = SkGetPackedR16(m) >> (SK_R16_BITS - 5);
456        int maskG = SkGetPackedG16(m) >> (SK_G16_BITS - 5);
457        int maskB = SkGetPackedB16(m) >> (SK_B16_BITS - 5);
458
459        // Now upscale them to 0..32, so we can use blend32
460        maskR = SkUpscale31To32(maskR);
461        maskG = SkUpscale31To32(maskG);
462        maskB = SkUpscale31To32(maskB);
463
464        int dstR = SkGetPackedR32(d);
465        int dstG = SkGetPackedG32(d);
466        int dstB = SkGetPackedB32(d);
467
468        // LCD blitting is only supported if the dst is known/required
469        // to be opaque
470        dst[i] = SkPackARGB32(0xFF,
471                              SkBlend32(srcR, dstR, maskR),
472                              SkBlend32(srcG, dstG, maskG),
473                              SkBlend32(srcB, dstB, maskB));
474    }
475}
476
477static void LCD32_RowProc_Blend(SkPMColor* SK_RESTRICT dst,
478                                const SkPMColor* SK_RESTRICT mask,
479                                const SkPMColor* SK_RESTRICT src, int count) {
480    for (int i = 0; i < count; ++i) {
481        SkPMColor m = mask[i];
482        if (0 == m) {
483            continue;
484        }
485
486        SkPMColor s = src[i];
487        int srcA = SkGetPackedA32(s);
488        int srcR = SkGetPackedR32(s);
489        int srcG = SkGetPackedG32(s);
490        int srcB = SkGetPackedB32(s);
491
492        srcA = SkAlpha255To256(srcA);
493
494        SkPMColor d = dst[i];
495
496        int maskR = SkGetPackedR32(m);
497        int maskG = SkGetPackedG32(m);
498        int maskB = SkGetPackedB32(m);
499
500        // Now upscale them to 0..256
501        maskR = SkAlpha255To256(maskR);
502        maskG = SkAlpha255To256(maskG);
503        maskB = SkAlpha255To256(maskB);
504
505        int dstR = SkGetPackedR32(d);
506        int dstG = SkGetPackedG32(d);
507        int dstB = SkGetPackedB32(d);
508
509        // LCD blitting is only supported if the dst is known/required
510        // to be opaque
511        dst[i] = SkPackARGB32(0xFF,
512                              src_alpha_blend(srcR, dstR, srcA, maskR),
513                              src_alpha_blend(srcG, dstG, srcA, maskG),
514                              src_alpha_blend(srcB, dstB, srcA, maskB));
515    }
516}
517
518static void LCD32_RowProc_Opaque(SkPMColor* SK_RESTRICT dst,
519                                 const SkPMColor* SK_RESTRICT mask,
520                                 const SkPMColor* SK_RESTRICT src, int count) {
521    for (int i = 0; i < count; ++i) {
522        SkPMColor m = mask[i];
523        if (0 == m) {
524            continue;
525        }
526
527        SkPMColor s = src[i];
528        SkPMColor d = dst[i];
529
530        int maskR = SkGetPackedR32(m);
531        int maskG = SkGetPackedG32(m);
532        int maskB = SkGetPackedB32(m);
533
534        int srcR = SkGetPackedR32(s);
535        int srcG = SkGetPackedG32(s);
536        int srcB = SkGetPackedB32(s);
537
538        int dstR = SkGetPackedR32(d);
539        int dstG = SkGetPackedG32(d);
540        int dstB = SkGetPackedB32(d);
541
542        // Now upscale them to 0..256, so we can use SkAlphaBlend
543        maskR = SkAlpha255To256(maskR);
544        maskG = SkAlpha255To256(maskG);
545        maskB = SkAlpha255To256(maskB);
546
547        // LCD blitting is only supported if the dst is known/required
548        // to be opaque
549        dst[i] = SkPackARGB32(0xFF,
550                              SkAlphaBlend(srcR, dstR, maskR),
551                              SkAlphaBlend(srcG, dstG, maskG),
552                              SkAlphaBlend(srcB, dstB, maskB));
553    }
554}
555
556SkBlitMask::RowProc SkBlitMask::RowFactory(SkBitmap::Config config,
557                                           SkMask::Format format,
558                                           RowFlags flags) {
559// make this opt-in until chrome can rebaseline
560    RowProc proc = PlatformRowProcs(config, format, flags);
561    if (proc) {
562        return proc;
563    }
564
565    static const RowProc gProcs[] = {
566        // need X coordinate to handle BW
567        NULL, NULL, //(RowProc)BW_RowProc_Blend,      (RowProc)BW_RowProc_Opaque,
568        (RowProc)A8_RowProc_Blend,      (RowProc)A8_RowProc_Opaque,
569        (RowProc)LCD16_RowProc_Blend,   (RowProc)LCD16_RowProc_Opaque,
570        (RowProc)LCD32_RowProc_Blend,   (RowProc)LCD32_RowProc_Opaque,
571    };
572
573    int index;
574    switch (config) {
575        case SkBitmap::kARGB_8888_Config:
576            switch (format) {
577                case SkMask::kBW_Format:    index = 0; break;
578                case SkMask::kA8_Format:    index = 2; break;
579                case SkMask::kLCD16_Format: index = 4; break;
580                case SkMask::kLCD32_Format: index = 6; break;
581                default:
582                    return NULL;
583            }
584            if (flags & kSrcIsOpaque_RowFlag) {
585                index |= 1;
586            }
587            SkASSERT((size_t)index < SK_ARRAY_COUNT(gProcs));
588            return gProcs[index];
589        default:
590            break;
591    }
592    return NULL;
593}
594
595