skia: blend32_16_row for neon version

src/core/SkBlitter_RGB16.cpp

 
 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkBlitRow.h"
@@ skipping 52 matching lines @@
     virtual void blitAntiH(int x, int y, const SkAlpha* antialias,
                            const int16_t* runs) SK_OVERRIDE;
     void blitV(int x, int y, int height, SkAlpha alpha) SK_OVERRIDE;
     void blitRect(int x, int y, int width, int height) SK_OVERRIDE;
     virtual void blitMask(const SkMask&,
                           const SkIRect&) SK_OVERRIDE;
     const SkBitmap* justAnOpaqueColor(uint32_t*) SK_OVERRIDE;
 
 protected:
     SkPMColor   fSrcColor32;
+    SkPMColor   fSrcColors32[8];
     uint32_t    fExpandedRaw16;
     unsigned    fScale;
     uint16_t    fColor16;       // already scaled by fScale
     uint16_t    fRawColor16;    // unscaled
     uint16_t    fRawDither16;   // unscaled
     SkBool8     fDoDither;
 
+    SkBlitRow::Blend32_16_row_Proc blendS32D16Row_Proc;
+
     // illegal
     SkRGB16_Blitter& operator=(const SkRGB16_Blitter&);
 
     typedef SkRasterBlitter INHERITED;
 };
 
 class SkRGB16_Opaque_Blitter : public SkRGB16_Blitter {
 public:
     SkRGB16_Opaque_Blitter(const SkBitmap& device, const SkPaint& paint);
     void blitH(int x, int y, int width) SK_OVERRIDE;
@@ skipping 430 matching lines @@
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkRGB16_Blitter::SkRGB16_Blitter(const SkBitmap& device, const SkPaint& paint)
     : INHERITED(device) {
     SkColor color = paint.getColor();
 
     fSrcColor32 = SkPreMultiplyColor(color);
+    for (int count = 0; count < 8; count++) {
+        fSrcColors32[count] = fSrcColor32;
+    }
+
     fScale = SkAlpha255To256(SkColorGetA(color));
 
     int r = SkColorGetR(color);
     int g = SkColorGetG(color);
     int b = SkColorGetB(color);
 
     fRawColor16 = fRawDither16 = SkPack888ToRGB16(r, g, b);
     // if we're dithered, use fRawDither16 to hold that.
     if ((fDoDither = paint.isDither()) != false) {
         fRawDither16 = SkDitherPack888ToRGB16(r, g, b);
     }
 
     fExpandedRaw16 = SkExpand_rgb_16(fRawColor16);
 
     fColor16 = SkPackRGB16( SkAlphaMul(r, fScale) >> (8 - SK_R16_BITS),
                             SkAlphaMul(g, fScale) >> (8 - SK_G16_BITS),
                             SkAlphaMul(b, fScale) >> (8 - SK_B16_BITS));
+
+    blendS32D16Row_Proc = SkBlitRow::Blend32_16_rowProcFactory();
 }
 
 const SkBitmap* SkRGB16_Blitter::justAnOpaqueColor(uint32_t* value) {
     if (!fDoDither && 256 == fScale) {
         *value = fRawColor16;
         return &fDevice;
     }
     return NULL;
 }
 
 static uint32_t pmcolor_to_expand16(SkPMColor c) {
     unsigned r = SkGetPackedR32(c);
     unsigned g = SkGetPackedG32(c);
     unsigned b = SkGetPackedB32(c);
     return (g << 24) | (r << 13) | (b << 2);
 }
 
-static inline void blend32_16_row(SkPMColor src, uint16_t dst[], int count) {
+static inline void blend32_16_row(const SkPMColor* SK_RESTRICT src,
+                                  uint16_t dst[], int count) {
     SkASSERT(count > 0);
-    uint32_t src_expand = pmcolor_to_expand16(src);
-    unsigned scale = SkAlpha255To256(0xFF - SkGetPackedA32(src)) >> 3;
+    uint32_t src_expand = pmcolor_to_expand16(*src);
+    unsigned scale = SkAlpha255To256(0xFF - SkGetPackedA32(*src)) >> 3;
     do {
         uint32_t dst_expand = SkExpand_rgb_16(*dst) * scale;
         *dst = SkCompact_rgb_16((src_expand + dst_expand) >> 5);
         dst += 1;
     } while (--count != 0);
 }
 
+SkBlitRow::Blend32_16_row_Proc SkBlitRow::Blend32_16_rowProcFactory() {
+    SkBlitRow::Blend32_16_row_Proc proc = NULL;
+    proc = PlatformBlend32_16_rowProc();
+    if (proc == NULL) {
+        proc = blend32_16_row;
+    }
+    return proc;
+};
+
 void SkRGB16_Blitter::blitH(int x, int y, int width) {
     SkASSERT(width > 0);
     SkASSERT(x + width <= fDevice.width());
     uint16_t* SK_RESTRICT device = fDevice.getAddr16(x, y);
 
     // TODO: respect fDoDither
-    blend32_16_row(fSrcColor32, device, width);
+    blendS32D16Row_Proc(fSrcColors32, device, width);
 }
 
 void SkRGB16_Blitter::blitAntiH(int x, int y,
                                 const SkAlpha* SK_RESTRICT antialias,
                                 const int16_t* SK_RESTRICT runs) {
     uint16_t* SK_RESTRICT device = fDevice.getAddr16(x, y);
     uint32_t    srcExpanded = fExpandedRaw16;
     unsigned    scale = fScale;
 
     // TODO: respect fDoDither
@@ skipping 82 matching lines @@
         uint32_t dst32 = SkExpand_rgb_16(*device) * scale5;
         *device = SkCompact_rgb_16((src32 + dst32) >> 5);
         device = (uint16_t*)((char*)device + deviceRB);
     } while (--height != 0);
 }
 
 void SkRGB16_Blitter::blitRect(int x, int y, int width, int height) {
     SkASSERT(x + width <= fDevice.width() && y + height <= fDevice.height());
     uint16_t* SK_RESTRICT device = fDevice.getAddr16(x, y);
     size_t    deviceRB = fDevice.rowBytes();
-    SkPMColor src32 = fSrcColor32;
 
     while (--height >= 0) {
-        blend32_16_row(src32, device, width);
+        blendS32D16Row_Proc(fSrcColors32, device, width);
         device = (uint16_t*)((char*)device + deviceRB);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkRGB16_Shader16_Blitter::SkRGB16_Shader16_Blitter(const SkBitmap& device,
                                                    const SkPaint& paint,
                                                    SkShader::Context* shaderContext)
     : SkRGB16_Shader_Blitter(device, paint, shaderContext) {
@@ skipping 362 matching lines @@
 #endif
         } else if (0xFF == SkColorGetA(color)) {
             blitter = allocator->createT<SkRGB16_Opaque_Blitter>(device, paint);
         } else {
             blitter = allocator->createT<SkRGB16_Blitter>(device, paint);
         }
     }
 
     return blitter;
 }