1 /* 2 * Copyright 2015 Google Inc. 3 * 4 * Use of this source code is governed by a BSD-style license that can be 5 * found in the LICENSE file. 6 */ 7 8 #include "GrBatchAtlas.h" 9 #include "GrBatchTarget.h" 10 #include "GrGpu.h" 11 #include "GrRectanizer.h" 12 #include "GrTracing.h" 13 #include "GrVertexBuffer.h" 14 15 static inline void adjust_for_offset(SkIPoint16* loc, const SkIPoint16& offset) { 16 loc->fX += offset.fX; 17 loc->fY += offset.fY; 18 } 19 20 static GrBatchAtlas::AtlasID create_id(int index, int generation) { 21 // Generation ID can roll over because we only check for equality 22 SkASSERT(index < (1 << 16)); 23 return generation << 16 | index; 24 } 25 26 // The backing GrTexture for a GrBatchAtlas is broken into a spatial grid of GrBatchPlots. 27 // The GrBatchPlots keep track of subimage placement via their GrRectanizer. In turn, a GrBatchPlot 28 // manages the lifetime of its data using two tokens, a last ref toke and a last upload token. 29 // Once a GrBatchPlot is "full" (i.e. there is no room for the new subimage according to the 30 // GrRectanizer), it can no longer be used unless the last ref on the GrPlot has already been 31 // flushed through to the gpu. 32 33 class BatchPlot : public SkRefCnt { 34 public: 35 typedef GrBatchAtlas::BatchToken BatchToken; 36 SK_DECLARE_INST_COUNT(BatchPlot); 37 SK_DECLARE_INTERNAL_LLIST_INTERFACE(BatchPlot); 38 39 // index() refers to the index of the plot in the owning GrAtlas's plot array. genID() is a 40 // monotonically incrementing number which is bumped every time the cpu backing store is 41 // wiped, or when the plot itself is evicted from the atlas(ie, there is continuity in genID() 42 // across atlas spills) 43 int index() const { return fIndex; } 44 int genID() const { return fGenID; } 45 GrBatchAtlas::AtlasID id() { return fID; } 46 47 GrTexture* texture() const { return fTexture; } 48 49 bool addSubImage(int width, int height, const void* image, SkIPoint16* loc, size_t rowBytes) { 50 if (!fRects->addRect(width, height, loc)) { 51 return false; 52 } 53 54 if (!fData) { 55 fData = reinterpret_cast<unsigned char*>(sk_calloc_throw(fBytesPerPixel * fWidth * 56 fHeight)); 57 } 58 const unsigned char* imagePtr = (const unsigned char*)image; 59 // point ourselves at the right starting spot 60 unsigned char* dataPtr = fData; 61 dataPtr += fBytesPerPixel * fWidth * loc->fY; 62 dataPtr += fBytesPerPixel * loc->fX; 63 // copy into the data buffer 64 for (int i = 0; i < height; ++i) { 65 memcpy(dataPtr, imagePtr, rowBytes); 66 dataPtr += fBytesPerPixel * fWidth; 67 imagePtr += rowBytes; 68 } 69 70 fDirtyRect.join(loc->fX, loc->fY, loc->fX + width, loc->fY + height); 71 adjust_for_offset(loc, fOffset); 72 SkDEBUGCODE(fDirty = true;) 73 74 return true; 75 } 76 77 // to manage the lifetime of a plot, we use two tokens. We use last upload token to know when 78 // we can 'piggy back' uploads, ie if the last upload hasn't been flushed to gpu, we don't need 79 // to issue a new upload even if we update the cpu backing store. We use lastref to determine 80 // when we can evict a plot from the cache, ie if the last ref has already flushed through 81 // the gpu then we can reuse the plot 82 BatchToken lastUploadToken() const { return fLastUpload; } 83 BatchToken lastUseToken() const { return fLastUse; } 84 void setLastUploadToken(BatchToken batchToken) { 85 SkASSERT(batchToken >= fLastUpload); 86 fLastUpload = batchToken; 87 } 88 void setLastUseToken(BatchToken batchToken) { 89 SkASSERT(batchToken >= fLastUse); 90 fLastUse = batchToken; 91 } 92 93 void uploadToTexture(GrBatchTarget::TextureUploader uploader) { 94 // We should only be issuing uploads if we are in fact dirty 95 SkASSERT(fDirty && fData && fTexture); 96 TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("skia.gpu"), "GrBatchPlot::uploadToTexture"); 97 size_t rowBytes = fBytesPerPixel * fRects->width(); 98 const unsigned char* dataPtr = fData; 99 dataPtr += rowBytes * fDirtyRect.fTop; 100 dataPtr += fBytesPerPixel * fDirtyRect.fLeft; 101 uploader.writeTexturePixels(fTexture, 102 fOffset.fX + fDirtyRect.fLeft, fOffset.fY + fDirtyRect.fTop, 103 fDirtyRect.width(), fDirtyRect.height(), 104 fTexture->config(), dataPtr, rowBytes); 105 fDirtyRect.setEmpty(); 106 SkDEBUGCODE(fDirty = false;) 107 } 108 109 void resetRects() { 110 SkASSERT(fRects); 111 fRects->reset(); 112 fGenID++; 113 fID = create_id(fIndex, fGenID); 114 115 // zero out the plot 116 if (fData) { 117 sk_bzero(fData, fBytesPerPixel * fWidth * fHeight); 118 } 119 120 fDirtyRect.setEmpty(); 121 SkDEBUGCODE(fDirty = false;) 122 } 123 124 int x() const { return fX; } 125 int y() const { return fY; } 126 127 private: 128 BatchPlot() 129 : fLastUpload(0) 130 , fLastUse(0) 131 , fIndex(-1) 132 , fGenID(-1) 133 , fID(0) 134 , fData(NULL) 135 , fWidth(0) 136 , fHeight(0) 137 , fX(0) 138 , fY(0) 139 , fTexture(NULL) 140 , fRects(NULL) 141 , fAtlas(NULL) 142 , fBytesPerPixel(1) 143 #ifdef SK_DEBUG 144 , fDirty(false) 145 #endif 146 { 147 fOffset.set(0, 0); 148 } 149 150 ~BatchPlot() { 151 sk_free(fData); 152 fData = NULL; 153 delete fRects; 154 } 155 156 void init(GrBatchAtlas* atlas, GrTexture* texture, int index, uint32_t generation, 157 int offX, int offY, int width, int height, size_t bpp) { 158 fIndex = index; 159 fGenID = generation; 160 fID = create_id(index, generation); 161 fWidth = width; 162 fHeight = height; 163 fX = offX; 164 fY = offY; 165 fRects = GrRectanizer::Factory(width, height); 166 fAtlas = atlas; 167 fOffset.set(offX * width, offY * height); 168 fBytesPerPixel = bpp; 169 fData = NULL; 170 fDirtyRect.setEmpty(); 171 SkDEBUGCODE(fDirty = false;) 172 fTexture = texture; 173 } 174 175 BatchToken fLastUpload; 176 BatchToken fLastUse; 177 178 uint32_t fIndex; 179 uint32_t fGenID; 180 GrBatchAtlas::AtlasID fID; 181 unsigned char* fData; 182 int fWidth; 183 int fHeight; 184 int fX; 185 int fY; 186 GrTexture* fTexture; 187 GrRectanizer* fRects; 188 GrBatchAtlas* fAtlas; 189 SkIPoint16 fOffset; // the offset of the plot in the backing texture 190 size_t fBytesPerPixel; 191 SkIRect fDirtyRect; 192 SkDEBUGCODE(bool fDirty;) 193 194 friend class GrBatchAtlas; 195 196 typedef SkRefCnt INHERITED; 197 }; 198 199 //////////////////////////////////////////////////////////////////////////////// 200 201 class GrPlotUploader : public GrBatchTarget::Uploader { 202 public: 203 GrPlotUploader(BatchPlot* plot) 204 : INHERITED(plot->lastUploadToken()) 205 , fPlot(SkRef(plot)) { 206 SkASSERT(plot); 207 } 208 209 void upload(GrBatchTarget::TextureUploader uploader) override { 210 fPlot->uploadToTexture(uploader); 211 } 212 213 private: 214 SkAutoTUnref<BatchPlot> fPlot; 215 216 typedef GrBatchTarget::Uploader INHERITED; 217 }; 218 219 /////////////////////////////////////////////////////////////////////////////// 220 221 GrBatchAtlas::GrBatchAtlas(GrTexture* texture, int numPlotsX, int numPlotsY) 222 : fTexture(texture) 223 , fNumPlotsX(numPlotsX) 224 , fNumPlotsY(numPlotsY) 225 , fPlotWidth(texture->width() / numPlotsX) 226 , fPlotHeight(texture->height() / numPlotsY) 227 , fAtlasGeneration(kInvalidAtlasGeneration + 1) { 228 SkASSERT(fNumPlotsX * fNumPlotsY <= BulkUseTokenUpdater::kMaxPlots); 229 SkASSERT(fPlotWidth * fNumPlotsX == texture->width()); 230 SkASSERT(fPlotHeight * fNumPlotsY == texture->height()); 231 232 // We currently do not support compressed atlases... 233 SkASSERT(!GrPixelConfigIsCompressed(texture->desc().fConfig)); 234 235 // set up allocated plots 236 fBPP = GrBytesPerPixel(texture->desc().fConfig); 237 fPlotArray = SkNEW_ARRAY(SkAutoTUnref<BatchPlot>, (fNumPlotsX * fNumPlotsY)); 238 239 SkAutoTUnref<BatchPlot>* currPlot = fPlotArray; 240 for (int y = fNumPlotsY - 1, r = 0; y >= 0; --y, ++r) { 241 for (int x = fNumPlotsX - 1, c = 0; x >= 0; --x, ++c) { 242 int id = r * fNumPlotsX + c; 243 currPlot->reset(SkNEW(BatchPlot)); 244 (*currPlot)->init(this, texture, id, 1, x, y, fPlotWidth, fPlotHeight, fBPP); 245 246 // build LRU list 247 fPlotList.addToHead(currPlot->get()); 248 ++currPlot; 249 } 250 } 251 } 252 253 GrBatchAtlas::~GrBatchAtlas() { 254 SkSafeUnref(fTexture); 255 SkDELETE_ARRAY(fPlotArray); 256 } 257 258 void GrBatchAtlas::processEviction(AtlasID id) { 259 for (int i = 0; i < fEvictionCallbacks.count(); i++) { 260 (*fEvictionCallbacks[i].fFunc)(id, fEvictionCallbacks[i].fData); 261 } 262 } 263 264 void GrBatchAtlas::makeMRU(BatchPlot* plot) { 265 if (fPlotList.head() == plot) { 266 return; 267 } 268 269 fPlotList.remove(plot); 270 fPlotList.addToHead(plot); 271 } 272 273 inline void GrBatchAtlas::updatePlot(GrBatchTarget* batchTarget, AtlasID* id, BatchPlot* plot) { 274 this->makeMRU(plot); 275 276 // If our most recent upload has already occurred then we have to insert a new 277 // upload. Otherwise, we already have a scheduled upload that hasn't yet ocurred. 278 // This new update will piggy back on that previously scheduled update. 279 if (batchTarget->isIssued(plot->lastUploadToken())) { 280 plot->setLastUploadToken(batchTarget->asapToken()); 281 SkAutoTUnref<GrPlotUploader> uploader(SkNEW_ARGS(GrPlotUploader, (plot))); 282 batchTarget->upload(uploader); 283 } 284 *id = plot->id(); 285 } 286 287 bool GrBatchAtlas::addToAtlas(AtlasID* id, GrBatchTarget* batchTarget, 288 int width, int height, const void* image, SkIPoint16* loc) { 289 // We should already have a texture, TODO clean this up 290 SkASSERT(fTexture && width <= fPlotWidth && height <= fPlotHeight); 291 292 // now look through all allocated plots for one we can share, in Most Recently Refed order 293 GrBatchPlotList::Iter plotIter; 294 plotIter.init(fPlotList, GrBatchPlotList::Iter::kHead_IterStart); 295 BatchPlot* plot; 296 while ((plot = plotIter.get())) { 297 if (plot->addSubImage(width, height, image, loc, fBPP * width)) { 298 this->updatePlot(batchTarget, id, plot); 299 return true; 300 } 301 plotIter.next(); 302 } 303 304 // If the above fails, then see if the least recently refed plot has already been flushed to the 305 // gpu 306 plotIter.init(fPlotList, GrBatchPlotList::Iter::kTail_IterStart); 307 plot = plotIter.get(); 308 SkASSERT(plot); 309 if (batchTarget->isIssued(plot->lastUseToken())) { 310 this->processEviction(plot->id()); 311 plot->resetRects(); 312 SkDEBUGCODE(bool verify = )plot->addSubImage(width, height, image, loc, fBPP * width); 313 SkASSERT(verify); 314 this->updatePlot(batchTarget, id, plot); 315 fAtlasGeneration++; 316 return true; 317 } 318 319 // The least recently refed plot hasn't been flushed to the gpu yet, however, if we have flushed 320 // it to the batch target than we can reuse it. Our last ref token is guaranteed to be less 321 // than or equal to the current token. If its 'less than' the current token, than we can spin 322 // off the plot(ie let the batch target manage it) and create a new plot in its place in our 323 // array. If it is equal to the currentToken, then the caller has to flush draws to the batch 324 // target so we can spin off the plot 325 if (plot->lastUseToken() == batchTarget->currentToken()) { 326 return false; 327 } 328 329 // We take an extra ref here so our plot isn't deleted when we reset its index in the array. 330 plot->ref(); 331 int index = plot->index(); 332 int x = plot->x(); 333 int y = plot->y(); 334 int generation = plot->genID(); 335 336 this->processEviction(plot->id()); 337 fPlotList.remove(plot); 338 SkAutoTUnref<BatchPlot>& newPlot = fPlotArray[plot->index()]; 339 newPlot.reset(SkNEW(BatchPlot)); 340 newPlot->init(this, fTexture, index, ++generation, x, y, fPlotWidth, fPlotHeight, fBPP); 341 342 fPlotList.addToHead(newPlot.get()); 343 SkDEBUGCODE(bool verify = )newPlot->addSubImage(width, height, image, loc, fBPP * width); 344 SkASSERT(verify); 345 newPlot->setLastUploadToken(batchTarget->currentToken()); 346 SkAutoTUnref<GrPlotUploader> uploader(SkNEW_ARGS(GrPlotUploader, (newPlot))); 347 batchTarget->upload(uploader); 348 *id = newPlot->id(); 349 plot->unref(); 350 fAtlasGeneration++; 351 return true; 352 } 353 354 bool GrBatchAtlas::hasID(AtlasID id) { 355 int index = GetIndexFromID(id); 356 SkASSERT(index < fNumPlotsX * fNumPlotsY); 357 return fPlotArray[index]->genID() == GetGenerationFromID(id); 358 } 359 360 void GrBatchAtlas::setLastUseToken(AtlasID id, BatchToken batchToken) { 361 SkASSERT(this->hasID(id)); 362 int index = GetIndexFromID(id); 363 SkASSERT(index < fNumPlotsX * fNumPlotsY); 364 this->makeMRU(fPlotArray[index]); 365 fPlotArray[index]->setLastUseToken(batchToken); 366 } 367 368 void GrBatchAtlas::setLastUseTokenBulk(const BulkUseTokenUpdater& updater, BatchToken batchToken) { 369 int count = updater.fPlotsToUpdate.count(); 370 for (int i = 0; i < count; i++) { 371 BatchPlot* plot = fPlotArray[updater.fPlotsToUpdate[i]]; 372 this->makeMRU(plot); 373 plot->setLastUseToken(batchToken); 374 } 375 } 376