Decouple contrast boost from fake gamma.

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 "SkAutoKern.h"
 #include "SkChecksum.h"
@@ skipping 941 matching lines @@
     if (zoom) {
         zoomMatrix.setScale(zoom, zoom);
         zoomPtr = &zoomMatrix;
     }
 
     FontMetrics storage;
     if (nullptr == metrics) {
         metrics = &storage;
     }
 
-    paint.descriptorProc(nullptr, FakeGamma::Off, zoomPtr, FontMetricsDescProc, metrics);
+    paint.descriptorProc(nullptr, kNone_ScalerContextFlags, zoomPtr, FontMetricsDescProc, metrics);
 
     if (scale) {
         metrics->fTop = SkScalarMul(metrics->fTop, scale);
         metrics->fAscent = SkScalarMul(metrics->fAscent, scale);
         metrics->fDescent = SkScalarMul(metrics->fDescent, scale);
         metrics->fBottom = SkScalarMul(metrics->fBottom, scale);
         metrics->fLeading = SkScalarMul(metrics->fLeading, scale);
         metrics->fAvgCharWidth = SkScalarMul(metrics->fAvgCharWidth, scale);
         metrics->fXMin = SkScalarMul(metrics->fXMin, scale);
         metrics->fXMax = SkScalarMul(metrics->fXMax, scale);
@@ skipping 536 matching lines @@
             SkColor color = rec->getLuminanceColor();
             U8CPU lum = SkComputeLuminance(SkColorGetR(color),
                                            SkColorGetG(color),
                                            SkColorGetB(color));
             // 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();
+            // No need to differentiate gamma or apply contrast if we're BW
+            rec->ignorePreBlend(false);

[bungeman-skia, 2016/04/07 20:15:45]

At the call site it's annoying that the bool parameter is non-descriptively
'false'. We could make this an enum, or we could split this into ignoreGamma and
setContrast(0), with ignorePreBlend calling both ignoreGamma and setContrast(0).
That way all of these ignorePreBlend(false) turn into ignorePreBlend(). Then in
fill_out_rec, the current ignorePreBlend becomes ignoreGamma, and then adds 'if
(boostContrast) { setContrast(0); }' right after.

[Brian Osman, 2016/04/07 21:23:46]

Done. (Yeah, I like the broken-out API better).

             break;
     }
 }
 
 #define MIN_SIZE_FOR_EFFECT_BUFFER  1024
 
 #ifdef SK_DEBUG
     #define TEST_DESC
 #endif
 
