src/gpu/graphite/RasterPathAtlas.cpp - skia - Git at Google

 /*
  * Copyright 2023 Google LLC
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */

 #include "src/gpu/graphite/RasterPathAtlas.h"

 #include "include/core/SkColorSpace.h"
 #include "include/gpu/graphite/Recorder.h"
 #include "src/core/SkIPoint16.h"
 #include "src/gpu/graphite/AtlasProvider.h"
 #include "src/gpu/graphite/DrawContext.h"
 #include "src/gpu/graphite/Log.h"
 #include "src/gpu/graphite/RasterPathUtils.h"
 #include "src/gpu/graphite/RecorderPriv.h"
 #include "src/gpu/graphite/TextureProxy.h"

 namespace skgpu::graphite {

 RasterPathAtlas::RasterPathAtlas(Recorder* recorder)
         : PathAtlas(recorder, kDefaultAtlasDim, kDefaultAtlasDim) {

     // set up LRU lists
     fPageArray = std::make_unique<std::unique_ptr<Page>[]>(kMaxCachedPages+kMaxUncachedPages);
     std::unique_ptr<Page>* currPage = &fPageArray[0];
     for (int i = 0; i < kMaxCachedPages; ++i) {
         *currPage = std::make_unique<Page>(this->width(), this->height(), i);
         fCachedPageList.addToHead(currPage->get());
         ++currPage;
     }
     for (int i = 0; i < kMaxUncachedPages; ++i) {
         *currPage = std::make_unique<Page>(this->width(), this->height(), kMaxCachedPages+i);
         fUncachedPageList.addToHead(currPage->get());
         ++currPage;
     }
 }

 void RasterPathAtlas::recordUploads(DrawContext* dc) {
     this->uploadPages(dc, &fCachedPageList);
     this->uploadPages(dc, &fUncachedPageList);
 }

 void RasterPathAtlas::uploadPages(DrawContext* dc, PageList* pageList) {
     // Cycle through all the pages and handle their uploads
     PageList::Iter pageIter;
     pageIter.init(*pageList, PageList::Iter::kHead_IterStart);
     while (Page* currPage = pageIter.get()) {
         // build an upload for the dirty rect and record it
         if (!currPage->fDirtyRect.isEmpty()) {
             // Clamp to 4-byte aligned boundaries
             size_t bpp = currPage->fPixels.info().bytesPerPixel();
             unsigned int clearBits = 0x3 / bpp;
             currPage->fDirtyRect.fLeft &= ~clearBits;
             currPage->fDirtyRect.fRight += clearBits;
             currPage->fDirtyRect.fRight &= ~clearBits;
             SkASSERT(currPage->fDirtyRect.fRight <= (int)this->width());
             // Set up dataPtr
             size_t rowBytes = currPage->fPixels.rowBytes();
             const uint8_t* dataPtr = (const uint8_t*) currPage->fPixels.addr();
             dataPtr += rowBytes * currPage->fDirtyRect.fTop;
             dataPtr += bpp * currPage->fDirtyRect.fLeft;

             std::vector<MipLevel> levels;
             levels.push_back({dataPtr, rowBytes});

             SkColorInfo colorInfo(kAlpha_8_SkColorType, kUnknown_SkAlphaType, nullptr);

             if (!dc->recordUpload(fRecorder, currPage->fTexture, colorInfo, colorInfo, levels,
                                   currPage->fDirtyRect, nullptr)) {
                 SKGPU_LOG_W("Coverage mask upload failed!");
                 return;
             }

             currPage->fDirtyRect.setEmpty();
         }
         pageIter.next();
     }
 }

 bool RasterPathAtlas::Page::initializeTextureIfNeeded(Recorder* recorder, uint16_t identifier) {
     if (!fTexture) {
         AtlasProvider* atlasProvider = recorder->priv().atlasProvider();
         fTexture = atlasProvider->getAtlasTexture(recorder,
                                                   fRectanizer.width(),
                                                   fRectanizer.height(),
                                                   kAlpha_8_SkColorType,
                                                   identifier,
                                                   /*requireStorageUsage=*/false);
     }
     return fTexture != nullptr;
 }

 void RasterPathAtlas::makeMRU(Page* page, PageList* pageList) {
     page->fLastUse = fRecorder->priv().tokenTracker()->nextFlushToken();

     if (pageList->head() == page) {
         return;
     }
     pageList->remove(page);
     pageList->addToHead(page);
 }

 RasterPathAtlas::Page* RasterPathAtlas::addRect(PageList* pageList,
                                                 skvx::half2 maskSize,
                                                 SkIPoint16* outPos) {
     // Look through all pages in MRU order and find the first one with room, and move that to MRU
     PageList::Iter pageIter;
     pageIter.init(*pageList, PageList::Iter::kHead_IterStart);
     for (Page* currPage = pageIter.get(); currPage; currPage = pageIter.next()) {
         if (!currPage->initializeTextureIfNeeded(fRecorder, currPage->fIdentifier)) {
             SKGPU_LOG_E("Failed to instantiate an atlas texture");
             return nullptr;
         }

         // An empty mask always fits, so just return the texture.
         // TODO: This may not be needed if we can handle clipped out bounds with inverse fills
         // another way. See PathAtlas::addShape().
         if (!all(maskSize)) {
             *outPos = {0, 0};
             return currPage;
         }

         if (!currPage->fRectanizer.addPaddedRect(
                 maskSize.x(), maskSize.y(), kEntryPadding, outPos)) {
             continue;
         }

         this->makeMRU(currPage, pageList);
         return currPage;
     }

     // If the above fails, then see if the least recently used page has already been
     // queued for upload, in which case we can reuse its space w/o corrupting prior atlas draws.
     Page* lru = pageList->tail();
     SkASSERT(lru);
     if (lru->fLastUse < fRecorder->priv().tokenTracker()->nextFlushToken()) {
         this->reset(lru);
         SkAssertResult(lru->fRectanizer.addPaddedRect(
                 maskSize.x(), maskSize.y(), kEntryPadding, outPos));
         this->makeMRU(lru, pageList);
         return lru;
     }

     // No room in any Page
     return nullptr;
 }

 const TextureProxy* RasterPathAtlas::onAddShape(const Shape& shape,
                                                 const Transform& transform,
                                                 const SkStrokeRec& strokeRec,
                                                 skvx::half2 maskSize,
                                                 skvx::half2* outPos) {
     skgpu::UniqueKey maskKey;
     bool hasKey = shape.hasKey();
     if (hasKey) {
         // Iterate through pagelist in MRU order and see if this shape is cached
         PageList::Iter pageIter;
         pageIter.init(fCachedPageList, PageList::Iter::kHead_IterStart);
         maskKey = GeneratePathMaskKey(shape, transform, strokeRec, maskSize);
         while (Page* currPage = pageIter.get()) {
             // Look up shape and use cached texture and position if found.
             skvx::half2* found = currPage->fCachedShapes.find(maskKey);
             if (found) {
                 *outPos = *found;
                 this->makeMRU(currPage, &fCachedPageList);
                 return currPage->fTexture.get();
             }
             pageIter.next();
         }
     }

     // Try to add to Rectanizer
     SkIPoint16 iPos;
     Page* maskPage = nullptr;
     if (hasKey) {
         maskPage = this->addRect(&fCachedPageList, maskSize, &iPos);
         // No room in the cached pages, try the uncached and don't worry about caching
         if (!maskPage) {
             maskPage = this->addRect(&fUncachedPageList, maskSize, &iPos);
             hasKey = false;
         }
     } else {
         maskPage = this->addRect(&fUncachedPageList, maskSize, &iPos);
     }
     if (!maskPage || !maskPage->fTexture) {
         return nullptr;
     }
     *outPos = skvx::half2(iPos.x(), iPos.y());
     // If the mask is empty, just return.
     // TODO: This may not be needed if we can handle clipped out bounds with inverse fills
     // another way. See PathAtlas::addShape().
     if (!all(maskSize)) {
         return maskPage->fTexture.get();
     }

     // Handle render

     // Rasterize path to backing pixmap
     RasterMaskHelper helper(&maskPage->fPixels);
     if (!helper.init({maskPage->fRectanizer.width(), maskPage->fRectanizer.height()})) {
         return nullptr;
     }
     SkIRect iAtlasBounds = SkIRect::MakeXYWH(iPos.x(), iPos.y(), maskSize.x(), maskSize.y());
     helper.drawShape(shape, transform, strokeRec, iAtlasBounds);

     // Add atlasBounds to dirtyRect for later upload, including the 1px padding applied by the
     // rectanizer. If we didn't include this then our uploads would not include writes to the
     // padded border, so the GPU texture might not then contain transparency even though the CPU
     // data was cleared properly.
     maskPage->fDirtyRect.join(iAtlasBounds.makeOutset(kEntryPadding, kEntryPadding));

     // Add to cache
     if (hasKey) {
         maskPage->fCachedShapes.set(maskKey, *outPos);
     }

     return maskPage->fTexture.get();
 }

 void RasterPathAtlas::reset(Page* lru) {
     lru->fRectanizer.reset();

     // clear backing data for next pass
     SkASSERT(lru->fDirtyRect.isEmpty());
     lru->fPixels.erase(0);
     lru->fCachedShapes.reset();
 }

 }  // namespace skgpu::graphite
	/*
	* Copyright 2023 Google LLC
	*
	* Use of this source code is governed by a BSD-style license that can be
	* found in the LICENSE file.
	*/

	#include "src/gpu/graphite/RasterPathAtlas.h"

	#include "include/core/SkColorSpace.h"
	#include "include/gpu/graphite/Recorder.h"
	#include "src/core/SkIPoint16.h"
	#include "src/gpu/graphite/AtlasProvider.h"
	#include "src/gpu/graphite/DrawContext.h"
	#include "src/gpu/graphite/Log.h"
	#include "src/gpu/graphite/RasterPathUtils.h"
	#include "src/gpu/graphite/RecorderPriv.h"
	#include "src/gpu/graphite/TextureProxy.h"

	namespace skgpu::graphite {

	RasterPathAtlas::RasterPathAtlas(Recorder* recorder)
	: PathAtlas(recorder, kDefaultAtlasDim, kDefaultAtlasDim) {

	// set up LRU lists
	fPageArray = std::make_unique<std::unique_ptr<Page>[]>(kMaxCachedPages+kMaxUncachedPages);
	std::unique_ptr<Page>* currPage = &fPageArray[0];
	for (int i = 0; i < kMaxCachedPages; ++i) {
	*currPage = std::make_unique<Page>(this->width(), this->height(), i);
	fCachedPageList.addToHead(currPage->get());
	++currPage;
	}
	for (int i = 0; i < kMaxUncachedPages; ++i) {
	*currPage = std::make_unique<Page>(this->width(), this->height(), kMaxCachedPages+i);
	fUncachedPageList.addToHead(currPage->get());
	++currPage;
	}
	}

	void RasterPathAtlas::recordUploads(DrawContext* dc) {
	this->uploadPages(dc, &fCachedPageList);
	this->uploadPages(dc, &fUncachedPageList);
	}

	void RasterPathAtlas::uploadPages(DrawContext* dc, PageList* pageList) {
	// Cycle through all the pages and handle their uploads
	PageList::Iter pageIter;
	pageIter.init(*pageList, PageList::Iter::kHead_IterStart);
	while (Page* currPage = pageIter.get()) {
	// build an upload for the dirty rect and record it
	if (!currPage->fDirtyRect.isEmpty()) {
	// Clamp to 4-byte aligned boundaries
	size_t bpp = currPage->fPixels.info().bytesPerPixel();
	unsigned int clearBits = 0x3 / bpp;
	currPage->fDirtyRect.fLeft &= ~clearBits;
	currPage->fDirtyRect.fRight += clearBits;
	currPage->fDirtyRect.fRight &= ~clearBits;
	SkASSERT(currPage->fDirtyRect.fRight <= (int)this->width());
	// Set up dataPtr
	size_t rowBytes = currPage->fPixels.rowBytes();
	const uint8_t* dataPtr = (const uint8_t*) currPage->fPixels.addr();
	dataPtr += rowBytes * currPage->fDirtyRect.fTop;
	dataPtr += bpp * currPage->fDirtyRect.fLeft;

	std::vector<MipLevel> levels;
	levels.push_back({dataPtr, rowBytes});

	SkColorInfo colorInfo(kAlpha_8_SkColorType, kUnknown_SkAlphaType, nullptr);

	if (!dc->recordUpload(fRecorder, currPage->fTexture, colorInfo, colorInfo, levels,
	currPage->fDirtyRect, nullptr)) {
	SKGPU_LOG_W("Coverage mask upload failed!");
	return;
	}

	currPage->fDirtyRect.setEmpty();
	}
	pageIter.next();
	}
	}

	bool RasterPathAtlas::Page::initializeTextureIfNeeded(Recorder* recorder, uint16_t identifier) {
	if (!fTexture) {
	AtlasProvider* atlasProvider = recorder->priv().atlasProvider();
	fTexture = atlasProvider->getAtlasTexture(recorder,
	fRectanizer.width(),
	fRectanizer.height(),
	kAlpha_8_SkColorType,
	identifier,
	/requireStorageUsage=/false);
	}
	return fTexture != nullptr;
	}

	void RasterPathAtlas::makeMRU(Page* page, PageList* pageList) {
	page->fLastUse = fRecorder->priv().tokenTracker()->nextFlushToken();

	if (pageList->head() == page) {
	return;
	}
	pageList->remove(page);
	pageList->addToHead(page);
	}

	RasterPathAtlas::Page* RasterPathAtlas::addRect(PageList* pageList,
	skvx::half2 maskSize,
	SkIPoint16* outPos) {
	// Look through all pages in MRU order and find the first one with room, and move that to MRU
	PageList::Iter pageIter;
	pageIter.init(*pageList, PageList::Iter::kHead_IterStart);
	for (Page* currPage = pageIter.get(); currPage; currPage = pageIter.next()) {
	if (!currPage->initializeTextureIfNeeded(fRecorder, currPage->fIdentifier)) {
	SKGPU_LOG_E("Failed to instantiate an atlas texture");
	return nullptr;
	}

	// An empty mask always fits, so just return the texture.
	// TODO: This may not be needed if we can handle clipped out bounds with inverse fills
	// another way. See PathAtlas::addShape().
	if (!all(maskSize)) {
	*outPos = {0, 0};
	return currPage;
	}

	if (!currPage->fRectanizer.addPaddedRect(
	maskSize.x(), maskSize.y(), kEntryPadding, outPos)) {
	continue;
	}

	this->makeMRU(currPage, pageList);
	return currPage;
	}

	// If the above fails, then see if the least recently used page has already been
	// queued for upload, in which case we can reuse its space w/o corrupting prior atlas draws.
	Page* lru = pageList->tail();
	SkASSERT(lru);
	if (lru->fLastUse < fRecorder->priv().tokenTracker()->nextFlushToken()) {
	this->reset(lru);
	SkAssertResult(lru->fRectanizer.addPaddedRect(
	maskSize.x(), maskSize.y(), kEntryPadding, outPos));
	this->makeMRU(lru, pageList);
	return lru;
	}

	// No room in any Page
	return nullptr;
	}

	const TextureProxy* RasterPathAtlas::onAddShape(const Shape& shape,
	const Transform& transform,
	const SkStrokeRec& strokeRec,
	skvx::half2 maskSize,
	skvx::half2* outPos) {
	skgpu::UniqueKey maskKey;
	bool hasKey = shape.hasKey();
	if (hasKey) {
	// Iterate through pagelist in MRU order and see if this shape is cached
	PageList::Iter pageIter;
	pageIter.init(fCachedPageList, PageList::Iter::kHead_IterStart);
	maskKey = GeneratePathMaskKey(shape, transform, strokeRec, maskSize);
	while (Page* currPage = pageIter.get()) {
	// Look up shape and use cached texture and position if found.
	skvx::half2* found = currPage->fCachedShapes.find(maskKey);
	if (found) {
	outPos = found;
	this->makeMRU(currPage, &fCachedPageList);
	return currPage->fTexture.get();
	}
	pageIter.next();
	}
	}

	// Try to add to Rectanizer
	SkIPoint16 iPos;
	Page* maskPage = nullptr;
	if (hasKey) {
	maskPage = this->addRect(&fCachedPageList, maskSize, &iPos);
	// No room in the cached pages, try the uncached and don't worry about caching
	if (!maskPage) {
	maskPage = this->addRect(&fUncachedPageList, maskSize, &iPos);
	hasKey = false;
	}
	} else {
	maskPage = this->addRect(&fUncachedPageList, maskSize, &iPos);
	}
	if (!maskPage \|\| !maskPage->fTexture) {
	return nullptr;
	}
	*outPos = skvx::half2(iPos.x(), iPos.y());
	// If the mask is empty, just return.
	// TODO: This may not be needed if we can handle clipped out bounds with inverse fills
	// another way. See PathAtlas::addShape().
	if (!all(maskSize)) {
	return maskPage->fTexture.get();
	}

	// Handle render

	// Rasterize path to backing pixmap
	RasterMaskHelper helper(&maskPage->fPixels);
	if (!helper.init({maskPage->fRectanizer.width(), maskPage->fRectanizer.height()})) {
	return nullptr;
	}
	SkIRect iAtlasBounds = SkIRect::MakeXYWH(iPos.x(), iPos.y(), maskSize.x(), maskSize.y());
	helper.drawShape(shape, transform, strokeRec, iAtlasBounds);

	// Add atlasBounds to dirtyRect for later upload, including the 1px padding applied by the
	// rectanizer. If we didn't include this then our uploads would not include writes to the
	// padded border, so the GPU texture might not then contain transparency even though the CPU
	// data was cleared properly.
	maskPage->fDirtyRect.join(iAtlasBounds.makeOutset(kEntryPadding, kEntryPadding));

	// Add to cache
	if (hasKey) {
	maskPage->fCachedShapes.set(maskKey, *outPos);
	}

	return maskPage->fTexture.get();
	}

	void RasterPathAtlas::reset(Page* lru) {
	lru->fRectanizer.reset();

	// clear backing data for next pass
	SkASSERT(lru->fDirtyRect.isEmpty());
	lru->fPixels.erase(0);
	lru->fCachedShapes.reset();
	}

	} // namespace skgpu::graphite