| /* |
| * 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 "GrResourceProvider.h" |
| #include "../private/GrSingleOwner.h" |
| #include "GrBackendSemaphore.h" |
| #include "GrCaps.h" |
| #include "GrContext.h" |
| #include "GrContextPriv.h" |
| #include "GrGpu.h" |
| #include "GrGpuBuffer.h" |
| #include "GrPath.h" |
| #include "GrPathRendering.h" |
| #include "GrProxyProvider.h" |
| #include "GrRenderTargetPriv.h" |
| #include "GrResourceCache.h" |
| #include "GrResourceKey.h" |
| #include "GrSemaphore.h" |
| #include "GrStencilAttachment.h" |
| #include "GrTexturePriv.h" |
| #include "SkGr.h" |
| #include "SkMathPriv.h" |
| |
| const uint32_t GrResourceProvider::kMinScratchTextureSize = 16; |
| |
| #define ASSERT_SINGLE_OWNER \ |
| SkDEBUGCODE(GrSingleOwner::AutoEnforce debug_SingleOwner(fSingleOwner);) |
| |
| GrResourceProvider::GrResourceProvider(GrGpu* gpu, GrResourceCache* cache, GrSingleOwner* owner, |
| bool explicitlyAllocateGPUResources) |
| : fCache(cache) |
| , fGpu(gpu) |
| , fExplicitlyAllocateGPUResources(explicitlyAllocateGPUResources) |
| #ifdef SK_DEBUG |
| , fSingleOwner(owner) |
| #endif |
| { |
| fCaps = sk_ref_sp(fGpu->caps()); |
| } |
| |
| sk_sp<GrTexture> GrResourceProvider::createTexture(const GrSurfaceDesc& desc, SkBudgeted budgeted, |
| const GrMipLevel texels[], int mipLevelCount) { |
| ASSERT_SINGLE_OWNER |
| |
| SkASSERT(mipLevelCount > 0); |
| |
| if (this->isAbandoned()) { |
| return nullptr; |
| } |
| |
| GrMipMapped mipMapped = mipLevelCount > 1 ? GrMipMapped::kYes : GrMipMapped::kNo; |
| if (!fCaps->validateSurfaceDesc(desc, mipMapped)) { |
| return nullptr; |
| } |
| |
| return fGpu->createTexture(desc, budgeted, texels, mipLevelCount); |
| } |
| |
| sk_sp<GrTexture> GrResourceProvider::getExactScratch(const GrSurfaceDesc& desc, |
| SkBudgeted budgeted, Flags flags) { |
| sk_sp<GrTexture> tex(this->refScratchTexture(desc, flags)); |
| if (tex && SkBudgeted::kNo == budgeted) { |
| tex->resourcePriv().makeUnbudgeted(); |
| } |
| |
| return tex; |
| } |
| |
| sk_sp<GrTexture> GrResourceProvider::createTexture(const GrSurfaceDesc& desc, |
| SkBudgeted budgeted, |
| SkBackingFit fit, |
| const GrMipLevel& mipLevel, |
| Flags flags) { |
| ASSERT_SINGLE_OWNER |
| |
| if (this->isAbandoned()) { |
| return nullptr; |
| } |
| |
| if (!mipLevel.fPixels) { |
| return nullptr; |
| } |
| |
| if (!fCaps->validateSurfaceDesc(desc, GrMipMapped::kNo)) { |
| return nullptr; |
| } |
| |
| GrContext* context = fGpu->getContext(); |
| GrProxyProvider* proxyProvider = context->priv().proxyProvider(); |
| |
| SkColorType colorType; |
| if (GrPixelConfigToColorType(desc.fConfig, &colorType)) { |
| sk_sp<GrTexture> tex = (SkBackingFit::kApprox == fit) |
| ? this->createApproxTexture(desc, flags) |
| : this->createTexture(desc, budgeted, flags); |
| if (!tex) { |
| return nullptr; |
| } |
| |
| sk_sp<GrTextureProxy> proxy = proxyProvider->createWrapped(std::move(tex), |
| kTopLeft_GrSurfaceOrigin); |
| if (!proxy) { |
| return nullptr; |
| } |
| auto srcInfo = SkImageInfo::Make(desc.fWidth, desc.fHeight, colorType, |
| kUnknown_SkAlphaType); |
| sk_sp<GrSurfaceContext> sContext = context->priv().makeWrappedSurfaceContext( |
| std::move(proxy)); |
| if (!sContext) { |
| return nullptr; |
| } |
| SkAssertResult(sContext->writePixels(srcInfo, mipLevel.fPixels, mipLevel.fRowBytes, 0, 0)); |
| return sk_ref_sp(sContext->asTextureProxy()->peekTexture()); |
| } else { |
| return fGpu->createTexture(desc, budgeted, &mipLevel, 1); |
| } |
| } |
| |
| sk_sp<GrTexture> GrResourceProvider::createTexture(const GrSurfaceDesc& desc, SkBudgeted budgeted, |
| Flags flags) { |
| ASSERT_SINGLE_OWNER |
| if (this->isAbandoned()) { |
| return nullptr; |
| } |
| |
| if (!fCaps->validateSurfaceDesc(desc, GrMipMapped::kNo)) { |
| return nullptr; |
| } |
| |
| // Compressed textures are read-only so they don't support re-use for scratch. |
| if (!GrPixelConfigIsCompressed(desc.fConfig)) { |
| sk_sp<GrTexture> tex = this->getExactScratch(desc, budgeted, flags); |
| if (tex) { |
| return tex; |
| } |
| } |
| |
| return fGpu->createTexture(desc, budgeted); |
| } |
| |
| sk_sp<GrTexture> GrResourceProvider::createApproxTexture(const GrSurfaceDesc& desc, |
| Flags flags) { |
| ASSERT_SINGLE_OWNER |
| SkASSERT(Flags::kNone == flags || Flags::kNoPendingIO == flags); |
| |
| if (this->isAbandoned()) { |
| return nullptr; |
| } |
| |
| // Currently we don't recycle compressed textures as scratch. |
| if (GrPixelConfigIsCompressed(desc.fConfig)) { |
| return nullptr; |
| } |
| |
| if (!fCaps->validateSurfaceDesc(desc, GrMipMapped::kNo)) { |
| return nullptr; |
| } |
| |
| if (auto tex = this->refScratchTexture(desc, flags)) { |
| return tex; |
| } |
| |
| SkTCopyOnFirstWrite<GrSurfaceDesc> copyDesc(desc); |
| |
| // bin by pow2 with a reasonable min |
| if (!SkToBool(desc.fFlags & kPerformInitialClear_GrSurfaceFlag) && |
| (fGpu->caps()->reuseScratchTextures() || (desc.fFlags & kRenderTarget_GrSurfaceFlag))) { |
| GrSurfaceDesc* wdesc = copyDesc.writable(); |
| wdesc->fWidth = SkTMax(kMinScratchTextureSize, GrNextPow2(desc.fWidth)); |
| wdesc->fHeight = SkTMax(kMinScratchTextureSize, GrNextPow2(desc.fHeight)); |
| } |
| |
| if (auto tex = this->refScratchTexture(*copyDesc, flags)) { |
| return tex; |
| } |
| |
| return fGpu->createTexture(*copyDesc, SkBudgeted::kYes); |
| } |
| |
| sk_sp<GrTexture> GrResourceProvider::refScratchTexture(const GrSurfaceDesc& desc, Flags flags) { |
| ASSERT_SINGLE_OWNER |
| SkASSERT(!this->isAbandoned()); |
| SkASSERT(!GrPixelConfigIsCompressed(desc.fConfig)); |
| SkASSERT(fCaps->validateSurfaceDesc(desc, GrMipMapped::kNo)); |
| |
| // 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 (!SkToBool(desc.fFlags & kPerformInitialClear_GrSurfaceFlag) && |
| (fGpu->caps()->reuseScratchTextures() || (desc.fFlags & kRenderTarget_GrSurfaceFlag))) { |
| |
| GrScratchKey key; |
| GrTexturePriv::ComputeScratchKey(desc, &key); |
| auto scratchFlags = GrResourceCache::ScratchFlags::kNone; |
| if (Flags::kNoPendingIO & flags) { |
| scratchFlags |= GrResourceCache::ScratchFlags::kRequireNoPendingIO; |
| } else if (!(desc.fFlags & kRenderTarget_GrSurfaceFlag)) { |
| // If it is not a render target then it will most likely be populated by |
| // writePixels() which will trigger a flush if the texture has pending IO. |
| scratchFlags |= GrResourceCache::ScratchFlags::kPreferNoPendingIO; |
| } |
| GrGpuResource* resource = fCache->findAndRefScratchResource(key, |
| GrSurface::WorstCaseSize(desc), |
| scratchFlags); |
| if (resource) { |
| GrSurface* surface = static_cast<GrSurface*>(resource); |
| return sk_sp<GrTexture>(surface->asTexture()); |
| } |
| } |
| |
| 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::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 GrUniqueKey& key, |
| GrGpuResource* resource) { |
| ASSERT_SINGLE_OWNER |
| if (this->isAbandoned() || !resource) { |
| return; |
| } |
| resource->resourcePriv().setUniqueKey(key); |
| } |
| |
| sk_sp<GrGpuResource> GrResourceProvider::findResourceByUniqueKey(const GrUniqueKey& 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* data, |
| const GrUniqueKey& key) { |
| if (auto buffer = this->findByUniqueKey<GrGpuBuffer>(key)) { |
| return std::move(buffer); |
| } |
| if (auto buffer = this->createBuffer(size, intendedType, kStatic_GrAccessPattern, data)) { |
| // We shouldn't bin and/or cache static buffers. |
| SkASSERT(buffer->size() == size); |
| SkASSERT(!buffer->resourcePriv().getScratchKey().isValid()); |
| SkASSERT(!buffer->resourcePriv().hasPendingIO_debugOnly()); |
| buffer->resourcePriv().setUniqueKey(key); |
| return sk_sp<const GrGpuBuffer>(buffer); |
| } |
| return nullptr; |
| } |
| |
| sk_sp<const GrGpuBuffer> GrResourceProvider::createPatternedIndexBuffer(const uint16_t* pattern, |
| int patternSize, |
| int reps, |
| int vertCount, |
| const GrUniqueKey* key) { |
| size_t bufferSize = patternSize * reps * sizeof(uint16_t); |
| |
| // This is typically used in GrMeshDrawOps, so we assume kNoPendingIO. |
| 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 kMaxQuads = 1 << 12; // max possible: (1 << 14) - 1; |
| |
| sk_sp<const GrGpuBuffer> GrResourceProvider::createQuadIndexBuffer() { |
| GR_STATIC_ASSERT(4 * kMaxQuads <= 65535); |
| static const uint16_t kPattern[] = { 0, 1, 2, 2, 1, 3 }; |
| return this->createPatternedIndexBuffer(kPattern, 6, kMaxQuads, 4, nullptr); |
| } |
| |
| int GrResourceProvider::QuadCountOfQuadBuffer() { return kMaxQuads; } |
| |
| sk_sp<GrPath> GrResourceProvider::createPath(const SkPath& path, const GrStyle& style) { |
| if (this->isAbandoned()) { |
| return nullptr; |
| } |
| |
| SkASSERT(this->gpu()->pathRendering()); |
| return this->gpu()->pathRendering()->createPath(path, style); |
| } |
| |
| 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 with a reasonable min |
| static const size_t MIN_SIZE = 1 << 12; |
| size_t allocSize = SkTMax(MIN_SIZE, GrNextSizePow2(size)); |
| |
| GrScratchKey key; |
| GrGpuBuffer::ComputeScratchKeyForDynamicVBO(allocSize, intendedType, &key); |
| auto buffer = |
| sk_sp<GrGpuBuffer>(static_cast<GrGpuBuffer*>(this->cache()->findAndRefScratchResource( |
| key, allocSize, GrResourceCache::ScratchFlags::kNone))); |
| if (!buffer) { |
| buffer = this->gpu()->createBuffer(allocSize, intendedType, kDynamic_GrAccessPattern); |
| if (!buffer) { |
| return nullptr; |
| } |
| } |
| if (data) { |
| buffer->updateData(data, size); |
| } |
| return buffer; |
| } |
| |
| bool GrResourceProvider::attachStencilAttachment(GrRenderTarget* rt) { |
| SkASSERT(rt); |
| if (rt->renderTargetPriv().getStencilAttachment()) { |
| return true; |
| } |
| |
| if (!rt->wasDestroyed() && rt->canAttemptStencilAttachment()) { |
| GrUniqueKey sbKey; |
| |
| int width = rt->width(); |
| int height = rt->height(); |
| #if 0 |
| if (this->caps()->oversizedStencilSupport()) { |
| width = SkNextPow2(width); |
| height = SkNextPow2(height); |
| } |
| #endif |
| GrStencilAttachment::ComputeSharedStencilAttachmentKey(width, height, |
| rt->numStencilSamples(), &sbKey); |
| auto stencil = this->findByUniqueKey<GrStencilAttachment>(sbKey); |
| if (!stencil) { |
| // Need to try and create a new stencil |
| stencil.reset(this->gpu()->createStencilAttachmentForRenderTarget(rt, width, height)); |
| if (!stencil) { |
| return false; |
| } |
| this->assignUniqueKeyToResource(sbKey, stencil.get()); |
| } |
| rt->renderTargetPriv().attachStencilAttachment(std::move(stencil)); |
| } |
| return SkToBool(rt->renderTargetPriv().getStencilAttachment()); |
| } |
| |
| sk_sp<GrRenderTarget> GrResourceProvider::wrapBackendTextureAsRenderTarget( |
| const GrBackendTexture& tex, int sampleCnt) |
| { |
| if (this->isAbandoned()) { |
| return nullptr; |
| } |
| return fGpu->wrapBackendTextureAsRenderTarget(tex, sampleCnt); |
| } |
| |
| sk_sp<GrSemaphore> SK_WARN_UNUSED_RESULT GrResourceProvider::makeSemaphore(bool isOwned) { |
| return fGpu->makeSemaphore(isOwned); |
| } |
| |
| sk_sp<GrSemaphore> GrResourceProvider::wrapBackendSemaphore(const GrBackendSemaphore& semaphore, |
| SemaphoreWrapType wrapType, |
| GrWrapOwnership ownership) { |
| ASSERT_SINGLE_OWNER |
| return this->isAbandoned() ? nullptr : fGpu->wrapBackendSemaphore(semaphore, |
| wrapType, |
| ownership); |
| } |