Home | History | Annotate | Download | only in core
      1 /*
      2  * Copyright 2014 Google Inc.
      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 #include "SkBlitMask.h"
      9 #include "SkColor.h"
     10 #include "SkColorPriv.h"
     11 #include "SkOpts.h"
     12 
     13 SkBlitMask::BlitLCD16RowProc SkBlitMask::BlitLCD16RowFactory(bool isOpaque) {
     14     BlitLCD16RowProc proc = PlatformBlitRowProcs16(isOpaque);
     15     if (proc) {
     16         return proc;
     17     }
     18 
     19     if (isOpaque) {
     20         return  SkBlitLCD16OpaqueRow;
     21     } else {
     22         return  SkBlitLCD16Row;
     23     }
     24 }
     25 
     26 static void D32_LCD16_Proc(void* SK_RESTRICT dst, size_t dstRB,
     27                            const void* SK_RESTRICT mask, size_t maskRB,
     28                            SkColor color, int width, int height) {
     29 
     30     SkPMColor*        dstRow = (SkPMColor*)dst;
     31     const uint16_t* srcRow = (const uint16_t*)mask;
     32     SkPMColor       opaqueDst;
     33 
     34     SkBlitMask::BlitLCD16RowProc proc = nullptr;
     35     bool isOpaque = (0xFF == SkColorGetA(color));
     36     proc = SkBlitMask::BlitLCD16RowFactory(isOpaque);
     37     SkASSERT(proc != nullptr);
     38 
     39     if (isOpaque) {
     40         opaqueDst = SkPreMultiplyColor(color);
     41     } else {
     42         opaqueDst = 0;  // ignored
     43     }
     44 
     45     do {
     46         proc(dstRow, srcRow, color, width, opaqueDst);
     47         dstRow = (SkPMColor*)((char*)dstRow + dstRB);
     48         srcRow = (const uint16_t*)((const char*)srcRow + maskRB);
     49     } while (--height != 0);
     50 }
     51 
     52 ///////////////////////////////////////////////////////////////////////////////
     53 
     54 bool SkBlitMask::BlitColor(const SkPixmap& device, const SkMask& mask,
     55                            const SkIRect& clip, SkColor color) {
     56     int x = clip.fLeft, y = clip.fTop;
     57 
     58     if (device.colorType() == kN32_SkColorType && mask.fFormat == SkMask::kA8_Format) {
     59         SkOpts::blit_mask_d32_a8(device.writable_addr32(x,y), device.rowBytes(),
     60                                  (const SkAlpha*)mask.getAddr(x,y), mask.fRowBytes,
     61                                  color, clip.width(), clip.height());
     62         return true;
     63     }
     64 
     65     if (device.colorType() == kN32_SkColorType && mask.fFormat == SkMask::kLCD16_Format) {
     66         // TODO: Is this reachable code?  Seems like no.
     67         D32_LCD16_Proc(device.writable_addr32(x,y), device.rowBytes(),
     68                        mask.getAddr(x,y), mask.fRowBytes,
     69                        color, clip.width(), clip.height());
     70         return true;
     71     }
     72 
     73     return false;
     74 }
     75 
     76 ///////////////////////////////////////////////////////////////////////////////
     77 ///////////////////////////////////////////////////////////////////////////////
     78 
     79 static void BW_RowProc_Blend(
     80         SkPMColor* SK_RESTRICT dst, const void* maskIn, const SkPMColor* SK_RESTRICT src, int count) {
     81     const uint8_t* SK_RESTRICT mask = static_cast<const uint8_t*>(maskIn);
     82     int i, octuple = (count + 7) >> 3;
     83     for (i = 0; i < octuple; ++i) {
     84         int m = *mask++;
     85         if (m & 0x80) { dst[0] = SkPMSrcOver(src[0], dst[0]); }
     86         if (m & 0x40) { dst[1] = SkPMSrcOver(src[1], dst[1]); }
     87         if (m & 0x20) { dst[2] = SkPMSrcOver(src[2], dst[2]); }
     88         if (m & 0x10) { dst[3] = SkPMSrcOver(src[3], dst[3]); }
     89         if (m & 0x08) { dst[4] = SkPMSrcOver(src[4], dst[4]); }
     90         if (m & 0x04) { dst[5] = SkPMSrcOver(src[5], dst[5]); }
     91         if (m & 0x02) { dst[6] = SkPMSrcOver(src[6], dst[6]); }
     92         if (m & 0x01) { dst[7] = SkPMSrcOver(src[7], dst[7]); }
     93         src += 8;
     94         dst += 8;
     95     }
     96     count &= 7;
     97     if (count > 0) {
     98         int m = *mask;
     99         do {
    100             if (m & 0x80) { dst[0] = SkPMSrcOver(src[0], dst[0]); }
    101             m <<= 1;
    102             src += 1;
    103             dst += 1;
    104         } while (--count > 0);
    105     }
    106 }
    107 
    108 static void BW_RowProc_Opaque(
    109         SkPMColor* SK_RESTRICT dst, const void* maskIn, const SkPMColor* SK_RESTRICT src, int count) {
    110     const uint8_t* SK_RESTRICT mask = static_cast<const uint8_t*>(maskIn);
    111     int i, octuple = (count + 7) >> 3;
    112     for (i = 0; i < octuple; ++i) {
    113         int m = *mask++;
    114         if (m & 0x80) { dst[0] = src[0]; }
    115         if (m & 0x40) { dst[1] = src[1]; }
    116         if (m & 0x20) { dst[2] = src[2]; }
    117         if (m & 0x10) { dst[3] = src[3]; }
    118         if (m & 0x08) { dst[4] = src[4]; }
    119         if (m & 0x04) { dst[5] = src[5]; }
    120         if (m & 0x02) { dst[6] = src[6]; }
    121         if (m & 0x01) { dst[7] = src[7]; }
    122         src += 8;
    123         dst += 8;
    124     }
    125     count &= 7;
    126     if (count > 0) {
    127         int m = *mask;
    128         do {
    129             if (m & 0x80) { dst[0] = SkPMSrcOver(src[0], dst[0]); }
    130             m <<= 1;
    131             src += 1;
    132             dst += 1;
    133         } while (--count > 0);
    134     }
    135 }
    136 
    137 static void A8_RowProc_Blend(
    138         SkPMColor* SK_RESTRICT dst, const void* maskIn, const SkPMColor* SK_RESTRICT src, int count) {
    139     const uint8_t* SK_RESTRICT mask = static_cast<const uint8_t*>(maskIn);
    140     for (int i = 0; i < count; ++i) {
    141         if (mask[i]) {
    142             dst[i] = SkBlendARGB32(src[i], dst[i], mask[i]);
    143         }
    144     }
    145 }
    146 
    147 // expand the steps that SkAlphaMulQ performs, but this way we can
    148 //  exand.. add.. combine
    149 // instead of
    150 // expand..combine add expand..combine
    151 //
    152 #define EXPAND0(v, m, s)    ((v) & (m)) * (s)
    153 #define EXPAND1(v, m, s)    (((v) >> 8) & (m)) * (s)
    154 #define COMBINE(e0, e1, m)  ((((e0) >> 8) & (m)) | ((e1) & ~(m)))
    155 
    156 static void A8_RowProc_Opaque(
    157         SkPMColor* SK_RESTRICT dst, const void* maskIn, const SkPMColor* SK_RESTRICT src, int count) {
    158     const uint8_t* SK_RESTRICT mask = static_cast<const uint8_t*>(maskIn);
    159     for (int i = 0; i < count; ++i) {
    160         int m = mask[i];
    161         if (m) {
    162             m += (m >> 7);
    163 #if 1
    164             // this is slightly slower than the expand/combine version, but it
    165             // is much closer to the old results, so we use it for now to reduce
    166             // rebaselining.
    167             dst[i] = SkAlphaMulQ(src[i], m) + SkAlphaMulQ(dst[i], 256 - m);
    168 #else
    169             uint32_t v = src[i];
    170             uint32_t s0 = EXPAND0(v, rbmask, m);
    171             uint32_t s1 = EXPAND1(v, rbmask, m);
    172             v = dst[i];
    173             uint32_t d0 = EXPAND0(v, rbmask, m);
    174             uint32_t d1 = EXPAND1(v, rbmask, m);
    175             dst[i] = COMBINE(s0 + d0, s1 + d1, rbmask);
    176 #endif
    177         }
    178     }
    179 }
    180 
    181 static int upscale31To255(int value) {
    182     value = (value << 3) | (value >> 2);
    183     return value;
    184 }
    185 
    186 static int src_alpha_blend(int src, int dst, int srcA, int mask) {
    187 
    188     return dst + SkAlphaMul(src - SkAlphaMul(srcA, dst), mask);
    189 }
    190 
    191 static void LCD16_RowProc_Blend(
    192         SkPMColor* SK_RESTRICT dst, const void* maskIn, const SkPMColor* SK_RESTRICT src, int count) {
    193     const uint16_t* SK_RESTRICT mask = static_cast<const uint16_t*>(maskIn);
    194     for (int i = 0; i < count; ++i) {
    195         uint16_t m = mask[i];
    196         if (0 == m) {
    197             continue;
    198         }
    199 
    200         SkPMColor s = src[i];
    201         SkPMColor d = dst[i];
    202 
    203         int srcA = SkGetPackedA32(s);
    204         int srcR = SkGetPackedR32(s);
    205         int srcG = SkGetPackedG32(s);
    206         int srcB = SkGetPackedB32(s);
    207 
    208         srcA += srcA >> 7;
    209 
    210         /*  We want all of these in 5bits, hence the shifts in case one of them
    211          *  (green) is 6bits.
    212          */
    213         int maskR = SkGetPackedR16(m) >> (SK_R16_BITS - 5);
    214         int maskG = SkGetPackedG16(m) >> (SK_G16_BITS - 5);
    215         int maskB = SkGetPackedB16(m) >> (SK_B16_BITS - 5);
    216 
    217         maskR = upscale31To255(maskR);
    218         maskG = upscale31To255(maskG);
    219         maskB = upscale31To255(maskB);
    220 
    221         int dstR = SkGetPackedR32(d);
    222         int dstG = SkGetPackedG32(d);
    223         int dstB = SkGetPackedB32(d);
    224 
    225         // LCD blitting is only supported if the dst is known/required
    226         // to be opaque
    227         dst[i] = SkPackARGB32(0xFF,
    228                               src_alpha_blend(srcR, dstR, srcA, maskR),
    229                               src_alpha_blend(srcG, dstG, srcA, maskG),
    230                               src_alpha_blend(srcB, dstB, srcA, maskB));
    231     }
    232 }
    233 
    234 static void LCD16_RowProc_Opaque(
    235         SkPMColor* SK_RESTRICT dst, const void* maskIn, const SkPMColor* SK_RESTRICT src, int count) {
    236     const uint16_t* SK_RESTRICT mask = static_cast<const uint16_t*>(maskIn);
    237     for (int i = 0; i < count; ++i) {
    238         uint16_t m = mask[i];
    239         if (0 == m) {
    240             continue;
    241         }
    242 
    243         SkPMColor s = src[i];
    244         SkPMColor d = dst[i];
    245 
    246         int srcR = SkGetPackedR32(s);
    247         int srcG = SkGetPackedG32(s);
    248         int srcB = SkGetPackedB32(s);
    249 
    250         /*  We want all of these in 5bits, hence the shifts in case one of them
    251          *  (green) is 6bits.
    252          */
    253         int maskR = SkGetPackedR16(m) >> (SK_R16_BITS - 5);
    254         int maskG = SkGetPackedG16(m) >> (SK_G16_BITS - 5);
    255         int maskB = SkGetPackedB16(m) >> (SK_B16_BITS - 5);
    256 
    257         // Now upscale them to 0..32, so we can use blend32
    258         maskR = SkUpscale31To32(maskR);
    259         maskG = SkUpscale31To32(maskG);
    260         maskB = SkUpscale31To32(maskB);
    261 
    262         int dstR = SkGetPackedR32(d);
    263         int dstG = SkGetPackedG32(d);
    264         int dstB = SkGetPackedB32(d);
    265 
    266         // LCD blitting is only supported if the dst is known/required
    267         // to be opaque
    268         dst[i] = SkPackARGB32(0xFF,
    269                               SkBlend32(srcR, dstR, maskR),
    270                               SkBlend32(srcG, dstG, maskG),
    271                               SkBlend32(srcB, dstB, maskB));
    272     }
    273 }
    274 
    275 SkBlitMask::RowProc SkBlitMask::RowFactory(SkColorType ct,
    276                                            SkMask::Format format,
    277                                            RowFlags flags) {
    278 // make this opt-in until chrome can rebaseline
    279     RowProc proc = PlatformRowProcs(ct, format, flags);
    280     if (proc) {
    281         return proc;
    282     }
    283 
    284     static const RowProc gProcs[] = {
    285         // need X coordinate to handle BW
    286         false ? (RowProc)BW_RowProc_Blend : nullptr, // suppress unused warning
    287         false ? (RowProc)BW_RowProc_Opaque : nullptr, // suppress unused warning
    288         (RowProc)A8_RowProc_Blend,      (RowProc)A8_RowProc_Opaque,
    289         (RowProc)LCD16_RowProc_Blend,   (RowProc)LCD16_RowProc_Opaque,
    290     };
    291 
    292     int index;
    293     switch (ct) {
    294         case kN32_SkColorType:
    295             switch (format) {
    296                 case SkMask::kBW_Format:    index = 0; break;
    297                 case SkMask::kA8_Format:    index = 2; break;
    298                 case SkMask::kLCD16_Format: index = 4; break;
    299                 default:
    300                     return nullptr;
    301             }
    302             if (flags & kSrcIsOpaque_RowFlag) {
    303                 index |= 1;
    304             }
    305             SkASSERT((size_t)index < SK_ARRAY_COUNT(gProcs));
    306             return gProcs[index];
    307         default:
    308             break;
    309     }
    310     return nullptr;
    311 }
    312