| /* |
| * 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 "GrGpu.h" |
| |
| #include "GrBackendSemaphore.h" |
| #include "GrBackendSurface.h" |
| #include "GrBuffer.h" |
| #include "GrCaps.h" |
| #include "GrContext.h" |
| #include "GrContextPriv.h" |
| #include "GrGpuResourcePriv.h" |
| #include "GrMesh.h" |
| #include "GrPathRendering.h" |
| #include "GrPipeline.h" |
| #include "GrRenderTargetPriv.h" |
| #include "GrResourceCache.h" |
| #include "GrResourceProvider.h" |
| #include "GrSemaphore.h" |
| #include "GrStencilAttachment.h" |
| #include "GrStencilSettings.h" |
| #include "GrSurfacePriv.h" |
| #include "GrTexturePriv.h" |
| #include "GrTextureProxyPriv.h" |
| #include "GrTracing.h" |
| #include "SkJSONWriter.h" |
| #include "SkMathPriv.h" |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| GrGpu::GrGpu(GrContext* context) |
| : fResetTimestamp(kExpiredTimestamp+1) |
| , fResetBits(kAll_GrBackendState) |
| , fContext(context) { |
| } |
| |
| GrGpu::~GrGpu() {} |
| |
| void GrGpu::disconnect(DisconnectType) {} |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| bool GrGpu::IsACopyNeededForRepeatWrapMode(const GrCaps* caps, GrTextureProxy* texProxy, |
| int width, int height, |
| GrSamplerState::Filter filter, |
| GrTextureProducer::CopyParams* copyParams, |
| SkScalar scaleAdjust[2]) { |
| if (!caps->npotTextureTileSupport() && |
| (!SkIsPow2(width) || !SkIsPow2(height))) { |
| SkASSERT(scaleAdjust); |
| copyParams->fWidth = GrNextPow2(width); |
| copyParams->fHeight = GrNextPow2(height); |
| SkASSERT(scaleAdjust); |
| scaleAdjust[0] = ((SkScalar)copyParams->fWidth) / width; |
| scaleAdjust[1] = ((SkScalar)copyParams->fHeight) / height; |
| switch (filter) { |
| case GrSamplerState::Filter::kNearest: |
| copyParams->fFilter = GrSamplerState::Filter::kNearest; |
| break; |
| case GrSamplerState::Filter::kBilerp: |
| case GrSamplerState::Filter::kMipMap: |
| // We are only ever scaling up so no reason to ever indicate kMipMap. |
| copyParams->fFilter = GrSamplerState::Filter::kBilerp; |
| break; |
| } |
| return true; |
| } |
| |
| if (texProxy) { |
| // If the texture format itself doesn't support repeat wrap mode or mipmapping (and |
| // those capabilities are required) force a copy. |
| if (texProxy->texPriv().isClampOnly()) { |
| copyParams->fFilter = GrSamplerState::Filter::kNearest; |
| copyParams->fWidth = texProxy->width(); |
| copyParams->fHeight = texProxy->height(); |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| bool GrGpu::IsACopyNeededForMips(const GrCaps* caps, const GrTextureProxy* texProxy, |
| GrSamplerState::Filter filter, |
| GrTextureProducer::CopyParams* copyParams) { |
| SkASSERT(texProxy); |
| bool willNeedMips = GrSamplerState::Filter::kMipMap == filter && caps->mipMapSupport(); |
| // If the texture format itself doesn't support mipmapping (and those capabilities are required) |
| // force a copy. |
| if (willNeedMips && texProxy->mipMapped() == GrMipMapped::kNo) { |
| copyParams->fFilter = GrSamplerState::Filter::kNearest; |
| copyParams->fWidth = texProxy->width(); |
| copyParams->fHeight = texProxy->height(); |
| return true; |
| } |
| |
| return false; |
| } |
| |
| sk_sp<GrTexture> GrGpu::createTexture(const GrSurfaceDesc& origDesc, SkBudgeted budgeted, |
| const GrMipLevel texels[], int mipLevelCount) { |
| GR_CREATE_TRACE_MARKER_CONTEXT("GrGpu", "createTexture", fContext); |
| GrSurfaceDesc desc = origDesc; |
| |
| GrMipMapped mipMapped = mipLevelCount > 1 ? GrMipMapped::kYes : GrMipMapped::kNo; |
| if (!this->caps()->validateSurfaceDesc(desc, mipMapped)) { |
| return nullptr; |
| } |
| |
| bool isRT = desc.fFlags & kRenderTarget_GrSurfaceFlag; |
| if (isRT) { |
| desc.fSampleCnt = this->caps()->getRenderTargetSampleCount(desc.fSampleCnt, desc.fConfig); |
| } |
| // Attempt to catch un- or wrongly initialized sample counts. |
| SkASSERT(desc.fSampleCnt > 0 && desc.fSampleCnt <= 64); |
| |
| if (mipLevelCount && (desc.fFlags & kPerformInitialClear_GrSurfaceFlag)) { |
| return nullptr; |
| } |
| |
| this->handleDirtyContext(); |
| sk_sp<GrTexture> tex = this->onCreateTexture(desc, budgeted, texels, mipLevelCount); |
| if (tex) { |
| if (!this->caps()->reuseScratchTextures() && !isRT) { |
| tex->resourcePriv().removeScratchKey(); |
| } |
| fStats.incTextureCreates(); |
| if (mipLevelCount) { |
| if (texels[0].fPixels) { |
| fStats.incTextureUploads(); |
| } |
| } |
| } |
| return tex; |
| } |
| |
| sk_sp<GrTexture> GrGpu::createTexture(const GrSurfaceDesc& desc, SkBudgeted budgeted) { |
| return this->createTexture(desc, budgeted, nullptr, 0); |
| } |
| |
| sk_sp<GrTexture> GrGpu::wrapBackendTexture(const GrBackendTexture& backendTex, |
| GrWrapOwnership ownership) { |
| this->handleDirtyContext(); |
| if (!this->caps()->isConfigTexturable(backendTex.config())) { |
| return nullptr; |
| } |
| if (backendTex.width() > this->caps()->maxTextureSize() || |
| backendTex.height() > this->caps()->maxTextureSize()) { |
| return nullptr; |
| } |
| return this->onWrapBackendTexture(backendTex, ownership); |
| } |
| |
| sk_sp<GrTexture> GrGpu::wrapRenderableBackendTexture(const GrBackendTexture& backendTex, |
| int sampleCnt, GrWrapOwnership ownership) { |
| this->handleDirtyContext(); |
| if (sampleCnt < 1) { |
| return nullptr; |
| } |
| if (!this->caps()->isConfigTexturable(backendTex.config()) || |
| !this->caps()->getRenderTargetSampleCount(sampleCnt, backendTex.config())) { |
| return nullptr; |
| } |
| |
| if (backendTex.width() > this->caps()->maxRenderTargetSize() || |
| backendTex.height() > this->caps()->maxRenderTargetSize()) { |
| return nullptr; |
| } |
| sk_sp<GrTexture> tex = this->onWrapRenderableBackendTexture(backendTex, sampleCnt, ownership); |
| SkASSERT(!tex || tex->asRenderTarget()); |
| return tex; |
| } |
| |
| sk_sp<GrRenderTarget> GrGpu::wrapBackendRenderTarget(const GrBackendRenderTarget& backendRT) { |
| if (0 == this->caps()->getRenderTargetSampleCount(backendRT.sampleCnt(), backendRT.config())) { |
| return nullptr; |
| } |
| this->handleDirtyContext(); |
| return this->onWrapBackendRenderTarget(backendRT); |
| } |
| |
| sk_sp<GrRenderTarget> GrGpu::wrapBackendTextureAsRenderTarget(const GrBackendTexture& tex, |
| int sampleCnt) { |
| if (0 == this->caps()->getRenderTargetSampleCount(sampleCnt, tex.config())) { |
| return nullptr; |
| } |
| int maxSize = this->caps()->maxTextureSize(); |
| if (tex.width() > maxSize || tex.height() > maxSize) { |
| return nullptr; |
| } |
| this->handleDirtyContext(); |
| return this->onWrapBackendTextureAsRenderTarget(tex, sampleCnt); |
| } |
| |
| GrBuffer* GrGpu::createBuffer(size_t size, GrBufferType intendedType, |
| GrAccessPattern accessPattern, const void* data) { |
| this->handleDirtyContext(); |
| GrBuffer* buffer = this->onCreateBuffer(size, intendedType, accessPattern, data); |
| if (!this->caps()->reuseScratchBuffers()) { |
| buffer->resourcePriv().removeScratchKey(); |
| } |
| return buffer; |
| } |
| |
| bool GrGpu::copySurface(GrSurface* dst, GrSurfaceOrigin dstOrigin, |
| GrSurface* src, GrSurfaceOrigin srcOrigin, |
| const SkIRect& srcRect, const SkIPoint& dstPoint, |
| bool canDiscardOutsideDstRect) { |
| GR_CREATE_TRACE_MARKER_CONTEXT("GrGpu", "copySurface", fContext); |
| SkASSERT(dst && src); |
| this->handleDirtyContext(); |
| return this->onCopySurface(dst, dstOrigin, src, srcOrigin, srcRect, dstPoint, |
| canDiscardOutsideDstRect); |
| } |
| |
| bool GrGpu::readPixels(GrSurface* surface, int left, int top, int width, int height, |
| GrColorType dstColorType, void* buffer, size_t rowBytes) { |
| SkASSERT(surface); |
| |
| int bpp = GrColorTypeBytesPerPixel(dstColorType); |
| if (!GrSurfacePriv::AdjustReadPixelParams(surface->width(), surface->height(), bpp, |
| &left, &top, &width, &height, |
| &buffer, |
| &rowBytes)) { |
| return false; |
| } |
| |
| this->handleDirtyContext(); |
| |
| return this->onReadPixels(surface, left, top, width, height, dstColorType, buffer, rowBytes); |
| } |
| |
| bool GrGpu::writePixels(GrSurface* surface, int left, int top, int width, int height, |
| GrColorType srcColorType, const GrMipLevel texels[], int mipLevelCount) { |
| SkASSERT(surface); |
| if (1 == mipLevelCount) { |
| // We require that if we are not mipped, then the write region is contained in the surface |
| SkIRect subRect = SkIRect::MakeXYWH(left, top, width, height); |
| SkIRect bounds = SkIRect::MakeWH(surface->width(), surface->height()); |
| if (!bounds.contains(subRect)) { |
| return false; |
| } |
| } else if (0 != left || 0 != top || width != surface->width() || height != surface->height()) { |
| // We require that if the texels are mipped, than the write region is the entire surface |
| return false; |
| } |
| |
| for (int currentMipLevel = 0; currentMipLevel < mipLevelCount; currentMipLevel++) { |
| if (!texels[currentMipLevel].fPixels ) { |
| return false; |
| } |
| } |
| |
| this->handleDirtyContext(); |
| if (this->onWritePixels(surface, left, top, width, height, srcColorType, texels, |
| mipLevelCount)) { |
| SkIRect rect = SkIRect::MakeXYWH(left, top, width, height); |
| this->didWriteToSurface(surface, kTopLeft_GrSurfaceOrigin, &rect, mipLevelCount); |
| fStats.incTextureUploads(); |
| return true; |
| } |
| return false; |
| } |
| |
| bool GrGpu::transferPixels(GrTexture* texture, int left, int top, int width, int height, |
| GrColorType bufferColorType, GrBuffer* transferBuffer, size_t offset, |
| size_t rowBytes) { |
| SkASSERT(transferBuffer); |
| |
| // We require that the write region is contained in the texture |
| SkIRect subRect = SkIRect::MakeXYWH(left, top, width, height); |
| SkIRect bounds = SkIRect::MakeWH(texture->width(), texture->height()); |
| if (!bounds.contains(subRect)) { |
| return false; |
| } |
| |
| this->handleDirtyContext(); |
| if (this->onTransferPixels(texture, left, top, width, height, bufferColorType, transferBuffer, |
| offset, rowBytes)) { |
| SkIRect rect = SkIRect::MakeXYWH(left, top, width, height); |
| this->didWriteToSurface(texture, kTopLeft_GrSurfaceOrigin, &rect); |
| fStats.incTransfersToTexture(); |
| |
| return true; |
| } |
| return false; |
| } |
| |
| bool GrGpu::regenerateMipMapLevels(GrTexture* texture) { |
| SkASSERT(texture); |
| SkASSERT(this->caps()->mipMapSupport()); |
| SkASSERT(texture->texturePriv().mipMapped() == GrMipMapped::kYes); |
| SkASSERT(texture->texturePriv().mipMapsAreDirty()); |
| SkASSERT(!texture->asRenderTarget() || !texture->asRenderTarget()->needsResolve()); |
| if (this->onRegenerateMipMapLevels(texture)) { |
| texture->texturePriv().markMipMapsClean(); |
| return true; |
| } |
| return false; |
| } |
| |
| void GrGpu::resolveRenderTarget(GrRenderTarget* target) { |
| SkASSERT(target); |
| this->handleDirtyContext(); |
| this->onResolveRenderTarget(target); |
| } |
| |
| void GrGpu::didWriteToSurface(GrSurface* surface, GrSurfaceOrigin origin, const SkIRect* bounds, |
| uint32_t mipLevels) const { |
| SkASSERT(surface); |
| // Mark any MIP chain and resolve buffer as dirty if and only if there is a non-empty bounds. |
| if (nullptr == bounds || !bounds->isEmpty()) { |
| if (GrRenderTarget* target = surface->asRenderTarget()) { |
| SkIRect flippedBounds; |
| if (kBottomLeft_GrSurfaceOrigin == origin && bounds) { |
| flippedBounds = {bounds->fLeft, surface->height() - bounds->fBottom, |
| bounds->fRight, surface->height() - bounds->fTop}; |
| bounds = &flippedBounds; |
| } |
| target->flagAsNeedingResolve(bounds); |
| } |
| GrTexture* texture = surface->asTexture(); |
| if (texture && 1 == mipLevels) { |
| texture->texturePriv().markMipMapsDirty(); |
| } |
| } |
| } |
| |
| GrSemaphoresSubmitted GrGpu::finishFlush(int numSemaphores, |
| GrBackendSemaphore backendSemaphores[]) { |
| GrResourceProvider* resourceProvider = fContext->contextPriv().resourceProvider(); |
| |
| if (this->caps()->fenceSyncSupport()) { |
| for (int i = 0; i < numSemaphores; ++i) { |
| sk_sp<GrSemaphore> semaphore; |
| if (backendSemaphores[i].isInitialized()) { |
| semaphore = resourceProvider->wrapBackendSemaphore( |
| backendSemaphores[i], GrResourceProvider::SemaphoreWrapType::kWillSignal, |
| kBorrow_GrWrapOwnership); |
| } else { |
| semaphore = resourceProvider->makeSemaphore(false); |
| } |
| this->insertSemaphore(semaphore, false); |
| |
| if (!backendSemaphores[i].isInitialized()) { |
| semaphore->setBackendSemaphore(&backendSemaphores[i]); |
| } |
| } |
| } |
| this->onFinishFlush((numSemaphores > 0 && this->caps()->fenceSyncSupport())); |
| return this->caps()->fenceSyncSupport() ? GrSemaphoresSubmitted::kYes |
| : GrSemaphoresSubmitted::kNo; |
| } |
| |
| void GrGpu::dumpJSON(SkJSONWriter* writer) const { |
| writer->beginObject(); |
| |
| // TODO: Is there anything useful in the base class to dump here? |
| |
| this->onDumpJSON(writer); |
| |
| writer->endObject(); |
| } |