blitters for sRGB and float16

src/core/SkBlitter.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 "SkBlitter.h"
 #include "SkAntiRun.h"
 #include "SkColor.h"
 #include "SkColorFilter.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
 #include "SkMask.h"
 #include "SkMaskFilter.h"
 #include "SkString.h"
 #include "SkTLazy.h"
 #include "SkUtils.h"
 #include "SkXfermode.h"
 #include "SkXfermodeInterpretation.h"
 
 // define this for testing srgb blits
 //#define SK_SUPPORT_SRGB_RASTER
 
 #ifdef SK_SUPPORT_SRGB_RASTER
     #define ALLOW_SRGB  true
 #else
     #define ALLOW_SRGB  false
 #endif

[f(malita), 2016/02/15 04:31:17]

I think we no longer need these.

[reed2, 2016/02/15 15:25:22]

Agreed. Replaced with SK_FORCE_PM4f_FOR_L32_BLITS so we can manually test the
new code-path on old surfaces (linear 32)

 
 SkBlitter::~SkBlitter() {}
 
 bool SkBlitter::isNullBlitter() const { return false; }
 
 bool SkBlitter::resetShaderContext(const SkShader::ContextRec&) {
     return true;
 }
 
 SkShader::Context* SkBlitter::getShaderContext() const {
@@ skipping 866 matching lines @@
             } else {
                 blitter = allocator->createT<SkA8_Blitter>(device, *paint);
             }
             break;
 
         case kRGB_565_SkColorType:
             blitter = SkBlitter_ChooseD565(device, *paint, shaderContext, allocator);
             break;
 
         case kN32_SkColorType:
-            if (shader) {
-                if (shaderContext->supports4f() && ALLOW_SRGB) {
-                    blitter = allocator->createT<SkARGB32_Shader4f_Blitter>(
-                                                                  device, *paint, shaderContext);
+            if (device.info().isSRGB()) {
+                blitter = SkBlitter_ARGB32_Create(device, *paint, shaderContext, allocator);
+            } else {
+                if (shader) {
+                        blitter = allocator->createT<SkARGB32_Shader_Blitter>(
+                                device, *paint, shaderContext);
+                } else if (paint->getColor() == SK_ColorBLACK) {
+                    blitter = allocator->createT<SkARGB32_Black_Blitter>(device, *paint);
+                } else if (paint->getAlpha() == 0xFF) {
+                    blitter = allocator->createT<SkARGB32_Opaque_Blitter>(device, *paint);
                 } else {
-                    blitter = allocator->createT<SkARGB32_Shader_Blitter>(
-                            device, *paint, shaderContext);
+                    blitter = allocator->createT<SkARGB32_Blitter>(device, *paint);
                 }
-            } else if (paint->getColor() == SK_ColorBLACK) {
-                blitter = allocator->createT<SkARGB32_Black_Blitter>(device, *paint);
-            } else if (paint->getAlpha() == 0xFF) {
-                blitter = allocator->createT<SkARGB32_Opaque_Blitter>(device, *paint);
-            } else {
-                blitter = allocator->createT<SkARGB32_Blitter>(device, *paint);
             }
             break;
 
+        case kRGBA_F16_SkColorType:
+        // kU16_SkColorType:
+            blitter = SkBlitter_ARGB64_Create(device, *paint, shaderContext, allocator);
+            break;
+
         default:
             SkDEBUGFAIL("unsupported device config");
             blitter = allocator->createT<SkNullBlitter>();
             break;
     }
 
     if (shader3D) {
         SkBlitter* innerBlitter = blitter;
         // innerBlitter was allocated by allocator, which will delete it.
         // We know shaderContext or its proxies is of type Sk3DShaderContext, so we need to
@@ skipping 22 matching lines @@
 SkShaderBlitter::SkShaderBlitter(const SkPixmap& device, const SkPaint& paint,
                                  SkShader::Context* shaderContext)
         : INHERITED(device)
         , fShader(paint.getShader())
         , fShaderContext(shaderContext) {
     SkASSERT(fShader);
     SkASSERT(fShaderContext);
 
     fShader->ref();
     fShaderFlags = fShaderContext->getFlags();
+    fConstInY = SkToBool(fShaderFlags & SkShader::kConstInY32_Flag);
 }
 
 SkShaderBlitter::~SkShaderBlitter() {
     fShader->unref();
 }
 
 bool SkShaderBlitter::resetShaderContext(const SkShader::ContextRec& rec) {
     // Only destroy the old context if we have a new one. We need to ensure to have a
     // live context in fShaderContext because the storage is owned by an SkSmallAllocator
     // outside of this class.
     // The new context will be of the same size as the old one because we use the same
     // shader to create it. It is therefore safe to re-use the storage.
     fShaderContext->~Context();
     SkShader::Context* ctx = fShader->createContext(rec, (void*)fShaderContext);
     if (nullptr == ctx) {
         // Need a valid context in fShaderContext's storage, so we can later (or our caller) call
         // the in-place destructor.
         new (fShaderContext) SkZeroShaderContext(*fShader, rec);
         return false;
     }
     return true;
 }