blob: 989fcef0c14842e5b9a20cbb77f1a21e2a6a2cd2 [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
Mathias Agopian8f938a52013-07-12 22:06:26 -070046 sp<BufferQueue> bq = new BufferQueue();
47 mST = new GLConsumer(bq, 123);
Mathias Agopiandb89edc2013-08-02 01:40:18 -070048 mSTC = new Surface(bq);
Jamie Gennis8b69def2011-04-06 15:43:16 -070049 mANW = mSTC;
Mathias Agopian7a5b22c2011-04-26 14:57:10 -070050
51 // We need a valid GL context so we can test updateTexImage()
52 // This initializes EGL and create a dummy GL context with a
53 // pbuffer render target.
54 mEglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
55 ASSERT_EQ(EGL_SUCCESS, eglGetError());
56 ASSERT_NE(EGL_NO_DISPLAY, mEglDisplay);
57
58 EGLint majorVersion, minorVersion;
59 EXPECT_TRUE(eglInitialize(mEglDisplay, &majorVersion, &minorVersion));
60 ASSERT_EQ(EGL_SUCCESS, eglGetError());
61
62 EGLConfig myConfig;
63 EGLint numConfigs = 0;
64 EXPECT_TRUE(eglChooseConfig(mEglDisplay, getConfigAttribs(),
65 &myConfig, 1, &numConfigs));
66 ASSERT_EQ(EGL_SUCCESS, eglGetError());
67
Mathias Agopian993e14f2013-02-22 19:34:49 -080068 mEglConfig = myConfig;
Mathias Agopian7a5b22c2011-04-26 14:57:10 -070069 EGLint pbufferAttribs[] = {
70 EGL_WIDTH, 16,
71 EGL_HEIGHT, 16,
72 EGL_NONE };
73 mEglSurface = eglCreatePbufferSurface(mEglDisplay, myConfig, pbufferAttribs);
74 ASSERT_EQ(EGL_SUCCESS, eglGetError());
75 ASSERT_NE(EGL_NO_SURFACE, mEglSurface);
76
77 mEglContext = eglCreateContext(mEglDisplay, myConfig, EGL_NO_CONTEXT, 0);
78 ASSERT_EQ(EGL_SUCCESS, eglGetError());
79 ASSERT_NE(EGL_NO_CONTEXT, mEglContext);
80
81 EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface, mEglContext));
82 ASSERT_EQ(EGL_SUCCESS, eglGetError());
Jamie Gennis134f0422011-03-08 12:18:54 -080083 }
84
85 virtual void TearDown() {
86 mST.clear();
87 mSTC.clear();
Jamie Gennis8b69def2011-04-06 15:43:16 -070088 mANW.clear();
89
Mathias Agopian7a5b22c2011-04-26 14:57:10 -070090 eglMakeCurrent(mEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
91 eglDestroyContext(mEglDisplay, mEglContext);
92 eglDestroySurface(mEglDisplay, mEglSurface);
93 eglTerminate(mEglDisplay);
Jamie Gennisfa5b40e2012-03-15 14:01:24 -070094
95 const ::testing::TestInfo* const testInfo =
96 ::testing::UnitTest::GetInstance()->current_test_info();
97 ALOGV("End test: %s.%s", testInfo->test_case_name(),
98 testInfo->name());
Mathias Agopian7a5b22c2011-04-26 14:57:10 -070099 }
100
101 virtual EGLint const* getConfigAttribs() {
102 static EGLint sDefaultConfigAttribs[] = {
Mathias Agopian993e14f2013-02-22 19:34:49 -0800103 EGL_SURFACE_TYPE, EGL_PBUFFER_BIT | EGL_WINDOW_BIT,
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700104 EGL_NONE
105 };
106
107 return sDefaultConfigAttribs;
Jamie Gennis134f0422011-03-08 12:18:54 -0800108 }
109
Andy McFadden2adaf042012-12-18 09:49:45 -0800110 sp<GLConsumer> mST;
Mathias Agopiane3c697f2013-02-14 17:11:02 -0800111 sp<Surface> mSTC;
Jamie Gennis8b69def2011-04-06 15:43:16 -0700112 sp<ANativeWindow> mANW;
113
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700114 EGLDisplay mEglDisplay;
115 EGLSurface mEglSurface;
116 EGLContext mEglContext;
Mathias Agopian993e14f2013-02-22 19:34:49 -0800117 EGLConfig mEglConfig;
Jamie Gennis134f0422011-03-08 12:18:54 -0800118};
119
Jamie Gennisbae774e2011-03-14 15:08:53 -0700120TEST_F(SurfaceTextureClientTest, GetISurfaceTextureIsNotNull) {
Mathias Agopiancf0b8c82013-02-19 18:24:40 -0800121 sp<IGraphicBufferProducer> ist(mSTC->getIGraphicBufferProducer());
Jamie Gennisbae774e2011-03-14 15:08:53 -0700122 ASSERT_TRUE(ist != NULL);
123}
124
Jamie Gennis134f0422011-03-08 12:18:54 -0800125TEST_F(SurfaceTextureClientTest, QueuesToWindowCompositorIsFalse) {
Jamie Gennis134f0422011-03-08 12:18:54 -0800126 int result = -123;
Jamie Gennis8b69def2011-04-06 15:43:16 -0700127 int err = mANW->query(mANW.get(), NATIVE_WINDOW_QUEUES_TO_WINDOW_COMPOSER,
Jamie Gennis134f0422011-03-08 12:18:54 -0800128 &result);
129 EXPECT_EQ(NO_ERROR, err);
130 EXPECT_EQ(0, result);
131}
132
Jamie Gennis391bbe22011-03-14 15:00:06 -0700133TEST_F(SurfaceTextureClientTest, ConcreteTypeIsSurfaceTextureClient) {
Jamie Gennis391bbe22011-03-14 15:00:06 -0700134 int result = -123;
Jamie Gennis8b69def2011-04-06 15:43:16 -0700135 int err = mANW->query(mANW.get(), NATIVE_WINDOW_CONCRETE_TYPE, &result);
Jamie Gennis391bbe22011-03-14 15:00:06 -0700136 EXPECT_EQ(NO_ERROR, err);
Mathias Agopiane3c697f2013-02-14 17:11:02 -0800137 EXPECT_EQ(NATIVE_WINDOW_SURFACE, result);
Jamie Gennis391bbe22011-03-14 15:00:06 -0700138}
139
Jamie Gennis1b528fb2011-04-25 16:41:11 -0700140TEST_F(SurfaceTextureClientTest, EglCreateWindowSurfaceSucceeds) {
Jamie Gennis5c0c93a2011-03-14 15:34:04 -0700141 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
142 ASSERT_EQ(EGL_SUCCESS, eglGetError());
143 ASSERT_NE(EGL_NO_DISPLAY, dpy);
144
145 EGLint majorVersion;
146 EGLint minorVersion;
147 EXPECT_TRUE(eglInitialize(dpy, &majorVersion, &minorVersion));
148 ASSERT_EQ(EGL_SUCCESS, eglGetError());
149
150 EGLConfig myConfig = {0};
151 EGLint numConfigs = 0;
152 EGLint configAttribs[] = {
153 EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
154 EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
155 EGL_RED_SIZE, 8,
156 EGL_GREEN_SIZE, 8,
157 EGL_BLUE_SIZE, 8,
158 EGL_ALPHA_SIZE, 8,
159 EGL_DEPTH_SIZE, 16,
160 EGL_STENCIL_SIZE, 8,
161 EGL_NONE };
162 EXPECT_TRUE(eglChooseConfig(dpy, configAttribs, &myConfig, 1,
163 &numConfigs));
164 ASSERT_EQ(EGL_SUCCESS, eglGetError());
165
Jamie Gennis8b69def2011-04-06 15:43:16 -0700166 EGLSurface eglSurface = eglCreateWindowSurface(dpy, myConfig, mANW.get(),
Jamie Gennis5c0c93a2011-03-14 15:34:04 -0700167 NULL);
Mathias Agopianeafabcd2011-04-20 14:20:59 -0700168 EXPECT_NE(EGL_NO_SURFACE, eglSurface);
169 EXPECT_EQ(EGL_SUCCESS, eglGetError());
Jamie Gennis5c0c93a2011-03-14 15:34:04 -0700170
Jamie Gennisfa5b40e2012-03-15 14:01:24 -0700171 if (eglSurface != EGL_NO_SURFACE) {
172 eglDestroySurface(dpy, eglSurface);
173 }
174
Jamie Gennis5c0c93a2011-03-14 15:34:04 -0700175 eglTerminate(dpy);
176}
177
Mathias Agopian993e14f2013-02-22 19:34:49 -0800178TEST_F(SurfaceTextureClientTest, EglSwapBuffersAbandonErrorIsEglBadSurface) {
179
180 EGLSurface eglSurface = eglCreateWindowSurface(mEglDisplay, mEglConfig, mANW.get(), NULL);
181 EXPECT_NE(EGL_NO_SURFACE, eglSurface);
182 EXPECT_EQ(EGL_SUCCESS, eglGetError());
183
184 EGLBoolean success = eglMakeCurrent(mEglDisplay, eglSurface, eglSurface, mEglContext);
Jamie Gennisad669b02013-04-05 16:41:27 -0700185 EXPECT_TRUE(success);
Mathias Agopian993e14f2013-02-22 19:34:49 -0800186
187 glClear(GL_COLOR_BUFFER_BIT);
188 success = eglSwapBuffers(mEglDisplay, eglSurface);
Jamie Gennisad669b02013-04-05 16:41:27 -0700189 EXPECT_TRUE(success);
Mathias Agopian993e14f2013-02-22 19:34:49 -0800190
191 mST->abandon();
192
193 glClear(GL_COLOR_BUFFER_BIT);
194 success = eglSwapBuffers(mEglDisplay, eglSurface);
Jamie Gennisad669b02013-04-05 16:41:27 -0700195 EXPECT_FALSE(success);
Mathias Agopian993e14f2013-02-22 19:34:49 -0800196 EXPECT_EQ(EGL_BAD_SURFACE, eglGetError());
197
198 success = eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface, mEglContext);
Jamie Gennisad669b02013-04-05 16:41:27 -0700199 ASSERT_TRUE(success);
Mathias Agopian993e14f2013-02-22 19:34:49 -0800200
201 if (eglSurface != EGL_NO_SURFACE) {
202 eglDestroySurface(mEglDisplay, eglSurface);
203 }
204}
205
Mathias Agopiana5c75c02011-03-31 19:10:24 -0700206TEST_F(SurfaceTextureClientTest, BufferGeometryInvalidSizesFail) {
Jamie Gennis8b69def2011-04-06 15:43:16 -0700207 EXPECT_GT(OK, native_window_set_buffers_geometry(mANW.get(), -1, 0, 0));
208 EXPECT_GT(OK, native_window_set_buffers_geometry(mANW.get(), 0, -1, 0));
209 EXPECT_GT(OK, native_window_set_buffers_geometry(mANW.get(), 0, 0, -1));
210 EXPECT_GT(OK, native_window_set_buffers_geometry(mANW.get(), -1, -1, 0));
211 EXPECT_GT(OK, native_window_set_buffers_geometry(mANW.get(), 0, 8, 0));
212 EXPECT_GT(OK, native_window_set_buffers_geometry(mANW.get(), 8, 0, 0));
Mathias Agopiana5c75c02011-03-31 19:10:24 -0700213}
214
215TEST_F(SurfaceTextureClientTest, DefaultGeometryValues) {
Iliyan Malchev697526b2011-05-01 11:33:26 -0700216 ANativeWindowBuffer* buf;
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700217 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf));
Mathias Agopiana5c75c02011-03-31 19:10:24 -0700218 EXPECT_EQ(1, buf->width);
219 EXPECT_EQ(1, buf->height);
220 EXPECT_EQ(PIXEL_FORMAT_RGBA_8888, buf->format);
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700221 ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf, -1));
Mathias Agopiana5c75c02011-03-31 19:10:24 -0700222}
223
224TEST_F(SurfaceTextureClientTest, BufferGeometryCanBeSet) {
Iliyan Malchev697526b2011-05-01 11:33:26 -0700225 ANativeWindowBuffer* buf;
Jamie Gennis8b69def2011-04-06 15:43:16 -0700226 EXPECT_EQ(OK, native_window_set_buffers_geometry(mANW.get(), 16, 8, 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;
Jamie Gennis8b69def2011-04-06 15:43:16 -0700236 EXPECT_EQ(OK, native_window_set_buffers_geometry(mANW.get(), 0, 0, PIXEL_FORMAT_RGB_565));
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700237 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf));
Mathias Agopiana5c75c02011-03-31 19:10:24 -0700238 EXPECT_EQ(1, buf->width);
239 EXPECT_EQ(1, buf->height);
240 EXPECT_EQ(PIXEL_FORMAT_RGB_565, buf->format);
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700241 ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf, -1));
Mathias Agopiana5c75c02011-03-31 19:10:24 -0700242}
243
244TEST_F(SurfaceTextureClientTest, BufferGeometrySetSizeDefaultFormat) {
Iliyan Malchev697526b2011-05-01 11:33:26 -0700245 ANativeWindowBuffer* buf;
Jamie Gennis8b69def2011-04-06 15:43:16 -0700246 EXPECT_EQ(OK, native_window_set_buffers_geometry(mANW.get(), 16, 8, 0));
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700247 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf));
Mathias Agopiana5c75c02011-03-31 19:10:24 -0700248 EXPECT_EQ(16, buf->width);
249 EXPECT_EQ(8, buf->height);
250 EXPECT_EQ(PIXEL_FORMAT_RGBA_8888, buf->format);
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700251 ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf, -1));
Mathias Agopiana5c75c02011-03-31 19:10:24 -0700252}
253
254TEST_F(SurfaceTextureClientTest, BufferGeometrySizeCanBeUnset) {
Iliyan Malchev697526b2011-05-01 11:33:26 -0700255 ANativeWindowBuffer* buf;
Jamie Gennis8b69def2011-04-06 15:43:16 -0700256 EXPECT_EQ(OK, native_window_set_buffers_geometry(mANW.get(), 16, 8, 0));
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700257 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf));
Mathias Agopiana5c75c02011-03-31 19:10:24 -0700258 EXPECT_EQ(16, buf->width);
259 EXPECT_EQ(8, buf->height);
260 EXPECT_EQ(PIXEL_FORMAT_RGBA_8888, buf->format);
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700261 ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf, -1));
Jamie Gennis8b69def2011-04-06 15:43:16 -0700262 EXPECT_EQ(OK, native_window_set_buffers_geometry(mANW.get(), 0, 0, 0));
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700263 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf));
Mathias Agopiana5c75c02011-03-31 19:10:24 -0700264 EXPECT_EQ(1, buf->width);
265 EXPECT_EQ(1, buf->height);
266 EXPECT_EQ(PIXEL_FORMAT_RGBA_8888, buf->format);
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700267 ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf, -1));
Mathias Agopiana5c75c02011-03-31 19:10:24 -0700268}
269
270TEST_F(SurfaceTextureClientTest, BufferGeometrySizeCanBeChangedWithoutFormat) {
Iliyan Malchev697526b2011-05-01 11:33:26 -0700271 ANativeWindowBuffer* buf;
Jamie Gennis8b69def2011-04-06 15:43:16 -0700272 EXPECT_EQ(OK, native_window_set_buffers_geometry(mANW.get(), 0, 0, PIXEL_FORMAT_RGB_565));
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700273 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf));
Mathias Agopiana5c75c02011-03-31 19:10:24 -0700274 EXPECT_EQ(1, buf->width);
275 EXPECT_EQ(1, buf->height);
276 EXPECT_EQ(PIXEL_FORMAT_RGB_565, buf->format);
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700277 ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf, -1));
Jamie Gennis46975282012-08-30 18:35:50 -0700278 EXPECT_EQ(OK, native_window_set_buffers_dimensions(mANW.get(), 16, 8));
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700279 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf));
Mathias Agopiana5c75c02011-03-31 19:10:24 -0700280 EXPECT_EQ(16, buf->width);
281 EXPECT_EQ(8, buf->height);
282 EXPECT_EQ(PIXEL_FORMAT_RGB_565, buf->format);
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700283 ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf, -1));
Mathias Agopiana5c75c02011-03-31 19:10:24 -0700284}
285
286TEST_F(SurfaceTextureClientTest, SurfaceTextureSetDefaultSize) {
Andy McFadden2adaf042012-12-18 09:49:45 -0800287 sp<GLConsumer> st(mST);
Iliyan Malchev697526b2011-05-01 11:33:26 -0700288 ANativeWindowBuffer* buf;
Mathias Agopiana5c75c02011-03-31 19:10:24 -0700289 EXPECT_EQ(OK, st->setDefaultBufferSize(16, 8));
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700290 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf));
Mathias Agopiana5c75c02011-03-31 19:10:24 -0700291 EXPECT_EQ(16, buf->width);
292 EXPECT_EQ(8, buf->height);
293 EXPECT_EQ(PIXEL_FORMAT_RGBA_8888, buf->format);
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700294 ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf, -1));
Mathias Agopiana5c75c02011-03-31 19:10:24 -0700295}
296
297TEST_F(SurfaceTextureClientTest, SurfaceTextureSetDefaultSizeAfterDequeue) {
Iliyan Malchev697526b2011-05-01 11:33:26 -0700298 ANativeWindowBuffer* buf[2];
Jamie Gennis8b69def2011-04-06 15:43:16 -0700299 ASSERT_EQ(OK, native_window_set_buffer_count(mANW.get(), 4));
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700300 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[0]));
301 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[1]));
Mathias Agopiana5c75c02011-03-31 19:10:24 -0700302 EXPECT_NE(buf[0], buf[1]);
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700303 ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf[0], -1));
304 ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf[1], -1));
Jamie Gennis8b69def2011-04-06 15:43:16 -0700305 EXPECT_EQ(OK, mST->setDefaultBufferSize(16, 8));
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700306 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[0]));
307 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[1]));
Mathias Agopiana5c75c02011-03-31 19:10:24 -0700308 EXPECT_NE(buf[0], buf[1]);
309 EXPECT_EQ(16, buf[0]->width);
310 EXPECT_EQ(16, buf[1]->width);
311 EXPECT_EQ(8, buf[0]->height);
312 EXPECT_EQ(8, buf[1]->height);
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700313 ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf[0], -1));
314 ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf[1], -1));
Mathias Agopiana5c75c02011-03-31 19:10:24 -0700315}
316
317TEST_F(SurfaceTextureClientTest, SurfaceTextureSetDefaultSizeVsGeometry) {
Iliyan Malchev697526b2011-05-01 11:33:26 -0700318 ANativeWindowBuffer* buf[2];
Jamie Gennis8b69def2011-04-06 15:43:16 -0700319 ASSERT_EQ(OK, native_window_set_buffer_count(mANW.get(), 4));
320 EXPECT_EQ(OK, mST->setDefaultBufferSize(16, 8));
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700321 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[0]));
322 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[1]));
Mathias Agopiana5c75c02011-03-31 19:10:24 -0700323 EXPECT_NE(buf[0], buf[1]);
324 EXPECT_EQ(16, buf[0]->width);
325 EXPECT_EQ(16, buf[1]->width);
326 EXPECT_EQ(8, buf[0]->height);
327 EXPECT_EQ(8, buf[1]->height);
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700328 ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf[0], -1));
329 ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf[1], -1));
Jamie Gennis8b69def2011-04-06 15:43:16 -0700330 EXPECT_EQ(OK, native_window_set_buffers_geometry(mANW.get(), 12, 24, 0));
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700331 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[0]));
332 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[1]));
Mathias Agopiana5c75c02011-03-31 19:10:24 -0700333 EXPECT_NE(buf[0], buf[1]);
334 EXPECT_EQ(12, buf[0]->width);
335 EXPECT_EQ(12, buf[1]->width);
336 EXPECT_EQ(24, buf[0]->height);
337 EXPECT_EQ(24, buf[1]->height);
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700338 ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf[0], -1));
339 ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf[1], -1));
Mathias Agopiana5c75c02011-03-31 19:10:24 -0700340}
341
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700342TEST_F(SurfaceTextureClientTest, SurfaceTextureTooManyUpdateTexImage) {
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700343 android_native_buffer_t* buf[3];
Mathias Agopian595264f2013-07-16 22:56:09 -0700344 ASSERT_EQ(OK, mANW->setSwapInterval(mANW.get(), 0));
Jamie Gennis8b69def2011-04-06 15:43:16 -0700345 ASSERT_EQ(OK, native_window_set_buffer_count(mANW.get(), 4));
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700346
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700347 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[0]));
348 ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[0], -1));
Jamie Gennis8b69def2011-04-06 15:43:16 -0700349 EXPECT_EQ(OK, mST->updateTexImage());
350 EXPECT_EQ(OK, mST->updateTexImage());
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700351
Mathias Agopian595264f2013-07-16 22:56:09 -0700352 ASSERT_EQ(OK, mANW->setSwapInterval(mANW.get(), 1));
Jamie Gennis8b69def2011-04-06 15:43:16 -0700353 ASSERT_EQ(OK, native_window_set_buffer_count(mANW.get(), 3));
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700354
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700355 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[0]));
356 ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[0], -1));
357 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[1]));
358 ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[1], -1));
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700359
Jamie Gennis8b69def2011-04-06 15:43:16 -0700360 EXPECT_EQ(OK, mST->updateTexImage());
361 EXPECT_EQ(OK, mST->updateTexImage());
362 EXPECT_EQ(OK, mST->updateTexImage());
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700363}
364
365TEST_F(SurfaceTextureClientTest, SurfaceTextureSyncModeSlowRetire) {
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700366 android_native_buffer_t* buf[3];
Jamie Gennis8b69def2011-04-06 15:43:16 -0700367 ASSERT_EQ(OK, native_window_set_buffer_count(mANW.get(), 4));
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700368 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[0]));
369 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[1]));
370 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[2]));
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700371 EXPECT_NE(buf[0], buf[1]);
372 EXPECT_NE(buf[1], buf[2]);
373 EXPECT_NE(buf[2], buf[0]);
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700374 ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[0], -1));
375 ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[1], -1));
376 ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[2], -1));
Jamie Gennis8b69def2011-04-06 15:43:16 -0700377 EXPECT_EQ(OK, mST->updateTexImage());
378 EXPECT_EQ(mST->getCurrentBuffer().get(), buf[0]);
379 EXPECT_EQ(OK, mST->updateTexImage());
380 EXPECT_EQ(mST->getCurrentBuffer().get(), buf[1]);
381 EXPECT_EQ(OK, mST->updateTexImage());
382 EXPECT_EQ(mST->getCurrentBuffer().get(), buf[2]);
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700383}
384
385TEST_F(SurfaceTextureClientTest, SurfaceTextureSyncModeFastRetire) {
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700386 android_native_buffer_t* buf[3];
Jamie Gennis8b69def2011-04-06 15:43:16 -0700387 ASSERT_EQ(OK, native_window_set_buffer_count(mANW.get(), 4));
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700388 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[0]));
389 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[1]));
390 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[2]));
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700391 EXPECT_NE(buf[0], buf[1]);
392 EXPECT_NE(buf[1], buf[2]);
393 EXPECT_NE(buf[2], buf[0]);
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700394 ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[0], -1));
Jamie Gennis8b69def2011-04-06 15:43:16 -0700395 EXPECT_EQ(OK, mST->updateTexImage());
396 EXPECT_EQ(mST->getCurrentBuffer().get(), buf[0]);
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700397 ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[1], -1));
Jamie Gennis8b69def2011-04-06 15:43:16 -0700398 EXPECT_EQ(OK, mST->updateTexImage());
399 EXPECT_EQ(mST->getCurrentBuffer().get(), buf[1]);
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700400 ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[2], -1));
Jamie Gennis8b69def2011-04-06 15:43:16 -0700401 EXPECT_EQ(OK, mST->updateTexImage());
402 EXPECT_EQ(mST->getCurrentBuffer().get(), buf[2]);
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700403}
404
405TEST_F(SurfaceTextureClientTest, SurfaceTextureSyncModeDQQR) {
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700406 android_native_buffer_t* buf[3];
Jamie Gennis8b69def2011-04-06 15:43:16 -0700407 ASSERT_EQ(OK, native_window_set_buffer_count(mANW.get(), 3));
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700408
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700409 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[0]));
410 ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[0], -1));
Jamie Gennis8b69def2011-04-06 15:43:16 -0700411 EXPECT_EQ(OK, mST->updateTexImage());
412 EXPECT_EQ(mST->getCurrentBuffer().get(), buf[0]);
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700413
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700414 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[1]));
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700415 EXPECT_NE(buf[0], buf[1]);
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700416 ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[1], -1));
Jamie Gennis8b69def2011-04-06 15:43:16 -0700417 EXPECT_EQ(OK, mST->updateTexImage());
418 EXPECT_EQ(mST->getCurrentBuffer().get(), buf[1]);
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[2]));
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700421 EXPECT_NE(buf[1], buf[2]);
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700422 ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[2], -1));
Jamie Gennis8b69def2011-04-06 15:43:16 -0700423 EXPECT_EQ(OK, mST->updateTexImage());
424 EXPECT_EQ(mST->getCurrentBuffer().get(), buf[2]);
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700425}
426
Jamie Gennis8cd5ba42011-05-19 13:33:00 -0700427// XXX: We currently have no hardware that properly handles dequeuing the
428// buffer that is currently bound to the texture.
429TEST_F(SurfaceTextureClientTest, DISABLED_SurfaceTextureSyncModeDequeueCurrent) {
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700430 android_native_buffer_t* buf[3];
431 android_native_buffer_t* firstBuf;
Jamie Gennis8b69def2011-04-06 15:43:16 -0700432 ASSERT_EQ(OK, native_window_set_buffer_count(mANW.get(), 3));
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700433 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &firstBuf));
434 ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), firstBuf, -1));
Jamie Gennis8b69def2011-04-06 15:43:16 -0700435 EXPECT_EQ(OK, mST->updateTexImage());
436 EXPECT_EQ(mST->getCurrentBuffer().get(), firstBuf);
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700437 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[0]));
438 ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[0], -1));
439 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[1]));
440 ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[1], -1));
441 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[2]));
442 ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[2], -1));
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700443 EXPECT_NE(buf[0], buf[1]);
444 EXPECT_NE(buf[1], buf[2]);
445 EXPECT_NE(buf[2], buf[0]);
446 EXPECT_EQ(firstBuf, buf[2]);
447}
448
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700449TEST_F(SurfaceTextureClientTest, SurfaceTextureSyncModeMinUndequeued) {
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700450 android_native_buffer_t* buf[3];
Jamie Gennis8b69def2011-04-06 15:43:16 -0700451 ASSERT_EQ(OK, native_window_set_buffer_count(mANW.get(), 3));
Jamie Gennisc2c8dfd2011-05-23 18:44:04 -0700452
Jamie Gennis8b69def2011-04-06 15:43:16 -0700453 // We should be able to dequeue all the buffers before we've queued mANWy.
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700454 EXPECT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[0]));
455 EXPECT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[1]));
456 EXPECT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[2]));
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700457
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700458 ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf[2], -1));
459 ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[1], -1));
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700460
Jamie Gennis8b69def2011-04-06 15:43:16 -0700461 EXPECT_EQ(OK, mST->updateTexImage());
462 EXPECT_EQ(mST->getCurrentBuffer().get(), buf[1]);
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700463
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700464 EXPECT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[2]));
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700465
Jamie Gennisc2c8dfd2011-05-23 18:44:04 -0700466 // Once we've queued a buffer, however we should not be able to dequeue more
467 // than (buffer-count - MIN_UNDEQUEUED_BUFFERS), which is 2 in this case.
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700468 EXPECT_EQ(-EBUSY, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[1]));
Jamie Gennisc2c8dfd2011-05-23 18:44:04 -0700469
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700470 ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf[0], -1));
471 ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf[2], -1));
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700472}
473
Jamie Gennisd72f2332012-05-07 13:50:11 -0700474TEST_F(SurfaceTextureClientTest, SetCropCropsCrop) {
475 android_native_rect_t rect = {-2, -13, 40, 18};
476 native_window_set_crop(mANW.get(), &rect);
477
478 ASSERT_EQ(OK, native_window_set_buffers_dimensions(mANW.get(), 4, 4));
479
480 android_native_buffer_t* buf;
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700481 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf));
482 ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf, -1));
Jamie Gennisd72f2332012-05-07 13:50:11 -0700483 ASSERT_EQ(OK, mST->updateTexImage());
484
485 Rect crop = mST->getCurrentCrop();
486 EXPECT_EQ(0, crop.left);
487 EXPECT_EQ(0, crop.top);
488 EXPECT_EQ(4, crop.right);
489 EXPECT_EQ(4, crop.bottom);
490}
491
Jamie Gennis8dda6b72011-05-24 18:39:46 -0700492// XXX: This is not expected to pass until the synchronization hacks are removed
493// from the SurfaceTexture class.
494TEST_F(SurfaceTextureClientTest, DISABLED_SurfaceTextureSyncModeWaitRetire) {
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700495 class MyThread : public Thread {
Andy McFadden2adaf042012-12-18 09:49:45 -0800496 sp<GLConsumer> mST;
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700497 EGLContext ctx;
498 EGLSurface sur;
499 EGLDisplay dpy;
500 bool mBufferRetired;
501 Mutex mLock;
502 virtual bool threadLoop() {
503 eglMakeCurrent(dpy, sur, sur, ctx);
504 usleep(20000);
505 Mutex::Autolock _l(mLock);
Jamie Gennis8b69def2011-04-06 15:43:16 -0700506 mST->updateTexImage();
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700507 mBufferRetired = true;
508 eglMakeCurrent(dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
509 return false;
510 }
511 public:
Andy McFadden2adaf042012-12-18 09:49:45 -0800512 MyThread(const sp<GLConsumer>& mST)
Jamie Gennis8b69def2011-04-06 15:43:16 -0700513 : mST(mST), mBufferRetired(false) {
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700514 ctx = eglGetCurrentContext();
515 sur = eglGetCurrentSurface(EGL_DRAW);
516 dpy = eglGetCurrentDisplay();
517 eglMakeCurrent(dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
518 }
519 ~MyThread() {
520 eglMakeCurrent(dpy, sur, sur, ctx);
521 }
522 void bufferDequeued() {
523 Mutex::Autolock _l(mLock);
524 EXPECT_EQ(true, mBufferRetired);
525 }
526 };
527
528 android_native_buffer_t* buf[3];
Jamie Gennis8b69def2011-04-06 15:43:16 -0700529 ASSERT_EQ(OK, native_window_set_buffer_count(mANW.get(), 3));
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700530 // dequeue/queue/update so we have a current buffer
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700531 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[0]));
532 ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[0], -1));
Jamie Gennis8b69def2011-04-06 15:43:16 -0700533 mST->updateTexImage();
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700534
Jamie Gennis8b69def2011-04-06 15:43:16 -0700535 MyThread* thread = new MyThread(mST);
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700536 sp<Thread> threadBase(thread);
537
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));
Mathias Agopiane1220792011-05-04 18:28:07 -0700540 thread->run();
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700541 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[1]));
542 ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[1], -1));
543 //ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[2]));
544 //ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[2], -1));
Mathias Agopian7a5b22c2011-04-26 14:57:10 -0700545 thread->bufferDequeued();
546 thread->requestExitAndWait();
547}
548
Jamie Gennis52226042011-06-07 15:23:23 -0700549TEST_F(SurfaceTextureClientTest, GetTransformMatrixReturnsVerticalFlip) {
Jamie Gennis52226042011-06-07 15:23:23 -0700550 android_native_buffer_t* buf[3];
551 float mtx[16] = {};
Jamie Gennis8b69def2011-04-06 15:43:16 -0700552 ASSERT_EQ(OK, native_window_set_buffer_count(mANW.get(), 4));
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700553 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[0]));
554 ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[0], -1));
Jamie Gennis8b69def2011-04-06 15:43:16 -0700555 ASSERT_EQ(OK, mST->updateTexImage());
556 mST->getTransformMatrix(mtx);
Jamie Gennis52226042011-06-07 15:23:23 -0700557
558 EXPECT_EQ(1.f, mtx[0]);
559 EXPECT_EQ(0.f, mtx[1]);
560 EXPECT_EQ(0.f, mtx[2]);
561 EXPECT_EQ(0.f, mtx[3]);
562
563 EXPECT_EQ(0.f, mtx[4]);
564 EXPECT_EQ(-1.f, mtx[5]);
565 EXPECT_EQ(0.f, mtx[6]);
566 EXPECT_EQ(0.f, mtx[7]);
567
568 EXPECT_EQ(0.f, mtx[8]);
569 EXPECT_EQ(0.f, mtx[9]);
570 EXPECT_EQ(1.f, mtx[10]);
571 EXPECT_EQ(0.f, mtx[11]);
572
573 EXPECT_EQ(0.f, mtx[12]);
574 EXPECT_EQ(1.f, mtx[13]);
575 EXPECT_EQ(0.f, mtx[14]);
576 EXPECT_EQ(1.f, mtx[15]);
Jamie Gennis134f0422011-03-08 12:18:54 -0800577}
Jamie Gennis52226042011-06-07 15:23:23 -0700578
579TEST_F(SurfaceTextureClientTest, GetTransformMatrixSucceedsAfterFreeingBuffers) {
Jamie Gennis52226042011-06-07 15:23:23 -0700580 android_native_buffer_t* buf[3];
581 float mtx[16] = {};
Jamie Gennis8b69def2011-04-06 15:43:16 -0700582 ASSERT_EQ(OK, native_window_set_buffer_count(mANW.get(), 4));
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700583 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[0]));
584 ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[0], -1));
Jamie Gennis8b69def2011-04-06 15:43:16 -0700585 ASSERT_EQ(OK, mST->updateTexImage());
586 ASSERT_EQ(OK, native_window_set_buffer_count(mANW.get(), 6)); // frees buffers
587 mST->getTransformMatrix(mtx);
Jamie Gennis52226042011-06-07 15:23:23 -0700588
589 EXPECT_EQ(1.f, mtx[0]);
590 EXPECT_EQ(0.f, mtx[1]);
591 EXPECT_EQ(0.f, mtx[2]);
592 EXPECT_EQ(0.f, mtx[3]);
593
594 EXPECT_EQ(0.f, mtx[4]);
595 EXPECT_EQ(-1.f, mtx[5]);
596 EXPECT_EQ(0.f, mtx[6]);
597 EXPECT_EQ(0.f, mtx[7]);
598
599 EXPECT_EQ(0.f, mtx[8]);
600 EXPECT_EQ(0.f, mtx[9]);
601 EXPECT_EQ(1.f, mtx[10]);
602 EXPECT_EQ(0.f, mtx[11]);
603
604 EXPECT_EQ(0.f, mtx[12]);
605 EXPECT_EQ(1.f, mtx[13]);
606 EXPECT_EQ(0.f, mtx[14]);
607 EXPECT_EQ(1.f, mtx[15]);
608}
609
610TEST_F(SurfaceTextureClientTest, GetTransformMatrixSucceedsAfterFreeingBuffersWithCrop) {
Jamie Gennis52226042011-06-07 15:23:23 -0700611 android_native_buffer_t* buf[3];
612 float mtx[16] = {};
613 android_native_rect_t crop;
614 crop.left = 0;
615 crop.top = 0;
616 crop.right = 5;
617 crop.bottom = 5;
618
Jamie Gennis8b69def2011-04-06 15:43:16 -0700619 ASSERT_EQ(OK, native_window_set_buffer_count(mANW.get(), 4));
620 ASSERT_EQ(OK, native_window_set_buffers_geometry(mANW.get(), 8, 8, 0));
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700621 ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[0]));
Jamie Gennis8b69def2011-04-06 15:43:16 -0700622 ASSERT_EQ(OK, native_window_set_crop(mANW.get(), &crop));
Jamie Gennisd8e812c2012-06-13 16:32:25 -0700623 ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[0], -1));
Jamie Gennis8b69def2011-04-06 15:43:16 -0700624 ASSERT_EQ(OK, mST->updateTexImage());
625 ASSERT_EQ(OK, native_window_set_buffer_count(mANW.get(), 6)); // frees buffers
626 mST->getTransformMatrix(mtx);
Jamie Gennis52226042011-06-07 15:23:23 -0700627
Jamie Gennis46975282012-08-30 18:35:50 -0700628 // This accounts for the .5 texel shrink for each edge that's included in the
Jamie Gennis52226042011-06-07 15:23:23 -0700629 // transform matrix to avoid texturing outside the crop region.
Jamie Gennis46975282012-08-30 18:35:50 -0700630 EXPECT_EQ(0.5, mtx[0]);
Jamie Gennis52226042011-06-07 15:23:23 -0700631 EXPECT_EQ(0.f, mtx[1]);
632 EXPECT_EQ(0.f, mtx[2]);
633 EXPECT_EQ(0.f, mtx[3]);
634
635 EXPECT_EQ(0.f, mtx[4]);
Jamie Gennis46975282012-08-30 18:35:50 -0700636 EXPECT_EQ(-0.5, mtx[5]);
Jamie Gennis52226042011-06-07 15:23:23 -0700637 EXPECT_EQ(0.f, mtx[6]);
638 EXPECT_EQ(0.f, mtx[7]);
639
640 EXPECT_EQ(0.f, mtx[8]);
641 EXPECT_EQ(0.f, mtx[9]);
642 EXPECT_EQ(1.f, mtx[10]);
643 EXPECT_EQ(0.f, mtx[11]);
644
Jamie Gennis46975282012-08-30 18:35:50 -0700645 EXPECT_EQ(0.0625f, mtx[12]);
646 EXPECT_EQ(0.5625f, mtx[13]);
Jamie Gennis52226042011-06-07 15:23:23 -0700647 EXPECT_EQ(0.f, mtx[14]);
648 EXPECT_EQ(1.f, mtx[15]);
649}
650
Jamie Gennisa6f35dd2011-06-12 13:56:15 -0700651// This test verifies that the buffer format can be queried immediately after
652// it is set.
Jamie Gennis07ed1a92011-06-14 17:04:29 -0700653TEST_F(SurfaceTextureClientTest, QueryFormatAfterSettingWorks) {
Jamie Gennisa6f35dd2011-06-12 13:56:15 -0700654 sp<ANativeWindow> anw(mSTC);
655 int fmts[] = {
656 // RGBA_8888 should not come first, as it's the default
657 HAL_PIXEL_FORMAT_RGBX_8888,
658 HAL_PIXEL_FORMAT_RGBA_8888,
659 HAL_PIXEL_FORMAT_RGB_888,
660 HAL_PIXEL_FORMAT_RGB_565,
661 HAL_PIXEL_FORMAT_BGRA_8888,
Jamie Gennisa6f35dd2011-06-12 13:56:15 -0700662 HAL_PIXEL_FORMAT_YV12,
663 };
664
665 const int numFmts = (sizeof(fmts) / sizeof(fmts[0]));
666 for (int i = 0; i < numFmts; i++) {
667 int fmt = -1;
668 ASSERT_EQ(OK, native_window_set_buffers_geometry(anw.get(), 0, 0, fmts[i]));
669 ASSERT_EQ(OK, anw->query(anw.get(), NATIVE_WINDOW_FORMAT, &fmt));
670 EXPECT_EQ(fmts[i], fmt);
671 }
672}
673
Jamie Gennisc8251a02011-07-11 19:00:51 -0700674class MultiSurfaceTextureClientTest : public ::testing::Test {
675
676public:
677 MultiSurfaceTextureClientTest() :
678 mEglDisplay(EGL_NO_DISPLAY),
679 mEglContext(EGL_NO_CONTEXT) {
680 for (int i = 0; i < NUM_SURFACE_TEXTURES; i++) {
681 mEglSurfaces[i] = EGL_NO_CONTEXT;
682 }
683 }
684
685protected:
686
687 enum { NUM_SURFACE_TEXTURES = 32 };
688
689 virtual void SetUp() {
690 mEglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
691 ASSERT_EQ(EGL_SUCCESS, eglGetError());
692 ASSERT_NE(EGL_NO_DISPLAY, mEglDisplay);
693
694 EGLint majorVersion, minorVersion;
695 EXPECT_TRUE(eglInitialize(mEglDisplay, &majorVersion, &minorVersion));
696 ASSERT_EQ(EGL_SUCCESS, eglGetError());
697
698 EGLConfig myConfig;
699 EGLint numConfigs = 0;
700 EGLint configAttribs[] = {
701 EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
702 EGL_NONE
703 };
704 EXPECT_TRUE(eglChooseConfig(mEglDisplay, configAttribs, &myConfig, 1,
705 &numConfigs));
706 ASSERT_EQ(EGL_SUCCESS, eglGetError());
707
708 mEglContext = eglCreateContext(mEglDisplay, myConfig, EGL_NO_CONTEXT,
709 0);
710 ASSERT_EQ(EGL_SUCCESS, eglGetError());
711 ASSERT_NE(EGL_NO_CONTEXT, mEglContext);
712
713 for (int i = 0; i < NUM_SURFACE_TEXTURES; i++) {
Mathias Agopian8f938a52013-07-12 22:06:26 -0700714 sp<BufferQueue> bq = new BufferQueue();
715 sp<GLConsumer> st(new GLConsumer(bq, i));
Mathias Agopiandb89edc2013-08-02 01:40:18 -0700716 sp<Surface> stc(new Surface(bq));
Jamie Gennisc8251a02011-07-11 19:00:51 -0700717 mEglSurfaces[i] = eglCreateWindowSurface(mEglDisplay, myConfig,
718 static_cast<ANativeWindow*>(stc.get()), NULL);
719 ASSERT_EQ(EGL_SUCCESS, eglGetError());
720 ASSERT_NE(EGL_NO_SURFACE, mEglSurfaces[i]);
721 }
722 }
723
724 virtual void TearDown() {
725 eglMakeCurrent(mEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE,
726 EGL_NO_CONTEXT);
727
728 for (int i = 0; i < NUM_SURFACE_TEXTURES; i++) {
729 if (mEglSurfaces[i] != EGL_NO_SURFACE) {
730 eglDestroySurface(mEglDisplay, mEglSurfaces[i]);
731 }
732 }
733
734 if (mEglContext != EGL_NO_CONTEXT) {
735 eglDestroyContext(mEglDisplay, mEglContext);
736 }
737
738 if (mEglDisplay != EGL_NO_DISPLAY) {
739 eglTerminate(mEglDisplay);
740 }
741 }
742
743 EGLDisplay mEglDisplay;
744 EGLSurface mEglSurfaces[NUM_SURFACE_TEXTURES];
745 EGLContext mEglContext;
746};
747
748// XXX: This test is disabled because it causes a hang on some devices. See bug
749// 5015672.
750TEST_F(MultiSurfaceTextureClientTest, DISABLED_MakeCurrentBetweenSurfacesWorks) {
751 for (int iter = 0; iter < 8; iter++) {
752 for (int i = 0; i < NUM_SURFACE_TEXTURES; i++) {
753 eglMakeCurrent(mEglDisplay, mEglSurfaces[i], mEglSurfaces[i],
754 mEglContext);
755 glClear(GL_COLOR_BUFFER_BIT);
756 eglSwapBuffers(mEglDisplay, mEglSurfaces[i]);
757 }
758 }
759}
760
Jamie Gennis52226042011-06-07 15:23:23 -0700761} // namespace android