blob: 7a1b8da2b2fac328371ebfcc4522f5ee3b5b5e58 [file] [log] [blame]
/*
* Copyright 2015 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "src/gpu/GrResourceProvider.h"
#include "include/gpu/GrBackendSemaphore.h"
#include "include/private/SingleOwner.h"
#include "src/core/SkConvertPixels.h"
#include "src/core/SkMathPriv.h"
#include "src/core/SkMipmap.h"
#include "src/gpu/BufferWriter.h"
#include "src/gpu/GrAttachment.h"
#include "src/gpu/GrCaps.h"
#include "src/gpu/GrDataUtils.h"
#include "src/gpu/GrGpu.h"
#include "src/gpu/GrGpuBuffer.h"
#include "src/gpu/GrImageInfo.h"
#include "src/gpu/GrProxyProvider.h"
#include "src/gpu/GrRenderTarget.h"
#include "src/gpu/GrResourceCache.h"
#include "src/gpu/GrSemaphore.h"
#include "src/gpu/GrTexture.h"
#include "src/gpu/ResourceKey.h"
#include "src/gpu/SkGr.h"
const int GrResourceProvider::kMinScratchTextureSize = 16;
#define ASSERT_SINGLE_OWNER SKGPU_ASSERT_SINGLE_OWNER(fSingleOwner)
GrResourceProvider::GrResourceProvider(GrGpu* gpu,
GrResourceCache* cache,
skgpu::SingleOwner* owner)
: fCache(cache)
, fGpu(gpu)
#ifdef SK_DEBUG
, fSingleOwner(owner)
#endif
{
fCaps = sk_ref_sp(fGpu->caps());
}
sk_sp<GrTexture> GrResourceProvider::createTexture(SkISize dimensions,
const GrBackendFormat& format,
GrTextureType textureType,
GrColorType colorType,
GrRenderable renderable,
int renderTargetSampleCnt,
SkBudgeted budgeted,
GrMipmapped mipmapped,
GrProtected isProtected,
const GrMipLevel texels[]) {
ASSERT_SINGLE_OWNER
if (this->isAbandoned()) {
return nullptr;
}
int numMipLevels = 1;
if (mipmapped == GrMipmapped::kYes) {
numMipLevels = SkMipmap::ComputeLevelCount(dimensions.fWidth, dimensions.fHeight) + 1;
}
if (!fCaps->validateSurfaceParams(dimensions,
format,
renderable,
renderTargetSampleCnt,
mipmapped,
textureType)) {
return nullptr;
}
// Current rule is that you can provide no level data, just the base, or all the levels.
bool hasPixels = texels[0].fPixels;
auto scratch = this->getExactScratch(dimensions,
format,
textureType,
renderable,
renderTargetSampleCnt,
budgeted,
mipmapped,
isProtected);
if (scratch) {
if (!hasPixels) {
return scratch;
}
return this->writePixels(std::move(scratch), colorType, dimensions, texels, numMipLevels);
}
SkAutoSTArray<14, GrMipLevel> tmpTexels;
SkAutoSTArray<14, std::unique_ptr<char[]>> tmpDatas;
GrColorType tempColorType = GrColorType::kUnknown;
if (hasPixels) {
tempColorType = this->prepareLevels(format, colorType, dimensions, texels, numMipLevels,
&tmpTexels, &tmpDatas);
if (tempColorType == GrColorType::kUnknown) {
return nullptr;
}
}
return fGpu->createTexture(dimensions,
format,
textureType,
renderable,
renderTargetSampleCnt,
budgeted,
isProtected,
colorType,
tempColorType,
tmpTexels.get(),
numMipLevels);
}
sk_sp<GrTexture> GrResourceProvider::getExactScratch(SkISize dimensions,
const GrBackendFormat& format,
GrTextureType textureType,
GrRenderable renderable,
int renderTargetSampleCnt,
SkBudgeted budgeted,
GrMipmapped mipmapped,
GrProtected isProtected) {
sk_sp<GrTexture> tex(this->findAndRefScratchTexture(dimensions,
format,
textureType,
renderable,
renderTargetSampleCnt,
mipmapped,
isProtected));
if (tex && SkBudgeted::kNo == budgeted) {
tex->resourcePriv().makeUnbudgeted();
}
return tex;
}
sk_sp<GrTexture> GrResourceProvider::createTexture(SkISize dimensions,
const GrBackendFormat& format,
GrTextureType textureType,
GrColorType colorType,
GrRenderable renderable,
int renderTargetSampleCnt,
SkBudgeted budgeted,
SkBackingFit fit,
GrProtected isProtected,
const GrMipLevel& mipLevel) {
ASSERT_SINGLE_OWNER
if (!mipLevel.fPixels) {
return nullptr;
}
if (SkBackingFit::kApprox == fit) {
if (this->isAbandoned()) {
return nullptr;
}
if (!fCaps->validateSurfaceParams(dimensions, format, renderable, renderTargetSampleCnt,
GrMipmapped::kNo, textureType)) {
return nullptr;
}
auto tex = this->createApproxTexture(dimensions, format, textureType, renderable,
renderTargetSampleCnt, isProtected);
if (!tex) {
return nullptr;
}
return this->writePixels(std::move(tex), colorType, dimensions, &mipLevel, 1);
} else {
return this->createTexture(dimensions,
format,
textureType,
colorType,
renderable,
renderTargetSampleCnt,
budgeted,
GrMipmapped::kNo,
isProtected,
&mipLevel);
}
}
sk_sp<GrTexture> GrResourceProvider::createCompressedTexture(SkISize dimensions,
const GrBackendFormat& format,
SkBudgeted budgeted,
GrMipmapped mipmapped,
GrProtected isProtected,
SkData* data) {
ASSERT_SINGLE_OWNER
if (this->isAbandoned()) {
return nullptr;
}
return fGpu->createCompressedTexture(dimensions, format, budgeted, mipmapped,
isProtected, data->data(), data->size());
}
sk_sp<GrTexture> GrResourceProvider::createTexture(SkISize dimensions,
const GrBackendFormat& format,
GrTextureType textureType,
GrRenderable renderable,
int renderTargetSampleCnt,
GrMipmapped mipmapped,
SkBudgeted budgeted,
GrProtected isProtected) {
ASSERT_SINGLE_OWNER
if (this->isAbandoned()) {
return nullptr;
}
if (!fCaps->validateSurfaceParams(dimensions, format, renderable, renderTargetSampleCnt,
mipmapped, textureType)) {
return nullptr;
}
// Currently we don't recycle compressed textures as scratch. Additionally all compressed
// textures should be created through the createCompressedTexture function.
SkASSERT(!this->caps()->isFormatCompressed(format));
// TODO: Support GrMipmapped::kYes in scratch texture lookup here.
sk_sp<GrTexture> tex =
this->getExactScratch(dimensions,
format,
textureType,
renderable,
renderTargetSampleCnt,
budgeted,
mipmapped,
isProtected);
if (tex) {
return tex;
}
return fGpu->createTexture(dimensions,
format,
textureType,
renderable,
renderTargetSampleCnt,
mipmapped,
budgeted,
isProtected);
}
// Map 'value' to a larger multiple of 2. Values <= 'kMagicTol' will pop up to
// the next power of 2. Those above 'kMagicTol' will only go up half the floor power of 2.
SkISize GrResourceProvider::MakeApprox(SkISize dimensions) {
auto adjust = [](int value) {
static const int kMagicTol = 1024;
value = std::max(kMinScratchTextureSize, value);
if (SkIsPow2(value)) {
return value;
}
int ceilPow2 = SkNextPow2(value);
if (value <= kMagicTol) {
return ceilPow2;
}
int floorPow2 = ceilPow2 >> 1;
int mid = floorPow2 + (floorPow2 >> 1);
if (value <= mid) {
return mid;
}
return ceilPow2;
};
return {adjust(dimensions.width()), adjust(dimensions.height())};
}
sk_sp<GrTexture> GrResourceProvider::createApproxTexture(SkISize dimensions,
const GrBackendFormat& format,
GrTextureType textureType,
GrRenderable renderable,
int renderTargetSampleCnt,
GrProtected isProtected) {
ASSERT_SINGLE_OWNER
if (this->isAbandoned()) {
return nullptr;
}
// Currently we don't recycle compressed textures as scratch. Additionally all compressed
// textures should be created through the createCompressedTexture function.
SkASSERT(!this->caps()->isFormatCompressed(format));
if (!fCaps->validateSurfaceParams(dimensions, format, renderable, renderTargetSampleCnt,
GrMipmapped::kNo, textureType)) {
return nullptr;
}
auto copyDimensions = MakeApprox(dimensions);
if (auto tex = this->findAndRefScratchTexture(copyDimensions, format, textureType, renderable,
renderTargetSampleCnt, GrMipmapped::kNo,
isProtected)) {
return tex;
}
return fGpu->createTexture(copyDimensions,
format,
textureType,
renderable,
renderTargetSampleCnt,
GrMipmapped::kNo,
SkBudgeted::kYes,
isProtected);
}
sk_sp<GrTexture> GrResourceProvider::findAndRefScratchTexture(const skgpu::ScratchKey& key) {
ASSERT_SINGLE_OWNER
SkASSERT(!this->isAbandoned());
SkASSERT(key.isValid());
if (GrGpuResource* resource = fCache->findAndRefScratchResource(key)) {
fGpu->stats()->incNumScratchTexturesReused();
GrSurface* surface = static_cast<GrSurface*>(resource);
return sk_sp<GrTexture>(surface->asTexture());
}
return nullptr;
}
sk_sp<GrTexture> GrResourceProvider::findAndRefScratchTexture(SkISize dimensions,
const GrBackendFormat& format,
GrTextureType textureType,
GrRenderable renderable,
int renderTargetSampleCnt,
GrMipmapped mipmapped,
GrProtected isProtected) {
ASSERT_SINGLE_OWNER
SkASSERT(!this->isAbandoned());
SkASSERT(!this->caps()->isFormatCompressed(format));
SkASSERT(fCaps->validateSurfaceParams(dimensions, format, renderable, renderTargetSampleCnt,
GrMipmapped::kNo, textureType));
// We could make initial clears work with scratch textures but it is a rare case so we just opt
// to fall back to making a new texture.
if (fGpu->caps()->reuseScratchTextures() || renderable == GrRenderable::kYes) {
skgpu::ScratchKey key;
GrTexture::ComputeScratchKey(*this->caps(), format, dimensions, renderable,
renderTargetSampleCnt, mipmapped, isProtected, &key);
return this->findAndRefScratchTexture(key);
}
return nullptr;
}
sk_sp<GrTexture> GrResourceProvider::wrapBackendTexture(const GrBackendTexture& tex,
GrWrapOwnership ownership,
GrWrapCacheable cacheable,
GrIOType ioType) {
ASSERT_SINGLE_OWNER
if (this->isAbandoned()) {
return nullptr;
}
return fGpu->wrapBackendTexture(tex, ownership, cacheable, ioType);
}
sk_sp<GrTexture> GrResourceProvider::wrapCompressedBackendTexture(const GrBackendTexture& tex,
GrWrapOwnership ownership,
GrWrapCacheable cacheable) {
ASSERT_SINGLE_OWNER
if (this->isAbandoned()) {
return nullptr;
}
return fGpu->wrapCompressedBackendTexture(tex, ownership, cacheable);
}
sk_sp<GrTexture> GrResourceProvider::wrapRenderableBackendTexture(const GrBackendTexture& tex,
int sampleCnt,
GrWrapOwnership ownership,
GrWrapCacheable cacheable) {
ASSERT_SINGLE_OWNER
if (this->isAbandoned()) {
return nullptr;
}
return fGpu->wrapRenderableBackendTexture(tex, sampleCnt, ownership, cacheable);
}
sk_sp<GrRenderTarget> GrResourceProvider::wrapBackendRenderTarget(
const GrBackendRenderTarget& backendRT) {
ASSERT_SINGLE_OWNER
return this->isAbandoned() ? nullptr : fGpu->wrapBackendRenderTarget(backendRT);
}
sk_sp<GrRenderTarget> GrResourceProvider::wrapVulkanSecondaryCBAsRenderTarget(
const SkImageInfo& imageInfo, const GrVkDrawableInfo& vkInfo) {
ASSERT_SINGLE_OWNER
return this->isAbandoned() ? nullptr : fGpu->wrapVulkanSecondaryCBAsRenderTarget(imageInfo,
vkInfo);
}
void GrResourceProvider::assignUniqueKeyToResource(const skgpu::UniqueKey& key,
GrGpuResource* resource) {
ASSERT_SINGLE_OWNER
if (this->isAbandoned() || !resource) {
return;
}
resource->resourcePriv().setUniqueKey(key);
}
sk_sp<GrGpuResource> GrResourceProvider::findResourceByUniqueKey(const skgpu::UniqueKey& key) {
ASSERT_SINGLE_OWNER
return this->isAbandoned() ? nullptr
: sk_sp<GrGpuResource>(fCache->findAndRefUniqueResource(key));
}
sk_sp<const GrGpuBuffer> GrResourceProvider::findOrMakeStaticBuffer(GrGpuBufferType intendedType,
size_t size,
const void* staticData,
const skgpu::UniqueKey& key) {
if (auto buffer = this->findByUniqueKey<GrGpuBuffer>(key)) {
return std::move(buffer);
}
if (auto buffer = this->createBuffer(size, intendedType, kStatic_GrAccessPattern, staticData)) {
// We shouldn't bin and/or cache static buffers.
SkASSERT(buffer->size() == size);
SkASSERT(!buffer->resourcePriv().getScratchKey().isValid());
buffer->resourcePriv().setUniqueKey(key);
return sk_sp<const GrGpuBuffer>(buffer);
}
return nullptr;
}
sk_sp<const GrGpuBuffer> GrResourceProvider::findOrMakeStaticBuffer(
GrGpuBufferType intendedType,
size_t size,
const skgpu::UniqueKey& uniqueKey,
InitializeBufferFn initializeBufferFn) {
if (auto buffer = this->findByUniqueKey<GrGpuBuffer>(uniqueKey)) {
return std::move(buffer);
}
if (auto buffer = this->createBuffer(size, intendedType, kStatic_GrAccessPattern)) {
// We shouldn't bin and/or cache static buffers.
SkASSERT(buffer->size() == size);
SkASSERT(!buffer->resourcePriv().getScratchKey().isValid());
buffer->resourcePriv().setUniqueKey(uniqueKey);
// Map the buffer. Use a staging buffer on the heap if mapping isn't supported.
skgpu::VertexWriter vertexWriter = {buffer->map(), size};
SkAutoTMalloc<char> stagingBuffer;
if (!vertexWriter) {
SkASSERT(!buffer->isMapped());
vertexWriter = {stagingBuffer.reset(size), size};
}
initializeBufferFn(std::move(vertexWriter), size);
if (buffer->isMapped()) {
buffer->unmap();
} else {
buffer->updateData(stagingBuffer, size);
}
return std::move(buffer);
}
return nullptr;
}
sk_sp<const GrGpuBuffer> GrResourceProvider::createPatternedIndexBuffer(
const uint16_t* pattern,
int patternSize,
int reps,
int vertCount,
const skgpu::UniqueKey* key) {
size_t bufferSize = patternSize * reps * sizeof(uint16_t);
sk_sp<GrGpuBuffer> buffer(
this->createBuffer(bufferSize, GrGpuBufferType::kIndex, kStatic_GrAccessPattern));
if (!buffer) {
return nullptr;
}
uint16_t* data = (uint16_t*) buffer->map();
SkAutoTArray<uint16_t> temp;
if (!data) {
temp.reset(reps * patternSize);
data = temp.get();
}
for (int i = 0; i < reps; ++i) {
int baseIdx = i * patternSize;
uint16_t baseVert = (uint16_t)(i * vertCount);
for (int j = 0; j < patternSize; ++j) {
data[baseIdx+j] = baseVert + pattern[j];
}
}
if (temp.get()) {
if (!buffer->updateData(data, bufferSize)) {
return nullptr;
}
} else {
buffer->unmap();
}
if (key) {
SkASSERT(key->isValid());
this->assignUniqueKeyToResource(*key, buffer.get());
}
return std::move(buffer);
}
///////////////////////////////////////////////////////////////////////////////////////////////////
static constexpr int kMaxNumNonAAQuads = 1 << 12; // max possible: (1 << 14) - 1;
static const int kVertsPerNonAAQuad = 4;
static const int kIndicesPerNonAAQuad = 6;
sk_sp<const GrGpuBuffer> GrResourceProvider::createNonAAQuadIndexBuffer() {
static_assert(kVertsPerNonAAQuad * kMaxNumNonAAQuads <= 65535); // indices fit in a uint16_t
static const uint16_t kNonAAQuadIndexPattern[] = {
0, 1, 2, 2, 1, 3
};
static_assert(SK_ARRAY_COUNT(kNonAAQuadIndexPattern) == kIndicesPerNonAAQuad);
return this->createPatternedIndexBuffer(kNonAAQuadIndexPattern, kIndicesPerNonAAQuad,
kMaxNumNonAAQuads, kVertsPerNonAAQuad, nullptr);
}
int GrResourceProvider::MaxNumNonAAQuads() { return kMaxNumNonAAQuads; }
int GrResourceProvider::NumVertsPerNonAAQuad() { return kVertsPerNonAAQuad; }
int GrResourceProvider::NumIndicesPerNonAAQuad() { return kIndicesPerNonAAQuad; }
///////////////////////////////////////////////////////////////////////////////////////////////////
static constexpr int kMaxNumAAQuads = 1 << 9; // max possible: (1 << 13) - 1;
static const int kVertsPerAAQuad = 8;
static const int kIndicesPerAAQuad = 30;
sk_sp<const GrGpuBuffer> GrResourceProvider::createAAQuadIndexBuffer() {
static_assert(kVertsPerAAQuad * kMaxNumAAQuads <= 65535); // indices fit in a uint16_t
// clang-format off
static const uint16_t kAAQuadIndexPattern[] = {
0, 1, 2, 1, 3, 2,
0, 4, 1, 4, 5, 1,
0, 6, 4, 0, 2, 6,
2, 3, 6, 3, 7, 6,
1, 5, 3, 3, 5, 7,
};
// clang-format on
static_assert(SK_ARRAY_COUNT(kAAQuadIndexPattern) == kIndicesPerAAQuad);
return this->createPatternedIndexBuffer(kAAQuadIndexPattern, kIndicesPerAAQuad,
kMaxNumAAQuads, kVertsPerAAQuad, nullptr);
}
int GrResourceProvider::MaxNumAAQuads() { return kMaxNumAAQuads; }
int GrResourceProvider::NumVertsPerAAQuad() { return kVertsPerAAQuad; }
int GrResourceProvider::NumIndicesPerAAQuad() { return kIndicesPerAAQuad; }
///////////////////////////////////////////////////////////////////////////////////////////////////
sk_sp<GrGpuBuffer> GrResourceProvider::createBuffer(size_t size, GrGpuBufferType intendedType,
GrAccessPattern accessPattern,
const void* data) {
if (this->isAbandoned()) {
return nullptr;
}
if (kDynamic_GrAccessPattern != accessPattern) {
return this->gpu()->createBuffer(size, intendedType, accessPattern, data);
}
// bin by pow2+midpoint with a reasonable min
static const size_t MIN_SIZE = 1 << 12;
static const size_t MIN_UNIFORM_SIZE = 1 << 7;
size_t allocSize = intendedType == GrGpuBufferType::kUniform ? std::max(size, MIN_UNIFORM_SIZE)
: std::max(size, MIN_SIZE);
size_t ceilPow2 = GrNextSizePow2(allocSize);
size_t floorPow2 = ceilPow2 >> 1;
size_t mid = floorPow2 + (floorPow2 >> 1);
allocSize = (allocSize <= mid) ? mid : ceilPow2;
skgpu::ScratchKey key;
GrGpuBuffer::ComputeScratchKeyForDynamicBuffer(allocSize, intendedType, &key);
auto buffer =
sk_sp<GrGpuBuffer>(static_cast<GrGpuBuffer*>(this->cache()->findAndRefScratchResource(
key)));
if (!buffer) {
buffer = this->gpu()->createBuffer(allocSize, intendedType, kDynamic_GrAccessPattern);
if (!buffer) {
return nullptr;
}
}
if (data) {
buffer->updateData(data, size);
}
return buffer;
}
static int num_stencil_samples(const GrRenderTarget* rt, bool useMSAASurface, const GrCaps& caps) {
int numSamples = rt->numSamples();
if (numSamples == 1 && useMSAASurface) { // Are we using dynamic msaa?
numSamples = caps.internalMultisampleCount(rt->backendFormat());
SkASSERT(numSamples > 1); // Caller must ensure dmsaa is supported before trying to use it.
}
return numSamples;
}
bool GrResourceProvider::attachStencilAttachment(GrRenderTarget* rt, bool useMSAASurface) {
SkASSERT(rt);
SkASSERT(!this->caps()->avoidStencilBuffers());
GrAttachment* stencil = rt->getStencilAttachment(useMSAASurface);
if (stencil) {
SkASSERT(stencil->numSamples() == num_stencil_samples(rt, useMSAASurface, *this->caps()));
return true;
}
if (!rt->wasDestroyed() && rt->canAttemptStencilAttachment(useMSAASurface)) {
skgpu::UniqueKey sbKey;
#if 0
if (this->caps()->oversizedStencilSupport()) {
width = SkNextPow2(width);
height = SkNextPow2(height);
}
#endif
GrBackendFormat stencilFormat = this->gpu()->getPreferredStencilFormat(rt->backendFormat());
if (!stencilFormat.isValid()) {
return false;
}
GrProtected isProtected = rt->isProtected() ? GrProtected::kYes : GrProtected::kNo;
int numStencilSamples = num_stencil_samples(rt, useMSAASurface, *this->caps());
GrAttachment::ComputeSharedAttachmentUniqueKey(
*this->caps(), stencilFormat, rt->dimensions(),
GrAttachment::UsageFlags::kStencilAttachment, numStencilSamples, GrMipmapped::kNo,
isProtected, GrMemoryless::kNo, &sbKey);
auto keyedStencil = this->findByUniqueKey<GrAttachment>(sbKey);
if (!keyedStencil) {
// Need to try and create a new stencil
keyedStencil = this->gpu()->makeStencilAttachment(rt->backendFormat(), rt->dimensions(),
numStencilSamples);
if (!keyedStencil) {
return false;
}
this->assignUniqueKeyToResource(sbKey, keyedStencil.get());
}
rt->attachStencilAttachment(std::move(keyedStencil), useMSAASurface);
}
stencil = rt->getStencilAttachment(useMSAASurface);
SkASSERT(!stencil ||
stencil->numSamples() == num_stencil_samples(rt, useMSAASurface, *this->caps()));
return stencil != nullptr;
}
sk_sp<GrAttachment> GrResourceProvider::getDiscardableMSAAAttachment(SkISize dimensions,
const GrBackendFormat& format,
int sampleCnt,
GrProtected isProtected,
GrMemoryless memoryless) {
ASSERT_SINGLE_OWNER
SkASSERT(sampleCnt > 1);
if (this->isAbandoned()) {
return nullptr;
}
if (!fCaps->validateSurfaceParams(dimensions,
format,
GrRenderable::kYes,
sampleCnt,
GrMipmapped::kNo,
GrTextureType::kNone)) {
return nullptr;
}
skgpu::UniqueKey key;
GrAttachment::ComputeSharedAttachmentUniqueKey(*this->caps(),
format,
dimensions,
GrAttachment::UsageFlags::kColorAttachment,
sampleCnt,
GrMipmapped::kNo,
isProtected,
memoryless,
&key);
auto msaaAttachment = this->findByUniqueKey<GrAttachment>(key);
if (msaaAttachment) {
return msaaAttachment;
}
msaaAttachment = this->makeMSAAAttachment(dimensions, format, sampleCnt, isProtected,
memoryless);
if (msaaAttachment) {
this->assignUniqueKeyToResource(key, msaaAttachment.get());
}
return msaaAttachment;
}
sk_sp<GrAttachment> GrResourceProvider::makeMSAAAttachment(SkISize dimensions,
const GrBackendFormat& format,
int sampleCnt,
GrProtected isProtected,
GrMemoryless memoryless) {
ASSERT_SINGLE_OWNER
SkASSERT(sampleCnt > 1);
if (this->isAbandoned()) {
return nullptr;
}
if (!fCaps->validateSurfaceParams(dimensions,
format,
GrRenderable::kYes,
sampleCnt,
GrMipmapped::kNo,
GrTextureType::kNone)) {
return nullptr;
}
auto scratch = this->refScratchMSAAAttachment(dimensions,
format,
sampleCnt,
isProtected,
memoryless);
if (scratch) {
return scratch;
}
return fGpu->makeMSAAAttachment(dimensions, format, sampleCnt, isProtected, memoryless);
}
sk_sp<GrAttachment> GrResourceProvider::refScratchMSAAAttachment(SkISize dimensions,
const GrBackendFormat& format,
int sampleCnt,
GrProtected isProtected,
GrMemoryless memoryless) {
ASSERT_SINGLE_OWNER
SkASSERT(!this->isAbandoned());
SkASSERT(!this->caps()->isFormatCompressed(format));
SkASSERT(fCaps->validateSurfaceParams(dimensions,
format,
GrRenderable::kYes,
sampleCnt,
GrMipmapped::kNo,
GrTextureType::kNone));
skgpu::ScratchKey key;
GrAttachment::ComputeScratchKey(*this->caps(), format, dimensions,
GrAttachment::UsageFlags::kColorAttachment, sampleCnt,
GrMipmapped::kNo, isProtected, memoryless, &key);
GrGpuResource* resource = fCache->findAndRefScratchResource(key);
if (resource) {
fGpu->stats()->incNumScratchMSAAAttachmentsReused();
GrAttachment* attachment = static_cast<GrAttachment*>(resource);
return sk_sp<GrAttachment>(attachment);
}
return nullptr;
}
std::unique_ptr<GrSemaphore> SK_WARN_UNUSED_RESULT GrResourceProvider::makeSemaphore(
bool isOwned) {
return this->isAbandoned() ? nullptr : fGpu->makeSemaphore(isOwned);
}
std::unique_ptr<GrSemaphore> GrResourceProvider::wrapBackendSemaphore(
const GrBackendSemaphore& semaphore,
GrSemaphoreWrapType wrapType,
GrWrapOwnership ownership) {
ASSERT_SINGLE_OWNER
return this->isAbandoned() ? nullptr : fGpu->wrapBackendSemaphore(semaphore,
wrapType,
ownership);
}
// Ensures the row bytes are populated (not 0) and makes a copy to a temporary
// to make the row bytes tight if necessary. Returns false if the input row bytes are invalid.
static bool prepare_level(const GrMipLevel& inLevel,
SkISize dimensions,
bool rowBytesSupport,
GrColorType origColorType,
GrColorType allowedColorType,
GrMipLevel* outLevel,
std::unique_ptr<char[]>* data) {
if (!inLevel.fPixels) {
outLevel->fPixels = nullptr;
outLevel->fRowBytes = 0;
return true;
}
size_t minRB = dimensions.fWidth * GrColorTypeBytesPerPixel(origColorType);
size_t actualRB = inLevel.fRowBytes ? inLevel.fRowBytes : minRB;
if (actualRB < minRB) {
return false;
}
if (origColorType == allowedColorType && (actualRB == minRB || rowBytesSupport)) {
outLevel->fRowBytes = actualRB;
outLevel->fPixels = inLevel.fPixels;
return true;
}
auto tempRB = dimensions.fWidth * GrColorTypeBytesPerPixel(allowedColorType);
data->reset(new char[tempRB * dimensions.fHeight]);
outLevel->fPixels = data->get();
outLevel->fRowBytes = tempRB;
GrImageInfo srcInfo( origColorType, kUnpremul_SkAlphaType, nullptr, dimensions);
GrImageInfo dstInfo(allowedColorType, kUnpremul_SkAlphaType, nullptr, dimensions);
return GrConvertPixels( GrPixmap(dstInfo, data->get(), tempRB),
GrCPixmap(srcInfo, inLevel.fPixels, actualRB));
}
GrColorType GrResourceProvider::prepareLevels(const GrBackendFormat& format,
GrColorType colorType,
SkISize baseSize,
const GrMipLevel texels[],
int mipLevelCount,
TempLevels* tempLevels,
TempLevelDatas* tempLevelDatas) const {
SkASSERT(mipLevelCount && texels && texels[0].fPixels);
auto allowedColorType =
this->caps()->supportedWritePixelsColorType(colorType, format, colorType).fColorType;
if (allowedColorType == GrColorType::kUnknown) {
return GrColorType::kUnknown;
}
bool rowBytesSupport = this->caps()->writePixelsRowBytesSupport();
tempLevels->reset(mipLevelCount);
tempLevelDatas->reset(mipLevelCount);
auto size = baseSize;
for (int i = 0; i < mipLevelCount; ++i) {
if (!prepare_level(texels[i], size, rowBytesSupport, colorType, allowedColorType,
&(*tempLevels)[i], &(*tempLevelDatas)[i])) {
return GrColorType::kUnknown;
}
size = {std::max(size.fWidth / 2, 1), std::max(size.fHeight / 2, 1)};
}
return allowedColorType;
}
sk_sp<GrTexture> GrResourceProvider::writePixels(sk_sp<GrTexture> texture,
GrColorType colorType,
SkISize baseSize,
const GrMipLevel texels[],
int mipLevelCount) const {
SkASSERT(!this->isAbandoned());
SkASSERT(texture);
SkASSERT(colorType != GrColorType::kUnknown);
SkASSERT(mipLevelCount && texels && texels[0].fPixels);
SkAutoSTArray<14, GrMipLevel> tmpTexels;
SkAutoSTArray<14, std::unique_ptr<char[]>> tmpDatas;
auto tempColorType = this->prepareLevels(texture->backendFormat(), colorType, baseSize, texels,
mipLevelCount, &tmpTexels, &tmpDatas);
if (tempColorType == GrColorType::kUnknown) {
return nullptr;
}
SkAssertResult(fGpu->writePixels(texture.get(),
SkIRect::MakeSize(baseSize),
colorType,
tempColorType,
tmpTexels.get(),
mipLevelCount));
return texture;
}