| /* | |
| * Copyright 2011 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/gl/GrGLRenderTarget.h" | |
| #include "include/core/SkTraceMemoryDump.h" | |
| #include "include/gpu/GrDirectContext.h" | |
| #include "src/gpu/GrBackendUtils.h" | |
| #include "src/gpu/GrDirectContextPriv.h" | |
| #include "src/gpu/GrGpuResourcePriv.h" | |
| #include "src/gpu/gl/GrGLGpu.h" | |
| #include "src/gpu/gl/GrGLUtil.h" | |
| #define GPUGL static_cast<GrGLGpu*>(this->getGpu()) | |
| #define GL_CALL(X) GR_GL_CALL(GPUGL->glInterface(), X) | |
| // Because this class is virtually derived from GrSurface we must explicitly call its constructor. | |
| // Constructor for wrapped render targets. | |
| GrGLRenderTarget::GrGLRenderTarget(GrGLGpu* gpu, | |
| const SkISize& dimensions, | |
| GrGLFormat format, | |
| int sampleCount, | |
| const IDs& ids, | |
| GrGLAttachment* stencil) | |
| : GrSurface(gpu, dimensions, GrProtected::kNo) | |
| , INHERITED(gpu, dimensions, sampleCount, GrProtected::kNo, stencil) { | |
| this->setFlags(gpu->glCaps(), ids); | |
| this->init(format, ids); | |
| this->registerWithCacheWrapped(GrWrapCacheable::kNo); | |
| } | |
| GrGLRenderTarget::GrGLRenderTarget(GrGLGpu* gpu, | |
| const SkISize& dimensions, | |
| GrGLFormat format, | |
| int sampleCount, | |
| const IDs& ids) | |
| : GrSurface(gpu, dimensions, GrProtected::kNo) | |
| , INHERITED(gpu, dimensions, sampleCount, GrProtected::kNo) { | |
| this->setFlags(gpu->glCaps(), ids); | |
| this->init(format, ids); | |
| } | |
| inline void GrGLRenderTarget::setFlags(const GrGLCaps& glCaps, const IDs& idDesc) { | |
| if (!idDesc.fRTFBOID) { | |
| this->setGLRTFBOIDIs0(); | |
| } | |
| } | |
| void GrGLRenderTarget::init(GrGLFormat format, const IDs& idDesc) { | |
| fRTFBOID = idDesc.fRTFBOID; | |
| fSingleSampleFBOID = idDesc.fSingleSampleFBOID; | |
| fMSColorRenderbufferID = idDesc.fMSColorRenderbufferID; | |
| fRTFBOOwnership = idDesc.fRTFBOOwnership; | |
| fRTFormat = format; | |
| fNumSamplesOwnedPerPixel = this->totalSamples(); | |
| } | |
| GrGLFormat stencil_bits_to_format(int stencilBits) { | |
| SkASSERT(stencilBits); | |
| switch (stencilBits) { | |
| case 8: | |
| // We pick the packed format here so when we query total size we are at least not | |
| // underestimating the total size of the stencil buffer. However, in reality this | |
| // rarely matters since we usually don't care about the size of wrapped objects. | |
| return GrGLFormat::kDEPTH24_STENCIL8; | |
| case 16: | |
| return GrGLFormat::kSTENCIL_INDEX16; | |
| default: | |
| SkASSERT(false); | |
| return GrGLFormat::kUnknown; | |
| } | |
| } | |
| sk_sp<GrGLRenderTarget> GrGLRenderTarget::MakeWrapped(GrGLGpu* gpu, | |
| const SkISize& dimensions, | |
| GrGLFormat format, | |
| int sampleCount, | |
| const IDs& idDesc, | |
| int stencilBits) { | |
| GrGLAttachment* sb = nullptr; | |
| if (stencilBits) { | |
| GrGLAttachment::IDDesc sbDesc; | |
| // We pick a "fake" actual format that matches the number of stencil bits. When wrapping | |
| // an FBO with some number of stencil bits all we care about in the future is that we have | |
| // a format with the same number of stencil bits. We don't even directly use the format or | |
| // any other properties. Thus it is fine for us to just assign an arbitrary format that | |
| // matches the stencil bit count. | |
| GrGLFormat sFmt = stencil_bits_to_format(stencilBits); | |
| // Ownership of sb is passed to the GrRenderTarget so doesn't need to be deleted | |
| sb = new GrGLAttachment(gpu, sbDesc, dimensions, | |
| GrAttachment::UsageFlags::kStencilAttachment, sampleCount, sFmt); | |
| } | |
| return sk_sp<GrGLRenderTarget>( | |
| new GrGLRenderTarget(gpu, dimensions, format, sampleCount, idDesc, sb)); | |
| } | |
| GrBackendRenderTarget GrGLRenderTarget::getBackendRenderTarget() const { | |
| GrGLFramebufferInfo fbi; | |
| fbi.fFBOID = fRTFBOID; | |
| fbi.fFormat = GrGLFormatToEnum(this->format()); | |
| int numStencilBits = 0; | |
| if (GrAttachment* stencil = this->getStencilAttachment()) { | |
| numStencilBits = GrBackendFormatStencilBits(stencil->backendFormat()); | |
| } | |
| return GrBackendRenderTarget( | |
| this->width(), this->height(), this->numSamples(), numStencilBits, fbi); | |
| } | |
| GrBackendFormat GrGLRenderTarget::backendFormat() const { | |
| // We should never have a GrGLRenderTarget (even a textureable one with a target that is not | |
| // texture 2D. | |
| return GrBackendFormat::MakeGL(GrGLFormatToEnum(fRTFormat), GR_GL_TEXTURE_2D); | |
| } | |
| size_t GrGLRenderTarget::onGpuMemorySize() const { | |
| return GrSurface::ComputeSize(this->backendFormat(), this->dimensions(), | |
| fNumSamplesOwnedPerPixel, GrMipmapped::kNo); | |
| } | |
| bool GrGLRenderTarget::completeStencilAttachment() { | |
| GrGLGpu* gpu = this->getGLGpu(); | |
| const GrGLInterface* interface = gpu->glInterface(); | |
| GrAttachment* stencil = this->getStencilAttachment(); | |
| if (nullptr == stencil) { | |
| GR_GL_CALL(interface, FramebufferRenderbuffer(GR_GL_FRAMEBUFFER, | |
| GR_GL_STENCIL_ATTACHMENT, | |
| GR_GL_RENDERBUFFER, 0)); | |
| GR_GL_CALL(interface, FramebufferRenderbuffer(GR_GL_FRAMEBUFFER, | |
| GR_GL_DEPTH_ATTACHMENT, | |
| GR_GL_RENDERBUFFER, 0)); | |
| #ifdef SK_DEBUG | |
| if (!gpu->glCaps().skipErrorChecks()) { | |
| // This check can cause problems in Chromium if the context has been asynchronously | |
| // abandoned (see skbug.com/5200) | |
| GrGLenum status; | |
| GR_GL_CALL_RET(interface, status, CheckFramebufferStatus(GR_GL_FRAMEBUFFER)); | |
| SkASSERT(GR_GL_FRAMEBUFFER_COMPLETE == status); | |
| } | |
| #endif | |
| return true; | |
| } else { | |
| const GrGLAttachment* glStencil = static_cast<const GrGLAttachment*>(stencil); | |
| GrGLuint rb = glStencil->renderbufferID(); | |
| gpu->invalidateBoundRenderTarget(); | |
| gpu->bindFramebuffer(GR_GL_FRAMEBUFFER, this->renderFBOID()); | |
| GR_GL_CALL(interface, FramebufferRenderbuffer(GR_GL_FRAMEBUFFER, | |
| GR_GL_STENCIL_ATTACHMENT, | |
| GR_GL_RENDERBUFFER, rb)); | |
| if (GrGLFormatIsPackedDepthStencil(glStencil->format())) { | |
| GR_GL_CALL(interface, FramebufferRenderbuffer(GR_GL_FRAMEBUFFER, | |
| GR_GL_DEPTH_ATTACHMENT, | |
| GR_GL_RENDERBUFFER, rb)); | |
| } else { | |
| GR_GL_CALL(interface, FramebufferRenderbuffer(GR_GL_FRAMEBUFFER, | |
| GR_GL_DEPTH_ATTACHMENT, | |
| GR_GL_RENDERBUFFER, 0)); | |
| } | |
| #ifdef SK_DEBUG | |
| if (!gpu->glCaps().skipErrorChecks()) { | |
| // This check can cause problems in Chromium if the context has been asynchronously | |
| // abandoned (see skbug.com/5200) | |
| GrGLenum status; | |
| GR_GL_CALL_RET(interface, status, CheckFramebufferStatus(GR_GL_FRAMEBUFFER)); | |
| SkASSERT(GR_GL_FRAMEBUFFER_COMPLETE == status); | |
| } | |
| #endif | |
| return true; | |
| } | |
| } | |
| void GrGLRenderTarget::onRelease() { | |
| if (GrBackendObjectOwnership::kBorrowed != fRTFBOOwnership) { | |
| GrGLGpu* gpu = this->getGLGpu(); | |
| if (fSingleSampleFBOID) { | |
| gpu->deleteFramebuffer(fSingleSampleFBOID); | |
| } | |
| if (fRTFBOID && fRTFBOID != fSingleSampleFBOID) { | |
| gpu->deleteFramebuffer(fRTFBOID); | |
| } | |
| if (fMSColorRenderbufferID) { | |
| GL_CALL(DeleteRenderbuffers(1, &fMSColorRenderbufferID)); | |
| } | |
| } | |
| fRTFBOID = 0; | |
| fSingleSampleFBOID = 0; | |
| fMSColorRenderbufferID = 0; | |
| INHERITED::onRelease(); | |
| } | |
| void GrGLRenderTarget::onAbandon() { | |
| fRTFBOID = 0; | |
| fSingleSampleFBOID = 0; | |
| fMSColorRenderbufferID = 0; | |
| INHERITED::onAbandon(); | |
| } | |
| GrGLGpu* GrGLRenderTarget::getGLGpu() const { | |
| SkASSERT(!this->wasDestroyed()); | |
| return static_cast<GrGLGpu*>(this->getGpu()); | |
| } | |
| bool GrGLRenderTarget::canAttemptStencilAttachment() const { | |
| // This cap should have been handled at a higher level. | |
| SkASSERT(!this->getGpu()->getContext()->priv().caps()->avoidStencilBuffers()); | |
| // Only modify the FBO's attachments if we have created the FBO. Public APIs do not currently | |
| // allow for borrowed FBO ownership, so we can safely assume that if an object is owned, | |
| // Skia created it. | |
| return this->fRTFBOOwnership == GrBackendObjectOwnership::kOwned; | |
| } | |
| void GrGLRenderTarget::dumpMemoryStatistics(SkTraceMemoryDump* traceMemoryDump) const { | |
| // Don't check this->fRefsWrappedObjects, as we might be the base of a GrGLTextureRenderTarget | |
| // which is multiply inherited from both ourselves and a texture. In these cases, one part | |
| // (texture, rt) may be wrapped, while the other is owned by Skia. | |
| bool refsWrappedRenderTargetObjects = | |
| this->fRTFBOOwnership == GrBackendObjectOwnership::kBorrowed; | |
| if (refsWrappedRenderTargetObjects && !traceMemoryDump->shouldDumpWrappedObjects()) { | |
| return; | |
| } | |
| // Don't log the framebuffer, as the framebuffer itself doesn't contribute to meaningful | |
| // memory usage. It is always a wrapper around either: | |
| // - a texture, which is owned elsewhere, and will be dumped there | |
| // - a renderbuffer, which will be dumped below. | |
| // Log any renderbuffer's contribution to memory. | |
| if (fMSColorRenderbufferID) { | |
| size_t size = GrSurface::ComputeSize(this->backendFormat(), this->dimensions(), | |
| this->msaaSamples(), GrMipmapped::kNo); | |
| // Due to this resource having both a texture and a renderbuffer component, dump as | |
| // skia/gpu_resources/resource_#/renderbuffer | |
| SkString resourceName = this->getResourceName(); | |
| resourceName.append("/renderbuffer"); | |
| this->dumpMemoryStatisticsPriv(traceMemoryDump, resourceName, "RenderTarget", size); | |
| SkString renderbuffer_id; | |
| renderbuffer_id.appendU32(fMSColorRenderbufferID); | |
| traceMemoryDump->setMemoryBacking(resourceName.c_str(), "gl_renderbuffer", | |
| renderbuffer_id.c_str()); | |
| } | |
| } | |
| int GrGLRenderTarget::msaaSamples() const { | |
| if (fSingleSampleFBOID == kUnresolvableFBOID || fSingleSampleFBOID != fRTFBOID) { | |
| // If the render target's FBO is external (fSingleSampleFBOID == kUnresolvableFBOID), or if | |
| // we own the render target's FBO (fSingleSampleFBOID == fRTFBOID) then we use the provided | |
| // sample count. | |
| return this->numSamples(); | |
| } | |
| // When fSingleSampleFBOID == fRTFBOID, we either are not using MSAA, or MSAA is auto resolving, | |
| // so use 0 for the sample count. | |
| return 0; | |
| } | |
| int GrGLRenderTarget::totalSamples() const { | |
| int total_samples = this->msaaSamples(); | |
| if (fSingleSampleFBOID != kUnresolvableFBOID) { | |
| // If we own the resolve buffer then that is one more sample per pixel. | |
| total_samples += 1; | |
| } | |
| return total_samples; | |
| } |