Add CPU backing store for GrAtlas to reduce texture uploads

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.
  */
 
 #include "GrAtlas.h"
 #include "GrContext.h"
@@ skipping 11 matching lines @@
 GrPlot::GrPlot() : fDrawToken(NULL, 0)
                  , fTexture(NULL)
                  , fRects(NULL)
                  , fAtlasMgr(NULL)
                  , fBytesPerPixel(1)
 {
     fOffset.set(0, 0);
 }
 
 GrPlot::~GrPlot() {
+    SkDELETE_ARRAY(fPlotData);
+    fPlotData = NULL;
     delete fRects;
 }
 
 void GrPlot::init(GrAtlasMgr* mgr, int offX, int offY, int width, int height, size_t bpp) {
     fRects = GrRectanizer::Factory(width, height);
     fAtlasMgr = mgr;
     fOffset.set(offX * width, offY * height);
     fBytesPerPixel = bpp;
+    fPlotData = NULL;
+    fDirtyRect.setEmpty();
+    fDirty = false;
 }
 
 static inline void adjust_for_offset(GrIPoint16* loc, const GrIPoint16& offset) {
     loc->fX += offset.fX;
     loc->fY += offset.fY;
 }
 
 bool GrPlot::addSubImage(int width, int height, const void* image,
                           GrIPoint16* loc) {
+    float percentFull = fRects->percentFull();
     if (!fRects->addRect(width, height, loc)) {
         return false;
     }
 
-    SkAutoSMalloc<1024> storage;
-    adjust_for_offset(loc, fOffset);
-    GrContext* context = fTexture->getContext();
-    // We pass the flag that does not force a flush. We assume our caller is
-    // 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, width, height,
-                                fTexture->config(), image, 0,
-                                GrContext::kDontFlush_PixelOpsFlag);
+    // create backing memory on first use

[robertphillips, 2014/05/12 19:45:52]

// Once the plot is nearly full we will revert to uploading each subimage
individually

[jvanverth1, 2014/05/12 20:44:04]

Done.

+    int plotWidth = fRects->width();
+    int plotHeight = fRects->height();
+    if (NULL == fPlotData && 0.0f == percentFull) {
+        fPlotData = SkNEW_ARRAY(unsigned char, fBytesPerPixel*plotWidth*plotHeight);
+        memset(fPlotData, 0, fBytesPerPixel*plotWidth*plotHeight);
+    }
+
+    // if we have backing memory, copy to the memory and set for future upload
+    if (NULL != fPlotData) {

[robertphillips, 2014/05/12 19:45:52]

const unsigned char* ?

[jvanverth1, 2014/05/12 20:44:04]

Done.

+        unsigned char* imagePtr = (unsigned char*) image;
+        // point ourselves at the right starting spot
+        unsigned char* dataPtr = fPlotData;
+        dataPtr += fBytesPerPixel*plotWidth*loc->fY;
+        dataPtr += fBytesPerPixel*loc->fX;
+        // copy into the data buffer
+        for (int i = 0; i < height; ++i) {
+            memcpy(dataPtr, imagePtr, fBytesPerPixel*width);
+            dataPtr += fBytesPerPixel*plotWidth;
+            imagePtr += fBytesPerPixel*width;
+        }
+
+        fDirtyRect.join(loc->fX, loc->fY, loc->fX + width, loc->fY + height);
+        adjust_for_offset(loc, fOffset);
+        fDirty = true;
+    // otherwise, just upload the image directly
+    } else {
+        adjust_for_offset(loc, fOffset);
+        GrContext* context = fTexture->getContext();
+        context->writeTexturePixels(fTexture,
+                                    loc->fX, loc->fY, width, height,
+                                    fTexture->config(), image, 0,
+                                    GrContext::kDontFlush_PixelOpsFlag);
+    }
 
 #if FONT_CACHE_STATS
     ++g_UploadCount;
 #endif
 
     return true;
 }
 
