| /* |
| * Copyright 2022 Google Inc. |
| * |
| * 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/GrBackendSurface.h" |
| #include "include/gpu/GrDirectContext.h" |
| #include "include/gpu/GrTypes.h" |
| #include "include/gpu/ganesh/SkSurfaceGanesh.h" |
| #include "include/private/SkColorData.h" |
| #include "include/private/gpu/ganesh/GrTypesPriv.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/GrFragmentProcessor.h" |
| #include "src/gpu/ganesh/GrPaint.h" |
| #include "src/gpu/ganesh/GrProxyProvider.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/CtsEnforcement.h" |
| #include "tests/Test.h" |
| #include "tests/TestUtils.h" |
| #include "tools/gpu/FenceSync.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; |
| } |
| } |
| } |
