| /* |
| * Copyright 2022 Google LLC |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| #include "include/core/SkAlphaType.h" |
| #include "include/core/SkBitmap.h" |
| #include "include/core/SkCanvas.h" |
| #include "include/core/SkColor.h" |
| #include "include/core/SkColorSpace.h" |
| #include "include/core/SkColorType.h" |
| #include "include/core/SkImageInfo.h" |
| #include "include/core/SkMatrix.h" |
| #include "include/core/SkRect.h" |
| #include "include/core/SkRefCnt.h" |
| #include "include/core/SkSamplingOptions.h" |
| #include "include/core/SkSurface.h" |
| #include "include/core/SkSurfaceProps.h" |
| #include "include/core/SkTypes.h" |
| #include "include/gpu/GpuTypes.h" |
| #include "include/gpu/ganesh/GrBackendSurface.h" |
| #include "include/gpu/ganesh/GrContextOptions.h" |
| #include "include/gpu/ganesh/GrDirectContext.h" |
| #include "include/gpu/ganesh/GrTypes.h" |
| #include "include/gpu/ganesh/SkSurfaceGanesh.h" |
| #include "include/gpu/ganesh/mock/GrMockTypes.h" |
| #include "include/private/gpu/ganesh/GrTypesPriv.h" |
| #include "src/core/SkColorData.h" |
| #include "src/gpu/SkBackingFit.h" |
| #include "src/gpu/Swizzle.h" |
| #include "src/gpu/ganesh/GrCaps.h" |
| #include "src/gpu/ganesh/GrDirectContextPriv.h" |
| #include "src/gpu/ganesh/GrDrawingManager.h" |
| #include "src/gpu/ganesh/GrFragmentProcessor.h" |
| #include "src/gpu/ganesh/GrOnFlushResourceProvider.h" |
| #include "src/gpu/ganesh/GrPaint.h" |
| #include "src/gpu/ganesh/GrProxyProvider.h" |
| #include "src/gpu/ganesh/GrRenderTargetProxy.h" |
| #include "src/gpu/ganesh/GrSamplerState.h" |
| #include "src/gpu/ganesh/GrSurfaceProxy.h" |
| #include "src/gpu/ganesh/GrSurfaceProxyView.h" |
| #include "src/gpu/ganesh/GrTextureProxy.h" |
| #include "src/gpu/ganesh/GrTextureResolveRenderTask.h" |
| #include "src/gpu/ganesh/SurfaceContext.h" |
| #include "src/gpu/ganesh/SurfaceDrawContext.h" |
| #include "src/gpu/ganesh/effects/GrTextureEffect.h" |
| #include "src/gpu/ganesh/ops/OpsTask.h" |
| #include "tests/ComparePixels.h" |
| #include "tests/CtsEnforcement.h" |
| #include "tests/Test.h" |
| #include "tools/gpu/ManagedBackendTexture.h" |
| |
| #include <functional> |
| #include <initializer_list> |
| #include <memory> |
| #include <utility> |
| |
| struct GrContextOptions; |
| |
| using namespace sk_gpu_test; |
| |
| bool check_pixels(skiatest::Reporter* reporter, |
| GrDirectContext* dContext, |
| const GrBackendTexture& tex, |
| const SkImageInfo& info, |
| SkColor expectedColor) { |
| // We have to do the readback of the backend texture wrapped in a different Skia surface than |
| // the one used in the main body of the test or else the readPixels call will trigger resolves |
| // itself. |
| sk_sp<SkSurface> surface = SkSurfaces::WrapBackendTexture(dContext, |
| tex, |
| kTopLeft_GrSurfaceOrigin, |
| /*sampleCnt=*/4, |
| kRGBA_8888_SkColorType, |
| nullptr, |
| nullptr); |
| SkBitmap actual; |
| actual.allocPixels(info); |
| if (!surface->readPixels(actual, 0, 0)) { |
| return false; |
| } |
| |
| SkBitmap expected; |
| expected.allocPixels(info); |
| SkCanvas tmp(expected); |
| tmp.clear(expectedColor); |
| expected.setImmutable(); |
| |
| const float tols[4] = { 0.0f, 0.0f, 0.0f, 0.0f }; |
| |
| auto error = std::function<ComparePixmapsErrorReporter>( |
| [reporter](int x, int y, const float diffs[4]) { |
| SkASSERT(x >= 0 && y >= 0); |
| ERRORF(reporter, "mismatch at %d, %d (%f, %f, %f %f)", |
| x, y, diffs[0], diffs[1], diffs[2], diffs[3]); |
| }); |
| |
| return ComparePixels(expected.pixmap(), actual.pixmap(), tols, error); |
| } |
| |
| DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS(SurfaceResolveTest, |
| reporter, |
| ctxInfo, |
| CtsEnforcement::kApiLevel_T) { |
| auto dContext = ctxInfo.directContext(); |
| |
| SkImageInfo info = SkImageInfo::Make(8, 8, kRGBA_8888_SkColorType, kPremul_SkAlphaType); |
| |
| auto managedTex = ManagedBackendTexture::MakeFromInfo( |
| dContext, info, skgpu::Mipmapped::kNo, GrRenderable::kYes); |
| if (!managedTex) { |
| return; |
| } |
| auto tex = managedTex->texture(); |
| // Wrap the backend surface but tell it rendering with MSAA so that the wrapped texture is the |
| // resolve. |
| sk_sp<SkSurface> surface = SkSurfaces::WrapBackendTexture(dContext, |
| tex, |
| kTopLeft_GrSurfaceOrigin, |
| /*sampleCnt=*/4, |
| kRGBA_8888_SkColorType, |
| nullptr, |
| nullptr); |
| |
| if (!surface) { |
| return; |
| } |
| |
| const GrCaps* caps = dContext->priv().caps(); |
| // In metal and vulkan if we prefer discardable msaa attachments we will also auto resolve. The |
| // GrBackendTexture and SkSurface are set up in a way that is compatible with discardable msaa |
| // for both backends. |
| bool autoResolves = caps->msaaResolvesAutomatically() || |
| caps->preferDiscardableMSAAAttachment(); |
| |
| // First do a simple test where we clear the surface than flush with SkSurface::flush. This |
| // should trigger the resolve and the texture should have the correct data. |
| surface->getCanvas()->clear(SK_ColorRED); |
| dContext->flush(surface.get()); |
| dContext->submit(); |
| REPORTER_ASSERT(reporter, check_pixels(reporter, dContext, tex, info, SK_ColorRED)); |
| |
| // Next try doing a GrDirectContext::flush without the surface which will not trigger a resolve |
| // on gpus without automatic msaa resolves. |
| surface->getCanvas()->clear(SK_ColorBLUE); |
| dContext->flush(); |
| dContext->submit(); |
| if (autoResolves) { |
| REPORTER_ASSERT(reporter, check_pixels(reporter, dContext, tex, info, SK_ColorBLUE)); |
| } else { |
| REPORTER_ASSERT(reporter, check_pixels(reporter, dContext, tex, info, SK_ColorRED)); |
| } |
| |
| // Now doing a surface flush (even without any queued up normal work) should still resolve the |
| // surface. |
| dContext->flush(surface.get()); |
| dContext->submit(); |
| REPORTER_ASSERT(reporter, check_pixels(reporter, dContext, tex, info, SK_ColorBLUE)); |
| |
| // Test using SkSurface::resolve with a GrDirectContext::flush |
| surface->getCanvas()->clear(SK_ColorRED); |
| SkSurfaces::ResolveMSAA(surface); |
| dContext->flush(); |
| dContext->submit(); |
| REPORTER_ASSERT(reporter, check_pixels(reporter, dContext, tex, info, SK_ColorRED)); |
| |
| // Calling resolve again should cause no issues as it is a no-op (there is an assert in the |
| // resolve op that the surface's msaa is dirty, we shouldn't hit that assert). |
| SkSurfaces::ResolveMSAA(surface); |
| dContext->flush(); |
| dContext->submit(); |
| REPORTER_ASSERT(reporter, check_pixels(reporter, dContext, tex, info, SK_ColorRED)); |
| |
| // Try resolving in the middle of draw calls. Non automatic resolve gpus should only see the |
| // results of the first draw. |
| surface->getCanvas()->clear(SK_ColorGREEN); |
| SkSurfaces::ResolveMSAA(surface); |
| surface->getCanvas()->clear(SK_ColorBLUE); |
| dContext->flush(); |
| dContext->submit(); |
| if (autoResolves) { |
| REPORTER_ASSERT(reporter, check_pixels(reporter, dContext, tex, info, SK_ColorBLUE)); |
| } else { |
| REPORTER_ASSERT(reporter, check_pixels(reporter, dContext, tex, info, SK_ColorGREEN)); |
| } |
| |
| // Test that a resolve between draws to a different surface doesn't cause the OpsTasks for that |
| // surface to be split. Fails if we hit validation asserts in GrDrawingManager. |
| // First clear out dirty msaa from previous test |
| dContext->flush(surface.get()); |
| |
| auto otherSurface = SkSurfaces::RenderTarget(dContext, skgpu::Budgeted::kYes, info); |
| REPORTER_ASSERT(reporter, otherSurface); |
| otherSurface->getCanvas()->clear(SK_ColorRED); |
| SkSurfaces::ResolveMSAA(surface); |
| otherSurface->getCanvas()->clear(SK_ColorBLUE); |
| dContext->flush(); |
| dContext->submit(); |
| |
| // Make sure resolving a non-msaa surface doesn't trigger a resolve call. We'll hit an assert |
| // that the msaa is not dirty if it does. |
| REPORTER_ASSERT(reporter, otherSurface); |
| otherSurface->getCanvas()->clear(SK_ColorRED); |
| SkSurfaces::ResolveMSAA(otherSurface); |
| dContext->flush(); |
| dContext->submit(); |
| } |
| |
| // This test comes from crbug.com/1355807 and crbug.com/1365578. The underlying issue was: |
| // * We would do a non-mipmapped draw of a proxy. This proxy would add a dependency from the ops |
| // task to the proxy's last render task, which was a copy task targetting the proxy. |
| // * We would do a mipmapped draw of the same proxy to the same ops task. |
| // GrRenderTask::addDependency would detect the pre-existing dependency and early out before |
| // adding the proxy to a resolve task. |
| // We also test the case where the first draw should add a MSAA resolve and the second draw should |
| // add a mipmap resolve. |
| DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS(NonmippedDrawBeforeMippedDraw, |
| reporter, |
| ctxInfo, |
| CtsEnforcement::kNever) { |
| using ResolveFlags = GrSurfaceProxy::ResolveFlags; |
| auto dc = ctxInfo.directContext(); |
| |
| if (!dc->priv().caps()->mipmapSupport()) { |
| return; |
| } |
| |
| for (int sampleCount : {1, 4}) { |
| GrRenderable renderable = sampleCount > 1 ? GrRenderable::kYes : GrRenderable::kNo; |
| |
| auto bef = dc->priv().caps()->getDefaultBackendFormat(GrColorType::kRGBA_8888, renderable); |
| if (sampleCount > 1) { |
| if (dc->priv().caps()->msaaResolvesAutomatically()) { |
| // MSAA won't add a resolve task. |
| continue; |
| } |
| sampleCount = dc->priv().caps()->getRenderTargetSampleCount(sampleCount, bef); |
| if (!sampleCount) { |
| continue; |
| } |
| } |
| |
| // Create a mipmapped proxy |
| auto mmProxy = dc->priv().proxyProvider()->createProxy(bef, |
| {64, 64}, |
| renderable, |
| sampleCount, |
| skgpu::Mipmapped::kYes, |
| SkBackingFit::kExact, |
| skgpu::Budgeted::kYes, |
| GrProtected::kNo, |
| "test MM Proxy"); |
| GrSurfaceProxyView mmProxyView{mmProxy, |
| kBottomLeft_GrSurfaceOrigin, |
| skgpu::Swizzle::RGBA()}; |
| |
| if (sampleCount > 1) { |
| // Make sure MSAA surface needs a resolve by drawing to it. This also adds a last |
| // render task to the proxy. |
| auto drawContext = skgpu::ganesh::SurfaceDrawContext::Make(dc, |
| GrColorType::kRGBA_8888, |
| mmProxy, |
| nullptr, |
| kBottomLeft_GrSurfaceOrigin, |
| SkSurfaceProps{}); |
| drawContext->fillWithFP(GrFragmentProcessor::MakeColor(SK_PMColor4fWHITE)); |
| } else { |
| // Use a copy, as in the original bug, to dirty the mipmap status and also install |
| // a last render task on the proxy. |
| auto src = dc->priv().proxyProvider()->createProxy(bef, |
| {64, 64}, |
| GrRenderable::kNo, |
| 1, |
| skgpu::Mipmapped::kNo, |
| SkBackingFit::kExact, |
| skgpu::Budgeted::kYes, |
| GrProtected::kNo, |
| "testSrc"); |
| skgpu::ganesh::SurfaceContext mmSC( |
| dc, mmProxyView, {GrColorType::kRGBA_8888, kPremul_SkAlphaType, nullptr}); |
| mmSC.testCopy(src); |
| } |
| |
| auto drawDst = skgpu::ganesh::SurfaceDrawContext::Make(dc, |
| GrColorType::kRGBA_8888, |
| nullptr, |
| SkBackingFit::kExact, |
| {8, 8}, |
| SkSurfaceProps{}, |
| "testDrawDst"); |
| |
| // Do a non-mipmapped draw from the mipmapped texture. This should add a dependency on the |
| // copy task recorded above. If the src texture is also multisampled this should record a |
| // msaa-only resolve. |
| { |
| auto te = GrTextureEffect::Make( |
| mmProxyView, |
| kPremul_SkAlphaType, |
| SkMatrix::I(), |
| GrSamplerState{SkFilterMode::kLinear, SkMipmapMode::kNone}, |
| *dc->priv().caps()); |
| |
| GrPaint paint; |
| paint.setColorFragmentProcessor(std::move(te)); |
| |
| drawDst->drawRect(nullptr, |
| std::move(paint), |
| GrAA::kNo, |
| SkMatrix::Scale(1/8.f, 1/8.f), |
| SkRect::Make(mmProxy->dimensions())); |
| if (sampleCount > 1) { |
| const GrTextureResolveRenderTask* resolveTask = |
| drawDst->getOpsTask()->resolveTask(); |
| if (!resolveTask) { |
| ERRORF(reporter, "No resolve task after drawing MSAA proxy"); |
| return; |
| } |
| if (resolveTask->flagsForProxy(mmProxy) != ResolveFlags::kMSAA) { |
| ERRORF(reporter, "Expected resolve flags to be kMSAA"); |
| return; |
| } |
| } |
| } |
| |
| // Now do a mipmapped draw from the same texture. Ensure that even though we have a |
| // dependency on the copy task we still ensure that a resolve is recorded. |
| { |
| auto te = GrTextureEffect::Make( |
| mmProxyView, |
| kPremul_SkAlphaType, |
| SkMatrix::I(), |
| GrSamplerState{SkFilterMode::kLinear, SkMipmapMode::kLinear}, |
| *dc->priv().caps()); |
| |
| GrPaint paint; |
| paint.setColorFragmentProcessor(std::move(te)); |
| |
| drawDst->drawRect(nullptr, |
| std::move(paint), |
| GrAA::kNo, |
| SkMatrix::Scale(1/8.f, 1/8.f), |
| SkRect::Make(mmProxy->dimensions())); |
| } |
| const GrTextureResolveRenderTask* resolveTask = drawDst->getOpsTask()->resolveTask(); |
| if (!resolveTask) { |
| ERRORF(reporter, "No resolve task after drawing mip mapped proxy"); |
| return; |
| } |
| |
| ResolveFlags expectedFlags = GrSurfaceProxy::ResolveFlags::kMipMaps; |
| const char* expectedStr = "kMipMaps"; |
| if (sampleCount > 1) { |
| expectedFlags |= GrSurfaceProxy::ResolveFlags::kMSAA; |
| expectedStr = "kMipMaps|kMSAA"; |
| } |
| if (resolveTask->flagsForProxy(mmProxy) != expectedFlags) { |
| ERRORF(reporter, "Expected resolve flags to be %s", expectedStr); |
| return; |
| } |
| } |
| } |
| |
| namespace { |
| // A preFlush callback that fails the first N flushes, simulating an allocation failure in an |
| // onFlush callback (e.g. atlas instantiation under memory pressure). |
| class FailingPreFlushCallback : public GrOnFlushCallbackObject { |
| public: |
| explicit FailingPreFlushCallback(int failCount) : fRemainingFailures(failCount) {} |
| bool preFlush(GrOnFlushResourceProvider*) override { |
| if (fRemainingFailures > 0) { |
| --fRemainingFailures; |
| return false; |
| } |
| return true; |
| } |
| bool retainOnFreeGpuResources() override { return true; } |
| |
| private: |
| int fRemainingFailures; |
| }; |
| } // namespace |
| |
| // GrTextureResolveRenderTask::addProxy() optimistically marks a proxy's mipmaps clean / MSAA |
| // resolved at recording time. If the owning flush is dropped without executing render tasks |
| // (e.g., a preFlush callback or the resource allocator fails) the proxy must be re-dirtied so a |
| // later flush will record a new resolve. |
| DEF_GANESH_TEST(SurfaceResolveProxyStateAfterFailedFlush, |
| reporter, |
| /* options */, |
| CtsEnforcement::kNever) { |
| using ResolveFlags = GrSurfaceProxy::ResolveFlags; |
| using Enable = GrContextOptions::Enable; |
| using MipmapMode = GrSamplerState::MipmapMode; |
| |
| for (auto reduceOpsTaskSplitting : {Enable::kYes, Enable::kNo}) { |
| for (int sampleCount : {1, 4}) { |
| GrMockOptions mockOptions; |
| mockOptions.fMipmapSupport = true; |
| mockOptions.fConfigOptions[(int)GrColorType::kRGBA_8888].fRenderability = |
| GrMockOptions::ConfigOptions::Renderability::kMSAA; |
| GrContextOptions ctxOptions; |
| ctxOptions.fReduceOpsTaskSplitting = reduceOpsTaskSplitting; |
| sk_sp<GrDirectContext> dContext = GrDirectContext::MakeMock(&mockOptions, ctxOptions); |
| if (!dContext) { |
| ERRORF(reporter, "could not create mock context"); |
| continue; |
| } |
| GrDrawingManager* drawingManager = dContext->priv().drawingManager(); |
| auto bef = dContext->priv().caps()->getDefaultBackendFormat(GrColorType::kRGBA_8888, |
| GrRenderable::kYes); |
| |
| sk_sp<GrSurfaceProxy> proxy = |
| dContext->priv().proxyProvider()->createProxy(bef, |
| {64, 64}, |
| GrRenderable::kYes, |
| sampleCount, |
| skgpu::Mipmapped::kYes, |
| SkBackingFit::kExact, |
| skgpu::Budgeted::kYes, |
| GrProtected::kNo, |
| "ResolveProxyStateTest"); |
| if (!proxy) { |
| ERRORF(reporter, "could not create proxy"); |
| continue; |
| } |
| GrTextureProxy* texProxy = proxy->asTextureProxy(); |
| GrRenderTargetProxy* rtProxy = proxy->asRenderTargetProxy(); |
| GrSurfaceProxyView proxyView{proxy, |
| kTopLeft_GrSurfaceOrigin, |
| skgpu::Swizzle::RGBA()}; |
| |
| const bool testMSAA = sampleCount > 1; |
| REPORTER_ASSERT(reporter, !testMSAA || proxy->requiresManualMSAAResolve()); |
| |
| auto recordDirtyingDrawAndMipmappedDependency = [&]() { |
| auto srcSDC = |
| skgpu::ganesh::SurfaceDrawContext::Make(dContext.get(), |
| GrColorType::kRGBA_8888, |
| proxy, |
| nullptr, |
| kTopLeft_GrSurfaceOrigin, |
| SkSurfaceProps{}); |
| srcSDC->fillWithFP(GrFragmentProcessor::MakeColor(SK_PMColor4fWHITE)); |
| |
| auto dstSDC = |
| skgpu::ganesh::SurfaceDrawContext::Make(dContext.get(), |
| GrColorType::kRGBA_8888, |
| nullptr, |
| SkBackingFit::kExact, |
| {8, 8}, |
| SkSurfaceProps{}, |
| "ResolveProxyStateTestDst"); |
| auto te = GrTextureEffect::Make( |
| proxyView, |
| kPremul_SkAlphaType, |
| SkMatrix::I(), |
| GrSamplerState{SkFilterMode::kLinear, MipmapMode::kLinear}, |
| *dContext->priv().caps()); |
| GrPaint paint; |
| paint.setColorFragmentProcessor(std::move(te)); |
| dstSDC->drawRect(nullptr, |
| std::move(paint), |
| GrAA::kNo, |
| SkMatrix::Scale(1/8.f, 1/8.f), |
| SkRect::Make(proxy->dimensions())); |
| return dstSDC; |
| }; |
| |
| // Record a flush whose preFlush callback fails. The resolve task records the proxy |
| // as resolved/clean and is then discarded without executing. |
| { |
| FailingPreFlushCallback failCB(1); |
| dContext->priv().addOnFlushCallbackObject(&failCB); |
| |
| auto dstSDC = recordDirtyingDrawAndMipmappedDependency(); |
| |
| ResolveFlags expectedFlags = ResolveFlags::kMipMaps; |
| if (testMSAA) { |
| expectedFlags |= ResolveFlags::kMSAA; |
| } |
| const GrTextureResolveRenderTask* resolveTask = |
| dstSDC->getOpsTask()->resolveTask(); |
| REPORTER_ASSERT(reporter, |
| resolveTask && |
| resolveTask->flagsForProxy(proxy) == expectedFlags); |
| REPORTER_ASSERT(reporter, !texProxy->mipmapsAreDirty()); |
| REPORTER_ASSERT(reporter, !testMSAA || !rtProxy->isMSAADirty()); |
| |
| dContext->flush(); |
| drawingManager->testingOnly_removeOnFlushCallbackObject(&failCB); |
| } |
| |
| // The resolve never executed so the proxy must once again report dirty mips/MSAA. |
| REPORTER_ASSERT(reporter, texProxy->mipmapsAreDirty()); |
| if (testMSAA) { |
| REPORTER_ASSERT(reporter, rtProxy->isMSAADirty()); |
| REPORTER_ASSERT(reporter, |
| rtProxy->msaaDirtyRect() == SkIRect::MakeSize(proxy->dimensions())); |
| } |
| |
| // A subsequent dependency must therefore record a new resolve task and the proxy |
| // should be clean once that flush succeeds. |
| { |
| auto dstSDC = recordDirtyingDrawAndMipmappedDependency(); |
| REPORTER_ASSERT(reporter, dstSDC->getOpsTask()->resolveTask()); |
| dContext->flush(); |
| } |
| REPORTER_ASSERT(reporter, !texProxy->mipmapsAreDirty()); |
| REPORTER_ASSERT(reporter, !testMSAA || !rtProxy->isMSAADirty()); |
| } |
| } |
| } |
| |
| // Directly read back 'tex' and return the first pixel color. |
| static bool read_backing_pixel(GrDirectContext* dContext, |
| const GrBackendTexture& tex, |
| const SkImageInfo& info, |
| SkColor* outPixel) { |
| sk_sp<SkSurface> reader = SkSurfaces::WrapBackendTexture(dContext, |
| tex, |
| kTopLeft_GrSurfaceOrigin, |
| /*sampleCnt=*/1, |
| kRGBA_8888_SkColorType, |
| nullptr, |
| nullptr); |
| if (!reader) { |
| return false; |
| } |
| SkBitmap bm; |
| bm.allocPixels(info); |
| if (!reader->readPixels(bm, 0, 0)) { |
| return false; |
| } |
| *outPixel = bm.getColor(0, 0); |
| return true; |
| } |
| |
| // This test wraps a backend texture as an MSAA render target twice. The first wrap establishes a |
| // known baseline color in the single-sample texture via a *successful* flush. The second wrap |
| // creates a *fresh, never-written* MSAA color attachment (on GL a new renderbuffer, on Vulkan a |
| // scratch/new GrVkImage), records a draw, forces the flush to fail via a failing preFlush |
| // callback, and then reads back the single-sample texture. The read-back must not show the |
| // uninitialized MSAA attachment contents; if it does, resolve_and_mipmap() ran despite the failed |
| // flush and copied uninitialized GPU memory into the client-visible texture. |
| DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS(SurfaceResolveAfterFailedFlush, |
| reporter, |
| ctxInfo, |
| CtsEnforcement::kNever) { |
| auto dContext = ctxInfo.directContext(); |
| const GrCaps* caps = dContext->priv().caps(); |
| |
| // Only meaningful on backends that require an explicit resolve of a persistent MSAA attachment. |
| if (caps->msaaResolvesAutomatically() || caps->preferDiscardableMSAAAttachment()) { |
| return; |
| } |
| |
| SkImageInfo info = SkImageInfo::Make(8, 8, kRGBA_8888_SkColorType, kPremul_SkAlphaType); |
| |
| auto managedTex = ManagedBackendTexture::MakeFromInfo( |
| dContext, info, skgpu::Mipmapped::kNo, GrRenderable::kYes); |
| if (!managedTex) { |
| return; |
| } |
| const GrBackendTexture& tex = managedTex->texture(); |
| |
| constexpr SkColor kBaseline = SK_ColorBLUE; // known content of the single-sample texture |
| constexpr SkColor kIntended = SK_ColorGREEN; // what the failed flush *would* have drawn |
| |
| // 1. Wrap once and successfully draw kBaseline so the single-sample texture holds known bytes. |
| { |
| sk_sp<SkSurface> surface = SkSurfaces::WrapBackendTexture(dContext, |
| tex, |
| kTopLeft_GrSurfaceOrigin, |
| /*sampleCnt=*/4, |
| kRGBA_8888_SkColorType, |
| nullptr, |
| nullptr); |
| if (!surface) { |
| return; // MSAA=4 unsupported on this config. |
| } |
| surface->getCanvas()->clear(kBaseline); |
| dContext->flush(surface.get()); |
| dContext->submit(GrSyncCpu::kYes); |
| } |
| // Ensure the second wrap below allocates a *fresh* MSAA attachment rather than recycling the |
| // one from the wrap above (whose contents would coincidentally match kBaseline). |
| dContext->purgeUnlockedResources(GrPurgeResourceOptions::kAllResources); |
| |
| SkColor pixel = 0; |
| REPORTER_ASSERT(reporter, read_backing_pixel(dContext, tex, info, &pixel)); |
| REPORTER_ASSERT(reporter, pixel == kBaseline, |
| "baseline flush failed to resolve, got 0x%x", pixel); |
| |
| // 2. Re-wrap: this creates a *new* persistent MSAA color attachment that has never been |
| // written by any render pass in this test. |
| sk_sp<SkSurface> surface = SkSurfaces::WrapBackendTexture(dContext, |
| tex, |
| kTopLeft_GrSurfaceOrigin, |
| /*sampleCnt=*/4, |
| kRGBA_8888_SkColorType, |
| nullptr, |
| nullptr); |
| if (!surface) { |
| return; |
| } |
| |
| // 3. Record a full-surface draw so OpsTask::onMakeClosed() returns kTargetDirty and |
| // markMSAADirty() is called during closeAllTasks(). Force the flush to fail. |
| FailingPreFlushCallback failCB(1); |
| dContext->priv().addOnFlushCallbackObject(&failCB); |
| |
| surface->getCanvas()->clear(kIntended); |
| GrSemaphoresSubmitted result = dContext->flush(surface.get(), GrFlushInfo{}); |
| dContext->submit(GrSyncCpu::kYes); |
| |
| GrDrawingManager* drawingManager = dContext->priv().drawingManager(); |
| drawingManager->testingOnly_removeOnFlushCallbackObject(&failCB); |
| |
| REPORTER_ASSERT(reporter, result == GrSemaphoresSubmitted::kNo, |
| "expected flush to report semaphores not submitted"); |
| |
| // 4. Read back the single-sample backing texture. |
| REPORTER_ASSERT(reporter, read_backing_pixel(dContext, tex, info, &pixel)); |
| |
| // The recorded draw never executed, so kIntended should not appear. |
| REPORTER_ASSERT(reporter, pixel != kIntended, |
| "flush failed but draw, somehow, occurred (got 0x%x)", pixel); |
| |
| // Since the flush failed the MSAA resolve step should not have occurred and the contents |
| // of the backend texture should have remained at 'kBaseline'. |
| REPORTER_ASSERT(reporter, pixel == kBaseline, |
| "Invalid resolve after a failed flush: expected 0x%x, actual 0x%x", |
| kBaseline, pixel); |
| } |
