blob: d750cd06b675798affddcbbf0dff9dc264433a9d [file] [log] [blame]
Jamie Gennis134f0422011-03-08 12:18:54 -08001/*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Jamie Gennisfa5b40e2012-03-15 14:01:24 -070017#define LOG_TAG "SurfaceTextureClient_test"
18//#define LOG_NDEBUG 0
19
Jamie Gennis5c0c93a2011-03-14 15:34:04 -070020#include <EGL/egl.h>
Mathias Agopianc6bae002013-08-14 16:26:43 -070021#include <GLES2/gl2.h>
22
Jamie Gennis134f0422011-03-08 12:18:54 -080023#include <gtest/gtest.h>
Mathias Agopianc6bae002013-08-14 16:26:43 -070024#include <gui/GLConsumer.h>
Mathias Agopiane3c697f2013-02-14 17:11:02 -080025#include <gui/Surface.h>
Jamie Gennisd72f2332012-05-07 13:50:11 -070026#include <system/graphics.h>
Jamie Gennisfa5b40e2012-03-15 14:01:24 -070027#include <utils/Log.h>
28#include <utils/Thread.h>
Jamie Gennis134f0422011-03-08 12:18:54 -080029
30namespace android {
31
32class SurfaceTextureClientTest : public ::testing::Test {
33protected:
Mathias Agopian7a5b22c2011-04-26 14:57:10 -070034 SurfaceTextureClientTest():
35 mEglDisplay(EGL_NO_DISPLAY),
36 mEglSurface(EGL_NO_SURFACE),
37 mEglContext(EGL_NO_CONTEXT) {
38 }
39
Jamie Gennis134f0422011-03-08 12:18:54 -080040 virtual void SetUp() {
Jamie Gennisfa5b40e2012-03-15 14:01:24 -070041 const ::testing::TestInfo* const testInfo =
42 ::testing::UnitTest::GetInstance()->current_test_info();
43 ALOGV("Begin test: %s.%s", testInfo->test_case_name(),
44 testInfo->name());
45
Dan Stoza5603a2f2014-04-07 13:41:37 -070046 sp<IGraphicBufferProducer> producer;
47 sp<IGraphicBufferConsumer> consumer;
48 BufferQueue::createBufferQueue(&producer, &consumer);
Dan Stozae49ba8e2014-06-24 13:09:19 -070049 mST = new GLConsumer(consumer, 123, GLConsumer::TEXTURE_EXTERNAL, true,
50 false);
Dan Stoza5603a2f2014-04-07 13:41:37 -070051 mSTC = new Surface(producer);
Jamie Gennis8b69def2011-04-06 15:43:16 -070052 mANW = mSTC;
Mathias Agopian7a5b22c2011-04-26 14:57:10 -070053
54 // We need a valid GL context so we can test updateTexImage()
55 // This initializes EGL and create a dummy GL context with a
56 // pbuffer render target.
57 mEglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
58 ASSERT_EQ(EGL_SUCCESS, eglGetError());
59 ASSERT_NE(EGL_NO_DISPLAY, mEglDisplay);
60
61 EGLint majorVersion, minorVersion;
62 EXPECT_TRUE(eglInitialize(mEglDisplay, &majorVersion, &minorVersion));
63 ASSERT_EQ(EGL_SUCCESS, eglGetError());
64
65 EGLConfig myConfig;
66 EGLint numConfigs = 0;
67 EXPECT_TRUE(eglChooseConfig(mEglDisplay, getConfigAttribs(),
68 &myConfig, 1, &numConfigs));
69 ASSERT_EQ(EGL_SUCCESS, eglGetError());
70
Mathias Agopian993e14f2013-02-22 19:34:49 -080071 mEglConfig = myConfig;
Mathias Agopian7a5b22c2011-04-26 14:57:10 -070072 EGLint pbufferAttribs[] = {
73 EGL_WIDTH, 16,
74 EGL_HEIGHT, 16,
75 EGL_NONE };
76 mEglSurface = eglCreatePbufferSurface(mEglDisplay, myConfig, pbufferAttribs);
77 ASSERT_EQ(EGL_SUCCESS, eglGetError());
78 ASSERT_NE(EGL_NO_SURFACE, mEglSurface);
79
80 mEglContext = eglCreateContext(mEglDisplay, myConfig, EGL_NO_CONTEXT, 0);
81 ASSERT_EQ(EGL_SUCCESS, eglGetError());
82 ASSERT_NE(EGL_NO_CONTEXT, mEglContext);
83
84 EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface, mEglContext));
85 ASSERT_EQ(EGL_SUCCESS, eglGetError());
Jamie Gennis134f0422011-03-08 12:18:54 -080086 }
87
88 virtual void TearDown() {
89 mST.clear();
90 mSTC.clear();
Jamie Gennis8b69def2011-04-06 15:43:16 -070091 mANW.clear();
92
Mathias Agopian7a5b22c2011-04-26 14:57:10 -070093 eglMakeCurrent(mEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
94 eglDestroyContext(mEglDisplay, mEglContext);
95 eglDestroySurface(mEglDisplay, mEglSurface);
96 eglTerminate(mEglDisplay);
Jamie Gennisfa5b40e2012-03-15 14:01:24 -070097
98 const ::testing::TestInfo* const testInfo =
99 ::testing::UnitTest::GetInstance()->current_test_info();
100 ALOGV("End test: %s.%s", testInfo->test_case_name(),
101 testInfo->name());
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700102 }
103
104 virtual EGLint const* getConfigAttribs() {
105 static EGLint sDefaultConfigAttribs[] = {
Mathias Agopian993e14f2013-02-22 19:34:49 -0800106 EGL_SURFACE_TYPE, EGL_PBUFFER_BIT | EGL_WINDOW_BIT,
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700107 EGL_NONE
108 };
109
110 return sDefaultConfigAttribs;
Jamie Gennis134f0422011-03-08 12:18:54 -0800111 }
112
Andy McFadden2adaf042012-12-18 09:49:45 -0800113 sp<GLConsumer> mST;
Mathias Agopiane3c697f2013-02-14 17:11:02 -0800114 sp<Surface> mSTC;
Jamie Gennis8b69def2011-04-06 15:43:16 -0700115 sp<ANativeWindow> mANW;
116
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700117 EGLDisplay mEglDisplay;
118 EGLSurface mEglSurface;
119 EGLContext mEglContext;
Mathias Agopian993e14f2013-02-22 19:34:49 -0800120 EGLConfig mEglConfig;
Jamie Gennis134f0422011-03-08 12:18:54 -0800121};
122
Jamie Gennisbae774e2011-03-14 15:08:53 -0700123TEST_F(SurfaceTextureClientTest, GetISurfaceTextureIsNotNull) {
Mathias Agopiancf0b8c82013-02-19 18:24:40 -0800124 sp<IGraphicBufferProducer> ist(mSTC->getIGraphicBufferProducer());
Jamie Gennisbae774e2011-03-14 15:08:53 -0700125 ASSERT_TRUE(ist != NULL);
126}
127
Jamie Gennis134f0422011-03-08 12:18:54 -0800128TEST_F(SurfaceTextureClientTest, QueuesToWindowCompositorIsFalse) {
Jamie Gennis134f0422011-03-08 12:18:54 -0800129 int result = -123;
Jamie Gennis8b69def2011-04-06 15:43:16 -0700130 int err = mANW->query(mANW.get(), NATIVE_WINDOW_QUEUES_TO_WINDOW_COMPOSER,
Jamie Gennis134f0422011-03-08 12:18:54 -0800131 &result);
132 EXPECT_EQ(NO_ERROR, err);
133 EXPECT_EQ(0, result);
134}
135
Jamie Gennis391bbe22011-03-14 15:00:06 -0700136TEST_F(SurfaceTextureClientTest, ConcreteTypeIsSurfaceTextureClient) {
Jamie Gennis391bbe22011-03-14 15:00:06 -0700137 int result = -123;
Jamie Gennis8b69def2011-04-06 15:43:16 -0700138 int err = mANW->query(mANW.get(), NATIVE_WINDOW_CONCRETE_TYPE, &result);
Jamie Gennis391bbe22011-03-14 15:00:06 -0700139 EXPECT_EQ(NO_ERROR, err);
Mathias Agopiane3c697f2013-02-14 17:11:02 -0800140 EXPECT_EQ(NATIVE_WINDOW_SURFACE, result);
Jamie Gennis391bbe22011-03-14 15:00:06 -0700141}
142
Jamie Gennis1b528fb2011-04-25 16:41:11 -0700143TEST_F(SurfaceTextureClientTest, EglCreateWindowSurfaceSucceeds) {
Jamie Gennis5c0c93a2011-03-14 15:34:04 -0700144 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
145 ASSERT_EQ(EGL_SUCCESS, eglGetError());
146 ASSERT_NE(EGL_NO_DISPLAY, dpy);
147
148 EGLint majorVersion;
149 EGLint minorVersion;
150 EXPECT_TRUE(eglInitialize(dpy, &majorVersion, &minorVersion));
151 ASSERT_EQ(EGL_SUCCESS, eglGetError());
152
153 EGLConfig myConfig = {0};
154 EGLint numConfigs = 0;
155 EGLint configAttribs[] = {
156 EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
157 EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
158 EGL_RED_SIZE, 8,
159 EGL_GREEN_SIZE, 8,
160 EGL_BLUE_SIZE, 8,
161 EGL_ALPHA_SIZE, 8,
162 EGL_DEPTH_SIZE, 16,
163 EGL_STENCIL_SIZE, 8,
164 EGL_NONE };
165 EXPECT_TRUE(eglChooseConfig(dpy, configAttribs, &myConfig, 1,
166 &numConfigs));
167 ASSERT_EQ(EGL_SUCCESS, eglGetError());
168
Jamie Gennis8b69def2011-04-06 15:43:16 -0700169 EGLSurface eglSurface = eglCreateWindowSurface(dpy, myConfig, mANW.get(),
Jamie Gennis5c0c93a2011-03-14 15:34:04 -0700170 NULL);
Mathias Agopianeafabcd2011-04-20 14:20:59 -0700171 EXPECT_NE(EGL_NO_SURFACE, eglSurface);
172 EXPECT_EQ(EGL_SUCCESS, eglGetError());
Jamie Gennis5c0c93a2011-03-14 15:34:04 -0700173
Jamie Gennisfa5b40e2012-03-15 14:01:24 -0700174 if (eglSurface != EGL_NO_SURFACE) {
175 eglDestroySurface(dpy, eglSurface);
176 }
177
Jamie Gennis5c0c93a2011-03-14 15:34:04 -0700178 eglTerminate(dpy);
179}
180
Mathias Agopian993e14f2013-02-22 19:34:49 -0800181TEST_F(SurfaceTextureClientTest, EglSwapBuffersAbandonErrorIsEglBadSurface) {
182
183 EGLSurface eglSurface = eglCreateWindowSurface(mEglDisplay, mEglConfig, mANW.get(), NULL);
184 EXPECT_NE(EGL_NO_SURFACE, eglSurface);
185 EXPECT_EQ(EGL_SUCCESS, eglGetError());
186
187 EGLBoolean success = eglMakeCurrent(mEglDisplay, eglSurface, eglSurface, mEglContext);
Jamie Gennisad669b02013-04-05 16:41:27 -0700188 EXPECT_TRUE(success);
Mathias Agopian993e14f2013-02-22 19:34:49 -0800189
190 glClear(GL_COLOR_BUFFER_BIT);
191 success = eglSwapBuffers(mEglDisplay, eglSurface);
Jamie Gennisad669b02013-04-05 16:41:27 -0700192 EXPECT_TRUE(success);
Mathias Agopian993e14f2013-02-22 19:34:49 -0800193
194 mST->abandon();
195
196 glClear(GL_COLOR_BUFFER_BIT);
197 success = eglSwapBuffers(mEglDisplay, eglSurface);
Jamie Gennisad669b02013-04-05 16:41:27 -0700198 EXPECT_FALSE(success);
Mathias Agopian993e14f2013-02-22 19:34:49 -0800199 EXPECT_EQ(EGL_BAD_SURFACE, eglGetError());
200
201 success = eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface, mEglContext);
Jamie Gennisad669b02013-04-05 16:41:27 -0700202 ASSERT_TRUE(success);
Mathias Agopian993e14f2013-02-22 19:34:49 -0800203
204 if (eglSurface != EGL_NO_SURFACE) {
205 eglDestroySurface(mEglDisplay, eglSurface);
206 }
207}
208
Mathias Agopiana5c75c02011-03-31 19:10:24 -0700209TEST_F(SurfaceTextureClientTest, BufferGeometryInvalidSizesFail) {
Dan Stozaf8cebe52015-04-20 12:09:38 -0700210 EXPECT_GT(OK, native_window_set_buffers_dimensions(mANW.get(), 0, 8));
211 EXPECT_GT(OK, native_window_set_buffers_dimensions(mANW.get(), 8, 0));
Mathias Agopiana5c75c02011-03-31 19:10:24 -0700212}
213
214TEST_F(SurfaceTextureClientTest, DefaultGeometryValues) {
Iliyan Malchev697526b2011-05-01 11:33:26 -0700215 ANativeWindowBuffer* buf;
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700216 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf));
Mathias Agopiana5c75c02011-03-31 19:10:24 -0700217 EXPECT_EQ(1, buf->width);
218 EXPECT_EQ(1, buf->height);
219 EXPECT_EQ(PIXEL_FORMAT_RGBA_8888, buf->format);
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700220 ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf, -1));
Mathias Agopiana5c75c02011-03-31 19:10:24 -0700221}
222
223TEST_F(SurfaceTextureClientTest, BufferGeometryCanBeSet) {
Iliyan Malchev697526b2011-05-01 11:33:26 -0700224 ANativeWindowBuffer* buf;
Dan Stozaf8cebe52015-04-20 12:09:38 -0700225 EXPECT_EQ(OK, native_window_set_buffers_dimensions(mANW.get(), 16, 8));
226 EXPECT_EQ(OK, native_window_set_buffers_format(mANW.get(), PIXEL_FORMAT_RGB_565));
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700227 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf));
Mathias Agopiana5c75c02011-03-31 19:10:24 -0700228 EXPECT_EQ(16, buf->width);
229 EXPECT_EQ(8, buf->height);
230 EXPECT_EQ(PIXEL_FORMAT_RGB_565, buf->format);
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700231 ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf, -1));
Mathias Agopiana5c75c02011-03-31 19:10:24 -0700232}
233
234TEST_F(SurfaceTextureClientTest, BufferGeometryDefaultSizeSetFormat) {
Iliyan Malchev697526b2011-05-01 11:33:26 -0700235 ANativeWindowBuffer* buf;
Dan Stozaf8cebe52015-04-20 12:09:38 -0700236 EXPECT_EQ(OK, native_window_set_buffers_dimensions(mANW.get(), 0, 0));
237 EXPECT_EQ(OK, native_window_set_buffers_format(mANW.get(), PIXEL_FORMAT_RGB_565));
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700238 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf));
Mathias Agopiana5c75c02011-03-31 19:10:24 -0700239 EXPECT_EQ(1, buf->width);
240 EXPECT_EQ(1, buf->height);
241 EXPECT_EQ(PIXEL_FORMAT_RGB_565, buf->format);
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700242 ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf, -1));
Mathias Agopiana5c75c02011-03-31 19:10:24 -0700243}
244
245TEST_F(SurfaceTextureClientTest, BufferGeometrySetSizeDefaultFormat) {
Iliyan Malchev697526b2011-05-01 11:33:26 -0700246 ANativeWindowBuffer* buf;
Dan Stozaf8cebe52015-04-20 12:09:38 -0700247 EXPECT_EQ(OK, native_window_set_buffers_dimensions(mANW.get(), 16, 8));
248 EXPECT_EQ(OK, native_window_set_buffers_format(mANW.get(), 0));
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700249 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf));
Mathias Agopiana5c75c02011-03-31 19:10:24 -0700250 EXPECT_EQ(16, buf->width);
251 EXPECT_EQ(8, buf->height);
252 EXPECT_EQ(PIXEL_FORMAT_RGBA_8888, buf->format);
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700253 ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf, -1));
Mathias Agopiana5c75c02011-03-31 19:10:24 -0700254}
255
256TEST_F(SurfaceTextureClientTest, BufferGeometrySizeCanBeUnset) {
Iliyan Malchev697526b2011-05-01 11:33:26 -0700257 ANativeWindowBuffer* buf;
Dan Stozaf8cebe52015-04-20 12:09:38 -0700258 EXPECT_EQ(OK, native_window_set_buffers_dimensions(mANW.get(), 16, 8));
259 EXPECT_EQ(OK, native_window_set_buffers_format(mANW.get(), 0));
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700260 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf));
Mathias Agopiana5c75c02011-03-31 19:10:24 -0700261 EXPECT_EQ(16, buf->width);
262 EXPECT_EQ(8, buf->height);
263 EXPECT_EQ(PIXEL_FORMAT_RGBA_8888, buf->format);
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700264 ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf, -1));
Dan Stozaf8cebe52015-04-20 12:09:38 -0700265 EXPECT_EQ(OK, native_window_set_buffers_dimensions(mANW.get(), 0, 0));
266 EXPECT_EQ(OK, native_window_set_buffers_format(mANW.get(), 0));
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700267 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf));
Mathias Agopiana5c75c02011-03-31 19:10:24 -0700268 EXPECT_EQ(1, buf->width);
269 EXPECT_EQ(1, buf->height);
270 EXPECT_EQ(PIXEL_FORMAT_RGBA_8888, buf->format);
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700271 ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf, -1));
Mathias Agopiana5c75c02011-03-31 19:10:24 -0700272}
273
274TEST_F(SurfaceTextureClientTest, BufferGeometrySizeCanBeChangedWithoutFormat) {
Iliyan Malchev697526b2011-05-01 11:33:26 -0700275 ANativeWindowBuffer* buf;
Dan Stozaf8cebe52015-04-20 12:09:38 -0700276 EXPECT_EQ(OK, native_window_set_buffers_dimensions(mANW.get(), 0, 0));
277 EXPECT_EQ(OK, native_window_set_buffers_format(mANW.get(), PIXEL_FORMAT_RGB_565));
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700278 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf));
Mathias Agopiana5c75c02011-03-31 19:10:24 -0700279 EXPECT_EQ(1, buf->width);
280 EXPECT_EQ(1, buf->height);
281 EXPECT_EQ(PIXEL_FORMAT_RGB_565, buf->format);
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700282 ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf, -1));
Jamie Gennis46975282012-08-30 18:35:50 -0700283 EXPECT_EQ(OK, native_window_set_buffers_dimensions(mANW.get(), 16, 8));
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700284 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf));
Mathias Agopiana5c75c02011-03-31 19:10:24 -0700285 EXPECT_EQ(16, buf->width);
286 EXPECT_EQ(8, buf->height);
287 EXPECT_EQ(PIXEL_FORMAT_RGB_565, buf->format);
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700288 ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf, -1));
Mathias Agopiana5c75c02011-03-31 19:10:24 -0700289}
290
291TEST_F(SurfaceTextureClientTest, SurfaceTextureSetDefaultSize) {
Andy McFadden2adaf042012-12-18 09:49:45 -0800292 sp<GLConsumer> st(mST);
Iliyan Malchev697526b2011-05-01 11:33:26 -0700293 ANativeWindowBuffer* buf;
Mathias Agopiana5c75c02011-03-31 19:10:24 -0700294 EXPECT_EQ(OK, st->setDefaultBufferSize(16, 8));
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700295 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf));
Mathias Agopiana5c75c02011-03-31 19:10:24 -0700296 EXPECT_EQ(16, buf->width);
297 EXPECT_EQ(8, buf->height);
298 EXPECT_EQ(PIXEL_FORMAT_RGBA_8888, buf->format);
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700299 ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf, -1));
Mathias Agopiana5c75c02011-03-31 19:10:24 -0700300}
301
302TEST_F(SurfaceTextureClientTest, SurfaceTextureSetDefaultSizeAfterDequeue) {
Iliyan Malchev697526b2011-05-01 11:33:26 -0700303 ANativeWindowBuffer* buf[2];
Jamie Gennis8b69def2011-04-06 15:43:16 -0700304 ASSERT_EQ(OK, native_window_set_buffer_count(mANW.get(), 4));
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700305 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[0]));
306 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[1]));
Mathias Agopiana5c75c02011-03-31 19:10:24 -0700307 EXPECT_NE(buf[0], buf[1]);
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700308 ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf[0], -1));
309 ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf[1], -1));
Jamie Gennis8b69def2011-04-06 15:43:16 -0700310 EXPECT_EQ(OK, mST->setDefaultBufferSize(16, 8));
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700311 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[0]));
312 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[1]));
Mathias Agopiana5c75c02011-03-31 19:10:24 -0700313 EXPECT_NE(buf[0], buf[1]);
314 EXPECT_EQ(16, buf[0]->width);
315 EXPECT_EQ(16, buf[1]->width);
316 EXPECT_EQ(8, buf[0]->height);
317 EXPECT_EQ(8, buf[1]->height);
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700318 ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf[0], -1));
319 ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf[1], -1));
Mathias Agopiana5c75c02011-03-31 19:10:24 -0700320}
321
322TEST_F(SurfaceTextureClientTest, SurfaceTextureSetDefaultSizeVsGeometry) {
Iliyan Malchev697526b2011-05-01 11:33:26 -0700323 ANativeWindowBuffer* buf[2];
Jamie Gennis8b69def2011-04-06 15:43:16 -0700324 ASSERT_EQ(OK, native_window_set_buffer_count(mANW.get(), 4));
325 EXPECT_EQ(OK, mST->setDefaultBufferSize(16, 8));
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700326 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[0]));
327 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[1]));
Mathias Agopiana5c75c02011-03-31 19:10:24 -0700328 EXPECT_NE(buf[0], buf[1]);
329 EXPECT_EQ(16, buf[0]->width);
330 EXPECT_EQ(16, buf[1]->width);
331 EXPECT_EQ(8, buf[0]->height);
332 EXPECT_EQ(8, buf[1]->height);
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700333 ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf[0], -1));
334 ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf[1], -1));
Dan Stozaf8cebe52015-04-20 12:09:38 -0700335 EXPECT_EQ(OK, native_window_set_buffers_dimensions(mANW.get(), 12, 24));
336 EXPECT_EQ(OK, native_window_set_buffers_format(mANW.get(), 0));
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700337 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[0]));
338 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[1]));
Mathias Agopiana5c75c02011-03-31 19:10:24 -0700339 EXPECT_NE(buf[0], buf[1]);
340 EXPECT_EQ(12, buf[0]->width);
341 EXPECT_EQ(12, buf[1]->width);
342 EXPECT_EQ(24, buf[0]->height);
343 EXPECT_EQ(24, buf[1]->height);
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700344 ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf[0], -1));
345 ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf[1], -1));
Mathias Agopiana5c75c02011-03-31 19:10:24 -0700346}
347
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700348TEST_F(SurfaceTextureClientTest, SurfaceTextureTooManyUpdateTexImage) {
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700349 android_native_buffer_t* buf[3];
Mathias Agopian595264f2013-07-16 22:56:09 -0700350 ASSERT_EQ(OK, mANW->setSwapInterval(mANW.get(), 0));
Jamie Gennis8b69def2011-04-06 15:43:16 -0700351 ASSERT_EQ(OK, native_window_set_buffer_count(mANW.get(), 4));
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700352
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700353 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[0]));
354 ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[0], -1));
Jamie Gennis8b69def2011-04-06 15:43:16 -0700355 EXPECT_EQ(OK, mST->updateTexImage());
356 EXPECT_EQ(OK, mST->updateTexImage());
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700357
Mathias Agopian595264f2013-07-16 22:56:09 -0700358 ASSERT_EQ(OK, mANW->setSwapInterval(mANW.get(), 1));
Jamie Gennis8b69def2011-04-06 15:43:16 -0700359 ASSERT_EQ(OK, native_window_set_buffer_count(mANW.get(), 3));
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700360
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700361 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[0]));
362 ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[0], -1));
363 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[1]));
364 ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[1], -1));
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700365
Jamie Gennis8b69def2011-04-06 15:43:16 -0700366 EXPECT_EQ(OK, mST->updateTexImage());
367 EXPECT_EQ(OK, mST->updateTexImage());
368 EXPECT_EQ(OK, mST->updateTexImage());
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700369}
370
371TEST_F(SurfaceTextureClientTest, SurfaceTextureSyncModeSlowRetire) {
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700372 android_native_buffer_t* buf[3];
Jamie Gennis8b69def2011-04-06 15:43:16 -0700373 ASSERT_EQ(OK, native_window_set_buffer_count(mANW.get(), 4));
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700374 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[0]));
375 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[1]));
376 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[2]));
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700377 EXPECT_NE(buf[0], buf[1]);
378 EXPECT_NE(buf[1], buf[2]);
379 EXPECT_NE(buf[2], buf[0]);
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700380 ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[0], -1));
381 ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[1], -1));
382 ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[2], -1));
Jamie Gennis8b69def2011-04-06 15:43:16 -0700383 EXPECT_EQ(OK, mST->updateTexImage());
384 EXPECT_EQ(mST->getCurrentBuffer().get(), buf[0]);
385 EXPECT_EQ(OK, mST->updateTexImage());
386 EXPECT_EQ(mST->getCurrentBuffer().get(), buf[1]);
387 EXPECT_EQ(OK, mST->updateTexImage());
388 EXPECT_EQ(mST->getCurrentBuffer().get(), buf[2]);
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700389}
390
391TEST_F(SurfaceTextureClientTest, SurfaceTextureSyncModeFastRetire) {
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700392 android_native_buffer_t* buf[3];
Jamie Gennis8b69def2011-04-06 15:43:16 -0700393 ASSERT_EQ(OK, native_window_set_buffer_count(mANW.get(), 4));
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700394 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[0]));
395 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[1]));
396 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[2]));
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700397 EXPECT_NE(buf[0], buf[1]);
398 EXPECT_NE(buf[1], buf[2]);
399 EXPECT_NE(buf[2], buf[0]);
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700400 ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[0], -1));
Jamie Gennis8b69def2011-04-06 15:43:16 -0700401 EXPECT_EQ(OK, mST->updateTexImage());
402 EXPECT_EQ(mST->getCurrentBuffer().get(), buf[0]);
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700403 ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[1], -1));
Jamie Gennis8b69def2011-04-06 15:43:16 -0700404 EXPECT_EQ(OK, mST->updateTexImage());
405 EXPECT_EQ(mST->getCurrentBuffer().get(), buf[1]);
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700406 ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[2], -1));
Jamie Gennis8b69def2011-04-06 15:43:16 -0700407 EXPECT_EQ(OK, mST->updateTexImage());
408 EXPECT_EQ(mST->getCurrentBuffer().get(), buf[2]);
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700409}
410
411TEST_F(SurfaceTextureClientTest, SurfaceTextureSyncModeDQQR) {
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700412 android_native_buffer_t* buf[3];
Jamie Gennis8b69def2011-04-06 15:43:16 -0700413 ASSERT_EQ(OK, native_window_set_buffer_count(mANW.get(), 3));
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700414
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700415 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[0]));
416 ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[0], -1));
Jamie Gennis8b69def2011-04-06 15:43:16 -0700417 EXPECT_EQ(OK, mST->updateTexImage());
418 EXPECT_EQ(mST->getCurrentBuffer().get(), buf[0]);
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700419
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700420 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[1]));
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700421 EXPECT_NE(buf[0], buf[1]);
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700422 ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[1], -1));
Jamie Gennis8b69def2011-04-06 15:43:16 -0700423 EXPECT_EQ(OK, mST->updateTexImage());
424 EXPECT_EQ(mST->getCurrentBuffer().get(), buf[1]);
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700425
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700426 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[2]));
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700427 EXPECT_NE(buf[1], buf[2]);
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700428 ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[2], -1));
Jamie Gennis8b69def2011-04-06 15:43:16 -0700429 EXPECT_EQ(OK, mST->updateTexImage());
430 EXPECT_EQ(mST->getCurrentBuffer().get(), buf[2]);
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700431}
432
Jamie Gennis8cd5ba42011-05-19 13:33:00 -0700433// XXX: We currently have no hardware that properly handles dequeuing the
434// buffer that is currently bound to the texture.
435TEST_F(SurfaceTextureClientTest, DISABLED_SurfaceTextureSyncModeDequeueCurrent) {
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700436 android_native_buffer_t* buf[3];
437 android_native_buffer_t* firstBuf;
Jamie Gennis8b69def2011-04-06 15:43:16 -0700438 ASSERT_EQ(OK, native_window_set_buffer_count(mANW.get(), 3));
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700439 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &firstBuf));
440 ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), firstBuf, -1));
Jamie Gennis8b69def2011-04-06 15:43:16 -0700441 EXPECT_EQ(OK, mST->updateTexImage());
442 EXPECT_EQ(mST->getCurrentBuffer().get(), firstBuf);
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700443 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[0]));
444 ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[0], -1));
445 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[1]));
446 ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[1], -1));
447 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[2]));
448 ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[2], -1));
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700449 EXPECT_NE(buf[0], buf[1]);
450 EXPECT_NE(buf[1], buf[2]);
451 EXPECT_NE(buf[2], buf[0]);
452 EXPECT_EQ(firstBuf, buf[2]);
453}
454
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700455TEST_F(SurfaceTextureClientTest, SurfaceTextureSyncModeMinUndequeued) {
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700456 android_native_buffer_t* buf[3];
Jamie Gennis8b69def2011-04-06 15:43:16 -0700457 ASSERT_EQ(OK, native_window_set_buffer_count(mANW.get(), 3));
Jamie Gennisc2c8dfd2011-05-23 18:44:04 -0700458
Jamie Gennis8b69def2011-04-06 15:43:16 -0700459 // We should be able to dequeue all the buffers before we've queued mANWy.
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700460 EXPECT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[0]));
461 EXPECT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[1]));
462 EXPECT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[2]));
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700463
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700464 ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf[2], -1));
465 ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[1], -1));
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700466
Jamie Gennis8b69def2011-04-06 15:43:16 -0700467 EXPECT_EQ(OK, mST->updateTexImage());
468 EXPECT_EQ(mST->getCurrentBuffer().get(), buf[1]);
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700469
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700470 EXPECT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[2]));
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700471
Jamie Gennisc2c8dfd2011-05-23 18:44:04 -0700472 // Once we've queued a buffer, however we should not be able to dequeue more
473 // than (buffer-count - MIN_UNDEQUEUED_BUFFERS), which is 2 in this case.
Dan Stozaf8cebe52015-04-20 12:09:38 -0700474 EXPECT_EQ(INVALID_OPERATION,
475 native_window_dequeue_buffer_and_wait(mANW.get(), &buf[1]));
Jamie Gennisc2c8dfd2011-05-23 18:44:04 -0700476
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700477 ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf[0], -1));
478 ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf[2], -1));
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700479}
480
Jamie Gennisd72f2332012-05-07 13:50:11 -0700481TEST_F(SurfaceTextureClientTest, SetCropCropsCrop) {
482 android_native_rect_t rect = {-2, -13, 40, 18};
483 native_window_set_crop(mANW.get(), &rect);
484
485 ASSERT_EQ(OK, native_window_set_buffers_dimensions(mANW.get(), 4, 4));
486
487 android_native_buffer_t* buf;
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700488 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf));
489 ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf, -1));
Jamie Gennisd72f2332012-05-07 13:50:11 -0700490 ASSERT_EQ(OK, mST->updateTexImage());
491
492 Rect crop = mST->getCurrentCrop();
493 EXPECT_EQ(0, crop.left);
494 EXPECT_EQ(0, crop.top);
495 EXPECT_EQ(4, crop.right);
496 EXPECT_EQ(4, crop.bottom);
497}
498
Jamie Gennis8dda6b72011-05-24 18:39:46 -0700499// XXX: This is not expected to pass until the synchronization hacks are removed
500// from the SurfaceTexture class.
501TEST_F(SurfaceTextureClientTest, DISABLED_SurfaceTextureSyncModeWaitRetire) {
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700502 class MyThread : public Thread {
Andy McFadden2adaf042012-12-18 09:49:45 -0800503 sp<GLConsumer> mST;
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700504 EGLContext ctx;
505 EGLSurface sur;
506 EGLDisplay dpy;
507 bool mBufferRetired;
508 Mutex mLock;
509 virtual bool threadLoop() {
510 eglMakeCurrent(dpy, sur, sur, ctx);
511 usleep(20000);
512 Mutex::Autolock _l(mLock);
Jamie Gennis8b69def2011-04-06 15:43:16 -0700513 mST->updateTexImage();
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700514 mBufferRetired = true;
515 eglMakeCurrent(dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
516 return false;
517 }
518 public:
Andy McFadden2adaf042012-12-18 09:49:45 -0800519 MyThread(const sp<GLConsumer>& mST)
Jamie Gennis8b69def2011-04-06 15:43:16 -0700520 : mST(mST), mBufferRetired(false) {
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700521 ctx = eglGetCurrentContext();
522 sur = eglGetCurrentSurface(EGL_DRAW);
523 dpy = eglGetCurrentDisplay();
524 eglMakeCurrent(dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
525 }
526 ~MyThread() {
527 eglMakeCurrent(dpy, sur, sur, ctx);
528 }
529 void bufferDequeued() {
530 Mutex::Autolock _l(mLock);
531 EXPECT_EQ(true, mBufferRetired);
532 }
533 };
534
535 android_native_buffer_t* buf[3];
Jamie Gennis8b69def2011-04-06 15:43:16 -0700536 ASSERT_EQ(OK, native_window_set_buffer_count(mANW.get(), 3));
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700537 // dequeue/queue/update so we have a current buffer
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700538 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[0]));
539 ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[0], -1));
Jamie Gennis8b69def2011-04-06 15:43:16 -0700540 mST->updateTexImage();
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700541
Jamie Gennis8b69def2011-04-06 15:43:16 -0700542 MyThread* thread = new MyThread(mST);
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700543 sp<Thread> threadBase(thread);
544
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700545 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[0]));
546 ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[0], -1));
Mathias Agopiane1220792011-05-04 18:28:07 -0700547 thread->run();
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700548 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[1]));
549 ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[1], -1));
550 //ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[2]));
551 //ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[2], -1));
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700552 thread->bufferDequeued();
553 thread->requestExitAndWait();
554}
555
Jamie Gennis52226042011-06-07 15:23:23 -0700556TEST_F(SurfaceTextureClientTest, GetTransformMatrixReturnsVerticalFlip) {
Jamie Gennis52226042011-06-07 15:23:23 -0700557 android_native_buffer_t* buf[3];
558 float mtx[16] = {};
Jamie Gennis8b69def2011-04-06 15:43:16 -0700559 ASSERT_EQ(OK, native_window_set_buffer_count(mANW.get(), 4));
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700560 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[0]));
561 ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[0], -1));
Jamie Gennis8b69def2011-04-06 15:43:16 -0700562 ASSERT_EQ(OK, mST->updateTexImage());
563 mST->getTransformMatrix(mtx);
Jamie Gennis52226042011-06-07 15:23:23 -0700564
565 EXPECT_EQ(1.f, mtx[0]);
566 EXPECT_EQ(0.f, mtx[1]);
567 EXPECT_EQ(0.f, mtx[2]);
568 EXPECT_EQ(0.f, mtx[3]);
569
570 EXPECT_EQ(0.f, mtx[4]);
571 EXPECT_EQ(-1.f, mtx[5]);
572 EXPECT_EQ(0.f, mtx[6]);
573 EXPECT_EQ(0.f, mtx[7]);
574
575 EXPECT_EQ(0.f, mtx[8]);
576 EXPECT_EQ(0.f, mtx[9]);
577 EXPECT_EQ(1.f, mtx[10]);
578 EXPECT_EQ(0.f, mtx[11]);
579
580 EXPECT_EQ(0.f, mtx[12]);
581 EXPECT_EQ(1.f, mtx[13]);
582 EXPECT_EQ(0.f, mtx[14]);
583 EXPECT_EQ(1.f, mtx[15]);
Jamie Gennis134f0422011-03-08 12:18:54 -0800584}
Jamie Gennis52226042011-06-07 15:23:23 -0700585
586TEST_F(SurfaceTextureClientTest, GetTransformMatrixSucceedsAfterFreeingBuffers) {
Jamie Gennis52226042011-06-07 15:23:23 -0700587 android_native_buffer_t* buf[3];
588 float mtx[16] = {};
Jamie Gennis8b69def2011-04-06 15:43:16 -0700589 ASSERT_EQ(OK, native_window_set_buffer_count(mANW.get(), 4));
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700590 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[0]));
591 ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[0], -1));
Jamie Gennis8b69def2011-04-06 15:43:16 -0700592 ASSERT_EQ(OK, mST->updateTexImage());
593 ASSERT_EQ(OK, native_window_set_buffer_count(mANW.get(), 6)); // frees buffers
594 mST->getTransformMatrix(mtx);
Jamie Gennis52226042011-06-07 15:23:23 -0700595
596 EXPECT_EQ(1.f, mtx[0]);
597 EXPECT_EQ(0.f, mtx[1]);
598 EXPECT_EQ(0.f, mtx[2]);
599 EXPECT_EQ(0.f, mtx[3]);
600
601 EXPECT_EQ(0.f, mtx[4]);
602 EXPECT_EQ(-1.f, mtx[5]);
603 EXPECT_EQ(0.f, mtx[6]);
604 EXPECT_EQ(0.f, mtx[7]);
605
606 EXPECT_EQ(0.f, mtx[8]);
607 EXPECT_EQ(0.f, mtx[9]);
608 EXPECT_EQ(1.f, mtx[10]);
609 EXPECT_EQ(0.f, mtx[11]);
610
611 EXPECT_EQ(0.f, mtx[12]);
612 EXPECT_EQ(1.f, mtx[13]);
613 EXPECT_EQ(0.f, mtx[14]);
614 EXPECT_EQ(1.f, mtx[15]);
615}
616
617TEST_F(SurfaceTextureClientTest, GetTransformMatrixSucceedsAfterFreeingBuffersWithCrop) {
Jamie Gennis52226042011-06-07 15:23:23 -0700618 android_native_buffer_t* buf[3];
619 float mtx[16] = {};
620 android_native_rect_t crop;
621 crop.left = 0;
622 crop.top = 0;
623 crop.right = 5;
624 crop.bottom = 5;
625
Jamie Gennis8b69def2011-04-06 15:43:16 -0700626 ASSERT_EQ(OK, native_window_set_buffer_count(mANW.get(), 4));
Dan Stozaf8cebe52015-04-20 12:09:38 -0700627 ASSERT_EQ(OK, native_window_set_buffers_dimensions(mANW.get(), 8, 8));
628 ASSERT_EQ(OK, native_window_set_buffers_format(mANW.get(), 0));
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700629 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[0]));
Jamie Gennis8b69def2011-04-06 15:43:16 -0700630 ASSERT_EQ(OK, native_window_set_crop(mANW.get(), &crop));
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700631 ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[0], -1));
Jamie Gennis8b69def2011-04-06 15:43:16 -0700632 ASSERT_EQ(OK, mST->updateTexImage());
633 ASSERT_EQ(OK, native_window_set_buffer_count(mANW.get(), 6)); // frees buffers
634 mST->getTransformMatrix(mtx);
Jamie Gennis52226042011-06-07 15:23:23 -0700635
Jamie Gennis46975282012-08-30 18:35:50 -0700636 // This accounts for the .5 texel shrink for each edge that's included in the
Jamie Gennis52226042011-06-07 15:23:23 -0700637 // transform matrix to avoid texturing outside the crop region.
Jamie Gennis46975282012-08-30 18:35:50 -0700638 EXPECT_EQ(0.5, mtx[0]);
Jamie Gennis52226042011-06-07 15:23:23 -0700639 EXPECT_EQ(0.f, mtx[1]);
640 EXPECT_EQ(0.f, mtx[2]);
641 EXPECT_EQ(0.f, mtx[3]);
642
643 EXPECT_EQ(0.f, mtx[4]);
Jamie Gennis46975282012-08-30 18:35:50 -0700644 EXPECT_EQ(-0.5, mtx[5]);
Jamie Gennis52226042011-06-07 15:23:23 -0700645 EXPECT_EQ(0.f, mtx[6]);
646 EXPECT_EQ(0.f, mtx[7]);
647
648 EXPECT_EQ(0.f, mtx[8]);
649 EXPECT_EQ(0.f, mtx[9]);
650 EXPECT_EQ(1.f, mtx[10]);
651 EXPECT_EQ(0.f, mtx[11]);
652
Jamie Gennis46975282012-08-30 18:35:50 -0700653 EXPECT_EQ(0.0625f, mtx[12]);
654 EXPECT_EQ(0.5625f, mtx[13]);
Jamie Gennis52226042011-06-07 15:23:23 -0700655 EXPECT_EQ(0.f, mtx[14]);
656 EXPECT_EQ(1.f, mtx[15]);
657}
658
Jamie Gennisa6f35dd2011-06-12 13:56:15 -0700659// This test verifies that the buffer format can be queried immediately after
660// it is set.
Jamie Gennis07ed1a92011-06-14 17:04:29 -0700661TEST_F(SurfaceTextureClientTest, QueryFormatAfterSettingWorks) {
Jamie Gennisa6f35dd2011-06-12 13:56:15 -0700662 sp<ANativeWindow> anw(mSTC);
663 int fmts[] = {
664 // RGBA_8888 should not come first, as it's the default
665 HAL_PIXEL_FORMAT_RGBX_8888,
666 HAL_PIXEL_FORMAT_RGBA_8888,
667 HAL_PIXEL_FORMAT_RGB_888,
668 HAL_PIXEL_FORMAT_RGB_565,
669 HAL_PIXEL_FORMAT_BGRA_8888,
Jamie Gennisa6f35dd2011-06-12 13:56:15 -0700670 HAL_PIXEL_FORMAT_YV12,
671 };
672
673 const int numFmts = (sizeof(fmts) / sizeof(fmts[0]));
674 for (int i = 0; i < numFmts; i++) {
675 int fmt = -1;
Dan Stozaf8cebe52015-04-20 12:09:38 -0700676 ASSERT_EQ(OK, native_window_set_buffers_dimensions(anw.get(), 0, 0));
677 ASSERT_EQ(OK, native_window_set_buffers_format(anw.get(), fmts[i]));
Jamie Gennisa6f35dd2011-06-12 13:56:15 -0700678 ASSERT_EQ(OK, anw->query(anw.get(), NATIVE_WINDOW_FORMAT, &fmt));
679 EXPECT_EQ(fmts[i], fmt);
680 }
681}
682
Jamie Gennisc8251a02011-07-11 19:00:51 -0700683class MultiSurfaceTextureClientTest : public ::testing::Test {
684
685public:
686 MultiSurfaceTextureClientTest() :
687 mEglDisplay(EGL_NO_DISPLAY),
688 mEglContext(EGL_NO_CONTEXT) {
689 for (int i = 0; i < NUM_SURFACE_TEXTURES; i++) {
690 mEglSurfaces[i] = EGL_NO_CONTEXT;
691 }
692 }
693
694protected:
695
696 enum { NUM_SURFACE_TEXTURES = 32 };
697
698 virtual void SetUp() {
699 mEglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
700 ASSERT_EQ(EGL_SUCCESS, eglGetError());
701 ASSERT_NE(EGL_NO_DISPLAY, mEglDisplay);
702
703 EGLint majorVersion, minorVersion;
704 EXPECT_TRUE(eglInitialize(mEglDisplay, &majorVersion, &minorVersion));
705 ASSERT_EQ(EGL_SUCCESS, eglGetError());
706
707 EGLConfig myConfig;
708 EGLint numConfigs = 0;
709 EGLint configAttribs[] = {
710 EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
711 EGL_NONE
712 };
713 EXPECT_TRUE(eglChooseConfig(mEglDisplay, configAttribs, &myConfig, 1,
714 &numConfigs));
715 ASSERT_EQ(EGL_SUCCESS, eglGetError());
716
717 mEglContext = eglCreateContext(mEglDisplay, myConfig, EGL_NO_CONTEXT,
718 0);
719 ASSERT_EQ(EGL_SUCCESS, eglGetError());
720 ASSERT_NE(EGL_NO_CONTEXT, mEglContext);
721
722 for (int i = 0; i < NUM_SURFACE_TEXTURES; i++) {
Dan Stoza5603a2f2014-04-07 13:41:37 -0700723 sp<IGraphicBufferProducer> producer;
724 sp<IGraphicBufferConsumer> consumer;
725 BufferQueue::createBufferQueue(&producer, &consumer);
Dan Stozae49ba8e2014-06-24 13:09:19 -0700726 sp<GLConsumer> st(new GLConsumer(consumer, i,
727 GLConsumer::TEXTURE_EXTERNAL, true, false));
Dan Stoza5603a2f2014-04-07 13:41:37 -0700728 sp<Surface> stc(new Surface(producer));
Jamie Gennisc8251a02011-07-11 19:00:51 -0700729 mEglSurfaces[i] = eglCreateWindowSurface(mEglDisplay, myConfig,
730 static_cast<ANativeWindow*>(stc.get()), NULL);
731 ASSERT_EQ(EGL_SUCCESS, eglGetError());
732 ASSERT_NE(EGL_NO_SURFACE, mEglSurfaces[i]);
733 }
734 }
735
736 virtual void TearDown() {
737 eglMakeCurrent(mEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE,
738 EGL_NO_CONTEXT);
739
740 for (int i = 0; i < NUM_SURFACE_TEXTURES; i++) {
741 if (mEglSurfaces[i] != EGL_NO_SURFACE) {
742 eglDestroySurface(mEglDisplay, mEglSurfaces[i]);
743 }
744 }
745
746 if (mEglContext != EGL_NO_CONTEXT) {
747 eglDestroyContext(mEglDisplay, mEglContext);
748 }
749
750 if (mEglDisplay != EGL_NO_DISPLAY) {
751 eglTerminate(mEglDisplay);
752 }
753 }
754
755 EGLDisplay mEglDisplay;
756 EGLSurface mEglSurfaces[NUM_SURFACE_TEXTURES];
757 EGLContext mEglContext;
758};
759
760// XXX: This test is disabled because it causes a hang on some devices. See bug
761// 5015672.
762TEST_F(MultiSurfaceTextureClientTest, DISABLED_MakeCurrentBetweenSurfacesWorks) {
763 for (int iter = 0; iter < 8; iter++) {
764 for (int i = 0; i < NUM_SURFACE_TEXTURES; i++) {
765 eglMakeCurrent(mEglDisplay, mEglSurfaces[i], mEglSurfaces[i],
766 mEglContext);
767 glClear(GL_COLOR_BUFFER_BIT);
768 eglSwapBuffers(mEglDisplay, mEglSurfaces[i]);
769 }
770 }
771}
772
Jamie Gennis52226042011-06-07 15:23:23 -0700773} // namespace android