Have SkRasterPipelineBlitter take over for F16 when it can.

src/core/SkRasterPipelineBlitter.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBlitter.h"
 #include "SkColor.h"
 #include "SkColorFilter.h"
+#include "SkHalf.h"
 #include "SkPM4f.h"
 #include "SkRasterPipeline.h"
 #include "SkShader.h"
 #include "SkSRGB.h"
 #include "SkXfermode.h"
 
 
 class SkRasterPipelineBlitter : public SkBlitter {
 public:
     static SkBlitter* Create(const SkPixmap&, const SkPaint&, SkTBlitterAllocator*);
@@ skipping 196 matching lines @@
 }
 
 // Store 1 565 pixel.
 static void SK_VECTORCALL store_565_1(SkRasterPipeline::Stage* st, size_t x,
                                       Sk4f  r, Sk4f  g, Sk4f  b, Sk4f  a,
                                       Sk4f dr, Sk4f dg, Sk4f db, Sk4f da) {
     auto ptr = st->ctx<uint16_t*>() + x;
     *ptr = to_565(r,g,b)[0];
 }
 
+// Load 4 F16 pixels.
+static void SK_VECTORCALL load_d_f16(SkRasterPipeline::Stage* st, size_t x,
+                                     Sk4f  r, Sk4f  g, Sk4f  b, Sk4f  a,
+                                     Sk4f dr, Sk4f dg, Sk4f db, Sk4f da) {
+    auto ptr = st->ctx<const uint64_t*>() + x;
+
+    // TODO: This can be made a lot more efficient with platform-specific code.
+    auto p0 = SkHalfToFloat_finite(ptr[0]),
+         p1 = SkHalfToFloat_finite(ptr[1]),
+         p2 = SkHalfToFloat_finite(ptr[2]),
+         p3 = SkHalfToFloat_finite(ptr[3]);
+    dr = { p0[0], p1[0], p2[0], p3[0] };
+    dg = { p0[1], p1[1], p2[1], p3[1] };
+    db = { p0[2], p1[2], p2[2], p3[2] };
+    da = { p0[3], p1[3], p2[3], p3[3] };
+
+    st->next(x, r,g,b,a, dr,dg,db,da);
+}
+
+// Load 1 F16 pixel.
+static void SK_VECTORCALL load_d_f16_1(SkRasterPipeline::Stage* st, size_t x,
+                                       Sk4f  r, Sk4f  g, Sk4f  b, Sk4f  a,
+                                       Sk4f dr, Sk4f dg, Sk4f db, Sk4f da) {
+    auto ptr = st->ctx<const uint64_t*>() + x;
+
+    auto p0 = SkHalfToFloat_finite(ptr[0]);
+    dr = { p0[0],0,0,0 };
+    dg = { p0[1],0,0,0 };
+    db = { p0[2],0,0,0 };
+    da = { p0[3],0,0,0 };
+
+    st->next(x, r,g,b,a, dr,dg,db,da);
+}
+
+// Store 4 F16 pixels.
+static void SK_VECTORCALL store_f16(SkRasterPipeline::Stage* st, size_t x,
+                                    Sk4f  r, Sk4f  g, Sk4f  b, Sk4f  a,
+                                    Sk4f dr, Sk4f dg, Sk4f db, Sk4f da) {
+    auto ptr = st->ctx<uint64_t*>() + x;
+
+    Sk4h_store4(ptr, SkFloatToHalf_finite(r), SkFloatToHalf_finite(g),
+                     SkFloatToHalf_finite(b), SkFloatToHalf_finite(a));
+}
+
+// Store 1 F16 pixel.
+static void SK_VECTORCALL store_f16_1(SkRasterPipeline::Stage* st, size_t x,
+                                      Sk4f  r, Sk4f  g, Sk4f  b, Sk4f  a,
+                                      Sk4f dr, Sk4f dg, Sk4f db, Sk4f da) {
+    auto ptr = st->ctx<uint64_t*>() + x;
+
+    SkFloatToHalf_finite({r[0], g[0], b[0], a[0]}).store(ptr);
+}
+
 // Load 4 8-bit sRGB pixels from SkPMColor order to RGBA.
 static void SK_VECTORCALL load_d_srgb(SkRasterPipeline::Stage* st, size_t x,
                                       Sk4f  r, Sk4f  g, Sk4f  b, Sk4f  a,
                                       Sk4f dr, Sk4f dg, Sk4f db, Sk4f da) {
     auto ptr = st->ctx<const uint32_t*>() + x;
 
     dr = { sk_linear_from_srgb[(ptr[0] >> SK_R32_SHIFT) & 0xff],
            sk_linear_from_srgb[(ptr[1] >> SK_R32_SHIFT) & 0xff],
            sk_linear_from_srgb[(ptr[2] >> SK_R32_SHIFT) & 0xff],
            sk_linear_from_srgb[(ptr[3] >> SK_R32_SHIFT) & 0xff] };
@@ skipping 46 matching lines @@
     auto dst = st->ctx<uint32_t*>() + x;
     Sk4i rgb = sk_linear_to_srgb_noclamp(swizzle_rb_if_bgra({ r[0], g[0], b[0], 0.0f }));
 
     uint32_t rgba;
     SkNx_cast<uint8_t>(rgb).store(&rgba);
     rgba |= (uint32_t)(255.0f * a[0] + 0.5f) << 24;
     *dst = rgba;
 }
 
 static bool supported(const SkImageInfo& info) {
-    // TODO: f16, more?
     switch (info.colorType()) {
-        case kN32_SkColorType:     return info.gammaCloseToSRGB();
-        case kRGB_565_SkColorType: return true;
-        default:                   return false;
+        case kN32_SkColorType:      return info.gammaCloseToSRGB();
+        case kRGBA_F16_SkColorType: return true;
+        case kRGB_565_SkColorType:  return true;
+        default:                    return false;
     }
 }
 
 template <typename Effect>
 static bool append_effect_stages(const Effect* effect, SkRasterPipeline* pipeline) {
     return !effect || effect->appendStages(pipeline);
 }
 
 
 SkBlitter* SkRasterPipelineBlitter::Create(const SkPixmap& dst,
                                            const SkPaint& paint,
                                            SkTBlitterAllocator* alloc) {
     if (!supported(dst.info())) {
         return nullptr;
     }
     if (paint.getShader()) {
         return nullptr;  // TODO: need to work out how shaders and their contexts work
     }
 
     SkRasterPipeline shader, colorFilter, xfermode;
     if (!append_effect_stages(paint.getColorFilter(), &colorFilter) ||
         !append_effect_stages(paint.getXfermode(),    &xfermode   )) {
         return nullptr;
     }
 
     uint32_t paintColor = paint.getColor();
 
     SkColor4f color;
-    if (dst.info().colorSpace()) {
+    if (SkImageInfoIsGammaCorrect(dst.info())) {
         color = SkColor4f::FromColor(paintColor);
     } else {
         swizzle_rb(SkNx_cast<float>(Sk4b::Load(&paintColor)) * (1/255.0f)).store(&color);
     }
 
     auto blitter = alloc->createT<SkRasterPipelineBlitter>(
             dst,
             shader, colorFilter, xfermode,
             color.premul());
 
     if (!paint.getShader()) {
         blitter->fShader.append(constant_color, &blitter->fPaintColor);
     }
     if (!paint.getXfermode()) {
         blitter->fXfermode.append(srcover);
     }
 
     return blitter;
 }
 
 void SkRasterPipelineBlitter::append_load_d(SkRasterPipeline* p, const void* dst) const {
     SkASSERT(supported(fDst.info()));
 
     switch (fDst.info().colorType()) {
         case kN32_SkColorType:
             if (fDst.info().gammaCloseToSRGB()) {
                 p->append(load_d_srgb, load_d_srgb_1, dst);
             }
             break;
+        case kRGBA_F16_SkColorType:
+            p->append(load_d_f16, load_d_f16_1, dst);
+            break;
         case kRGB_565_SkColorType:
             p->append(load_d_565, load_d_565_1, dst);
             break;
         default: break;
     }
 }
 
 void SkRasterPipelineBlitter::append_store(SkRasterPipeline* p, void* dst) const {
     SkASSERT(supported(fDst.info()));
 
     p->append(clamp_01_premul);
     switch (fDst.info().colorType()) {
         case kN32_SkColorType:
             if (fDst.info().gammaCloseToSRGB()) {
                 p->append(store_srgb, store_srgb_1, dst);
             }
             break;
+        case kRGBA_F16_SkColorType:
+            p->append(store_f16, store_f16_1, dst);
+            break;
         case kRGB_565_SkColorType:
             p->append(store_565, store_565_1, dst);
             break;
         default: break;
     }
 }
 
 void SkRasterPipelineBlitter::blitH(int x, int y, int w) {
     auto dst = fDst.writable_addr(0,y);
 
@@ skipping 51 matching lines @@
             case SkMask::kLCD16_Format:
                 p.append(lerp_lcd16, lerp_lcd16_1, mask.getAddrLCD16(x,y)-x);
                 break;
             default: break;
         }
         this->append_store(&p, dst);
 
         p.run(x, clip.width());
     }
 }