GPU Font Cache improvements:

src/gpu/GrAtlas.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.
  */
 
 
 
@@ skipping 26 matching lines @@
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #define BORDER      1
 
 #if GR_DEBUG
     static int gCounter;
 #endif
 
+// for testing
+#define FONT_CACHE_STATS 0
+#if FONT_CACHE_STATS
+static int g_UploadCount = 0;
+#endif
+
 GrAtlas::GrAtlas(GrAtlasMgr* mgr, int plotX, int plotY, GrMaskFormat format) {
     fAtlasMgr = mgr;    // just a pointer, not an owner
     fNext = NULL;
+    fUsed = false;
+
     fTexture = mgr->getTexture(format); // we're not an owner, just a pointer
     fPlot.set(plotX, plotY);
 
     fRects = GrRectanizer::Factory(GR_ATLAS_WIDTH - BORDER,
                                    GR_ATLAS_HEIGHT - BORDER);
 
     fMaskFormat = format;
 
 #if GR_DEBUG
 //    GrPrintf(" GrAtlas %p [%d %d] %d\n", this, plotX, plotY, gCounter);
     gCounter += 1;
 #endif
 }
 
 GrAtlas::~GrAtlas() {
-    fAtlasMgr->freePlot(fPlot.fX, fPlot.fY);
+    fAtlasMgr->freePlot(fMaskFormat, fPlot.fX, fPlot.fY);
 
     delete fRects;
 
 #if GR_DEBUG
     --gCounter;
 //    GrPrintf("~GrAtlas %p [%d %d] %d\n", this, fPlot.fX, fPlot.fY, gCounter);
 #endif
 }
 
+bool GrAtlas::RemoveUnusedAtlases(GrAtlasMgr* atlasMgr, GrAtlas** startAtlas) {
+    // GrAtlas** is used so that a pointer to the head element can be passed in and
+    // modified when the first element is deleted
+    GrAtlas** atlasRef = startAtlas;
+    GrAtlas* atlas = *startAtlas;
+    bool removed = false;
+    while (NULL != atlas) {
+        if (!atlas->used()) {
+            *atlasRef = atlas->fNext;
+            atlasMgr->deleteAtlas(atlas);
+            atlas = *atlasRef;
+            removed = true;
+        } else {
+            atlasRef = &atlas->fNext;
+            atlas = atlas->fNext;
+        }
+    }
+
+    return removed;
+}
+
 static void adjustForPlot(GrIPoint16* loc, const GrIPoint16& plot) {
     loc->fX += plot.fX * GR_ATLAS_WIDTH;
     loc->fY += plot.fY * GR_ATLAS_HEIGHT;
 }
 
 static uint8_t* zerofill(uint8_t* ptr, int count) {
     while (--count >= 0) {
         *ptr++ = 0;
     }
     return ptr;
@@ skipping 30 matching lines @@
     // smart and hasn't referenced the part of the texture we're about to update
     // since the last flush.
     context->writeTexturePixels(fTexture,
                                 loc->fX, loc->fY, dstW, dstH,
                                 fTexture->config(), image, 0,
                                 GrContext::kDontFlush_PixelOpsFlag);
 
     // now tell the caller to skip the top/left BORDER
     loc->fX += BORDER;
     loc->fY += BORDER;
+
+#if FONT_CACHE_STATS
+    ++g_UploadCount;
+#endif
+
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 GrAtlasMgr::GrAtlasMgr(GrGpu* gpu) {
     fGpu = gpu;
     gpu->ref();
     Gr_bzero(fTexture, sizeof(fTexture));
     fPlotMgr = SkNEW_ARGS(GrPlotMgr, (GR_PLOT_WIDTH, GR_PLOT_HEIGHT));
 }
 
 GrAtlasMgr::~GrAtlasMgr() {
     for (size_t i = 0; i < GR_ARRAY_COUNT(fTexture); i++) {
         GrSafeUnref(fTexture[i]);
     }
     delete fPlotMgr;
+
     fGpu->unref();
+#if FONT_CACHE_STATS
+      GrPrintf("Num uploads: %d\n", g_UploadCount);
+#endif
 }
 
 static GrPixelConfig maskformat2pixelconfig(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:
             GrAssert(!"unknown maskformat");
     }
     return kUnknown_GrPixelConfig;
 }
 
-GrAtlas* GrAtlasMgr::addToAtlas(GrAtlas* atlas,
+GrAtlas* GrAtlasMgr::addToAtlas(GrAtlas** atlas,
                                 int width, int height, const void* image,
                                 GrMaskFormat format,
                                 GrIPoint16* loc) {
-    GrAssert(NULL == atlas || atlas->getMaskFormat() == format);
+    GrAssert(NULL == *atlas || (*atlas)->getMaskFormat() == format);
 
-    if (atlas && atlas->addSubImage(width, height, image, loc)) {
-        return atlas;
+    // iterate through entire atlas list, see if we can find a hole
+    GrAtlas* atlasIter = *atlas;
+    while (atlasIter) {
+        if (atlasIter->addSubImage(width, height, image, loc)) {
+            return atlasIter;
+        }
+        atlasIter = atlasIter->fNext;
     }
 
     // If the above fails, then either we have no starting atlas, or the current
-    // one is full. Either way we need to allocate a new atlas
+    // atlas list is full. Either way we need to allocate a new atlas
 
     GrIPoint16 plot;
     if (!fPlotMgr->newPlot(&plot)) {
         return NULL;
     }
 
     GrAssert(0 == kA8_GrMaskFormat);
     GrAssert(1 == kA565_GrMaskFormat);
     if (NULL == fTexture[format]) {
         // TODO: Update this to use the cache rather than directly creating a texture.
         GrTextureDesc desc;
         desc.fFlags = kDynamicUpdate_GrTextureFlagBit;
         desc.fWidth = GR_ATLAS_TEXTURE_WIDTH;
         desc.fHeight = GR_ATLAS_TEXTURE_HEIGHT;
         desc.fConfig = maskformat2pixelconfig(format);
 
         fTexture[format] = fGpu->createTexture(desc, NULL, 0);
         if (NULL == fTexture[format]) {
             return NULL;
         }
     }
 
     GrAtlas* newAtlas = SkNEW_ARGS(GrAtlas, (this, plot.fX, plot.fY, format));
     if (!newAtlas->addSubImage(width, height, image, loc)) {
         delete newAtlas;
         return NULL;
     }
 
-    newAtlas->fNext = atlas;
+    // new atlas, put at head
+    newAtlas->fNext = *atlas;
+    *atlas = newAtlas;
+
     return newAtlas;
 }
 
-void GrAtlasMgr::freePlot(int x, int y) {
+void GrAtlasMgr::freePlot(GrMaskFormat format, int x, int y) {
     GrAssert(fPlotMgr->isBusy(x, y));
     fPlotMgr->freePlot(x, y);
 }