Remove border from GrAtlas entries, and associated copy.

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 17 matching lines @@
 #define GR_ATLAS_WIDTH  256
 #define GR_ATLAS_HEIGHT 256
 
 #define GR_PLOT_WIDTH   (GR_ATLAS_TEXTURE_WIDTH / GR_ATLAS_WIDTH)
 #define GR_PLOT_HEIGHT  (GR_ATLAS_TEXTURE_HEIGHT / GR_ATLAS_HEIGHT)
 
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 
-#define BORDER      1
-
 #ifdef SK_DEBUG
     static int gCounter;
 #endif
 
 // for testing
 #define FONT_CACHE_STATS 0
 #if FONT_CACHE_STATS
 static int g_UploadCount = 0;
 #endif
 
 GrPlot::GrPlot() : fDrawToken(NULL, 0)
                  , fNext(NULL)
                  , fTexture(NULL)
                  , fAtlasMgr(NULL)
                  , fBytesPerPixel(1)
 {
-    fRects = GrRectanizer::Factory(GR_ATLAS_WIDTH - BORDER,
-                                   GR_ATLAS_HEIGHT - BORDER);
+    fRects = GrRectanizer::Factory(GR_ATLAS_WIDTH,
+                                   GR_ATLAS_HEIGHT);
     fOffset.set(0, 0);
 }
 
 GrPlot::~GrPlot() {
     delete fRects;
 }
 
 static inline void adjust_for_offset(GrIPoint16* loc, const GrIPoint16& offset) {
     loc->fX += offset.fX * GR_ATLAS_WIDTH;
     loc->fY += offset.fY * GR_ATLAS_HEIGHT;
 }
 
 static inline uint8_t* zero_fill(uint8_t* ptr, size_t count) {
     sk_bzero(ptr, count);
     return ptr + count;
 }
 
 bool GrPlot::addSubImage(int width, int height, const void* image,
                           GrIPoint16* loc) {
-    if (!fRects->addRect(width + BORDER, height + BORDER, loc)) {
+    if (!fRects->addRect(width, height, loc)) {
         return false;
     }
 
     SkAutoSMalloc<1024> storage;
-    int dstW = width + 2*BORDER;
-    int dstH = height + 2*BORDER;
-    if (BORDER) {
-        const size_t dstRB = dstW * fBytesPerPixel;
-        uint8_t* dst = (uint8_t*)storage.reset(dstH * dstRB);
-        sk_bzero(dst, dstRB);                // zero top row
-        dst += dstRB;
-        for (int y = 0; y < height; y++) {
-            dst = zero_fill(dst, fBytesPerPixel);   // zero left edge
-            memcpy(dst, image, width * fBytesPerPixel);
-            dst += width * fBytesPerPixel;
-            dst = zero_fill(dst, fBytesPerPixel);   // zero right edge
-            image = (const void*)((const char*)image + width * fBytesPerPixel);
-        }
-        sk_bzero(dst, dstRB);                // zero bottom row
-        image = storage.get();
-    }
     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, dstW, dstH,
+                                loc->fX, loc->fY, width, height,
                                 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, GrPixelConfig config) {
@@ skipping 129 matching lines @@
 
     plot->fRects->reset();
     plot->fNext = fFreePlots;
     fFreePlots = plot;
 
 #ifdef SK_DEBUG
     --gCounter;
 //    GrPrintf("~GrPlot %p [%d %d] %d\n", this, plot->fOffset.fX, plot->fOffset.fY, gCounter);
 #endif
 }