refresh image shader cs/at logic

Was working on SkVM versions of these when I noticed the existing
SkRasterPipeline code wasn't terribly tidy.  The main gist here is that
we can let SkColorSpaceXformSteps::apply() handle almost all the
final transformation on the way out of the shader.

I remain a little puzzled why I got a few significant diffs when I tried
leaving the A8 color unpremul, letting the steps handle matching the
alpha types instead of me manually with SkRasterPipeline::premul.  For
now I've left that as-is.

Similarly I think we could transform that A8 color ahead of time rather
than doing that over and over at runtime.  This is something I've left
as a TODO, largely because I don't care enough about coloring A8 to
investigate right now.

I've inlined all the logic of explaining src-is-normalized into this
shader (which is its only user).  That makes it clearer that we can
always set that bit when bicubic sampling, since we're clamping anyway.
This causes some invisible diffs when switching to the optimized sRGB
transfer function stages, which we may or may not be able to get away
with without guarding...

Change-Id: Ie6670c6ca5c69958f41aac88324341a10eb3bee1
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/261763
Reviewed-by: Brian Osman <brianosman@google.com>
Commit-Queue: Mike Klein <mtklein@google.com>

Author: Mike Klein

src/core/SkColorSpaceXformSteps.h

@@ -43,10 +43,6 @@ struct SkColorSpaceXformSteps {
     void apply(float rgba[4]) const;
     void apply(SkRasterPipeline*, bool src_is_normalized) const;
 
-    void apply(SkRasterPipeline* p, SkColorType srcCT) const {
-        return this->apply(p, SkColorTypeIsNormalized(srcCT));
-    }
-
     Flags flags;
 
     bool srcTF_is_sRGB,

src/shaders/SkImageShader.cpp

@@ -479,36 +479,37 @@ bool SkImageShader::doStages(const SkStageRec& rec, SkImageStageUpdater* updater
     };
 
     auto append_misc = [&] {
-        // TODO: if ref.fDstCS isn't null, we'll premul here then immediately unpremul
-        // to do the color space transformation.  Might be possible to streamline.
+        SkColorSpace* cs = info.colorSpace();
+        SkAlphaType   at = info.alphaType();
+
+        // Color for A8 images comes from the paint.    TODO: all alpha formats?  maybe none?
         if (info.colorType() == kAlpha_8_SkColorType) {
-            // The color for A8 images comes from the (sRGB) paint color.
             p->append_set_rgb(alloc, rec.fPaint.getColor4f());
             p->append(SkRasterPipeline::premul);
-        } else if (info.alphaType() == kUnpremul_SkAlphaType) {
-            // Convert unpremul images to premul before we carry on with the rest of the pipeline.
-            p->append(SkRasterPipeline::premul);
+            cs = sk_srgb_singleton();  // TODO: transform to dstCS here instead of at runtime?
+            at = kPremul_SkAlphaType;
         }
 
+        // This is an unessential optimization... it's logically safe to set this to false.
+        // But if...
+        //      - we know the image is definitely normalized, and
+        //      - we're doing some color space conversion, and
+        //      - sRGB curves are involved,
+        // then we can use slightly faster math that doesn't work well outside [0,1].
+        bool src_is_normalized = SkColorTypeIsNormalized(info.colorType());
+
+        // Bicubic filtering naturally produces out of range values on both sides of [0,1].
         if (quality > kLow_SkFilterQuality) {
-            // Bicubic filtering naturally produces out of range values on both sides.
             p->append(SkRasterPipeline::clamp_0);
             p->append(fClampAsIfUnpremul ? SkRasterPipeline::clamp_1
                                          : SkRasterPipeline::clamp_a);
+            src_is_normalized = true;
         }
 
-        if (rec.fDstCS) {
-            // If color managed, convert from premul source all the way to premul dst color space.
-            auto srcCS = info.colorSpace();
-            if (!srcCS || info.colorType() == kAlpha_8_SkColorType) {
-                // We treat untagged images as sRGB.
-                // A8 images get their r,g,b from the paint color, so they're also sRGB.
-                srcCS = sk_srgb_singleton();
-            }
-            alloc->make<SkColorSpaceXformSteps>(srcCS     , kPremul_SkAlphaType,
-                                                rec.fDstCS, kPremul_SkAlphaType)
-                ->apply(p, info.colorType());
-        }
+        // Transform color space and alpha type to match shader convention (dst CS, premul alpha).
+        alloc->make<SkColorSpaceXformSteps>(cs, at,
+                                            rec.fDstCS, kPremul_SkAlphaType)
+            ->apply(p, src_is_normalized);
 
         return true;
     };