Remove gamma field from SkDeviceProperties

src/gpu/GrAtlasTextContext.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "GrAtlasTextContext.h"
 
 #include "GrBatch.h"
 #include "GrBatchFontCache.h"
@@ skipping 81 matching lines @@
 
 };
 
 // TODO
 // Distance field text in textblobs
 
 GrAtlasTextContext::GrAtlasTextContext(GrContext* context,
                                        GrDrawContext* drawContext,
                                        const SkDeviceProperties& properties)
     : INHERITED(context, drawContext, properties)
-    , fDistanceAdjustTable(SkNEW_ARGS(DistanceAdjustTable, (properties.gamma()))) {
+    , fDistanceAdjustTable(SkNEW(DistanceAdjustTable)) {
     // We overallocate vertices in our textblobs based on the assumption that A8 has the greatest
     // vertexStride
     SK_COMPILE_ASSERT(kGrayTextVASize >= kColorTextVASize && kGrayTextVASize >= kLCDTextVASize,
                       vertex_attribute_changed);
     fCurrStrike = NULL;
     fCache = context->getTextBlobCache();
 }
 
-void GrAtlasTextContext::DistanceAdjustTable::buildDistanceAdjustTable(float gamma) {
+void GrAtlasTextContext::DistanceAdjustTable::buildDistanceAdjustTable() {
 
     // This is used for an approximation of the mask gamma hack, used by raster and bitmap
     // text. The mask gamma hack is based off of guessing what the blend color is going to
     // be, and adjusting the mask so that when run through the linear blend will
     // produce the value closest to the desired result. However, in practice this means
     // that the 'adjusted' mask is just increasing or decreasing the coverage of
     // the mask depending on what it is thought it will blit against. For black (on
     // assumed white) this means that coverages are decreased (on a curve). For white (on
     // assumed black) this means that coverages are increased (on a a curve). At
     // middle (perceptual) gray (which could be blit against anything) the coverages
@@ skipping 24 matching lines @@
     //     previously covered at all.
 
     int width, height;
     size_t size;
 
 #ifdef SK_GAMMA_CONTRAST
     SkScalar contrast = SK_GAMMA_CONTRAST;
 #else
     SkScalar contrast = 0.5f;
 #endif
-    SkScalar paintGamma = gamma;
-    SkScalar deviceGamma = gamma;
+    SkScalar paintGamma = SK_GAMMA_EXPONENT;
+    SkScalar deviceGamma = SK_GAMMA_EXPONENT;
 
     size = SkScalerContext::GetGammaLUTSize(contrast, paintGamma, deviceGamma,
         &width, &height);
 
     SkASSERT(kExpectedDistanceAdjustTableSize == height);
     fTable = SkNEW_ARRAY(SkScalar, height);
 
     SkAutoTArray<uint8_t> data((int)size);
     SkScalerContext::GetGammaLUTData(contrast, paintGamma, deviceGamma, data.get());
 
@@ skipping 1275 matching lines @@
 
     static BitmapTextBatch* Create(GrMaskFormat maskFormat, int glyphCount,
                                    GrBatchFontCache* fontCache) {
         return SkNEW_ARGS(BitmapTextBatch, (maskFormat, glyphCount, fontCache));
     }
 
     static BitmapTextBatch* Create(GrMaskFormat maskFormat, int glyphCount,
                                    GrBatchFontCache* fontCache,
                                    DistanceAdjustTable* distanceAdjustTable,
                                    SkColor filteredColor, bool useLCDText,
-                                   bool useBGR, float gamma) {
+                                   bool useBGR) {
         return SkNEW_ARGS(BitmapTextBatch, (maskFormat, glyphCount, fontCache, distanceAdjustTable,
-                                            filteredColor, useLCDText, useBGR, gamma));
+                                            filteredColor, useLCDText, useBGR));
     }
 
     const char* name() const override { return "BitmapTextBatch"; }
 
     void getInvariantOutputColor(GrInitInvariantOutput* out) const override {
         if (kARGB_GrMaskFormat == fMaskFormat) {
             out->setUnknownFourComponents();
         } else {
             out->setKnownFourComponents(fBatch.fColor);
         }
@@ skipping 300 matching lines @@
             , fFontCache(fontCache)
             , fUseDistanceFields(false) {
         this->initClassID<BitmapTextBatch>();
         fBatch.fNumGlyphs = glyphCount;
         fInstanceCount = 1;
         fAllocatedCount = kMinAllocated;
     }
 
     BitmapTextBatch(GrMaskFormat maskFormat, int glyphCount, GrBatchFontCache* fontCache,
                     DistanceAdjustTable* distanceAdjustTable, SkColor filteredColor,
-                    bool useLCDText, bool useBGR, float gamma)
+                    bool useLCDText, bool useBGR)
             : fMaskFormat(maskFormat)
             , fPixelConfig(fontCache->getPixelConfig(maskFormat))
             , fFontCache(fontCache)
             , fDistanceAdjustTable(SkRef(distanceAdjustTable))
             , fFilteredColor(filteredColor)
             , fUseDistanceFields(true)
             , fUseLCDText(useLCDText)
-            , fUseBGR(useBGR)
-            , fGamma(gamma) {
+            , fUseBGR(useBGR) {
         this->initClassID<BitmapTextBatch>();
         fBatch.fNumGlyphs = glyphCount;
         fInstanceCount = 1;
         fAllocatedCount = kMinAllocated;
         SkASSERT(fMaskFormat == kA8_GrMaskFormat);
     }
 
     ~BitmapTextBatch() {
         for (int i = 0; i < fInstanceCount; i++) {
             fGeoData[i].fBlob->unref();
@@ skipping 109 matching lines @@
             }
 
             if (fUseLCDText != that->fUseLCDText) {
                 return false;
             }
 
             if (fUseBGR != that->fUseBGR) {
                 return false;
             }
 
-            if (fGamma != that->fGamma) {
-                return false;
-            }
-
             // TODO see note above
             if (fUseLCDText && this->color() != that->color()) {
                 return false;
             }
         }
 
         fBatch.fNumGlyphs += that->numGlyphs();
 
         // copy that->geoData().  We do this manually for performance reasons
         SkAutoSTMalloc<kMinAllocated, Geometry>* otherGeoData = that->geoData();
@@ skipping 50 matching lines @@
             return GrDistanceFieldLCDTextGeoProc::Create(color,
                                                          viewMatrix,
                                                          texture,
                                                          params,
                                                          widthAdjust,
                                                          flags,
                                                          this->usesLocalCoords());
         } else {
             flags |= kColorAttr_DistanceFieldEffectFlag;
 #ifdef SK_GAMMA_APPLY_TO_A8
-            U8CPU lum = SkColorSpaceLuminance::computeLuminance(fGamma, filteredColor);
+            U8CPU lum = SkColorSpaceLuminance::computeLuminance(SK_GAMMA_EXPONENT, filteredColor);
             float correction = (*fDistanceAdjustTable)[lum >> kDistanceAdjustLumShift];
             return GrDistanceFieldA8TextGeoProc::Create(color,
                                                         viewMatrix,
                                                         texture,
                                                         params,
                                                         correction,
                                                         flags,
                                                         this->usesLocalCoords());
 #else
             return GrDistanceFieldA8TextGeoProc::Create(color,
@@ skipping 18 matching lines @@
 
     BatchTracker fBatch;
     SkAutoSTMalloc<kMinAllocated, Geometry> fGeoData;
     int fInstanceCount;
     int fAllocatedCount;
     GrMaskFormat fMaskFormat;
     GrPixelConfig fPixelConfig;
     GrBatchFontCache* fFontCache;
 
     // Distance field properties
-    SkAutoTUnref<DistanceAdjustTable> fDistanceAdjustTable;
+    SkAutoTUnref<const DistanceAdjustTable> fDistanceAdjustTable;
     SkColor fFilteredColor;
     bool fUseDistanceFields;
     bool fUseLCDText;
     bool fUseBGR;
-    float fGamma;
 };
 
 void GrAtlasTextContext::flushRunAsPaths(GrRenderTarget* rt, const SkTextBlob::RunIterator& it, 
                                          const GrClip& clip, const SkPaint& skPaint,
                                          SkDrawFilter* drawFilter, const SkMatrix& viewMatrix,
                                          const SkIRect& clipBounds, SkScalar x, SkScalar y) {
     SkPaint runPaint = skPaint;
 
     size_t textLen = it.glyphCount() * sizeof(uint16_t);
     const SkPoint& offset = it.offset();
@@ skipping 44 matching lines @@
     BitmapTextBatch* batch;
     if (info.fDrawAsDistanceFields) {
         SkColor filteredColor;
         SkColorFilter* colorFilter = skPaint.getColorFilter();
         if (colorFilter) {
             filteredColor = colorFilter->filterColor(skPaint.getColor());
         } else {
             filteredColor = skPaint.getColor();
         }
         bool useBGR = SkPixelGeometryIsBGR(fDeviceProperties.pixelGeometry());
-        float gamma = fDeviceProperties.gamma();
         batch = BitmapTextBatch::Create(format, glyphCount, fContext->getBatchFontCache(),
                                         fDistanceAdjustTable, filteredColor,
-                                        info.fUseLCDText, useBGR,
-                                        gamma);
+                                        info.fUseLCDText, useBGR);
     } else {
         batch = BitmapTextBatch::Create(format, glyphCount, fContext->getBatchFontCache());
     }
     BitmapTextBatch::Geometry& geometry = batch->geometry();
     geometry.fBlob = SkRef(cacheBlob);
     geometry.fRun = run;
     geometry.fSubRun = subRun;
     geometry.fColor = subRunColor;
     geometry.fTransX = transX;
     geometry.fTransY = transY;
@@ skipping 159 matching lines @@
             gTextContext->createDrawTextBlob(rt, clip, grPaint, skPaint, viewMatrix, text,
                                              static_cast<size_t>(textLen), 0, 0, noClip));
 
     SkScalar transX = static_cast<SkScalar>(random->nextU());
     SkScalar transY = static_cast<SkScalar>(random->nextU());
     const GrAtlasTextContext::BitmapTextBlob::Run::SubRunInfo& info = blob->fRuns[0].fSubRunInfo[0];
     return gTextContext->createBatch(blob, info, textLen, 0, 0, color, transX, transY, skPaint);
 }
 
 #endif