99d5d0fe67
Change-Id: Id12f811c1dc6a6070bb52ff2278234679ce49aff Reviewed-on: https://skia-review.googlesource.com/c/skia/+/532136 Reviewed-by: Greg Daniel <egdaniel@google.com>
244 lines
10 KiB
C++
244 lines
10 KiB
C++
/*
|
|
* Copyright 2018 Google Inc.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license that can be
|
|
* found in the LICENSE file.
|
|
*/
|
|
|
|
// This is a GPU-backend specific test. It relies on static initializers to work
|
|
|
|
#include "include/core/SkTypes.h"
|
|
|
|
#if defined(SK_VULKAN)
|
|
|
|
#include "include/core/SkImage.h"
|
|
#include "include/gpu/GrBackendSurface.h"
|
|
#include "include/gpu/GrDirectContext.h"
|
|
#include "include/gpu/vk/GrVkTypes.h"
|
|
#include "include/gpu/vk/GrVkVulkan.h"
|
|
#include "src/gpu/ganesh/GrDirectContextPriv.h"
|
|
#include "src/gpu/ganesh/GrTexture.h"
|
|
#include "src/gpu/ganesh/GrTextureProxy.h"
|
|
#include "src/gpu/ganesh/vk/GrVkGpu.h"
|
|
#include "src/gpu/ganesh/vk/GrVkImageLayout.h"
|
|
#include "src/gpu/ganesh/vk/GrVkTexture.h"
|
|
#include "src/image/SkImage_Base.h"
|
|
#include "src/image/SkImage_Gpu.h"
|
|
#include "src/image/SkImage_GpuBase.h"
|
|
#include "src/image/SkSurface_Gpu.h"
|
|
#include "tests/Test.h"
|
|
#include "tools/gpu/ManagedBackendTexture.h"
|
|
#include "tools/gpu/ProxyUtils.h"
|
|
|
|
DEF_GPUTEST_FOR_VULKAN_CONTEXT(VkDRMModifierTest, reporter, ctxInfo) {
|
|
auto dContext = ctxInfo.directContext();
|
|
|
|
const GrVkCaps* vkCaps = static_cast<const GrVkCaps*>(dContext->priv().caps());
|
|
if (!vkCaps->supportsDRMFormatModifiers()) {
|
|
return;
|
|
}
|
|
|
|
// First make a normal backend texture with DRM
|
|
auto mbet = sk_gpu_test::ManagedBackendTexture::MakeWithoutData(
|
|
dContext, 1, 1, kRGBA_8888_SkColorType, GrMipmapped::kNo, GrRenderable::kNo);
|
|
if (!mbet) {
|
|
ERRORF(reporter, "Could not create backend texture.");
|
|
return;
|
|
}
|
|
|
|
GrVkImageInfo info;
|
|
REPORTER_ASSERT(reporter, mbet->texture().getVkImageInfo(&info));
|
|
|
|
// Next we will use the same VkImageInfo but lie to say tiling is a DRM modifier. This should
|
|
// cause us to think the resource is eternal/read only internally. Though since we don't
|
|
// explicitly pass in the tiling to anything, this shouldn't cause us to do anything illegal.
|
|
info.fImageTiling = VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT;
|
|
|
|
GrBackendTexture drmBETex = GrBackendTexture(1, 1, info);
|
|
GrBackendFormat drmFormat = GrBackendFormat::MakeVk(info.fFormat, true);
|
|
REPORTER_ASSERT(reporter, drmFormat == drmBETex.getBackendFormat());
|
|
REPORTER_ASSERT(reporter, drmBETex.textureType() == GrTextureType::kExternal);
|
|
|
|
// Now wrap the texture in an SkImage and make sure we have the required read only properties
|
|
sk_sp<SkImage> drmImage = SkImage::MakeFromTexture(dContext,
|
|
drmBETex,
|
|
kTopLeft_GrSurfaceOrigin,
|
|
kRGBA_8888_SkColorType,
|
|
kPremul_SkAlphaType,
|
|
nullptr);
|
|
REPORTER_ASSERT(reporter, drmImage);
|
|
|
|
REPORTER_ASSERT(reporter,
|
|
GrBackendTexture::TestingOnly_Equals(drmImage->getBackendTexture(false), drmBETex));
|
|
|
|
auto[view, _] = as_IB(drmImage.get()) -> asView(dContext, GrMipmapped::kNo);
|
|
REPORTER_ASSERT(reporter, view);
|
|
const GrSurfaceProxy* proxy = view.proxy();
|
|
REPORTER_ASSERT(reporter, proxy);
|
|
|
|
REPORTER_ASSERT(reporter, proxy->readOnly());
|
|
|
|
const GrSurface* surf = proxy->peekSurface();
|
|
REPORTER_ASSERT(reporter, surf);
|
|
REPORTER_ASSERT(reporter, surf->readOnly());
|
|
|
|
drmImage.reset();
|
|
}
|
|
|
|
DEF_GPUTEST_FOR_VULKAN_CONTEXT(VkImageLayoutTest, reporter, ctxInfo) {
|
|
auto dContext = ctxInfo.directContext();
|
|
|
|
auto mbet = sk_gpu_test::ManagedBackendTexture::MakeWithoutData(
|
|
dContext, 1, 1, kRGBA_8888_SkColorType, GrMipmapped::kNo, GrRenderable::kNo);
|
|
if (!mbet) {
|
|
ERRORF(reporter, "Could not create backend texture.");
|
|
return;
|
|
}
|
|
|
|
GrVkImageInfo info;
|
|
REPORTER_ASSERT(reporter, mbet->texture().getVkImageInfo(&info));
|
|
VkImageLayout initLayout = info.fImageLayout;
|
|
|
|
// Verify that setting that layout via a copy of a backendTexture is reflected in all the
|
|
// backendTextures.
|
|
GrBackendTexture backendTex1 = mbet->texture();
|
|
GrBackendTexture backendTex2 = backendTex1;
|
|
REPORTER_ASSERT(reporter, backendTex2.getVkImageInfo(&info));
|
|
REPORTER_ASSERT(reporter, initLayout == info.fImageLayout);
|
|
|
|
backendTex2.setVkImageLayout(VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
|
|
|
|
REPORTER_ASSERT(reporter, backendTex1.getVkImageInfo(&info));
|
|
REPORTER_ASSERT(reporter, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL == info.fImageLayout);
|
|
|
|
REPORTER_ASSERT(reporter, backendTex2.getVkImageInfo(&info));
|
|
REPORTER_ASSERT(reporter, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL == info.fImageLayout);
|
|
|
|
// Setting back the layout since we didn't actually change it
|
|
backendTex1.setVkImageLayout(initLayout);
|
|
|
|
sk_sp<SkImage> wrappedImage = SkImage::MakeFromTexture(
|
|
dContext,
|
|
backendTex1,
|
|
kTopLeft_GrSurfaceOrigin,
|
|
kRGBA_8888_SkColorType,
|
|
kPremul_SkAlphaType,
|
|
/*color space*/ nullptr,
|
|
sk_gpu_test::ManagedBackendTexture::ReleaseProc,
|
|
mbet->releaseContext());
|
|
REPORTER_ASSERT(reporter, wrappedImage.get());
|
|
|
|
GrSurfaceProxy* proxy = sk_gpu_test::GetTextureImageProxy(wrappedImage.get(), dContext);
|
|
REPORTER_ASSERT(reporter, proxy);
|
|
REPORTER_ASSERT(reporter, proxy->isInstantiated());
|
|
GrTexture* texture = proxy->peekTexture();
|
|
REPORTER_ASSERT(reporter, texture);
|
|
|
|
// Verify that modifying the layout via the GrVkTexture is reflected in the GrBackendTexture
|
|
GrVkImage* vkTexture = static_cast<GrVkTexture*>(texture)->textureImage();
|
|
REPORTER_ASSERT(reporter, initLayout == vkTexture->currentLayout());
|
|
vkTexture->updateImageLayout(VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
|
|
|
|
REPORTER_ASSERT(reporter, backendTex1.getVkImageInfo(&info));
|
|
REPORTER_ASSERT(reporter, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL == info.fImageLayout);
|
|
|
|
GrBackendTexture backendTexImage = wrappedImage->getBackendTexture(false);
|
|
REPORTER_ASSERT(reporter, backendTexImage.getVkImageInfo(&info));
|
|
REPORTER_ASSERT(reporter, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL == info.fImageLayout);
|
|
|
|
// Verify that modifying the layout via the GrBackendTexutre is reflected in the GrVkTexture
|
|
backendTexImage.setVkImageLayout(VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
|
|
REPORTER_ASSERT(reporter, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL == vkTexture->currentLayout());
|
|
|
|
vkTexture->updateImageLayout(initLayout);
|
|
|
|
REPORTER_ASSERT(reporter, backendTex1.getVkImageInfo(&info));
|
|
REPORTER_ASSERT(reporter, initLayout == info.fImageLayout);
|
|
|
|
REPORTER_ASSERT(reporter, backendTex2.getVkImageInfo(&info));
|
|
REPORTER_ASSERT(reporter, initLayout == info.fImageLayout);
|
|
|
|
REPORTER_ASSERT(reporter, backendTexImage.getVkImageInfo(&info));
|
|
REPORTER_ASSERT(reporter, initLayout == info.fImageLayout);
|
|
|
|
// Check that we can do things like assigning the backend texture to invalid one, assign an
|
|
// invalid one, assin a backend texture to inself etc. Success here is that we don't hit any of
|
|
// our ref counting asserts.
|
|
REPORTER_ASSERT(reporter, GrBackendTexture::TestingOnly_Equals(backendTex1, backendTex2));
|
|
|
|
GrBackendTexture invalidTexture;
|
|
REPORTER_ASSERT(reporter, !invalidTexture.isValid());
|
|
REPORTER_ASSERT(reporter, !GrBackendTexture::TestingOnly_Equals(invalidTexture, backendTex2));
|
|
|
|
backendTex2 = invalidTexture;
|
|
REPORTER_ASSERT(reporter, !backendTex2.isValid());
|
|
REPORTER_ASSERT(reporter, !GrBackendTexture::TestingOnly_Equals(invalidTexture, backendTex2));
|
|
|
|
invalidTexture = backendTex1;
|
|
REPORTER_ASSERT(reporter, invalidTexture.isValid());
|
|
REPORTER_ASSERT(reporter, GrBackendTexture::TestingOnly_Equals(invalidTexture, backendTex1));
|
|
|
|
invalidTexture = static_cast<decltype(invalidTexture)&>(invalidTexture);
|
|
REPORTER_ASSERT(reporter, invalidTexture.isValid());
|
|
REPORTER_ASSERT(reporter, GrBackendTexture::TestingOnly_Equals(invalidTexture, invalidTexture));
|
|
}
|
|
|
|
// This test is disabled because it executes illegal vulkan calls which cause the validations layers
|
|
// to fail and makes us assert. Once fixed to use a valid vulkan call sequence it should be
|
|
// renenabled, see skbug.com/8936.
|
|
#if 0
|
|
// Test to make sure we transition from the EXTERNAL queue even when no layout transition is needed.
|
|
DEF_GPUTEST_FOR_VULKAN_CONTEXT(VkTransitionExternalQueueTest, reporter, ctxInfo) {
|
|
auto dContext = ctxInfo.directContext();
|
|
GrGpu* gpu = dContext->priv().getGpu();
|
|
GrVkGpu* vkGpu = static_cast<GrVkGpu*>(gpu);
|
|
if (!vkGpu->vkCaps().supportsExternalMemory()) {
|
|
return;
|
|
}
|
|
|
|
GrBackendTexture backendTex = dContext->createBackendTexture(
|
|
1, 1, kRGBA_8888_SkColorType,
|
|
SkColors::kTransparent, GrMipmapped::kNo, GrRenderable::kNo);
|
|
sk_sp<SkImage> image;
|
|
// Make a backend texture with an external queue family and general layout.
|
|
GrVkImageInfo vkInfo;
|
|
if (!backendTex.getVkImageInfo(&vkInfo)) {
|
|
return;
|
|
}
|
|
vkInfo.fCurrentQueueFamily = VK_QUEUE_FAMILY_EXTERNAL;
|
|
// Use a read-only layout as these are the ones where we can otherwise skip a transition.
|
|
vkInfo.fImageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
|
|
|
|
GrBackendTexture vkExtTex(1, 1, vkInfo);
|
|
REPORTER_ASSERT(reporter, vkExtTex.isValid());
|
|
image = SkImage::MakeFromTexture(dContext, vkExtTex, kTopLeft_GrSurfaceOrigin,
|
|
kRGBA_8888_SkColorType, kPremul_SkAlphaType, nullptr, nullptr,
|
|
nullptr);
|
|
|
|
if (!image) {
|
|
return;
|
|
}
|
|
|
|
GrTexture* texture = image->getTexture();
|
|
REPORTER_ASSERT(reporter, texture);
|
|
GrVkTexture* vkTex = static_cast<GrVkTexture*>(texture);
|
|
|
|
// Change our backend texture to the internal queue, with the same layout. This should force a
|
|
// queue transition even though the layouts match.
|
|
vkTex->setImageLayout(vkGpu, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, 0,
|
|
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, false);
|
|
|
|
// Get our image info again and make sure we transitioned queues.
|
|
GrBackendTexture newBackendTexture = image->getBackendTexture(true);
|
|
GrVkImageInfo newVkInfo;
|
|
REPORTER_ASSERT(reporter, newBackendTexture.getVkImageInfo(&newVkInfo));
|
|
REPORTER_ASSERT(reporter, newVkInfo.fCurrentQueueFamily == vkGpu->queueIndex());
|
|
|
|
image.reset();
|
|
dContext->submit(true);
|
|
dContext->deleteBackendTexture(backendTex);
|
|
}
|
|
#endif
|
|
|
|
#endif
|