Add GPU support for color bitmap fonts

src/gpu/GrTextStrike.cpp

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAtlas.h"
 #include "GrGpu.h"
 #include "GrRectanizer.h"
@@ skipping 10 matching lines @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #define FONT_CACHE_STATS 0
 #if FONT_CACHE_STATS
 static int g_PurgeCount = 0;
 #endif
 
 GrFontCache::GrFontCache(GrGpu* gpu) : fGpu(gpu) {
     gpu->ref();
-    for (int i = 0; i < kMaskFormatCount; ++i) {
+    for (int i = 0; i < kAtlasCount; ++i) {
         fAtlasMgr[i] = NULL;
     }
 
     fHead = fTail = NULL;
 }
 
 GrFontCache::~GrFontCache() {
     fCache.deleteAll();
-    for (int i = 0; i < kMaskFormatCount; ++i) {
+    for (int i = 0; i < kAtlasCount; ++i) {
         delete fAtlasMgr[i];
     }
     fGpu->unref();
 #if FONT_CACHE_STATS
       GrPrintf("Num purges: %d\n", g_PurgeCount);
 #endif
 }
 
 static GrPixelConfig mask_format_to_pixel_config(GrMaskFormat format) {
-    switch (format) {
-        case kA8_GrMaskFormat:
-            return kAlpha_8_GrPixelConfig;
-        case kA565_GrMaskFormat:
-            return kRGB_565_GrPixelConfig;
-        case kA888_GrMaskFormat:
-            return kSkia8888_GrPixelConfig;
-        default:
-            SkDEBUGFAIL("unknown maskformat");
-    }
-    return kUnknown_GrPixelConfig;
+    static const GrPixelConfig sPixelConfigs[] = { 
+        kAlpha_8_GrPixelConfig, 
+        kRGB_565_GrPixelConfig, 
+        kSkia8888_GrPixelConfig,
+        kSkia8888_GrPixelConfig
+    };
+    SK_COMPILE_ASSERT(SK_ARRAY_COUNT(sPixelConfigs) == kMaskFormatCount, array_size_mismatch);
+
+    return sPixelConfigs[format];
+}
+
+static int mask_format_to_atlas_index(GrMaskFormat format) {
+    static const int sAtlasIndices[] = { 
+        GrFontCache::kA8_AtlasType, 
+        GrFontCache::k565_AtlasType, 
+        GrFontCache::k8888_AtlasType, 
+        GrFontCache::k8888_AtlasType 
+    };
+    SK_COMPILE_ASSERT(SK_ARRAY_COUNT(sAtlasIndices) == kMaskFormatCount, array_size_mismatch);
+
+    SkASSERT(sAtlasIndices[format] < GrFontCache::kAtlasCount);
+    return sAtlasIndices[format];
 }
 
 GrTextStrike* GrFontCache::generateStrike(GrFontScaler* scaler,
                                           const Key& key) {
     GrMaskFormat format = scaler->getMaskFormat();
     GrPixelConfig config = mask_format_to_pixel_config(format);
-    if (NULL == fAtlasMgr[format]) {
-        fAtlasMgr[format] = SkNEW_ARGS(GrAtlasMgr, (fGpu, config));
+    int atlasIndex = mask_format_to_atlas_index(format);
+    if (NULL == fAtlasMgr[atlasIndex]) {
+        fAtlasMgr[atlasIndex] = SkNEW_ARGS(GrAtlasMgr, (fGpu, config));
     }
     GrTextStrike* strike = SkNEW_ARGS(GrTextStrike,
-                                      (this, scaler->getKey(), format, fAtlasMgr[format]));
+                                      (this, scaler->getKey(), format, fAtlasMgr[atlasIndex]));
     fCache.insert(key, strike);
 
     if (fHead) {
         fHead->fPrev = strike;
     } else {
         SkASSERT(NULL == fTail);
         fTail = strike;
     }
     strike->fPrev = NULL;
     strike->fNext = fHead;
     fHead = strike;
 
     return strike;
 }
 
 void GrFontCache::freeAll() {
     fCache.deleteAll();
-    for (int i = 0; i < kMaskFormatCount; ++i) {
+    for (int i = 0; i < kAtlasCount; ++i) {
         delete fAtlasMgr[i];
         fAtlasMgr[i] = NULL;
     }
     fHead = NULL;
     fTail = NULL;
 }
 
 void GrFontCache::purgeStrike(GrTextStrike* strike) {
     const GrFontCache::Key key(strike->fFontScalerKey);
     fCache.remove(key, strike);
@@ skipping 70 matching lines @@
         count2 += 1;
         strike = strike->fPrev;
     }
     SkASSERT(count == count2);
 }
 #endif
 
 #ifdef SK_DEVELOPER
 void GrFontCache::dump() const {
     static int gDumpCount = 0;
-    for (int i = 0; i < kMaskFormatCount; ++i) {
+    for (int i = 0; i < kAtlasCount; ++i) {
         if (NULL != fAtlasMgr[i]) {
             GrTexture* texture = fAtlasMgr[i]->getTexture();
             if (NULL != texture) {
                 SkString filename;
                 filename.printf("fontcache_%d%d.png", gDumpCount, i);
                 texture->savePixels(filename.c_str());
             }
         }
     }
     ++gDumpCount;
@@ skipping 210 matching lines @@
     }
 #endif
 
     if (NULL == plot) {
         return false;
     }
 
     glyph->fPlot = plot;
     return true;
 }