Remove lookup3 gamma code

Also clean up gamma / glyph cache properties

Change-Id: I75b1ac0cb55638bf787ffd3cf457483ae314f03b

11 files changed, 60 insertions, 340 deletions

diff --git a/libs/hwui/Caches.cpp b/libs/hwui/Caches.cpp
index ff713133e389..7c63e316ba38 100644
--- a/libs/hwui/Caches.cpp
+++ b/libs/hwui/Caches.cpp
@@ -54,7 +54,6 @@ Caches::Caches(RenderState& renderState)
         , mInitialized(false) {
     INIT_LOGD("Creating OpenGL renderer caches");
     init();
-    initFont();
     initConstraints();
     initStaticProperties();
     initExtensions();
@@ -78,10 +77,6 @@ bool Caches::init() {
     return true;
 }
 
-void Caches::initFont() {
-    fontRenderer = GammaFontRenderer::createRenderer();
-}
-
 void Caches::initExtensions() {
     if (mExtensions.hasDebugMarker()) {
         eventMark = glInsertEventMarkerEXT;
@@ -100,15 +95,9 @@ void Caches::initConstraints() {
 }
 
 void Caches::initStaticProperties() {
-    gpuPixelBuffersEnabled = false;
-
     // OpenGL ES 3.0+ specific features
-    if (mExtensions.hasPixelBufferObjects()) {
-        char property[PROPERTY_VALUE_MAX];
-        if (property_get(PROPERTY_ENABLE_GPU_PIXEL_BUFFERS, property, "true") > 0) {
-            gpuPixelBuffersEnabled = !strcmp(property, "true");
-        }
-    }
+    gpuPixelBuffersEnabled = mExtensions.hasPixelBufferObjects()
+            && property_get_bool(PROPERTY_ENABLE_GPU_PIXEL_BUFFERS, true);
 }
 
 void Caches::terminate() {
@@ -203,14 +192,14 @@ void Caches::dumpMemoryUsage(String8 &log) {
             dropShadowCache.getMaxSize());
     log.appendFormat("  PatchCache           %8d / %8d\n",
             patchCache.getSize(), patchCache.getMaxSize());
-    for (uint32_t i = 0; i < fontRenderer->getFontRendererCount(); i++) {
-        const uint32_t sizeA8 = fontRenderer->getFontRendererSize(i, GL_ALPHA);
-        const uint32_t sizeRGBA = fontRenderer->getFontRendererSize(i, GL_RGBA);
-        log.appendFormat("  FontRenderer %d A8    %8d / %8d\n", i, sizeA8, sizeA8);
-        log.appendFormat("  FontRenderer %d RGBA  %8d / %8d\n", i, sizeRGBA, sizeRGBA);
-        log.appendFormat("  FontRenderer %d total %8d / %8d\n", i, sizeA8 + sizeRGBA,
-                sizeA8 + sizeRGBA);
-    }
+
+    const uint32_t sizeA8 = fontRenderer.getFontRendererSize(GL_ALPHA);
+    const uint32_t sizeRGBA = fontRenderer.getFontRendererSize(GL_RGBA);
+    log.appendFormat("  FontRenderer A8    %8d / %8d\n", sizeA8, sizeA8);
+    log.appendFormat("  FontRenderer RGBA  %8d / %8d\n", sizeRGBA, sizeRGBA);
+    log.appendFormat("  FontRenderer total %8d / %8d\n", sizeA8 + sizeRGBA,
+            sizeA8 + sizeRGBA);
+
     log.appendFormat("Other:\n");
     log.appendFormat("  FboCache             %8d / %8d\n",
             fboCache.getSize(), fboCache.getMaxSize());
@@ -222,10 +211,8 @@ void Caches::dumpMemoryUsage(String8 &log) {
     total += tessellationCache.getSize();
     total += dropShadowCache.getSize();
     total += patchCache.getSize();
-    for (uint32_t i = 0; i < fontRenderer->getFontRendererCount(); i++) {
-        total += fontRenderer->getFontRendererSize(i, GL_ALPHA);
-        total += fontRenderer->getFontRendererSize(i, GL_RGBA);
-    }
+    total += fontRenderer.getFontRendererSize(GL_ALPHA);
+    total += fontRenderer.getFontRendererSize(GL_RGBA);
 
     log.appendFormat("Total memory usage:\n");
     log.appendFormat("  %d bytes, %.2f MB\n", total, total / 1024.0f / 1024.0f);
@@ -250,12 +237,12 @@ void Caches::flush(FlushMode mode) {
             patchCache.clear();
             dropShadowCache.clear();
             gradientCache.clear();
-            fontRenderer->clear();
+            fontRenderer.clear();
             fboCache.clear();
             dither.clear();
             // fall through
         case FlushMode::Moderate:
-            fontRenderer->flush();
+            fontRenderer.flush();
             textureCache.flush();
             pathCache.clear();
             tessellationCache.clear();
diff --git a/libs/hwui/Caches.h b/libs/hwui/Caches.h
index 929db17a22a8..61e958d42148 100644
--- a/libs/hwui/Caches.h
+++ b/libs/hwui/Caches.h
@@ -21,6 +21,7 @@
 #include "Dither.h"
 #include "Extensions.h"
 #include "FboCache.h"
+#include "GammaFontRenderer.h"
 #include "GradientCache.h"
 #include "LayerCache.h"
 #include "PatchCache.h"
@@ -53,8 +54,6 @@
 namespace android {
 namespace uirenderer {
 
-class GammaFontRenderer;
-
 ///////////////////////////////////////////////////////////////////////////////
 // Caches
 ///////////////////////////////////////////////////////////////////////////////
@@ -156,7 +155,7 @@ public:
     TextDropShadowCache dropShadowCache;
     FboCache fboCache;
 
-    GammaFontRenderer* fontRenderer;
+    GammaFontRenderer fontRenderer;
 
     TaskManager tasks;
 
@@ -178,8 +177,6 @@ public:
     TextureState& textureState() { return *mTextureState; }
 
 private:
-
-    void initFont();
     void initExtensions();
     void initConstraints();
     void initStaticProperties();
diff --git a/libs/hwui/DeferredDisplayList.cpp b/libs/hwui/DeferredDisplayList.cpp
index 9fb1e756c00d..a81ffb9f59fa 100644
--- a/libs/hwui/DeferredDisplayList.cpp
+++ b/libs/hwui/DeferredDisplayList.cpp
@@ -631,7 +631,7 @@ static void replayBatchList(const std::vector<Batch*>& batchList,
 
 void DeferredDisplayList::flush(OpenGLRenderer& renderer, Rect& dirty) {
     ATRACE_NAME("flush drawing commands");
-    Caches::getInstance().fontRenderer->endPrecaching();
+    Caches::getInstance().fontRenderer.endPrecaching();
 
     if (isEmpty()) return; // nothing to flush
     renderer.restoreToCount(1);
diff --git a/libs/hwui/DisplayListOp.h b/libs/hwui/DisplayListOp.h
index 14126a9e31a7..dc5cb8b349f1 100644
--- a/libs/hwui/DisplayListOp.h
+++ b/libs/hwui/DisplayListOp.h
@@ -1246,7 +1246,7 @@ public:
 
     virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo,
             const DeferredDisplayState& state) override {
-        FontRenderer& fontRenderer = renderer.getCaches().fontRenderer->getFontRenderer(mPaint);
+        FontRenderer& fontRenderer = renderer.getCaches().fontRenderer.getFontRenderer();
         fontRenderer.precache(mPaint, mText, mCount, SkMatrix::I());
 
         deferInfo.batchId = mPaint->getColor() == SK_ColorBLACK ?
@@ -1311,7 +1311,7 @@ public:
 
     virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo,
             const DeferredDisplayState& state) override {
-        FontRenderer& fontRenderer = renderer.getCaches().fontRenderer->getFontRenderer(mPaint);
+        FontRenderer& fontRenderer = renderer.getCaches().fontRenderer.getFontRenderer();
         SkMatrix transform;
         renderer.findBestFontTransform(state.mMatrix, &transform);
         if (mPrecacheTransform != transform) {
diff --git a/libs/hwui/FontRenderer.cpp b/libs/hwui/FontRenderer.cpp
index 75c3ead68f7b..4b9d4f90675c 100644
--- a/libs/hwui/FontRenderer.cpp
+++ b/libs/hwui/FontRenderer.cpp
@@ -75,8 +75,8 @@ void TextDrawFunctor::draw(CacheTexture& texture, bool linearFiltering) {
 
 static bool sLogFontRendererCreate = true;
 
-FontRenderer::FontRenderer()
-        : mGammaTable(nullptr)
+FontRenderer::FontRenderer(const uint8_t* gammaTable)
+        : mGammaTable(gammaTable)
         , mCurrentFont(nullptr)
         , mActiveFonts(LruCache<Font::FontDescription, Font*>::kUnlimitedCapacity)
         , mCurrentCacheTexture(nullptr)
@@ -92,27 +92,15 @@ FontRenderer::FontRenderer()
         INIT_LOGD("Creating FontRenderer");
     }
 
-    mSmallCacheWidth = DEFAULT_TEXT_SMALL_CACHE_WIDTH;
-    mSmallCacheHeight = DEFAULT_TEXT_SMALL_CACHE_HEIGHT;
-    mLargeCacheWidth = DEFAULT_TEXT_LARGE_CACHE_WIDTH;
-    mLargeCacheHeight = DEFAULT_TEXT_LARGE_CACHE_HEIGHT;
+    mSmallCacheWidth = property_get_int32(PROPERTY_TEXT_SMALL_CACHE_WIDTH,
+            DEFAULT_TEXT_SMALL_CACHE_WIDTH);
+    mSmallCacheHeight = property_get_int32(PROPERTY_TEXT_SMALL_CACHE_HEIGHT,
+            DEFAULT_TEXT_SMALL_CACHE_HEIGHT);
 
-    char property[PROPERTY_VALUE_MAX];
-    if (property_get(PROPERTY_TEXT_SMALL_CACHE_WIDTH, property, nullptr) > 0) {
-        mSmallCacheWidth = atoi(property);
-    }
-
-    if (property_get(PROPERTY_TEXT_SMALL_CACHE_HEIGHT, property, nullptr) > 0) {
-        mSmallCacheHeight = atoi(property);
-    }
-
-    if (property_get(PROPERTY_TEXT_LARGE_CACHE_WIDTH, property, nullptr) > 0) {
-        mLargeCacheWidth = atoi(property);
-    }
-
-    if (property_get(PROPERTY_TEXT_LARGE_CACHE_HEIGHT, property, nullptr) > 0) {
-        mLargeCacheHeight = atoi(property);
-    }
+    mLargeCacheWidth = property_get_int32(PROPERTY_TEXT_LARGE_CACHE_WIDTH,
+            DEFAULT_TEXT_LARGE_CACHE_WIDTH);
+    mLargeCacheHeight = property_get_int32(PROPERTY_TEXT_LARGE_CACHE_HEIGHT,
+            DEFAULT_TEXT_LARGE_CACHE_HEIGHT);
 
     uint32_t maxTextureSize = (uint32_t) Caches::getInstance().maxTextureSize;
 
diff --git a/libs/hwui/FontRenderer.h b/libs/hwui/FontRenderer.h
index 2954975b1413..936c838bd6e4 100644
--- a/libs/hwui/FontRenderer.h
+++ b/libs/hwui/FontRenderer.h
@@ -72,16 +72,12 @@ public:
 
 class FontRenderer {
 public:
-    FontRenderer();
+    FontRenderer(const uint8_t* gammaTable);
     ~FontRenderer();
 
     void flushLargeCaches(std::vector<CacheTexture*>& cacheTextures);
     void flushLargeCaches();
 
-    void setGammaTable(const uint8_t* gammaTable) {
-        mGammaTable = gammaTable;
-    }
-
     void setFont(const SkPaint* paint, const SkMatrix& matrix);
 
     void precache(const SkPaint* paint, const char* text, int numGlyphs, const SkMatrix& matrix);
diff --git a/libs/hwui/GammaFontRenderer.cpp b/libs/hwui/GammaFontRenderer.cpp
index 6c3d04e7400e..96cac86386b5 100644
--- a/libs/hwui/GammaFontRenderer.cpp
+++ b/libs/hwui/GammaFontRenderer.cpp
@@ -21,183 +21,22 @@
 namespace android {
 namespace uirenderer {
 
-///////////////////////////////////////////////////////////////////////////////
-// Utils
-///////////////////////////////////////////////////////////////////////////////
-
-static int luminance(const SkPaint* paint) {
-    uint32_t c = paint->getColor();
-    const int r = (c >> 16) & 0xFF;
-    const int g = (c >>  8) & 0xFF;
-    const int b = (c      ) & 0xFF;
-    return (r * 2 + g * 5 + b) >> 3;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// Base class GammaFontRenderer
-///////////////////////////////////////////////////////////////////////////////
-
-GammaFontRenderer* GammaFontRenderer::createRenderer() {
-    // Choose the best renderer
-    char property[PROPERTY_VALUE_MAX];
-    if (property_get(PROPERTY_TEXT_GAMMA_METHOD, property, DEFAULT_TEXT_GAMMA_METHOD) > 0) {
-        if (!strcasecmp(property, "lookup")) {
-            return new LookupGammaFontRenderer();
-        }
-    }
-
-    return new Lookup3GammaFontRenderer();
-}
-
 GammaFontRenderer::GammaFontRenderer() {
-    // Get the renderer properties
-    char property[PROPERTY_VALUE_MAX];
-
-    // Get the gamma
-    mGamma = DEFAULT_TEXT_GAMMA;
-    if (property_get(PROPERTY_TEXT_GAMMA, property, nullptr) > 0) {
-        INIT_LOGD("  Setting text gamma to %s", property);
-        mGamma = atof(property);
-    } else {
-        INIT_LOGD("  Using default text gamma of %.2f", DEFAULT_TEXT_GAMMA);
-    }
-
-    // Get the black gamma threshold
-    mBlackThreshold = DEFAULT_TEXT_BLACK_GAMMA_THRESHOLD;
-    if (property_get(PROPERTY_TEXT_BLACK_GAMMA_THRESHOLD, property, nullptr) > 0) {
-        INIT_LOGD("  Setting text black gamma threshold to %s", property);
-        mBlackThreshold = atoi(property);
-    } else {
-        INIT_LOGD("  Using default text black gamma threshold of %d",
-                DEFAULT_TEXT_BLACK_GAMMA_THRESHOLD);
-    }
-
-    // Get the white gamma threshold
-    mWhiteThreshold = DEFAULT_TEXT_WHITE_GAMMA_THRESHOLD;
-    if (property_get(PROPERTY_TEXT_WHITE_GAMMA_THRESHOLD, property, nullptr) > 0) {
-        INIT_LOGD("  Setting text white gamma threshold to %s", property);
-        mWhiteThreshold = atoi(property);
-    } else {
-        INIT_LOGD("  Using default white black gamma threshold of %d",
-                DEFAULT_TEXT_WHITE_GAMMA_THRESHOLD);
-    }
-}
-
-GammaFontRenderer::~GammaFontRenderer() {
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// Lookup-based renderer
-///////////////////////////////////////////////////////////////////////////////
-
-LookupGammaFontRenderer::LookupGammaFontRenderer()
-        : GammaFontRenderer() {
     INIT_LOGD("Creating lookup gamma font renderer");
 
     // Compute the gamma tables
-    const float gamma = 1.0f / mGamma;
+    const float gamma = 1.0f / Properties::textGamma;
 
     for (uint32_t i = 0; i <= 255; i++) {
         mGammaTable[i] = uint8_t((float)::floor(pow(i / 255.0f, gamma) * 255.0f + 0.5f));
     }
-
-    mRenderer = nullptr;
 }
 
-void LookupGammaFontRenderer::endPrecaching() {
+void GammaFontRenderer::endPrecaching() {
     if (mRenderer) {
         mRenderer->endPrecaching();
     }
 }
 
-///////////////////////////////////////////////////////////////////////////////
-// Lookup-based renderer, using 3 different correction tables
-///////////////////////////////////////////////////////////////////////////////
-
-Lookup3GammaFontRenderer::Lookup3GammaFontRenderer()
-        : GammaFontRenderer() {
-    INIT_LOGD("Creating lookup3 gamma font renderer");
-
-    // Compute the gamma tables
-    const float blackGamma = mGamma;
-    const float whiteGamma = 1.0f / mGamma;
-
-    for (uint32_t i = 0; i <= 255; i++) {
-        const float v = i / 255.0f;
-        const float black = pow(v, blackGamma);
-        const float white = pow(v, whiteGamma);
-
-        mGammaTable[i] = i;
-        mGammaTable[256 + i] = uint8_t((float)::floor(black * 255.0f + 0.5f));
-        mGammaTable[512 + i] = uint8_t((float)::floor(white * 255.0f + 0.5f));
-    }
-
-    memset(mRenderers, 0, sizeof(FontRenderer*) * kGammaCount);
-    memset(mRenderersUsageCount, 0, sizeof(uint32_t) * kGammaCount);
-}
-
-void Lookup3GammaFontRenderer::endPrecaching() {
-    for (int i = 0; i < kGammaCount; i++) {
-        if (mRenderers[i]) {
-            mRenderers[i]->endPrecaching();
-        }
-    }
-}
-
-void Lookup3GammaFontRenderer::clear() {
-    for (int i = 0; i < kGammaCount; i++) {
-        mRenderers[i].release();
-    }
-}
-
-void Lookup3GammaFontRenderer::flush() {
-    int count = 0;
-    int min = -1;
-    uint32_t minCount = UINT_MAX;
-
-    for (int i = 0; i < kGammaCount; i++) {
-        if (mRenderers[i]) {
-            count++;
-            if (mRenderersUsageCount[i] < minCount) {
-                minCount = mRenderersUsageCount[i];
-                min = i;
-            }
-        }
-    }
-
-    if (count <= 1 || min < 0) return;
-
-    mRenderers[min].release();
-
-    // Also eliminate the caches for large glyphs, as they consume significant memory
-    for (int i = 0; i < kGammaCount; ++i) {
-        if (mRenderers[i]) {
-            mRenderers[i]->flushLargeCaches();
-        }
-    }
-}
-
-FontRenderer* Lookup3GammaFontRenderer::getRenderer(Gamma gamma) {
-    if (!mRenderers[gamma]) {
-        mRenderers[gamma].reset(new FontRenderer());
-        mRenderers[gamma]->setGammaTable(&mGammaTable[gamma * 256]);
-    }
-    mRenderersUsageCount[gamma]++;
-    return mRenderers[gamma].get();
-}
-
-FontRenderer& Lookup3GammaFontRenderer::getFontRenderer(const SkPaint* paint) {
-    if (paint->getShader() == nullptr) {
-        const int l = luminance(paint);
-
-        if (l <= mBlackThreshold) {
-            return *getRenderer(kGammaBlack);
-        } else if (l >= mWhiteThreshold) {
-            return *getRenderer(kGammaWhite);
-        }
-    }
-    return *getRenderer(kGammaDefault);
-}
-
 }; // namespace uirenderer
 }; // namespace android
diff --git a/libs/hwui/GammaFontRenderer.h b/libs/hwui/GammaFontRenderer.h
index 03f25106de38..146d385e1173 100644
--- a/libs/hwui/GammaFontRenderer.h
+++ b/libs/hwui/GammaFontRenderer.h
@@ -17,122 +17,44 @@
 #ifndef ANDROID_HWUI_GAMMA_FONT_RENDERER_H
 #define ANDROID_HWUI_GAMMA_FONT_RENDERER_H
 
-#include <SkPaint.h>
-
 #include "FontRenderer.h"
 #include "Program.h"
 
+#include <SkPaint.h>
+
 namespace android {
 namespace uirenderer {
 
 class GammaFontRenderer {
 public:
-    virtual ~GammaFontRenderer();
-
-    virtual void clear() = 0;
-    virtual void flush() = 0;
-
-    virtual FontRenderer& getFontRenderer(const SkPaint* paint) = 0;
-
-    virtual uint32_t getFontRendererCount() const = 0;
-    virtual uint32_t getFontRendererSize(uint32_t fontRenderer, GLenum format) const = 0;
-
-    virtual void endPrecaching() = 0;
-
-    static GammaFontRenderer* createRenderer();
-
-protected:
     GammaFontRenderer();
 
-    int mBlackThreshold;
-    int mWhiteThreshold;
-
-    float mGamma;
-};
-
-class LookupGammaFontRenderer: public GammaFontRenderer {
-public:
-    ~LookupGammaFontRenderer() {
-        delete mRenderer;
+    void clear() {
+        mRenderer.release();
     }
 
-    void clear() override {
-        delete mRenderer;
-        mRenderer = nullptr;
-    }
-
-    void flush() override {
+    void flush() {
         if (mRenderer) {
             mRenderer->flushLargeCaches();
         }
     }
 
-    FontRenderer& getFontRenderer(const SkPaint* paint) override {
+    FontRenderer& getFontRenderer() {
         if (!mRenderer) {
-            mRenderer = new FontRenderer;
-            mRenderer->setGammaTable(&mGammaTable[0]);
+            mRenderer.reset(new FontRenderer(&mGammaTable[0]));
         }
         return *mRenderer;
     }
 
-    uint32_t getFontRendererCount() const override {
-        return 1;
-    }
-
-    uint32_t getFontRendererSize(uint32_t fontRenderer, GLenum format) const override {
+    uint32_t getFontRendererSize(GLenum format) const {
         return mRenderer ? mRenderer->getCacheSize(format) : 0;
     }
 
-    void endPrecaching() override;
+    void endPrecaching();
 
 private:
-    LookupGammaFontRenderer();
-
-    FontRenderer* mRenderer;
+    std::unique_ptr<FontRenderer> mRenderer;
     uint8_t mGammaTable[256];
-
-    friend class GammaFontRenderer;
-};
-
-class Lookup3GammaFontRenderer: public GammaFontRenderer {
-public:
-    void clear() override;
-    void flush() override;
-
-    FontRenderer& getFontRenderer(const SkPaint* paint) override;
-
-    uint32_t getFontRendererCount() const override {
-        return kGammaCount;
-    }
-
-    uint32_t getFontRendererSize(uint32_t fontRenderer, GLenum format) const override {
-        if (fontRenderer >= kGammaCount) return 0;
-
-        if (!mRenderers[fontRenderer]) return 0;
-
-        return mRenderers[fontRenderer]->getCacheSize(format);
-    }
-
-    void endPrecaching() override;
-
-private:
-    Lookup3GammaFontRenderer();
-
-    enum Gamma {
-        kGammaDefault = 0,
-        kGammaBlack = 1,
-        kGammaWhite = 2,
-        kGammaCount = 3
-    };
-
-    FontRenderer* getRenderer(Gamma gamma);
-
-    uint32_t mRenderersUsageCount[kGammaCount];
-    std::unique_ptr<FontRenderer> mRenderers[kGammaCount];
-
-    uint8_t mGammaTable[256 * kGammaCount];
-
-    friend class GammaFontRenderer;
 };
 
 }; // namespace uirenderer
diff --git a/libs/hwui/OpenGLRenderer.cpp b/libs/hwui/OpenGLRenderer.cpp
index e06e34849a91..a401ce119021 100644
--- a/libs/hwui/OpenGLRenderer.cpp
+++ b/libs/hwui/OpenGLRenderer.cpp
@@ -2014,7 +2014,7 @@ void OpenGLRenderer::drawPosText(const char* text, int bytesCount, int count,
         y = floorf(y + currentTransform()->getTranslateY() + 0.5f);
     }
 
-    FontRenderer& fontRenderer = mCaches.fontRenderer->getFontRenderer(paint);
+    FontRenderer& fontRenderer = mCaches.fontRenderer.getFontRenderer();
     fontRenderer.setFont(paint, SkMatrix::I());
 
     int alpha;
@@ -2166,7 +2166,7 @@ void OpenGLRenderer::drawText(const char* text, int bytesCount, int count, float
     SkXfermode::Mode mode;
     getAlphaAndMode(paint, &alpha, &mode);
 
-    FontRenderer& fontRenderer = mCaches.fontRenderer->getFontRenderer(paint);
+    FontRenderer& fontRenderer = mCaches.fontRenderer.getFontRenderer();
 
     if (CC_UNLIKELY(hasTextShadow(paint))) {
         fontRenderer.setFont(paint, SkMatrix::I());
@@ -2234,7 +2234,7 @@ void OpenGLRenderer::drawTextOnPath(const char* text, int bytesCount, int count,
     // TODO: avoid scissor by calculating maximum bounds using path bounds + font metrics
     mRenderState.scissor().setEnabled(true);
 
-    FontRenderer& fontRenderer = mCaches.fontRenderer->getFontRenderer(paint);
+    FontRenderer& fontRenderer = mCaches.fontRenderer.getFontRenderer();
     fontRenderer.setFont(paint, SkMatrix::I());
     fontRenderer.setTextureFiltering(true);
 
diff --git a/libs/hwui/Properties.cpp b/libs/hwui/Properties.cpp
index b8f8585e5af6..36a8dac9d0c1 100644
--- a/libs/hwui/Properties.cpp
+++ b/libs/hwui/Properties.cpp
@@ -33,6 +33,8 @@ bool Properties::swapBuffersWithDamage = true;
 bool Properties::useBufferAge = true;
 bool Properties::enablePartialUpdates = true;
 
+float Properties::textGamma = DEFAULT_TEXT_GAMMA;
+
 DebugLevel Properties::debugLevel = kDebugDisabled;
 OverdrawColorSet Properties::overdrawColorSet = OverdrawColorSet::Default;
 StencilClipDebug Properties::debugStencilClip = StencilClipDebug::Hide;
@@ -47,6 +49,15 @@ int Properties::overrideSpotShadowStrength = -1;
 ProfileType Properties::sProfileType = ProfileType::None;
 bool Properties::sDisableProfileBars = false;
 
+static float property_get_float(const char* key, float defaultValue) {
+    char buf[PROPERTY_VALUE_MAX] = {'\0',};
+
+    if (property_get(PROPERTY_PROFILE, buf, "") > 0) {
+        return atof(buf);
+    }
+    return defaultValue;
+}
+
 bool Properties::load() {
     char property[PROPERTY_VALUE_MAX];
     bool prevDebugLayersUpdates = debugLayersUpdates;
@@ -110,6 +121,8 @@ bool Properties::load() {
     useBufferAge = property_get_bool(PROPERTY_USE_BUFFER_AGE, true);
     enablePartialUpdates = property_get_bool(PROPERTY_ENABLE_PARTIAL_UPDATES, true);
 
+    textGamma = property_get_float(PROPERTY_TEXT_GAMMA, DEFAULT_TEXT_GAMMA);
+
     return (prevDebugLayersUpdates != debugLayersUpdates)
             || (prevDebugOverdraw != debugOverdraw)
             || (prevDebugStencilClip != debugStencilClip);
diff --git a/libs/hwui/Properties.h b/libs/hwui/Properties.h
index 98834b8f561d..3512c36417e1 100644
--- a/libs/hwui/Properties.h
+++ b/libs/hwui/Properties.h
@@ -208,30 +208,8 @@ enum DebugLevel {
 #define PROPERTY_TEXT_LARGE_CACHE_WIDTH "ro.hwui.text_large_cache_width"
 #define PROPERTY_TEXT_LARGE_CACHE_HEIGHT "ro.hwui.text_large_cache_height"
 
-// Indicates whether gamma correction should be applied in the shaders
-// or in lookup tables. Accepted values:
-//
-//     - "lookup3", correction based on lookup tables. Gamma correction
-//        is different for black and white text (see thresholds below)
-//
-//     - "lookup", correction based on a single lookup table
-//
-//     - "shader3", correction applied by a GLSL shader. Gamma correction
-//        is different for black and white text (see thresholds below)
-//
-//     - "shader", correction applied by a GLSL shader
-//
-// See PROPERTY_TEXT_GAMMA, PROPERTY_TEXT_BLACK_GAMMA_THRESHOLD and
-// PROPERTY_TEXT_WHITE_GAMMA_THRESHOLD for more control.
-#define PROPERTY_TEXT_GAMMA_METHOD "hwui.text_gamma_correction"
-#define DEFAULT_TEXT_GAMMA_METHOD "lookup"
-
 // Gamma (>= 1.0, <= 10.0)
 #define PROPERTY_TEXT_GAMMA "hwui.text_gamma"
-// Luminance threshold below which black gamma correction is applied. Range: [0..255]
-#define PROPERTY_TEXT_BLACK_GAMMA_THRESHOLD "hwui.text_gamma.black_threshold"
-// Lumincance threshold above which white gamma correction is applied. Range: [0..255]
-#define PROPERTY_TEXT_WHITE_GAMMA_THRESHOLD "hwui.text_gamma.white_threshold"
 
 ///////////////////////////////////////////////////////////////////////////////
 // Default property values
@@ -250,8 +228,6 @@ enum DebugLevel {
 #define DEFAULT_TEXTURE_CACHE_FLUSH_RATE 0.6f
 
 #define DEFAULT_TEXT_GAMMA 1.4f
-#define DEFAULT_TEXT_BLACK_GAMMA_THRESHOLD 64
-#define DEFAULT_TEXT_WHITE_GAMMA_THRESHOLD 192
 
 ///////////////////////////////////////////////////////////////////////////////
 // Misc
@@ -300,6 +276,8 @@ public:
     static bool useBufferAge;
     static bool enablePartialUpdates;
 
+    static float textGamma;
+
     static DebugLevel debugLevel;
     static OverdrawColorSet overdrawColorSet;
     static StencilClipDebug debugStencilClip;