libs/gui/tests/SurfaceTextureClient_test.cpp

   1 /*
   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
  17 #define LOG_TAG "SurfaceTextureClient_test"
  18 //#define LOG_NDEBUG 0
  19
  20 #include <EGL/egl.h>
  21 #include <GLES2/gl2.h>
  22
  23 #include <gtest/gtest.h>
  24 #include <gui/GLConsumer.h>
  25 #include <gui/Surface.h>
  26 #include <gui/BufferQueue.h>
  27 #include <system/graphics.h>
  28 #include <utils/Log.h>
  29 #include <utils/Thread.h>
  30
  31 extern "C" EGLAPI const char* eglQueryStringImplementationANDROID(EGLDisplay dpy, EGLint name);
  32 #define CROP_EXT_STR "EGL_ANDROID_image_crop"
  33
  34 namespace android {
  35
  36 class SurfaceTextureClientTest : public ::testing::Test {
  37 protected:
  38     SurfaceTextureClientTest():
  39             mEglDisplay(EGL_NO_DISPLAY),
  40             mEglSurface(EGL_NO_SURFACE),
  41             mEglContext(EGL_NO_CONTEXT),
  42             mEglConfig(NULL) {
  43     }
  44
  45     virtual void SetUp() {
  46         const ::testing::TestInfo* const testInfo =
  47             ::testing::UnitTest::GetInstance()->current_test_info();
  48         ALOGV("Begin test: %s.%s", testInfo->test_case_name(),
  49                 testInfo->name());
  50
  51         sp<IGraphicBufferProducer> producer;
  52         sp<IGraphicBufferConsumer> consumer;
  53         BufferQueue::createBufferQueue(&producer, &consumer);
  54         mST = new GLConsumer(consumer, 123, GLConsumer::TEXTURE_EXTERNAL, true,
  55                 false);
  56         mSTC = new Surface(producer);
  57         mANW = mSTC;
  58
  59         // We need a valid GL context so we can test updateTexImage()
  60         // This initializes EGL and create a dummy GL context with a
  61         // pbuffer render target.
  62         mEglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
  63         ASSERT_EQ(EGL_SUCCESS, eglGetError());
  64         ASSERT_NE(EGL_NO_DISPLAY, mEglDisplay);
  65
  66         EGLint majorVersion, minorVersion;
  67         EXPECT_TRUE(eglInitialize(mEglDisplay, &majorVersion, &minorVersion));
  68         ASSERT_EQ(EGL_SUCCESS, eglGetError());
  69
  70         EGLConfig myConfig;
  71         EGLint numConfigs = 0;
  72         EXPECT_TRUE(eglChooseConfig(mEglDisplay, getConfigAttribs(),
  73                 &myConfig, 1, &numConfigs));
  74         ASSERT_EQ(EGL_SUCCESS, eglGetError());
  75
  76         mEglConfig = myConfig;
  77         EGLint pbufferAttribs[] = {
  78             EGL_WIDTH, 16,
  79             EGL_HEIGHT, 16,
  80             EGL_NONE };
  81         mEglSurface = eglCreatePbufferSurface(mEglDisplay, myConfig, pbufferAttribs);
  82         ASSERT_EQ(EGL_SUCCESS, eglGetError());
  83         ASSERT_NE(EGL_NO_SURFACE, mEglSurface);
  84
  85         mEglContext = eglCreateContext(mEglDisplay, myConfig, EGL_NO_CONTEXT, 0);
  86         ASSERT_EQ(EGL_SUCCESS, eglGetError());
  87         ASSERT_NE(EGL_NO_CONTEXT, mEglContext);
  88
  89         EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface, mEglContext));
  90         ASSERT_EQ(EGL_SUCCESS, eglGetError());
  91     }
  92
  93     virtual void TearDown() {
  94         mST.clear();
  95         mSTC.clear();
  96         mANW.clear();
  97
  98         eglMakeCurrent(mEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
  99         eglDestroyContext(mEglDisplay, mEglContext);
 100         eglDestroySurface(mEglDisplay, mEglSurface);
 101         eglTerminate(mEglDisplay);
 102
 103         const ::testing::TestInfo* const testInfo =
 104             ::testing::UnitTest::GetInstance()->current_test_info();
 105         ALOGV("End test:   %s.%s", testInfo->test_case_name(),
 106                 testInfo->name());
 107     }
 108
 109     virtual EGLint const* getConfigAttribs() {
 110         static EGLint sDefaultConfigAttribs[] = {
 111             EGL_SURFACE_TYPE, EGL_PBUFFER_BIT | EGL_WINDOW_BIT,
 112             EGL_NONE
 113         };
 114
 115         return sDefaultConfigAttribs;
 116     }
 117
 118     sp<GLConsumer> mST;
 119     sp<Surface> mSTC;
 120     sp<ANativeWindow> mANW;
 121
 122     EGLDisplay mEglDisplay;
 123     EGLSurface mEglSurface;
 124     EGLContext mEglContext;
 125     EGLConfig  mEglConfig;
 126 };
 127
 128 TEST_F(SurfaceTextureClientTest, GetISurfaceTextureIsNotNull) {
 129     sp<IGraphicBufferProducer> ist(mSTC->getIGraphicBufferProducer());
 130     ASSERT_TRUE(ist != NULL);
 131 }
 132
 133 TEST_F(SurfaceTextureClientTest, QueuesToWindowCompositorIsFalse) {
 134     int result = -123;
 135     int err = mANW->query(mANW.get(), NATIVE_WINDOW_QUEUES_TO_WINDOW_COMPOSER,
 136             &result);
 137     EXPECT_EQ(NO_ERROR, err);
 138     EXPECT_EQ(0, result);
 139 }
 140
 141 TEST_F(SurfaceTextureClientTest, ConcreteTypeIsSurfaceTextureClient) {
 142     int result = -123;
 143     int err = mANW->query(mANW.get(), NATIVE_WINDOW_CONCRETE_TYPE, &result);
 144     EXPECT_EQ(NO_ERROR, err);
 145     EXPECT_EQ(NATIVE_WINDOW_SURFACE, result);
 146 }
 147
 148 TEST_F(SurfaceTextureClientTest, EglCreateWindowSurfaceSucceeds) {
 149     EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
 150     ASSERT_EQ(EGL_SUCCESS, eglGetError());
 151     ASSERT_NE(EGL_NO_DISPLAY, dpy);
 152
 153     EGLint majorVersion;
 154     EGLint minorVersion;
 155     EXPECT_TRUE(eglInitialize(dpy, &majorVersion, &minorVersion));
 156     ASSERT_EQ(EGL_SUCCESS, eglGetError());
 157
 158     EGLConfig myConfig = {0};
 159     EGLint numConfigs = 0;
 160     EGLint configAttribs[] = {
 161         EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
 162         EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
 163         EGL_RED_SIZE, 8,
 164         EGL_GREEN_SIZE, 8,
 165         EGL_BLUE_SIZE, 8,
 166         EGL_ALPHA_SIZE, 8,
 167         EGL_DEPTH_SIZE, 16,
 168         EGL_STENCIL_SIZE, 8,
 169         EGL_NONE };
 170     EXPECT_TRUE(eglChooseConfig(dpy, configAttribs, &myConfig, 1,
 171             &numConfigs));
 172     ASSERT_EQ(EGL_SUCCESS, eglGetError());
 173
 174     EGLSurface eglSurface = eglCreateWindowSurface(dpy, myConfig, mANW.get(),
 175             NULL);
 176     EXPECT_NE(EGL_NO_SURFACE, eglSurface);
 177     EXPECT_EQ(EGL_SUCCESS, eglGetError());
 178
 179     if (eglSurface != EGL_NO_SURFACE) {
 180         eglDestroySurface(dpy, eglSurface);
 181     }
 182
 183     eglTerminate(dpy);
 184 }
 185
 186 TEST_F(SurfaceTextureClientTest, EglSwapBuffersAbandonErrorIsEglBadSurface) {
 187
 188     EGLSurface eglSurface = eglCreateWindowSurface(mEglDisplay, mEglConfig, mANW.get(), NULL);
 189     EXPECT_NE(EGL_NO_SURFACE, eglSurface);
 190     EXPECT_EQ(EGL_SUCCESS, eglGetError());
 191
 192     EGLBoolean success = eglMakeCurrent(mEglDisplay, eglSurface, eglSurface, mEglContext);
 193     EXPECT_TRUE(success);
 194
 195     glClear(GL_COLOR_BUFFER_BIT);
 196     success = eglSwapBuffers(mEglDisplay, eglSurface);
 197     EXPECT_TRUE(success);
 198
 199     mST->abandon();
 200
 201     glClear(GL_COLOR_BUFFER_BIT);
 202     success = eglSwapBuffers(mEglDisplay, eglSurface);
 203     EXPECT_FALSE(success);
 204     EXPECT_EQ(EGL_BAD_SURFACE, eglGetError());
 205
 206     success = eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface, mEglContext);
 207     ASSERT_TRUE(success);
 208
 209     if (eglSurface != EGL_NO_SURFACE) {
 210         eglDestroySurface(mEglDisplay, eglSurface);
 211     }
 212 }
 213
 214 TEST_F(SurfaceTextureClientTest, BufferGeometryInvalidSizesFail) {
 215     EXPECT_GT(OK, native_window_set_buffers_dimensions(mANW.get(),  0,  8));
 216     EXPECT_GT(OK, native_window_set_buffers_dimensions(mANW.get(),  8,  0));
 217 }
 218
 219 TEST_F(SurfaceTextureClientTest, DefaultGeometryValues) {
 220     ASSERT_EQ(OK, native_window_api_connect(mANW.get(), NATIVE_WINDOW_API_CPU));
 221     ANativeWindowBuffer* buf;
 222     ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf));
 223     EXPECT_EQ(1, buf->width);
 224     EXPECT_EQ(1, buf->height);
 225     EXPECT_EQ(PIXEL_FORMAT_RGBA_8888, buf->format);
 226     ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf, -1));
 227 }
 228
 229 TEST_F(SurfaceTextureClientTest, BufferGeometryCanBeSet) {
 230     ASSERT_EQ(OK, native_window_api_connect(mANW.get(), NATIVE_WINDOW_API_CPU));
 231     ANativeWindowBuffer* buf;
 232     EXPECT_EQ(OK, native_window_set_buffers_dimensions(mANW.get(), 16, 8));
 233     EXPECT_EQ(OK, native_window_set_buffers_format(mANW.get(), PIXEL_FORMAT_RGB_565));
 234     ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf));
 235     EXPECT_EQ(16, buf->width);
 236     EXPECT_EQ(8, buf->height);
 237     EXPECT_EQ(PIXEL_FORMAT_RGB_565, buf->format);
 238     ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf, -1));
 239 }
 240
 241 TEST_F(SurfaceTextureClientTest, BufferGeometryDefaultSizeSetFormat) {
 242     ASSERT_EQ(OK, native_window_api_connect(mANW.get(), NATIVE_WINDOW_API_CPU));
 243     ANativeWindowBuffer* buf;
 244     EXPECT_EQ(OK, native_window_set_buffers_dimensions(mANW.get(), 0, 0));
 245     EXPECT_EQ(OK, native_window_set_buffers_format(mANW.get(), PIXEL_FORMAT_RGB_565));
 246     ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf));
 247     EXPECT_EQ(1, buf->width);
 248     EXPECT_EQ(1, buf->height);
 249     EXPECT_EQ(PIXEL_FORMAT_RGB_565, buf->format);
 250     ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf, -1));
 251 }
 252
 253 TEST_F(SurfaceTextureClientTest, BufferGeometrySetSizeDefaultFormat) {
 254     ASSERT_EQ(OK, native_window_api_connect(mANW.get(), NATIVE_WINDOW_API_CPU));
 255     ANativeWindowBuffer* buf;
 256     EXPECT_EQ(OK, native_window_set_buffers_dimensions(mANW.get(), 16, 8));
 257     EXPECT_EQ(OK, native_window_set_buffers_format(mANW.get(), 0));
 258     ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf));
 259     EXPECT_EQ(16, buf->width);
 260     EXPECT_EQ(8, buf->height);
 261     EXPECT_EQ(PIXEL_FORMAT_RGBA_8888, buf->format);
 262     ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf, -1));
 263 }
 264
 265 TEST_F(SurfaceTextureClientTest, BufferGeometrySizeCanBeUnset) {
 266     ASSERT_EQ(OK, native_window_api_connect(mANW.get(), NATIVE_WINDOW_API_CPU));
 267     ANativeWindowBuffer* buf;
 268     EXPECT_EQ(OK, native_window_set_buffers_dimensions(mANW.get(), 16, 8));
 269     EXPECT_EQ(OK, native_window_set_buffers_format(mANW.get(), 0));
 270     ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf));
 271     EXPECT_EQ(16, buf->width);
 272     EXPECT_EQ(8, buf->height);
 273     EXPECT_EQ(PIXEL_FORMAT_RGBA_8888, buf->format);
 274     ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf, -1));
 275     EXPECT_EQ(OK, native_window_set_buffers_dimensions(mANW.get(), 0, 0));
 276     EXPECT_EQ(OK, native_window_set_buffers_format(mANW.get(), 0));
 277     ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf));
 278     EXPECT_EQ(1, buf->width);
 279     EXPECT_EQ(1, buf->height);
 280     EXPECT_EQ(PIXEL_FORMAT_RGBA_8888, buf->format);
 281     ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf, -1));
 282 }
 283
 284 TEST_F(SurfaceTextureClientTest, BufferGeometrySizeCanBeChangedWithoutFormat) {
 285     ASSERT_EQ(OK, native_window_api_connect(mANW.get(), NATIVE_WINDOW_API_CPU));
 286     ANativeWindowBuffer* buf;
 287     EXPECT_EQ(OK, native_window_set_buffers_dimensions(mANW.get(), 0, 0));
 288     EXPECT_EQ(OK, native_window_set_buffers_format(mANW.get(), PIXEL_FORMAT_RGB_565));
 289     ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf));
 290     EXPECT_EQ(1, buf->width);
 291     EXPECT_EQ(1, buf->height);
 292     EXPECT_EQ(PIXEL_FORMAT_RGB_565, buf->format);
 293     ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf, -1));
 294     EXPECT_EQ(OK, native_window_set_buffers_dimensions(mANW.get(), 16, 8));
 295     ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf));
 296     EXPECT_EQ(16, buf->width);
 297     EXPECT_EQ(8, buf->height);
 298     EXPECT_EQ(PIXEL_FORMAT_RGB_565, buf->format);
 299     ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf, -1));
 300 }
 301
 302 TEST_F(SurfaceTextureClientTest, SurfaceTextureSetDefaultSize) {
 303     ASSERT_EQ(OK, native_window_api_connect(mANW.get(), NATIVE_WINDOW_API_CPU));
 304     sp<GLConsumer> st(mST);
 305     ANativeWindowBuffer* buf;
 306     EXPECT_EQ(OK, st->setDefaultBufferSize(16, 8));
 307     ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf));
 308     EXPECT_EQ(16, buf->width);
 309     EXPECT_EQ(8, buf->height);
 310     EXPECT_EQ(PIXEL_FORMAT_RGBA_8888, buf->format);
 311     ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf, -1));
 312 }
 313
 314 TEST_F(SurfaceTextureClientTest, SurfaceTextureSetDefaultSizeAfterDequeue) {
 315     ANativeWindowBuffer* buf[2];
 316     ASSERT_EQ(OK, native_window_api_connect(mANW.get(), NATIVE_WINDOW_API_CPU));
 317     ASSERT_EQ(OK, native_window_set_buffer_count(mANW.get(), 4));
 318     ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[0]));
 319     ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[1]));
 320     EXPECT_NE(buf[0], buf[1]);
 321     ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf[0], -1));
 322     ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf[1], -1));
 323     EXPECT_EQ(OK, mST->setDefaultBufferSize(16, 8));
 324     ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[0]));
 325     ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[1]));
 326     EXPECT_NE(buf[0], buf[1]);
 327     EXPECT_EQ(16, buf[0]->width);
 328     EXPECT_EQ(16, buf[1]->width);
 329     EXPECT_EQ(8, buf[0]->height);
 330     EXPECT_EQ(8, buf[1]->height);
 331     ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf[0], -1));
 332     ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf[1], -1));
 333 }
 334
 335 TEST_F(SurfaceTextureClientTest, SurfaceTextureSetDefaultSizeVsGeometry) {
 336     ANativeWindowBuffer* buf[2];
 337     ASSERT_EQ(OK, native_window_api_connect(mANW.get(), NATIVE_WINDOW_API_CPU));
 338     ASSERT_EQ(OK, native_window_set_buffer_count(mANW.get(), 4));
 339     EXPECT_EQ(OK, mST->setDefaultBufferSize(16, 8));
 340     ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[0]));
 341     ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[1]));
 342     EXPECT_NE(buf[0], buf[1]);
 343     EXPECT_EQ(16, buf[0]->width);
 344     EXPECT_EQ(16, buf[1]->width);
 345     EXPECT_EQ(8, buf[0]->height);
 346     EXPECT_EQ(8, buf[1]->height);
 347     ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf[0], -1));
 348     ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf[1], -1));
 349     EXPECT_EQ(OK, native_window_set_buffers_dimensions(mANW.get(), 12, 24));
 350     EXPECT_EQ(OK, native_window_set_buffers_format(mANW.get(), 0));
 351     ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[0]));
 352     ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[1]));
 353     EXPECT_NE(buf[0], buf[1]);
 354     EXPECT_EQ(12, buf[0]->width);
 355     EXPECT_EQ(12, buf[1]->width);
 356     EXPECT_EQ(24, buf[0]->height);
 357     EXPECT_EQ(24, buf[1]->height);
 358     ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf[0], -1));
 359     ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf[1], -1));
 360 }
 361
 362 TEST_F(SurfaceTextureClientTest, SurfaceTextureTooManyUpdateTexImage) {
 363     android_native_buffer_t* buf[3];
 364     ASSERT_EQ(OK, native_window_api_connect(mANW.get(), NATIVE_WINDOW_API_CPU));
 365     ASSERT_EQ(OK, mANW->setSwapInterval(mANW.get(), 0));
 366     ASSERT_EQ(OK, native_window_set_buffer_count(mANW.get(), 4));
 367
 368     ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[0]));
 369     ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[0], -1));
 370     EXPECT_EQ(OK, mST->updateTexImage());
 371     EXPECT_EQ(OK, mST->updateTexImage());
 372
 373     ASSERT_EQ(OK, mANW->setSwapInterval(mANW.get(), 1));
 374     ASSERT_EQ(OK, native_window_set_buffer_count(mANW.get(), 3));
 375
 376     ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[0]));
 377     ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[0], -1));
 378     ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[1]));
 379     ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[1], -1));
 380
 381     EXPECT_EQ(OK, mST->updateTexImage());
 382     EXPECT_EQ(OK, mST->updateTexImage());
 383     EXPECT_EQ(OK, mST->updateTexImage());
 384 }
 385
 386 TEST_F(SurfaceTextureClientTest, SurfaceTextureSyncModeSlowRetire) {
 387     android_native_buffer_t* buf[3];
 388     ASSERT_EQ(OK, native_window_api_connect(mANW.get(), NATIVE_WINDOW_API_CPU));
 389     ASSERT_EQ(OK, native_window_set_buffer_count(mANW.get(), 4));
 390     ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[0]));
 391     ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[1]));
 392     ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[2]));
 393     EXPECT_NE(buf[0], buf[1]);
 394     EXPECT_NE(buf[1], buf[2]);
 395     EXPECT_NE(buf[2], buf[0]);
 396     ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[0], -1));
 397     ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[1], -1));
 398     ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[2], -1));
 399     EXPECT_EQ(OK, mST->updateTexImage());
 400     EXPECT_EQ(mST->getCurrentBuffer().get(), buf[0]);
 401     EXPECT_EQ(OK, mST->updateTexImage());
 402     EXPECT_EQ(mST->getCurrentBuffer().get(), buf[1]);
 403     EXPECT_EQ(OK, mST->updateTexImage());
 404     EXPECT_EQ(mST->getCurrentBuffer().get(), buf[2]);
 405 }
 406
 407 TEST_F(SurfaceTextureClientTest, SurfaceTextureSyncModeFastRetire) {
 408     android_native_buffer_t* buf[3];
 409     ASSERT_EQ(OK, native_window_api_connect(mANW.get(), NATIVE_WINDOW_API_CPU));
 410     ASSERT_EQ(OK, native_window_set_buffer_count(mANW.get(), 4));
 411     ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[0]));
 412     ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[1]));
 413     ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[2]));
 414     EXPECT_NE(buf[0], buf[1]);
 415     EXPECT_NE(buf[1], buf[2]);
 416     EXPECT_NE(buf[2], buf[0]);
 417     ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[0], -1));
 418     EXPECT_EQ(OK, mST->updateTexImage());
 419     EXPECT_EQ(mST->getCurrentBuffer().get(), buf[0]);
 420     ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[1], -1));
 421     EXPECT_EQ(OK, mST->updateTexImage());
 422     EXPECT_EQ(mST->getCurrentBuffer().get(), buf[1]);
 423     ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[2], -1));
 424     EXPECT_EQ(OK, mST->updateTexImage());
 425     EXPECT_EQ(mST->getCurrentBuffer().get(), buf[2]);
 426 }
 427
 428 TEST_F(SurfaceTextureClientTest, SurfaceTextureSyncModeDQQR) {
 429     android_native_buffer_t* buf[3];
 430     ASSERT_EQ(OK, native_window_api_connect(mANW.get(), NATIVE_WINDOW_API_CPU));
 431     ASSERT_EQ(OK, native_window_set_buffer_count(mANW.get(), 3));
 432     ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[0]));
 433     ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[0], -1));
 434     EXPECT_EQ(OK, mST->updateTexImage());
 435     EXPECT_EQ(mST->getCurrentBuffer().get(), buf[0]);
 436
 437     ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[1]));
 438     EXPECT_NE(buf[0], buf[1]);
 439     ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[1], -1));
 440     EXPECT_EQ(OK, mST->updateTexImage());
 441     EXPECT_EQ(mST->getCurrentBuffer().get(), buf[1]);
 442
 443     ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[2]));
 444     EXPECT_NE(buf[1], buf[2]);
 445     ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[2], -1));
 446     EXPECT_EQ(OK, mST->updateTexImage());
 447     EXPECT_EQ(mST->getCurrentBuffer().get(), buf[2]);
 448 }
 449
 450 // XXX: We currently have no hardware that properly handles dequeuing the
 451 // buffer that is currently bound to the texture.
 452 TEST_F(SurfaceTextureClientTest, DISABLED_SurfaceTextureSyncModeDequeueCurrent) {
 453     android_native_buffer_t* buf[3];
 454     android_native_buffer_t* firstBuf;
 455     ASSERT_EQ(OK, native_window_api_connect(mANW.get(), NATIVE_WINDOW_API_CPU));
 456     ASSERT_EQ(OK, native_window_set_buffer_count(mANW.get(), 3));
 457     ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &firstBuf));
 458     ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), firstBuf, -1));
 459     EXPECT_EQ(OK, mST->updateTexImage());
 460     EXPECT_EQ(mST->getCurrentBuffer().get(), firstBuf);
 461     ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[0]));
 462     ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[0], -1));
 463     ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[1]));
 464     ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[1], -1));
 465     ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[2]));
 466     ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[2], -1));
 467     EXPECT_NE(buf[0], buf[1]);
 468     EXPECT_NE(buf[1], buf[2]);
 469     EXPECT_NE(buf[2], buf[0]);
 470     EXPECT_EQ(firstBuf, buf[2]);
 471 }
 472
 473 TEST_F(SurfaceTextureClientTest, SurfaceTextureSyncModeMinUndequeued) {
 474     android_native_buffer_t* buf[3];
 475     ASSERT_EQ(OK, native_window_api_connect(mANW.get(), NATIVE_WINDOW_API_CPU));
 476     ASSERT_EQ(OK, native_window_set_buffer_count(mANW.get(), 3));
 477
 478     // We should be able to dequeue all the buffers before we've queued mANWy.
 479     EXPECT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[0]));
 480     EXPECT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[1]));
 481     EXPECT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[2]));
 482
 483     ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf[2], -1));
 484     ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[1], -1));
 485
 486     EXPECT_EQ(OK, mST->updateTexImage());
 487     EXPECT_EQ(mST->getCurrentBuffer().get(), buf[1]);
 488
 489     EXPECT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[2]));
 490
 491     // Once we've queued a buffer, however we should not be able to dequeue more
 492     // than (buffer-count - MIN_UNDEQUEUED_BUFFERS), which is 2 in this case.
 493     EXPECT_EQ(INVALID_OPERATION,
 494             native_window_dequeue_buffer_and_wait(mANW.get(), &buf[1]));
 495
 496     ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf[0], -1));
 497     ASSERT_EQ(OK, mANW->cancelBuffer(mANW.get(), buf[2], -1));
 498 }
 499
 500 TEST_F(SurfaceTextureClientTest, SetCropCropsCrop) {
 501     ASSERT_EQ(OK, native_window_api_connect(mANW.get(), NATIVE_WINDOW_API_CPU));
 502     android_native_rect_t rect = {-2, -13, 40, 18};
 503     native_window_set_crop(mANW.get(), &rect);
 504
 505     ASSERT_EQ(OK, native_window_set_buffers_dimensions(mANW.get(), 4, 4));
 506
 507     android_native_buffer_t* buf;
 508     ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf));
 509     ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf, -1));
 510     ASSERT_EQ(OK, mST->updateTexImage());
 511
 512     Rect crop = mST->getCurrentCrop();
 513     EXPECT_EQ(0, crop.left);
 514     EXPECT_EQ(0, crop.top);
 515     EXPECT_EQ(4, crop.right);
 516     EXPECT_EQ(4, crop.bottom);
 517 }
 518
 519 // XXX: This is not expected to pass until the synchronization hacks are removed
 520 // from the SurfaceTexture class.
 521 TEST_F(SurfaceTextureClientTest, DISABLED_SurfaceTextureSyncModeWaitRetire) {
 522     class MyThread : public Thread {
 523         sp<GLConsumer> mST;
 524         EGLContext ctx;
 525         EGLSurface sur;
 526         EGLDisplay dpy;
 527         bool mBufferRetired;
 528         Mutex mLock;
 529         virtual bool threadLoop() {
 530             eglMakeCurrent(dpy, sur, sur, ctx);
 531             usleep(20000);
 532             Mutex::Autolock _l(mLock);
 533             mST->updateTexImage();
 534             mBufferRetired = true;
 535             eglMakeCurrent(dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
 536             return false;
 537         }
 538     public:
 539         explicit MyThread(const sp<GLConsumer>& mST)
 540             : mST(mST), mBufferRetired(false) {
 541             ctx = eglGetCurrentContext();
 542             sur = eglGetCurrentSurface(EGL_DRAW);
 543             dpy = eglGetCurrentDisplay();
 544             eglMakeCurrent(dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
 545         }
 546         ~MyThread() {
 547             eglMakeCurrent(dpy, sur, sur, ctx);
 548         }
 549         void bufferDequeued() {
 550             Mutex::Autolock _l(mLock);
 551             EXPECT_EQ(true, mBufferRetired);
 552         }
 553     };
 554
 555     android_native_buffer_t* buf[3];
 556     ASSERT_EQ(OK, native_window_api_connect(mANW.get(), NATIVE_WINDOW_API_CPU));
 557     ASSERT_EQ(OK, native_window_set_buffer_count(mANW.get(), 3));
 558     // dequeue/queue/update so we have a current buffer
 559     ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[0]));
 560     ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[0], -1));
 561     mST->updateTexImage();
 562
 563     MyThread* thread = new MyThread(mST);
 564     sp<Thread> threadBase(thread);
 565
 566     ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[0]));
 567     ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[0], -1));
 568     thread->run("MyThread");
 569     ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[1]));
 570     ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[1], -1));
 571     //ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[2]));
 572     //ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[2], -1));
 573     thread->bufferDequeued();
 574     thread->requestExitAndWait();
 575 }
 576
 577 TEST_F(SurfaceTextureClientTest, GetTransformMatrixReturnsVerticalFlip) {
 578     android_native_buffer_t* buf[3];
 579     float mtx[16] = {};
 580     ASSERT_EQ(OK, native_window_api_connect(mANW.get(), NATIVE_WINDOW_API_CPU));
 581     ASSERT_EQ(OK, native_window_set_buffer_count(mANW.get(), 4));
 582     ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[0]));
 583     ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[0], -1));
 584     ASSERT_EQ(OK, mST->updateTexImage());
 585     mST->getTransformMatrix(mtx);
 586
 587     EXPECT_EQ(1.f, mtx[0]);
 588     EXPECT_EQ(0.f, mtx[1]);
 589     EXPECT_EQ(0.f, mtx[2]);
 590     EXPECT_EQ(0.f, mtx[3]);
 591
 592     EXPECT_EQ(0.f, mtx[4]);
 593     EXPECT_EQ(-1.f, mtx[5]);
 594     EXPECT_EQ(0.f, mtx[6]);
 595     EXPECT_EQ(0.f, mtx[7]);
 596
 597     EXPECT_EQ(0.f, mtx[8]);
 598     EXPECT_EQ(0.f, mtx[9]);
 599     EXPECT_EQ(1.f, mtx[10]);
 600     EXPECT_EQ(0.f, mtx[11]);
 601
 602     EXPECT_EQ(0.f, mtx[12]);
 603     EXPECT_EQ(1.f, mtx[13]);
 604     EXPECT_EQ(0.f, mtx[14]);
 605     EXPECT_EQ(1.f, mtx[15]);
 606 }
 607
 608 TEST_F(SurfaceTextureClientTest, GetTransformMatrixSucceedsAfterFreeingBuffers) {
 609     android_native_buffer_t* buf[3];
 610     float mtx[16] = {};
 611     ASSERT_EQ(OK, native_window_api_connect(mANW.get(), NATIVE_WINDOW_API_CPU));
 612     ASSERT_EQ(OK, native_window_set_buffer_count(mANW.get(), 4));
 613     ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[0]));
 614     ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[0], -1));
 615     ASSERT_EQ(OK, mST->updateTexImage());
 616     ASSERT_EQ(OK, native_window_set_buffer_count(mANW.get(), 6)); // frees buffers
 617     mST->getTransformMatrix(mtx);
 618
 619     EXPECT_EQ(1.f, mtx[0]);
 620     EXPECT_EQ(0.f, mtx[1]);
 621     EXPECT_EQ(0.f, mtx[2]);
 622     EXPECT_EQ(0.f, mtx[3]);
 623
 624     EXPECT_EQ(0.f, mtx[4]);
 625     EXPECT_EQ(-1.f, mtx[5]);
 626     EXPECT_EQ(0.f, mtx[6]);
 627     EXPECT_EQ(0.f, mtx[7]);
 628
 629     EXPECT_EQ(0.f, mtx[8]);
 630     EXPECT_EQ(0.f, mtx[9]);
 631     EXPECT_EQ(1.f, mtx[10]);
 632     EXPECT_EQ(0.f, mtx[11]);
 633
 634     EXPECT_EQ(0.f, mtx[12]);
 635     EXPECT_EQ(1.f, mtx[13]);
 636     EXPECT_EQ(0.f, mtx[14]);
 637     EXPECT_EQ(1.f, mtx[15]);
 638 }
 639
 640 TEST_F(SurfaceTextureClientTest, GetTransformMatrixSucceedsAfterFreeingBuffersWithCrop) {
 641     // Query to see if the image crop extension exists
 642     EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
 643     const char* exts = eglQueryStringImplementationANDROID(dpy, EGL_EXTENSIONS);
 644     size_t cropExtLen = strlen(CROP_EXT_STR);
 645     size_t extsLen = strlen(exts);
 646     bool equal = !strcmp(CROP_EXT_STR, exts);
 647     bool atStart = !strncmp(CROP_EXT_STR " ", exts, cropExtLen+1);
 648     bool atEnd = (cropExtLen+1) < extsLen &&
 649             !strcmp(" " CROP_EXT_STR, exts + extsLen - (cropExtLen+1));
 650     bool inMiddle = strstr(exts, " " CROP_EXT_STR " ");
 651     bool hasEglAndroidImageCrop = equal || atStart || atEnd || inMiddle;
 652
 653     android_native_buffer_t* buf[3];
 654     float mtx[16] = {};
 655     android_native_rect_t crop;
 656     crop.left = 0;
 657     crop.top = 0;
 658     crop.right = 5;
 659     crop.bottom = 5;
 660
 661     ASSERT_EQ(OK, native_window_api_connect(mANW.get(), NATIVE_WINDOW_API_CPU));
 662     ASSERT_EQ(OK, native_window_set_buffer_count(mANW.get(), 4));
 663     ASSERT_EQ(OK, native_window_set_buffers_dimensions(mANW.get(), 8, 8));
 664     ASSERT_EQ(OK, native_window_set_buffers_format(mANW.get(), 0));
 665     ASSERT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &buf[0]));
 666     ASSERT_EQ(OK, native_window_set_crop(mANW.get(), &crop));
 667     ASSERT_EQ(OK, mANW->queueBuffer(mANW.get(), buf[0], -1));
 668     ASSERT_EQ(OK, mST->updateTexImage());
 669     ASSERT_EQ(OK, native_window_set_buffer_count(mANW.get(), 6)); // frees buffers
 670     mST->getTransformMatrix(mtx);
 671
 672     // If the egl image crop extension is not present, this accounts for the
 673     // .5 texel shrink for each edge that's included in the transform matrix
 674     // to avoid texturing outside the crop region. Otherwise the crop is not
 675     // included in the transform matrix.
 676     EXPECT_EQ(hasEglAndroidImageCrop ? 1 : 0.5, mtx[0]);
 677     EXPECT_EQ(0.f, mtx[1]);
 678     EXPECT_EQ(0.f, mtx[2]);
 679     EXPECT_EQ(0.f, mtx[3]);
 680
 681     EXPECT_EQ(0.f, mtx[4]);
 682     EXPECT_EQ(hasEglAndroidImageCrop ? -1 : -0.5, mtx[5]);
 683     EXPECT_EQ(0.f, mtx[6]);
 684     EXPECT_EQ(0.f, mtx[7]);
 685
 686     EXPECT_EQ(0.f, mtx[8]);
 687     EXPECT_EQ(0.f, mtx[9]);
 688     EXPECT_EQ(1.f, mtx[10]);
 689     EXPECT_EQ(0.f, mtx[11]);
 690
 691     EXPECT_EQ(hasEglAndroidImageCrop ? 0 : 0.0625f, mtx[12]);
 692     EXPECT_EQ(hasEglAndroidImageCrop ? 1 : 0.5625f, mtx[13]);
 693     EXPECT_EQ(0.f, mtx[14]);
 694     EXPECT_EQ(1.f, mtx[15]);
 695 }
 696
 697 // This test verifies that the buffer format can be queried immediately after
 698 // it is set.
 699 TEST_F(SurfaceTextureClientTest, QueryFormatAfterSettingWorks) {
 700     sp<ANativeWindow> anw(mSTC);
 701     int fmts[] = {
 702         // RGBA_8888 should not come first, as it's the default
 703         HAL_PIXEL_FORMAT_RGBX_8888,
 704         HAL_PIXEL_FORMAT_RGBA_8888,
 705         HAL_PIXEL_FORMAT_RGB_888,
 706         HAL_PIXEL_FORMAT_RGB_565,
 707         HAL_PIXEL_FORMAT_BGRA_8888,
 708         HAL_PIXEL_FORMAT_YV12,
 709     };
 710
 711     const int numFmts = (sizeof(fmts) / sizeof(fmts[0]));
 712     for (int i = 0; i < numFmts; i++) {
 713       int fmt = -1;
 714       ASSERT_EQ(OK, native_window_set_buffers_dimensions(anw.get(), 0, 0));
 715       ASSERT_EQ(OK, native_window_set_buffers_format(anw.get(), fmts[i]));
 716       ASSERT_EQ(OK, anw->query(anw.get(), NATIVE_WINDOW_FORMAT, &fmt));
 717       EXPECT_EQ(fmts[i], fmt);
 718     }
 719 }
 720
 721 class MultiSurfaceTextureClientTest : public ::testing::Test {
 722
 723 public:
 724     MultiSurfaceTextureClientTest() :
 725             mEglDisplay(EGL_NO_DISPLAY),
 726             mEglContext(EGL_NO_CONTEXT) {
 727         for (int i = 0; i < NUM_SURFACE_TEXTURES; i++) {
 728             mEglSurfaces[i] = EGL_NO_CONTEXT;
 729         }
 730     }
 731
 732 protected:
 733
 734     enum { NUM_SURFACE_TEXTURES = 32 };
 735
 736     virtual void SetUp() {
 737         mEglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
 738         ASSERT_EQ(EGL_SUCCESS, eglGetError());
 739         ASSERT_NE(EGL_NO_DISPLAY, mEglDisplay);
 740
 741         EGLint majorVersion, minorVersion;
 742         EXPECT_TRUE(eglInitialize(mEglDisplay, &majorVersion, &minorVersion));
 743         ASSERT_EQ(EGL_SUCCESS, eglGetError());
 744
 745         EGLConfig myConfig;
 746         EGLint numConfigs = 0;
 747         EGLint configAttribs[] = {
 748             EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
 749             EGL_NONE
 750         };
 751         EXPECT_TRUE(eglChooseConfig(mEglDisplay, configAttribs, &myConfig, 1,
 752                 &numConfigs));
 753         ASSERT_EQ(EGL_SUCCESS, eglGetError());
 754
 755         mEglContext = eglCreateContext(mEglDisplay, myConfig, EGL_NO_CONTEXT,
 756                 0);
 757         ASSERT_EQ(EGL_SUCCESS, eglGetError());
 758         ASSERT_NE(EGL_NO_CONTEXT, mEglContext);
 759
 760         for (int i = 0; i < NUM_SURFACE_TEXTURES; i++) {
 761             sp<IGraphicBufferProducer> producer;
 762             sp<IGraphicBufferConsumer> consumer;
 763             BufferQueue::createBufferQueue(&producer, &consumer);
 764             sp<GLConsumer> st(new GLConsumer(consumer, i,
 765                     GLConsumer::TEXTURE_EXTERNAL, true, false));
 766             sp<Surface> stc(new Surface(producer));
 767             mEglSurfaces[i] = eglCreateWindowSurface(mEglDisplay, myConfig,
 768                     static_cast<ANativeWindow*>(stc.get()), NULL);
 769             ASSERT_EQ(EGL_SUCCESS, eglGetError());
 770             ASSERT_NE(EGL_NO_SURFACE, mEglSurfaces[i]);
 771         }
 772     }
 773
 774     virtual void TearDown() {
 775         eglMakeCurrent(mEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE,
 776                 EGL_NO_CONTEXT);
 777
 778         for (int i = 0; i < NUM_SURFACE_TEXTURES; i++) {
 779             if (mEglSurfaces[i] != EGL_NO_SURFACE) {
 780                 eglDestroySurface(mEglDisplay, mEglSurfaces[i]);
 781             }
 782         }
 783
 784         if (mEglContext != EGL_NO_CONTEXT) {
 785             eglDestroyContext(mEglDisplay, mEglContext);
 786         }
 787
 788         if (mEglDisplay != EGL_NO_DISPLAY) {
 789             eglTerminate(mEglDisplay);
 790         }
 791     }
 792
 793     EGLDisplay mEglDisplay;
 794     EGLSurface mEglSurfaces[NUM_SURFACE_TEXTURES];
 795     EGLContext mEglContext;
 796 };
 797
 798 // XXX: This test is disabled because it causes a hang on some devices.  See bug
 799 // 5015672.
 800 TEST_F(MultiSurfaceTextureClientTest, DISABLED_MakeCurrentBetweenSurfacesWorks) {
 801     for (int iter = 0; iter < 8; iter++) {
 802         for (int i = 0; i < NUM_SURFACE_TEXTURES; i++) {
 803             eglMakeCurrent(mEglDisplay, mEglSurfaces[i], mEglSurfaces[i],
 804                     mEglContext);
 805             glClear(GL_COLOR_BUFFER_BIT);
 806             eglSwapBuffers(mEglDisplay, mEglSurfaces[i]);
 807         }
 808     }
 809 }
 810
 811 } // namespace android