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::ColorProc16 fColorProc16;
+
     // 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++) {

[djsollen, 2015/01/14 14:57:54]

We shouldn't need to do this here.  You can just do it in the assembly using the
vdup instructions

http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.dui0491g/BABDBBJB...

Then you shouldn't need to update the proc to pass an array instead of a single
value.

[mlee, 2015/01/15 08:12:36]

On 2015/01/14 14:57:54, djsollen wrote:

Hi, djsollen.

Thanks for the review.

This is the reason why I prepare eight RGBA pixels in memory.

src pixel is RGBA and this is in order to prepare eight src pixles,
which are arrached in memory as R, G, B, A, R, G, B, A ... R, G, B, A.

"ld4" command pull data from memory and simultaneously separate values into
different four 128 bit registers:
 : V24 has 8 red componets(each one has 8bit), V25 has 8 green, v26 has 8 blue,
v27 has 8 alpha.

I have no idea if we can prepare this using DUP command, though. As I
understand, with DUP, I can replicate
src to 128bit register, but it doesn't separate values into different registers.
Let me know if I am missing something.

If maintaining to load single src rather than src[] is necessary as original
code does,
I can do prepare 8 src pixels array in neon function inside, but this will be
done
in every function call, which can be overhead.
Because of that, I've prepared it in constructor.

Let me know your thought once again. As I mentioned, if you want to maintain
original single src load, I will move this array preparation into neon function
inside.
 
Thanks,
Min-wuk Lee.

[mlee, 2015/01/21 10:17:32]

On 2015/01/14 14:57:54, djsollen wrote:
Done in patch set 4.

+        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));
+
+    // compute SkBlitRow::Procs
+    unsigned flags = 0;
+
+    // TODO: respect fDoDither
+    flags |= SkBlitRow::kSrcPixelAlpha_Flag;
+
+    fColorProc16 = SkBlitRow::PlatformColorFactory565(flags);
 }
 
 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) {
-    SkASSERT(count > 0);
-    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);
-}
-
 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);
+    fColorProc16(device, fSrcColors32, width, x, y);
 }
 
 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);
+        fColorProc16(device, fSrcColors32, width, x, y);
         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 361 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;
 }