2015-11-22 22:51:00 +00:00
|
|
|
/*
|
|
|
|
* Copyright 2015 Google Inc.
|
|
|
|
*
|
|
|
|
* Use of this source code is governed by a BSD-style license that can be
|
|
|
|
* found in the LICENSE file.
|
|
|
|
*/
|
|
|
|
|
2020-07-06 14:56:46 +00:00
|
|
|
#include "include/gpu/GrDirectContext.h"
|
2020-10-14 15:23:11 +00:00
|
|
|
#include "src/gpu/GrDirectContextPriv.h"
|
2020-04-06 17:57:30 +00:00
|
|
|
#include "src/gpu/GrProxyProvider.h"
|
2019-04-23 17:05:21 +00:00
|
|
|
#include "src/gpu/GrRenderTargetContext.h"
|
|
|
|
#include "src/gpu/GrShaderCaps.h"
|
2020-03-05 19:14:18 +00:00
|
|
|
#include "src/gpu/GrTexture.h"
|
2019-04-23 17:05:21 +00:00
|
|
|
#include "src/gpu/GrTextureProxyPriv.h"
|
|
|
|
#include "src/gpu/gl/GrGLGpu.h"
|
|
|
|
#include "src/gpu/gl/GrGLUtil.h"
|
|
|
|
#include "tests/Test.h"
|
|
|
|
#include "tests/TestUtils.h"
|
|
|
|
#include "tools/gpu/GrContextFactory.h"
|
2020-10-13 00:45:06 +00:00
|
|
|
#include "tools/gpu/ManagedBackendTexture.h"
|
2019-04-23 17:05:21 +00:00
|
|
|
#include "tools/gpu/gl/GLTestContext.h"
|
2015-11-22 22:51:00 +00:00
|
|
|
|
2019-11-08 21:18:15 +00:00
|
|
|
#ifdef SK_GL
|
|
|
|
|
2016-03-31 17:59:06 +00:00
|
|
|
using sk_gpu_test::GLTestContext;
|
2016-03-31 01:56:19 +00:00
|
|
|
|
2020-10-13 00:45:06 +00:00
|
|
|
static void cleanup(GLTestContext* glctx0,
|
|
|
|
GrGLuint texID0,
|
|
|
|
GLTestContext* glctx1,
|
|
|
|
sk_sp<GrDirectContext> dContext,
|
2017-07-25 14:05:01 +00:00
|
|
|
GrEGLImage image1) {
|
2015-11-22 22:51:00 +00:00
|
|
|
if (glctx1) {
|
|
|
|
glctx1->makeCurrent();
|
|
|
|
if (GR_EGL_NO_IMAGE != image1) {
|
|
|
|
glctx1->destroyEGLImage(image1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
glctx0->makeCurrent();
|
|
|
|
if (texID0) {
|
|
|
|
GR_GL_CALL(glctx0->gl(), DeleteTextures(1, &texID0));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-04-06 21:02:39 +00:00
|
|
|
DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(EGLImageTest, reporter, ctxInfo) {
|
2020-07-06 14:56:46 +00:00
|
|
|
auto context0 = ctxInfo.directContext();
|
2016-05-11 13:33:06 +00:00
|
|
|
sk_gpu_test::GLTestContext* glCtx0 = ctxInfo.glContext();
|
2016-04-05 19:59:06 +00:00
|
|
|
|
2015-11-23 07:23:53 +00:00
|
|
|
// Try to create a second GL context and then check if the contexts have necessary
|
|
|
|
// extensions to run this test.
|
2015-11-22 22:51:00 +00:00
|
|
|
|
2015-11-23 07:23:53 +00:00
|
|
|
if (kGLES_GrGLStandard != glCtx0->gl()->fStandard) {
|
|
|
|
return;
|
|
|
|
}
|
2019-02-04 18:26:26 +00:00
|
|
|
GrGLGpu* gpu0 = static_cast<GrGLGpu*>(context0->priv().getGpu());
|
2016-11-29 18:43:46 +00:00
|
|
|
if (!gpu0->glCaps().shaderCaps()->externalTextureSupport()) {
|
2015-11-23 07:23:53 +00:00
|
|
|
return;
|
|
|
|
}
|
2015-11-22 22:51:00 +00:00
|
|
|
|
2016-11-03 18:40:50 +00:00
|
|
|
std::unique_ptr<GLTestContext> glCtx1 = glCtx0->makeNew();
|
2015-11-23 07:23:53 +00:00
|
|
|
if (!glCtx1) {
|
|
|
|
return;
|
|
|
|
}
|
2020-07-13 20:13:31 +00:00
|
|
|
sk_sp<GrDirectContext> context1 = GrDirectContext::MakeGL(sk_ref_sp(glCtx1->gl()));
|
2015-11-23 07:23:53 +00:00
|
|
|
GrEGLImage image = GR_EGL_NO_IMAGE;
|
|
|
|
GrGLTextureInfo externalTexture;
|
|
|
|
externalTexture.fID = 0;
|
2015-11-22 22:51:00 +00:00
|
|
|
|
2015-11-23 07:23:53 +00:00
|
|
|
if (!context1) {
|
2020-10-13 00:45:06 +00:00
|
|
|
cleanup(glCtx0, externalTexture.fID, glCtx1.get(), context1, image);
|
2015-11-23 07:23:53 +00:00
|
|
|
return;
|
|
|
|
}
|
2015-11-22 22:51:00 +00:00
|
|
|
|
2015-11-23 07:23:53 +00:00
|
|
|
if (!glCtx1->gl()->hasExtension("EGL_KHR_image") ||
|
|
|
|
!glCtx1->gl()->hasExtension("EGL_KHR_gl_texture_2D_image")) {
|
2020-10-13 00:45:06 +00:00
|
|
|
cleanup(glCtx0, externalTexture.fID, glCtx1.get(), context1, image);
|
2015-11-23 07:23:53 +00:00
|
|
|
return;
|
|
|
|
}
|
2015-11-22 22:51:00 +00:00
|
|
|
|
2015-11-23 07:23:53 +00:00
|
|
|
///////////////////////////////// CONTEXT 1 ///////////////////////////////////
|
2015-11-22 22:51:00 +00:00
|
|
|
|
2020-08-11 16:02:22 +00:00
|
|
|
// Use GL Context 1 to create a texture unknown to context 0.
|
2020-05-14 19:45:44 +00:00
|
|
|
context1->flushAndSubmit();
|
2015-11-23 07:23:53 +00:00
|
|
|
static const int kSize = 100;
|
2020-05-06 15:40:03 +00:00
|
|
|
|
2020-10-13 00:45:06 +00:00
|
|
|
auto mbet = sk_gpu_test::ManagedBackendTexture::MakeWithoutData(
|
|
|
|
context1.get(), kSize, kSize, kRGBA_8888_SkColorType, GrMipmapped::kNo,
|
|
|
|
GrRenderable::kNo, GrProtected::kNo);
|
2018-01-10 14:57:53 +00:00
|
|
|
|
2020-10-13 00:45:06 +00:00
|
|
|
if (!mbet) {
|
2015-11-23 07:23:53 +00:00
|
|
|
ERRORF(reporter, "Error creating texture for EGL Image");
|
2020-10-13 00:45:06 +00:00
|
|
|
cleanup(glCtx0, externalTexture.fID, glCtx1.get(), context1, image);
|
2015-11-23 07:23:53 +00:00
|
|
|
return;
|
|
|
|
}
|
2017-12-12 18:01:25 +00:00
|
|
|
|
2018-04-10 13:34:07 +00:00
|
|
|
GrGLTextureInfo texInfo;
|
2020-10-13 00:45:06 +00:00
|
|
|
if (!mbet->texture().getGLTextureInfo(&texInfo)) {
|
2018-04-10 13:34:07 +00:00
|
|
|
ERRORF(reporter, "Failed to get GrGLTextureInfo");
|
|
|
|
return;
|
|
|
|
}
|
2017-12-12 18:01:25 +00:00
|
|
|
|
2018-04-10 13:34:07 +00:00
|
|
|
if (GR_GL_TEXTURE_2D != texInfo.fTarget) {
|
2015-11-23 07:23:53 +00:00
|
|
|
ERRORF(reporter, "Expected backend texture to be 2D");
|
2020-10-13 00:45:06 +00:00
|
|
|
cleanup(glCtx0, externalTexture.fID, glCtx1.get(), context1, image);
|
2015-11-23 07:23:53 +00:00
|
|
|
return;
|
|
|
|
}
|
2015-11-22 22:51:00 +00:00
|
|
|
|
2015-11-23 07:23:53 +00:00
|
|
|
// Wrap the texture in an EGLImage
|
2018-04-10 13:34:07 +00:00
|
|
|
image = glCtx1->texture2DToEGLImage(texInfo.fID);
|
2015-11-23 07:23:53 +00:00
|
|
|
if (GR_EGL_NO_IMAGE == image) {
|
|
|
|
ERRORF(reporter, "Error creating EGL Image from texture");
|
2020-10-13 00:45:06 +00:00
|
|
|
cleanup(glCtx0, externalTexture.fID, glCtx1.get(), context1, image);
|
2015-11-23 07:23:53 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2017-10-23 13:37:36 +00:00
|
|
|
// Since we are dealing with two different GL contexts here, we need to call finish so that the
|
|
|
|
// clearing of the texture that happens in createTextingOnlyBackendTexture occurs before we call
|
|
|
|
// TexSubImage below on the other context. Otherwise, it is possible the calls get reordered and
|
|
|
|
// the clearing overwrites the TexSubImage writes.
|
|
|
|
GR_GL_CALL(glCtx1->gl(), Finish());
|
|
|
|
|
2015-11-23 07:23:53 +00:00
|
|
|
// Populate the texture using GL context 1. Important to use TexSubImage as TexImage orphans
|
|
|
|
// the EGL image. Also, this must be done after creating the EGLImage as the texture
|
|
|
|
// contents may not be preserved when the image is created.
|
|
|
|
SkAutoTMalloc<uint32_t> pixels(kSize * kSize);
|
|
|
|
for (int i = 0; i < kSize*kSize; ++i) {
|
|
|
|
pixels.get()[i] = 0xDDAABBCC;
|
|
|
|
}
|
|
|
|
GR_GL_CALL(glCtx1->gl(), ActiveTexture(GR_GL_TEXTURE0));
|
2018-04-10 13:34:07 +00:00
|
|
|
GR_GL_CALL(glCtx1->gl(), BindTexture(texInfo.fTarget, texInfo.fID));
|
|
|
|
GR_GL_CALL(glCtx1->gl(), TexSubImage2D(texInfo.fTarget, 0, 0, 0, kSize, kSize,
|
2015-11-23 07:23:53 +00:00
|
|
|
GR_GL_RGBA, GR_GL_UNSIGNED_BYTE, pixels.get()));
|
|
|
|
GR_GL_CALL(glCtx1->gl(), Finish());
|
2020-07-23 17:54:35 +00:00
|
|
|
// We've been making direct GL calls in GL context 1, let GrDirectContext 1 know its internal
|
2015-11-23 07:23:53 +00:00
|
|
|
// state is invalid.
|
|
|
|
context1->resetContext();
|
|
|
|
|
|
|
|
///////////////////////////////// CONTEXT 0 ///////////////////////////////////
|
|
|
|
|
|
|
|
// Make a new texture ID in GL Context 0 from the EGL Image
|
|
|
|
glCtx0->makeCurrent();
|
|
|
|
externalTexture.fTarget = GR_GL_TEXTURE_EXTERNAL;
|
|
|
|
externalTexture.fID = glCtx0->eglImageToExternalTexture(image);
|
2019-06-13 20:50:49 +00:00
|
|
|
externalTexture.fFormat = GR_GL_RGBA8;
|
2017-06-08 22:22:53 +00:00
|
|
|
if (0 == externalTexture.fID) {
|
|
|
|
ERRORF(reporter, "Error converting EGL Image back to texture");
|
2020-10-13 00:45:06 +00:00
|
|
|
cleanup(glCtx0, externalTexture.fID, glCtx1.get(), context1, image);
|
2017-06-08 22:22:53 +00:00
|
|
|
return;
|
|
|
|
}
|
2015-11-23 07:23:53 +00:00
|
|
|
|
|
|
|
// Wrap this texture ID in a GrTexture
|
2020-07-21 13:27:25 +00:00
|
|
|
GrBackendTexture backendTex(kSize, kSize, GrMipmapped::kNo, externalTexture);
|
2017-01-25 17:10:37 +00:00
|
|
|
|
2019-12-19 21:41:40 +00:00
|
|
|
GrColorType colorType = GrColorType::kRGBA_8888;
|
|
|
|
SkAlphaType alphaType = kPremul_SkAlphaType;
|
Revert "Revert "Plumb GrBackendTexture throughout skia.""
This reverts commit 7fa5c31c2c9af834bee66d5fcf476e250076c8d6.
Reason for revert: Relanding this change now that other fixes have landed.
Original change's description:
> Revert "Plumb GrBackendTexture throughout skia."
>
> This reverts commit 7da62b9059f3c1d31624a0e4da96ee5f908f9c12.
>
> Reason for revert: fix android roll
>
> Original change's description:
> > Plumb GrBackendTexture throughout skia.
> >
> > Bug: skia:
> > Change-Id: I1bae6768ee7229818a83ba608035a1f7867e6875
> > Reviewed-on: https://skia-review.googlesource.com/13645
> > Commit-Queue: Greg Daniel <egdaniel@google.com>
> > Reviewed-by: Robert Phillips <robertphillips@google.com>
> >
>
> TBR=egdaniel@google.com,bsalomon@google.com,robertphillips@google.com,brianosman@google.com,reviews@skia.org,stani@google.com
> NOPRESUBMIT=true
> NOTREECHECKS=true
> NOTRY=true
>
> Change-Id: I5cb8763cc837c83ebc6d10366fe2dd3efe35fb89
> Reviewed-on: https://skia-review.googlesource.com/13773
> Reviewed-by: Stan Iliev <stani@google.com>
> Commit-Queue: Stan Iliev <stani@google.com>
>
TBR=egdaniel@google.com,bsalomon@google.com,robertphillips@google.com,reviews@skia.org,brianosman@google.com,stani@google.com
# Not skipping CQ checks because original CL landed > 1 day ago.
Change-Id: I92bc074e4fe37fa5c83186afadc472c03802e8f2
Reviewed-on: https://skia-review.googlesource.com/13975
Reviewed-by: Greg Daniel <egdaniel@google.com>
Commit-Queue: Greg Daniel <egdaniel@google.com>
2017-04-20 16:41:55 +00:00
|
|
|
// TODO: If I make this TopLeft origin to match resolve_origin calls for kDefault, this test
|
|
|
|
// fails on the Nexus5. Why?
|
2019-12-19 21:41:40 +00:00
|
|
|
GrSurfaceOrigin origin = kBottomLeft_GrSurfaceOrigin;
|
|
|
|
sk_sp<GrSurfaceProxy> texProxy = context0->priv().proxyProvider()->wrapBackendTexture(
|
2020-03-27 14:42:15 +00:00
|
|
|
backendTex, kBorrow_GrWrapOwnership, GrWrapCacheable::kNo, kRW_GrIOType);
|
2019-12-19 21:41:40 +00:00
|
|
|
if (!texProxy) {
|
|
|
|
ERRORF(reporter, "Error wrapping external texture in GrTextureProxy.");
|
2020-10-13 00:45:06 +00:00
|
|
|
cleanup(glCtx0, externalTexture.fID, glCtx1.get(), context1, image);
|
2019-12-19 21:41:40 +00:00
|
|
|
return;
|
|
|
|
}
|
2020-02-05 15:45:39 +00:00
|
|
|
GrSwizzle swizzle =
|
|
|
|
context0->priv().caps()->getReadSwizzle(texProxy->backendFormat(), colorType);
|
|
|
|
GrSurfaceProxyView view(std::move(texProxy), origin, swizzle);
|
|
|
|
auto surfaceContext =
|
|
|
|
GrSurfaceContext::Make(context0, std::move(view), colorType, alphaType, nullptr);
|
2017-01-25 17:10:37 +00:00
|
|
|
|
2017-01-27 15:58:31 +00:00
|
|
|
if (!surfaceContext) {
|
|
|
|
ERRORF(reporter, "Error wrapping external texture in GrSurfaceContext.");
|
2020-10-13 00:45:06 +00:00
|
|
|
cleanup(glCtx0, externalTexture.fID, glCtx1.get(), context1, image);
|
2017-01-27 15:58:31 +00:00
|
|
|
return;
|
2015-11-23 07:23:53 +00:00
|
|
|
}
|
|
|
|
|
2018-03-21 16:13:37 +00:00
|
|
|
GrTextureProxy* proxy = surfaceContext->asTextureProxy();
|
2020-07-21 16:09:58 +00:00
|
|
|
REPORTER_ASSERT(reporter, proxy->mipmapped() == GrMipmapped::kNo);
|
2020-07-23 14:33:24 +00:00
|
|
|
REPORTER_ASSERT(reporter, proxy->peekTexture()->mipmapped() == GrMipmapped::kNo);
|
2018-07-31 21:25:29 +00:00
|
|
|
|
|
|
|
REPORTER_ASSERT(reporter, proxy->textureType() == GrTextureType::kExternal);
|
2020-07-23 14:33:24 +00:00
|
|
|
REPORTER_ASSERT(reporter, proxy->peekTexture()->textureType() == GrTextureType::kExternal);
|
2018-07-31 21:25:29 +00:00
|
|
|
REPORTER_ASSERT(reporter, proxy->hasRestrictedSampling());
|
2020-07-23 14:33:24 +00:00
|
|
|
REPORTER_ASSERT(reporter, proxy->peekTexture()->hasRestrictedSampling());
|
2018-03-21 16:13:37 +00:00
|
|
|
|
2015-11-23 15:09:50 +00:00
|
|
|
// Should not be able to wrap as a RT
|
2017-01-25 17:10:37 +00:00
|
|
|
{
|
2020-01-07 20:42:57 +00:00
|
|
|
auto temp = GrRenderTargetContext::MakeFromBackendTexture(
|
2020-06-29 17:05:29 +00:00
|
|
|
context0, colorType, nullptr, backendTex, 1, origin, nullptr, nullptr);
|
2017-01-27 15:58:31 +00:00
|
|
|
if (temp) {
|
2017-01-25 17:10:37 +00:00
|
|
|
ERRORF(reporter, "Should not be able to wrap an EXTERNAL texture as a RT.");
|
|
|
|
}
|
2015-11-23 07:23:53 +00:00
|
|
|
}
|
2015-11-23 15:09:50 +00:00
|
|
|
|
2020-08-11 16:02:22 +00:00
|
|
|
TestReadPixels(reporter, context0, surfaceContext.get(), pixels.get(), "EGLImageTest-read");
|
2015-11-23 15:09:50 +00:00
|
|
|
|
2020-08-11 16:02:22 +00:00
|
|
|
// We should not be able to write to an EXTERNAL texture
|
|
|
|
TestWritePixels(reporter, context0, surfaceContext.get(), false, "EGLImageTest-write");
|
2015-11-23 15:09:50 +00:00
|
|
|
|
2017-01-27 15:11:42 +00:00
|
|
|
// Only test RT-config
|
|
|
|
// TODO: why do we always need to draw to copy from an external texture?
|
2019-10-25 00:07:39 +00:00
|
|
|
TestCopyFromSurface(reporter, context0, surfaceContext->asSurfaceProxy(),
|
2020-01-30 19:55:05 +00:00
|
|
|
surfaceContext->origin(), colorType, pixels.get(), "EGLImageTest-copy");
|
2015-11-23 15:09:50 +00:00
|
|
|
|
2020-10-13 00:45:06 +00:00
|
|
|
cleanup(glCtx0, externalTexture.fID, glCtx1.get(), context1, image);
|
2015-11-22 22:51:00 +00:00
|
|
|
}
|
2019-11-08 21:18:15 +00:00
|
|
|
|
|
|
|
#endif // SK_GL
|