+void GrPlot::uploadToTexture() {
+    if (fDirty && NULL != fTexture) {
+        GrContext* context = fTexture->getContext();
+        // We pass the flag that does not force a flush. We assume our caller is
+        // smart and hasn't referenced the part of the texture we're about to update
+        // since the last flush.
+        int rowBytes = fBytesPerPixel*fRects->width();

[robertphillips, 2014/05/12 19:45:52]

const unsigned char* ?

[jvanverth1, 2014/05/12 20:44:04]

Done.

+        unsigned char* dataPtr = fPlotData;
+        dataPtr += rowBytes*fDirtyRect.fTop;
+        dataPtr += fBytesPerPixel*fDirtyRect.fLeft;
+        context->writeTexturePixels(fTexture,
+                                    fOffset.fX + fDirtyRect.fLeft, fOffset.fY + fDirtyRect.fTop, 
+                                    fDirtyRect.width(), fDirtyRect.height(),
+                                    fTexture->config(), dataPtr, 
+                                    rowBytes,
+                                    GrContext::kDontFlush_PixelOpsFlag);
+        fDirtyRect.setEmpty();
+        // If the Plot is nearly full, anything else we add will probably be small and one
+        // at a time, so free up the memory and upload any new images directly.

[robertphillips, 2014/05/12 19:45:52]

static const int kNearlyFullTolerance = 0.85f; ?

[jvanverth1, 2014/05/12 20:44:04]

Done.

+        if (fRects->percentFull() > 0.85f) {
+            SkDELETE_ARRAY(fPlotData);
+            fPlotData = NULL;
+        }
+    }

[robertphillips, 2014/05/12 19:45:52]

It seems like if we're going to clear fDirty out here we should also be clearing
fDirtyRect here too?

[jvanverth1, 2014/05/12 20:44:04]

Cleaned up. We shouldn't hit the 'if' block unless a texture is assigned, so all
we need to check is fDirty, and can clear both in there.

+    fDirty = false;
+}
+
 void GrPlot::resetRects() {
     SkASSERT(NULL != fRects);
     fRects->reset();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 GrAtlasMgr::GrAtlasMgr(GrGpu* gpu, GrPixelConfig config,
                        const SkISize& backingTextureSize,
                        int numPlotsX, int numPlotsY) {
     fGpu = SkRef(gpu);
     fPixelConfig = config;
     fBackingTextureSize = backingTextureSize;
     fNumPlotsX = numPlotsX;
     fNumPlotsY = numPlotsY;
     fTexture = NULL;
 
-    int plotWidth = fBackingTextureSize.width() / fNumPlotsX;
-    int plotHeight = fBackingTextureSize.height() / fNumPlotsY;
+    int textureWidth = fBackingTextureSize.width();
+    int textureHeight = fBackingTextureSize.height();
 
-    SkASSERT(plotWidth * fNumPlotsX == fBackingTextureSize.width());
-    SkASSERT(plotHeight * fNumPlotsY == fBackingTextureSize.height());
+    int plotWidth = textureWidth / fNumPlotsX;
+    int plotHeight = textureHeight / fNumPlotsY;
+
+    SkASSERT(plotWidth * fNumPlotsX == textureWidth);
+    SkASSERT(plotHeight * fNumPlotsY == textureHeight);
 
     // set up allocated plots
     size_t bpp = GrBytesPerPixel(fPixelConfig);
     fPlotArray = SkNEW_ARRAY(GrPlot, (fNumPlotsX*fNumPlotsY));
 
     GrPlot* currPlot = fPlotArray;
     for (int y = numPlotsY-1; y >= 0; --y) {
         for (int x = numPlotsX-1; x >= 0; --x) {
             currPlot->init(this, x, y, plotWidth, plotHeight, bpp);
 
@@ skipping 91 matching lines @@
     GrPlot* plot;
     while (NULL != (plot = plotIter.get())) {
         if (plot->drawToken().isIssued()) {
             return plot;
         }
         plotIter.prev();
     }
 
     return NULL;
 }
+
+void GrAtlasMgr::uploadPlotsToTexture() {
+    GrPlotList::Iter plotIter;
+    plotIter.init(fPlotList, GrPlotList::Iter::kHead_IterStart);
+    GrPlot* plot;
+    while (NULL != (plot = plotIter.get())) {
+        plot->uploadToTexture();
+        plotIter.next();
+    }
+}