@@ skipping 13 matching lines @@
     }
     if (ra) {
         add_flattenable(desc, kRasterizer_SkDescriptorTag, raBuffer);
     }
 
     desc->computeChecksum();
 }
 
 static size_t fill_out_rec(const SkPaint& paint, SkScalerContext::Rec* rec,
                            const SkSurfaceProps* surfaceProps,
-                           bool fakeGamma,
+                           bool fakeGamma, bool boostContrast,
                            const SkMatrix* deviceMatrix,
                            const SkPathEffect* pe, SkWriteBuffer* peBuffer,
                            const SkMaskFilter* mf, SkWriteBuffer* mfBuffer,
                            const SkRasterizer* ra, SkWriteBuffer* raBuffer) {
     SkScalerContext::MakeRec(paint, surfaceProps, deviceMatrix, rec);
     if (!fakeGamma) {
-        rec->ignorePreBlend();
+        rec->ignorePreBlend(boostContrast);
     }
 
     int entryCount = 1;
     size_t descSize = sizeof(*rec);
 
     if (pe) {
         peBuffer->writeFlattenable(pe);
         descSize += peBuffer->bytesWritten();
         entryCount += 1;
         rec->fMaskFormat = SkMask::kA8_Format;  // force antialiasing when we do the scan conversion
         // seems like we could support kLCD as well at this point...
     }
     if (mf) {
         mfBuffer->writeFlattenable(mf);
         descSize += mfBuffer->bytesWritten();
         entryCount += 1;
         rec->fMaskFormat = SkMask::kA8_Format;   // force antialiasing with maskfilters
         /* Pre-blend is not currently applied to filtered text.
            The primary filter is blur, for which contrast makes no sense,
            and for which the destination guess error is more visible.
            Also, all existing users of blur have calibrated for linear. */
-        rec->ignorePreBlend();
+        rec->ignorePreBlend(false);
     }
     if (ra) {
         raBuffer->writeFlattenable(ra);
         descSize += raBuffer->bytesWritten();
         entryCount += 1;
         rec->fMaskFormat = SkMask::kA8_Format;  // force antialiasing when we do the scan conversion
     }
 
     ///////////////////////////////////////////////////////////////////////////
     // Now that we're done tweaking the rec, call the PostMakeRec cleanup
@@ skipping 46 matching lines @@
     desc1->computeChecksum();
     desc2->computeChecksum();
     SkASSERT(!memcmp(desc, desc1, descSize));
     SkASSERT(!memcmp(desc, desc2, descSize));
 }
 #endif
 
 /* see the note on ignoreGamma on descriptorProc */
 void SkPaint::getScalerContextDescriptor(SkAutoDescriptor* ad,
                                          const SkSurfaceProps& surfaceProps,
-                                         FakeGamma fakeGamma,
+                                         uint32_t scalerContextFlags,
                                          const SkMatrix* deviceMatrix) const {
     SkScalerContext::Rec    rec;
 
     SkPathEffect*   pe = this->getPathEffect();
     SkMaskFilter*   mf = this->getMaskFilter();
     SkRasterizer*   ra = this->getRasterizer();
 
     SkWriteBuffer   peBuffer, mfBuffer, raBuffer;
-    size_t descSize = fill_out_rec(*this, &rec,
-                                   &surfaceProps, FakeGamma::On == fakeGamma, deviceMatrix,
-                                   pe, &peBuffer, mf, &mfBuffer, ra, &raBuffer);
+    size_t descSize = fill_out_rec(*this, &rec, &surfaceProps,
+                                   SkToBool(scalerContextFlags & kFakeGamma_ScalerContextFlag),
+                                   SkToBool(scalerContextFlags & kBoostContrast_ScalerContextFlag),
+                                   deviceMatrix, pe, &peBuffer, mf, &mfBuffer, ra, &raBuffer);
 
     ad->reset(descSize);
     SkDescriptor* desc = ad->getDesc();
 
     write_out_descriptor(desc, rec, pe, &peBuffer, mf, &mfBuffer, ra, &raBuffer, descSize);
 
     SkASSERT(descSize == desc->getLength());
 
 #ifdef TEST_DESC
     test_desc(rec, pe, &peBuffer, mf, &mfBuffer, ra, &raBuffer, desc, descSize);
 #endif
 }
 
 /*
  *  ignoreGamma tells us that the caller just wants metrics that are unaffected
  *  by gamma correction, so we set the rec to ignore preblend: i.e. gamma = 1,
  *  contrast = 0, luminanceColor = transparent black.
  */
 void SkPaint::descriptorProc(const SkSurfaceProps* surfaceProps,
-                             FakeGamma fakeGamma,
+                             uint32_t scalerContextFlags,
                              const SkMatrix* deviceMatrix,
                              void (*proc)(SkTypeface*, const SkDescriptor*, void*),
                              void* context) const {
     SkScalerContext::Rec    rec;
 
     SkPathEffect*   pe = this->getPathEffect();
     SkMaskFilter*   mf = this->getMaskFilter();
     SkRasterizer*   ra = this->getRasterizer();
 
     SkWriteBuffer   peBuffer, mfBuffer, raBuffer;
-    size_t descSize = fill_out_rec(*this, &rec,
-                                   surfaceProps, FakeGamma::On == fakeGamma, deviceMatrix,
-                                   pe, &peBuffer, mf, &mfBuffer, ra, &raBuffer);
+    size_t descSize = fill_out_rec(*this, &rec, surfaceProps,
+                                   SkToBool(scalerContextFlags & kFakeGamma_ScalerContextFlag),
+                                   SkToBool(scalerContextFlags & kBoostContrast_ScalerContextFlag),
+                                   deviceMatrix, pe, &peBuffer, mf, &mfBuffer, ra, &raBuffer);
 
     SkAutoDescriptor    ad(descSize);
     SkDescriptor*       desc = ad.getDesc();
 
     write_out_descriptor(desc, rec, pe, &peBuffer, mf, &mfBuffer, ra, &raBuffer, descSize);
 
     SkASSERT(descSize == desc->getLength());
 
 #ifdef TEST_DESC
     test_desc(rec, pe, &peBuffer, mf, &mfBuffer, ra, &raBuffer, desc, descSize);
 #endif
 
     proc(fTypeface.get(), desc, context);
 }
 
 SkGlyphCache* SkPaint::detachCache(const SkSurfaceProps* surfaceProps,
-                                   FakeGamma fakeGamma,
+                                   uint32_t scalerContextFlags,
                                    const SkMatrix* deviceMatrix) const {
     SkGlyphCache* cache;
-    this->descriptorProc(surfaceProps, fakeGamma, deviceMatrix, DetachDescProc, &cache);
+    this->descriptorProc(surfaceProps, scalerContextFlags, deviceMatrix, DetachDescProc, &cache);
     return cache;
 }
 
 /**
  * Expands fDeviceGamma, fPaintGamma, fContrast, and fLumBits into a mask pre-blend.
  */
 //static
 SkMaskGamma::PreBlend SkScalerContext::GetMaskPreBlend(const SkScalerContext::Rec& rec) {
     SkAutoMutexAcquire ama(gMaskGammaCacheMutex);
     const SkMaskGamma& maskGamma = cachedMaskGamma(rec.getContrast(),
@@ skipping 514 matching lines @@
         }
     } else {
         fScale = SK_Scalar1;
     }
 
     if (!applyStrokeAndPathEffects) {
         fPaint.setStyle(SkPaint::kFill_Style);
         fPaint.setPathEffect(nullptr);
     }
 
-    fCache = fPaint.detachCache(nullptr, SkPaint::FakeGamma::On, nullptr);
+    // SRGBTODO: Is this correct?
+    fCache = fPaint.detachCache(nullptr, SkPaint::kFakeGammaAndBoostContrast_ScalerContextFlags,
+                                nullptr);
 
     SkPaint::Style  style = SkPaint::kFill_Style;
     sk_sp<SkPathEffect> pe;
 
     if (!applyStrokeAndPathEffects) {
         style = paint.getStyle();   // restore
         pe = sk_ref_sp(paint.getPathEffect());     // restore
     }
     fPaint.setStyle(style);
     fPaint.setPathEffect(pe);
@@ skipping 99 matching lines @@
 }
 
 uint32_t SkPaint::getHash() const {
     // We're going to hash 10 pointers and 7 32-bit values, finishing up with fBitfields,
     // so fBitfields should be 10 pointers and 6 32-bit values from the start.
     static_assert(offsetof(SkPaint, fBitfields) == 9 * sizeof(void*) + 6 * sizeof(uint32_t),
                   "SkPaint_notPackedTightly");
     return SkChecksum::Murmur3(reinterpret_cast<const uint32_t*>(this),
                                offsetof(SkPaint, fBitfields) + sizeof(fBitfields));
 }