Add a clamp stage to SkRasterPipelineBlitter.

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 "SkPM4f.h"
-#include "SkPM4fPriv.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 27 matching lines @@
 
     typedef SkBlitter INHERITED;
 };
 
 SkBlitter* SkCreateRasterPipelineBlitter(const SkPixmap& dst,
                                          const SkPaint& paint,
                                          SkTBlitterAllocator* alloc) {
     return SkRasterPipelineBlitter::Create(dst, paint, alloc);
 }
 
+// Clamp colors into [0,1] premul (e.g. just before storing back to memory).
+static void SK_VECTORCALL clamp_01_premul(SkRasterPipeline::Stage* st, size_t x,
+                                          Sk4f  r, Sk4f  g, Sk4f  b, Sk4f  a,
+                                          Sk4f dr, Sk4f dg, Sk4f db, Sk4f da) {
+    a = Sk4f::Max(a, 0.0f);
+    r = Sk4f::Max(r, 0.0f);
+    g = Sk4f::Max(g, 0.0f);
+    b = Sk4f::Max(b, 0.0f);
+
+    a = Sk4f::Min(a, 1.0f);
+    r = Sk4f::Min(r, a);
+    g = Sk4f::Min(g, a);
+    b = Sk4f::Min(b, a);
+
+    st->next(x, r,g,b,a, dr,dg,db,da);
+}
 
 // The default shader produces a constant color (from the SkPaint).
 static void SK_VECTORCALL constant_color(SkRasterPipeline::Stage* st, size_t x,
                                          Sk4f  r, Sk4f  g, Sk4f  b, Sk4f  a,
                                          Sk4f dr, Sk4f dg, Sk4f db, Sk4f da) {
     auto color = st->ctx<const SkPM4f*>();
     r = color->r();
     g = color->g();
     b = color->b();
     a = color->a();
@@ skipping 178 matching lines @@
     da = {        (1/255.0f) * (*ptr >> SK_A32_SHIFT)        , 0,0,0 };
 
     st->next(x, r,g,b,a, dr,dg,db,da);
 }
 
 // Write out 4 pixels as 8-bit SkPMColor-order sRGB.
 static void SK_VECTORCALL store_srgb(SkRasterPipeline::Stage* st, size_t x,
                                      Sk4f  r, Sk4f  g, Sk4f  b, Sk4f  a,
                                      Sk4f dr, Sk4f dg, Sk4f db, Sk4f da) {
     auto dst = st->ctx<uint32_t*>() + x;
-    ( sk_linear_to_srgb(r) << SK_R32_SHIFT
-    | sk_linear_to_srgb(g) << SK_G32_SHIFT
-    | sk_linear_to_srgb(b) << SK_B32_SHIFT
-    | Sk4f_round(255.0f*a) << SK_A32_SHIFT).store(dst);
+    ( sk_linear_to_srgb_noclamp(r) << SK_R32_SHIFT
+    | sk_linear_to_srgb_noclamp(g) << SK_G32_SHIFT
+    | sk_linear_to_srgb_noclamp(b) << SK_B32_SHIFT
+    |       Sk4f_round(255.0f * a) << SK_A32_SHIFT).store(dst);
 }
 
 // Tail variant of store_srgb() handling 1 pixel at a time.
 static void SK_VECTORCALL store_srgb_1(SkRasterPipeline::Stage* st, size_t x,
                                        Sk4f  r, Sk4f  g, Sk4f  b, Sk4f  a,
                                        Sk4f dr, Sk4f dg, Sk4f db, Sk4f da) {
     auto dst = st->ctx<uint32_t*>() + x;
-    *dst = Sk4f_toS32(swizzle_rb_if_bgra({ r[0], g[0], b[0], a[0] }));
+    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;
     }
 }
@@ skipping 56 matching lines @@
         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 kRGB_565_SkColorType:
             p->append(store_565, store_565_1, dst);
             break;
         default: break;
@@ skipping 57 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());
     }
 }