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