EGLImageTest.cpp revision 3500b77f7d08dbe4c17811733cc3e4dbab889f0a 
1/*
2 * Copyright 2015 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8#include "Test.h"
9#include "TestUtils.h"
10#if SK_SUPPORT_GPU
11#include "GrContext.h"
12#include "GrContextPriv.h"
13#include "GrContextFactory.h"
14#include "GrShaderCaps.h"
15#include "GrSurfaceContext.h"
16#include "gl/GrGLGpu.h"
17#include "gl/GrGLUtil.h"
18#include "gl/GLTestContext.h"
19
20using sk_gpu_test::GLTestContext;
21
22static void cleanup(GLTestContext* glctx0, GrGLuint texID0, GLTestContext* glctx1, GrContext* grctx1,
23                    const GrGLTextureInfo* grbackendtex1, GrEGLImage image1) {
24    if (glctx1) {
25        glctx1->makeCurrent();
26        if (grctx1) {
27            if (grbackendtex1) {
28                GrGLGpu* gpu1 = static_cast<GrGLGpu*>(grctx1->getGpu());
29                GrBackendObject handle = reinterpret_cast<GrBackendObject>(grbackendtex1);
30                gpu1->deleteTestingOnlyBackendTexture(handle, false);
31            }
32            grctx1->unref();
33        }
34        if (GR_EGL_NO_IMAGE != image1) {
35            glctx1->destroyEGLImage(image1);
36        }
37    }
38
39    glctx0->makeCurrent();
40    if (texID0) {
41        GR_GL_CALL(glctx0->gl(), DeleteTextures(1, &texID0));
42    }
43}
44
45DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(EGLImageTest, reporter, ctxInfo) {
46    GrContext* context0 = ctxInfo.grContext();
47    sk_gpu_test::GLTestContext* glCtx0 = ctxInfo.glContext();
48
49    // Try to create a second GL context and then check if the contexts have necessary
50    // extensions to run this test.
51
52    if (kGLES_GrGLStandard != glCtx0->gl()->fStandard) {
53        return;
54    }
55    GrGLGpu* gpu0 = static_cast<GrGLGpu*>(context0->getGpu());
56    if (!gpu0->glCaps().shaderCaps()->externalTextureSupport()) {
57        return;
58    }
59
60    std::unique_ptr<GLTestContext> glCtx1 = glCtx0->makeNew();
61    if (!glCtx1) {
62        return;
63    }
64    GrContext* context1 = GrContext::Create(kOpenGL_GrBackend, (GrBackendContext)glCtx1->gl());
65    const GrGLTextureInfo* backendTexture1 = nullptr;
66    GrEGLImage image = GR_EGL_NO_IMAGE;
67    GrGLTextureInfo externalTexture;
68    externalTexture.fID = 0;
69
70    if (!context1) {
71        cleanup(glCtx0, externalTexture.fID, glCtx1.get(), context1, backendTexture1, image);
72        return;
73    }
74
75    if (!glCtx1->gl()->hasExtension("EGL_KHR_image") ||
76        !glCtx1->gl()->hasExtension("EGL_KHR_gl_texture_2D_image")) {
77        cleanup(glCtx0, externalTexture.fID, glCtx1.get(), context1, backendTexture1, image);
78        return;
79    }
80
81    ///////////////////////////////// CONTEXT 1 ///////////////////////////////////
82
83    // Use GL Context 1 to create a texture unknown to GrContext.
84    context1->flush();
85    GrGpu* gpu1 = context1->getGpu();
86    static const int kSize = 100;
87    backendTexture1 = reinterpret_cast<const GrGLTextureInfo*>(
88        gpu1->createTestingOnlyBackendTexture(nullptr, kSize, kSize, kRGBA_8888_GrPixelConfig));
89    if (!backendTexture1 || !backendTexture1->fID) {
90        ERRORF(reporter, "Error creating texture for EGL Image");
91        cleanup(glCtx0, externalTexture.fID, glCtx1.get(), context1, backendTexture1, image);
92        return;
93    }
94    if (GR_GL_TEXTURE_2D != backendTexture1->fTarget) {
95        ERRORF(reporter, "Expected backend texture to be 2D");
96        cleanup(glCtx0, externalTexture.fID, glCtx1.get(), context1, backendTexture1, image);
97        return;
98    }
99
100    // Wrap the texture in an EGLImage
101    image = glCtx1->texture2DToEGLImage(backendTexture1->fID);
102    if (GR_EGL_NO_IMAGE == image) {
103        ERRORF(reporter, "Error creating EGL Image from texture");
104        cleanup(glCtx0, externalTexture.fID, glCtx1.get(), context1, backendTexture1, image);
105        return;
106    }
107
108    // Populate the texture using GL context 1. Important to use TexSubImage as TexImage orphans
109    // the EGL image. Also, this must be done after creating the EGLImage as the texture
110    // contents may not be preserved when the image is created.
111    SkAutoTMalloc<uint32_t> pixels(kSize * kSize);
112    for (int i = 0; i < kSize*kSize; ++i) {
113        pixels.get()[i] = 0xDDAABBCC;
114    }
115    GR_GL_CALL(glCtx1->gl(), ActiveTexture(GR_GL_TEXTURE0));
116    GR_GL_CALL(glCtx1->gl(), BindTexture(backendTexture1->fTarget, backendTexture1->fID));
117    GR_GL_CALL(glCtx1->gl(), TexSubImage2D(backendTexture1->fTarget, 0, 0, 0, kSize, kSize,
118                                           GR_GL_RGBA, GR_GL_UNSIGNED_BYTE, pixels.get()));
119    GR_GL_CALL(glCtx1->gl(), Finish());
120    // We've been making direct GL calls in GL context 1, let GrContext 1 know its internal
121    // state is invalid.
122    context1->resetContext();
123
124    ///////////////////////////////// CONTEXT 0 ///////////////////////////////////
125
126    // Make a new texture ID in GL Context 0 from the EGL Image
127    glCtx0->makeCurrent();
128    externalTexture.fTarget = GR_GL_TEXTURE_EXTERNAL;
129    externalTexture.fID = glCtx0->eglImageToExternalTexture(image);
130
131    // Wrap this texture ID in a GrTexture
132    GrBackendTextureDesc externalDesc;
133    externalDesc.fConfig = kRGBA_8888_GrPixelConfig;
134    externalDesc.fWidth = kSize;
135    externalDesc.fHeight = kSize;
136    externalDesc.fTextureHandle = reinterpret_cast<GrBackendObject>(&externalTexture);
137
138    sk_sp<GrSurfaceContext> externalTextureContext;
139
140    {
141        sk_sp<GrTexture> externalTextureObj(
142            context0->textureProvider()->wrapBackendTexture(externalDesc));
143        if (!externalTextureObj) {
144            ERRORF(reporter, "Error wrapping external texture in GrTexture.");
145            cleanup(glCtx0, externalTexture.fID, glCtx1.get(), context1, backendTexture1, image);
146            return;
147        }
148
149        externalTextureContext = context0->contextPriv().makeWrappedSurfaceContext(
150                                                                    std::move(externalTextureObj));
151    }
152
153    // Should not be able to wrap as a RT
154    {
155        externalDesc.fFlags = kRenderTarget_GrBackendTextureFlag;
156        sk_sp<GrTexture> externalTextureRTObj(
157            context0->textureProvider()->wrapBackendTexture(externalDesc));
158        if (externalTextureRTObj) {
159            ERRORF(reporter, "Should not be able to wrap an EXTERNAL texture as a RT.");
160        }
161        externalDesc.fFlags = kNone_GrBackendTextureFlag;
162    }
163
164    // Should not be able to wrap with a sample count
165    {
166        externalDesc.fSampleCnt = 4;
167        sk_sp<GrTexture> externalTextureMSAAObj(
168            context0->textureProvider()->wrapBackendTexture(externalDesc));
169        if (externalTextureMSAAObj) {
170            ERRORF(reporter, "Should not be able to wrap an EXTERNAL texture with MSAA.");
171        }
172        externalDesc.fSampleCnt = 0;
173    }
174
175    test_read_pixels(reporter, context0, externalTextureContext.get(), pixels.get(),
176                     "EGLImageTest-read");
177
178    // We should not be able to write to a EXTERNAL texture
179    test_write_pixels(reporter, context0, externalTextureContext.get(), false,
180                      "EGLImageTest-write");
181
182    // Only test RT-config
183    // TODO: why do we always need to draw to copy from an external texture?
184    test_copy_from_surface(reporter, context0, externalTextureContext->asDeferredSurface(),
185                           pixels.get(), true, "EGLImageTest-copy");
186
187    cleanup(glCtx0, externalTexture.fID, glCtx1.get(), context1, backendTexture1, image);
188}
189
190#endif
191