Gamma correction for distance field text.

src/core/SkPaint.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 "SkPaint.h"
 #include "SkAnnotation.h"
 #include "SkAutoKern.h"
@@ skipping 1755 matching lines @@
     SkSafeUnref(gMaskGamma);
     gMaskGamma = NULL;
     SkDEBUGCODE(gContrast = SK_ScalarMin;)
     SkDEBUGCODE(gPaintGamma = SK_ScalarMin;)
     SkDEBUGCODE(gDeviceGamma = SK_ScalarMin;)
 }
 
 /**
  *  We ensure that the rec is self-consistent and efficient (where possible)
  */
-void SkScalerContext::PostMakeRec(const SkPaint&, SkScalerContext::Rec* rec) {
+void SkScalerContext::PostMakeRec(const SkPaint& paint, SkScalerContext::Rec* rec) {
     /**
      *  If we're asking for A8, we force the colorlum to be gray, since that
      *  limits the number of unique entries, and the scaler will only look at
      *  the lum of one of them.
      */
     switch (rec->fMaskFormat) {
         case SkMask::kLCD16_Format:
         case SkMask::kLCD32_Format: {
             // filter down the luminance color to a finite number of bits
             SkColor color = rec->getLuminanceColor();
@@ skipping 15 matching lines @@
             // reduce to our finite number of bits
             color = SkColorSetRGB(lum, lum, lum);
             rec->setLuminanceColor(SkMaskGamma::CanonicalColor(color));
             break;
         }
         case SkMask::kBW_Format:
             // No need to differentiate gamma if we're BW
             rec->ignorePreBlend();
             break;
     }
+
+    /**
+     *  If we're using distance fields we need to reset the rec to default values
+     */
+    if (paint.isDistanceFieldTextTEMP()) {

[reed1, 2014/06/03 19:46:44]

What is the expected lifespan of this TEMP flag?

[jvanverth1, 2014/06/05 18:18:23]

I don't know. Though I just realized a problem with using this flag even if it's
decided to make it permanent.  Suppose a client sets the flag requesting
distance field text, but then we fall back to bitmaps (because it's a color
font, or they're using a MaskFilter, or some such thing). Then when we generate
the rec for the GrBitmapTextContext it will also call this code, and you'll end
up with a non-gamma corrected, non-LCD, subpixel result, which may not be what
you want.

I might be able do this by munging my copy of the SkPaint, and also copying the
DeviceProperties and munging those to set the gamma to 1.

[jvanverth1, 2014/06/06 15:34:44]

Done. I was not able to use the DeviceProperties because the contrast also has
to be 0. However, there was an old 'ignoreGamma' parameter to descriptorProc()
that I was able to make use of, and create SkAutoGlyphCacheNoGamma, that
actually sets it.

+        rec->ignorePreBlend();
+
+        rec->fFlags |= SkScalerContext::kSubpixelPositioning_Flag;
+        rec->fFlags &= ~SkScalerContext::kForceAutohinting_Flag;
+
+        if (SkMask::kLCD16_Format == rec->fMaskFormat ||
+            SkMask::kLCD32_Format == rec->fMaskFormat) {
+            rec->fMaskFormat = SkMask::kA8_Format;
+        }
+        rec->setHinting(SkPaint::kNo_Hinting);
+    }
+
 }
 
 #define MIN_SIZE_FOR_EFFECT_BUFFER  1024
 
 #ifdef SK_DEBUG
     #define TEST_DESC
 #endif
 
 /*
  *  ignoreGamma tells us that the caller just wants metrics that are unaffected
@@ skipping 145 matching lines @@
  */
 //static
 SkMaskGamma::PreBlend SkScalerContext::GetMaskPreBlend(const SkScalerContext::Rec& rec) {
     SkAutoMutexAcquire ama(gMaskGammaCacheMutex);
     const SkMaskGamma& maskGamma = cachedMaskGamma(rec.getContrast(),
                                                    rec.getPaintGamma(),
                                                    rec.getDeviceGamma());
     return maskGamma.preBlend(rec.getLuminanceColor());
 }
 
+size_t SkScalerContext::getGammaLUTSize(SkScalar contrast, SkScalar paintGamma,
+                                        SkScalar deviceGamma, int* width, int* height) {
+    SkAutoMutexAcquire ama(gMaskGammaCacheMutex);
+    const SkMaskGamma& maskGamma = cachedMaskGamma(contrast,
+                                                   paintGamma,
+                                                   deviceGamma);
+
+    maskGamma.getGammaTableDimensions(width, height);
+    size_t size = (*width)*(*height)*sizeof(uint8_t);
+
+    return size;
+}
+
+void SkScalerContext::getGammaLUTData(SkScalar contrast, SkScalar paintGamma, SkScalar deviceGamma,
+                                      void* data) {
+    SkAutoMutexAcquire ama(gMaskGammaCacheMutex);
+    const SkMaskGamma& maskGamma = cachedMaskGamma(contrast,
+                                                   paintGamma,
+                                                   deviceGamma);
+    int width, height;
+    maskGamma.getGammaTableDimensions(&width, &height);
+    size_t size = width*height*sizeof(uint8_t);
+    const uint8_t* gammaTables = maskGamma.getGammaTables();
+    memcpy(data, gammaTables, size);
+}
+
+
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "SkStream.h"
 
 static uintptr_t asint(const void* p) {
     return reinterpret_cast<uintptr_t>(p);
 }
 
 union Scalar32 {
     SkScalar    fScalar;
@@ skipping 747 matching lines @@
     }
 #ifdef SK_BUILD_FOR_ANDROID
     if (dirty & kPaintOptionsAndroid_DirtyBit) {
         SkPaintOptionsAndroid options;
         options.unflatten(buffer);
         paint->setPaintOptionsAndroid(options);
     }
 #endif
     SkASSERT(dirty == paint->fDirtyBits);
 }