Dan Stoza | cb1fcde | 2013-12-03 12:37:36 -0800 | [diff] [blame] | 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 "SurfaceTextureGL_test" |
| 18 | //#define LOG_NDEBUG 0 |
| 19 | |
| 20 | #include "SurfaceTextureGL.h" |
| 21 | |
| 22 | #include "DisconnectWaiter.h" |
| 23 | #include "FillBuffer.h" |
| 24 | |
| 25 | namespace android { |
| 26 | |
| 27 | TEST_F(SurfaceTextureGLTest, TexturingFromCpuFilledYV12BufferNpot) { |
| 28 | const int texWidth = 64; |
| 29 | const int texHeight = 66; |
| 30 | |
Dan Stoza | f8cebe5 | 2015-04-20 12:09:38 -0700 | [diff] [blame^] | 31 | ASSERT_EQ(NO_ERROR, native_window_set_buffers_dimensions(mANW.get(), |
| 32 | texWidth, texHeight)); |
| 33 | ASSERT_EQ(NO_ERROR, native_window_set_buffers_format(mANW.get(), |
| 34 | HAL_PIXEL_FORMAT_YV12)); |
Dan Stoza | cb1fcde | 2013-12-03 12:37:36 -0800 | [diff] [blame] | 35 | ASSERT_EQ(NO_ERROR, native_window_set_usage(mANW.get(), |
| 36 | GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN)); |
| 37 | |
| 38 | ANativeWindowBuffer* anb; |
| 39 | ASSERT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(mANW.get(), |
| 40 | &anb)); |
| 41 | ASSERT_TRUE(anb != NULL); |
| 42 | |
| 43 | sp<GraphicBuffer> buf(new GraphicBuffer(anb, false)); |
| 44 | |
| 45 | // Fill the buffer with the a checkerboard pattern |
| 46 | uint8_t* img = NULL; |
| 47 | buf->lock(GRALLOC_USAGE_SW_WRITE_OFTEN, (void**)(&img)); |
| 48 | fillYV12Buffer(img, texWidth, texHeight, buf->getStride()); |
| 49 | buf->unlock(); |
| 50 | ASSERT_EQ(NO_ERROR, mANW->queueBuffer(mANW.get(), buf->getNativeBuffer(), |
| 51 | -1)); |
| 52 | |
| 53 | ASSERT_EQ(NO_ERROR, mST->updateTexImage()); |
| 54 | |
| 55 | glClearColor(0.2, 0.2, 0.2, 0.2); |
| 56 | glClear(GL_COLOR_BUFFER_BIT); |
| 57 | |
| 58 | glViewport(0, 0, texWidth, texHeight); |
| 59 | drawTexture(); |
| 60 | |
| 61 | EXPECT_TRUE(checkPixel( 0, 0, 255, 127, 255, 255, 3)); |
| 62 | EXPECT_TRUE(checkPixel(63, 0, 0, 133, 0, 255, 3)); |
| 63 | EXPECT_TRUE(checkPixel(63, 65, 0, 133, 0, 255, 3)); |
| 64 | EXPECT_TRUE(checkPixel( 0, 65, 255, 127, 255, 255, 3)); |
| 65 | |
| 66 | EXPECT_TRUE(checkPixel(22, 44, 255, 127, 255, 255, 3)); |
| 67 | EXPECT_TRUE(checkPixel(45, 52, 255, 127, 255, 255, 3)); |
| 68 | EXPECT_TRUE(checkPixel(52, 51, 98, 255, 73, 255, 3)); |
| 69 | EXPECT_TRUE(checkPixel( 7, 31, 155, 0, 118, 255, 3)); |
| 70 | EXPECT_TRUE(checkPixel(31, 9, 107, 24, 87, 255, 3)); |
| 71 | EXPECT_TRUE(checkPixel(29, 35, 255, 127, 255, 255, 3)); |
| 72 | EXPECT_TRUE(checkPixel(36, 22, 155, 29, 0, 255, 3)); |
| 73 | } |
| 74 | |
| 75 | TEST_F(SurfaceTextureGLTest, TexturingFromCpuFilledYV12BufferPow2) { |
| 76 | const int texWidth = 64; |
| 77 | const int texHeight = 64; |
| 78 | |
Dan Stoza | f8cebe5 | 2015-04-20 12:09:38 -0700 | [diff] [blame^] | 79 | ASSERT_EQ(NO_ERROR, native_window_set_buffers_dimensions(mANW.get(), |
| 80 | texWidth, texHeight)); |
| 81 | ASSERT_EQ(NO_ERROR, native_window_set_buffers_format(mANW.get(), |
| 82 | HAL_PIXEL_FORMAT_YV12)); |
Dan Stoza | cb1fcde | 2013-12-03 12:37:36 -0800 | [diff] [blame] | 83 | ASSERT_EQ(NO_ERROR, native_window_set_usage(mANW.get(), |
| 84 | GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN)); |
| 85 | |
| 86 | ANativeWindowBuffer* anb; |
| 87 | ASSERT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(mANW.get(), |
| 88 | &anb)); |
| 89 | ASSERT_TRUE(anb != NULL); |
| 90 | |
| 91 | sp<GraphicBuffer> buf(new GraphicBuffer(anb, false)); |
| 92 | |
| 93 | // Fill the buffer with the a checkerboard pattern |
| 94 | uint8_t* img = NULL; |
| 95 | buf->lock(GRALLOC_USAGE_SW_WRITE_OFTEN, (void**)(&img)); |
| 96 | fillYV12Buffer(img, texWidth, texHeight, buf->getStride()); |
| 97 | buf->unlock(); |
| 98 | ASSERT_EQ(NO_ERROR, mANW->queueBuffer(mANW.get(), buf->getNativeBuffer(), |
| 99 | -1)); |
| 100 | |
| 101 | ASSERT_EQ(NO_ERROR, mST->updateTexImage()); |
| 102 | |
| 103 | glClearColor(0.2, 0.2, 0.2, 0.2); |
| 104 | glClear(GL_COLOR_BUFFER_BIT); |
| 105 | |
| 106 | glViewport(0, 0, texWidth, texHeight); |
| 107 | drawTexture(); |
| 108 | |
| 109 | EXPECT_TRUE(checkPixel( 0, 0, 0, 133, 0, 255)); |
| 110 | EXPECT_TRUE(checkPixel(63, 0, 255, 127, 255, 255)); |
| 111 | EXPECT_TRUE(checkPixel(63, 63, 0, 133, 0, 255)); |
| 112 | EXPECT_TRUE(checkPixel( 0, 63, 255, 127, 255, 255)); |
| 113 | |
| 114 | EXPECT_TRUE(checkPixel(22, 19, 100, 255, 74, 255)); |
| 115 | EXPECT_TRUE(checkPixel(45, 11, 100, 255, 74, 255)); |
| 116 | EXPECT_TRUE(checkPixel(52, 12, 155, 0, 181, 255)); |
| 117 | EXPECT_TRUE(checkPixel( 7, 32, 150, 237, 170, 255)); |
| 118 | EXPECT_TRUE(checkPixel(31, 54, 0, 71, 117, 255)); |
| 119 | EXPECT_TRUE(checkPixel(29, 28, 0, 133, 0, 255)); |
| 120 | EXPECT_TRUE(checkPixel(36, 41, 100, 232, 255, 255)); |
| 121 | } |
| 122 | |
| 123 | TEST_F(SurfaceTextureGLTest, TexturingFromCpuFilledYV12BufferWithCrop) { |
| 124 | const int texWidth = 64; |
| 125 | const int texHeight = 66; |
| 126 | |
Dan Stoza | f8cebe5 | 2015-04-20 12:09:38 -0700 | [diff] [blame^] | 127 | ASSERT_EQ(NO_ERROR, native_window_set_buffers_dimensions(mANW.get(), |
| 128 | texWidth, texHeight)); |
| 129 | ASSERT_EQ(NO_ERROR, native_window_set_buffers_format(mANW.get(), |
| 130 | HAL_PIXEL_FORMAT_YV12)); |
Dan Stoza | cb1fcde | 2013-12-03 12:37:36 -0800 | [diff] [blame] | 131 | ASSERT_EQ(NO_ERROR, native_window_set_usage(mANW.get(), |
| 132 | GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN)); |
| 133 | |
| 134 | android_native_rect_t crops[] = { |
| 135 | {4, 6, 22, 36}, |
| 136 | {0, 6, 22, 36}, |
| 137 | {4, 0, 22, 36}, |
| 138 | {4, 6, texWidth, 36}, |
| 139 | {4, 6, 22, texHeight}, |
| 140 | }; |
| 141 | |
| 142 | for (int i = 0; i < 5; i++) { |
| 143 | const android_native_rect_t& crop(crops[i]); |
| 144 | SCOPED_TRACE(String8::format("rect{ l: %d t: %d r: %d b: %d }", |
| 145 | crop.left, crop.top, crop.right, crop.bottom).string()); |
| 146 | |
| 147 | ASSERT_EQ(NO_ERROR, native_window_set_crop(mANW.get(), &crop)); |
| 148 | |
| 149 | ANativeWindowBuffer* anb; |
| 150 | ASSERT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(mANW.get(), |
| 151 | &anb)); |
| 152 | ASSERT_TRUE(anb != NULL); |
| 153 | |
| 154 | sp<GraphicBuffer> buf(new GraphicBuffer(anb, false)); |
| 155 | |
| 156 | uint8_t* img = NULL; |
| 157 | buf->lock(GRALLOC_USAGE_SW_WRITE_OFTEN, (void**)(&img)); |
| 158 | fillYV12BufferRect(img, texWidth, texHeight, buf->getStride(), crop); |
| 159 | buf->unlock(); |
| 160 | ASSERT_EQ(NO_ERROR, mANW->queueBuffer(mANW.get(), |
| 161 | buf->getNativeBuffer(), -1)); |
| 162 | |
| 163 | ASSERT_EQ(NO_ERROR, mST->updateTexImage()); |
| 164 | |
| 165 | glClearColor(0.2, 0.2, 0.2, 0.2); |
| 166 | glClear(GL_COLOR_BUFFER_BIT); |
| 167 | |
| 168 | glViewport(0, 0, 64, 64); |
| 169 | drawTexture(); |
| 170 | |
| 171 | EXPECT_TRUE(checkPixel( 0, 0, 82, 255, 35, 255)); |
| 172 | EXPECT_TRUE(checkPixel(63, 0, 82, 255, 35, 255)); |
| 173 | EXPECT_TRUE(checkPixel(63, 63, 82, 255, 35, 255)); |
| 174 | EXPECT_TRUE(checkPixel( 0, 63, 82, 255, 35, 255)); |
| 175 | |
| 176 | EXPECT_TRUE(checkPixel(25, 14, 82, 255, 35, 255)); |
| 177 | EXPECT_TRUE(checkPixel(35, 31, 82, 255, 35, 255)); |
| 178 | EXPECT_TRUE(checkPixel(57, 6, 82, 255, 35, 255)); |
| 179 | EXPECT_TRUE(checkPixel( 5, 42, 82, 255, 35, 255)); |
| 180 | EXPECT_TRUE(checkPixel(32, 33, 82, 255, 35, 255)); |
| 181 | EXPECT_TRUE(checkPixel(16, 26, 82, 255, 35, 255)); |
| 182 | EXPECT_TRUE(checkPixel(46, 51, 82, 255, 35, 255)); |
| 183 | } |
| 184 | } |
| 185 | |
| 186 | // This test is intended to catch synchronization bugs between the CPU-written |
| 187 | // and GPU-read buffers. |
| 188 | TEST_F(SurfaceTextureGLTest, TexturingFromCpuFilledYV12BuffersRepeatedly) { |
| 189 | enum { texWidth = 16 }; |
| 190 | enum { texHeight = 16 }; |
| 191 | enum { numFrames = 1024 }; |
| 192 | |
| 193 | ASSERT_EQ(NO_ERROR, mST->setDefaultMaxBufferCount(2)); |
Dan Stoza | f8cebe5 | 2015-04-20 12:09:38 -0700 | [diff] [blame^] | 194 | ASSERT_EQ(NO_ERROR, native_window_set_buffers_dimensions(mANW.get(), |
| 195 | texWidth, texHeight)); |
| 196 | ASSERT_EQ(NO_ERROR, native_window_set_buffers_format(mANW.get(), |
| 197 | HAL_PIXEL_FORMAT_YV12)); |
Dan Stoza | cb1fcde | 2013-12-03 12:37:36 -0800 | [diff] [blame] | 198 | ASSERT_EQ(NO_ERROR, native_window_set_usage(mANW.get(), |
| 199 | GRALLOC_USAGE_SW_WRITE_OFTEN)); |
| 200 | |
| 201 | struct TestPixel { |
| 202 | int x; |
| 203 | int y; |
| 204 | }; |
| 205 | const TestPixel testPixels[] = { |
| 206 | { 4, 11 }, |
| 207 | { 12, 14 }, |
| 208 | { 7, 2 }, |
| 209 | }; |
| 210 | enum {numTestPixels = sizeof(testPixels) / sizeof(testPixels[0])}; |
| 211 | |
| 212 | class ProducerThread : public Thread { |
| 213 | public: |
| 214 | ProducerThread(const sp<ANativeWindow>& anw, |
| 215 | const TestPixel* testPixels): |
| 216 | mANW(anw), |
| 217 | mTestPixels(testPixels) { |
| 218 | } |
| 219 | |
| 220 | virtual ~ProducerThread() { |
| 221 | } |
| 222 | |
| 223 | virtual bool threadLoop() { |
| 224 | for (int i = 0; i < numFrames; i++) { |
| 225 | ANativeWindowBuffer* anb; |
| 226 | if (native_window_dequeue_buffer_and_wait(mANW.get(), |
| 227 | &anb) != NO_ERROR) { |
| 228 | return false; |
| 229 | } |
| 230 | if (anb == NULL) { |
| 231 | return false; |
| 232 | } |
| 233 | |
| 234 | sp<GraphicBuffer> buf(new GraphicBuffer(anb, false)); |
| 235 | |
| 236 | const int yuvTexOffsetY = 0; |
| 237 | int stride = buf->getStride(); |
| 238 | int yuvTexStrideY = stride; |
| 239 | int yuvTexOffsetV = yuvTexStrideY * texHeight; |
| 240 | int yuvTexStrideV = (yuvTexStrideY/2 + 0xf) & ~0xf; |
| 241 | int yuvTexOffsetU = yuvTexOffsetV + yuvTexStrideV * texHeight/2; |
| 242 | int yuvTexStrideU = yuvTexStrideV; |
| 243 | |
| 244 | uint8_t* img = NULL; |
| 245 | buf->lock(GRALLOC_USAGE_SW_WRITE_OFTEN, (void**)(&img)); |
| 246 | |
| 247 | // Gray out all the test pixels first, so we're more likely to |
| 248 | // see a failure if GL is still texturing from the buffer we |
| 249 | // just dequeued. |
| 250 | for (int j = 0; j < numTestPixels; j++) { |
| 251 | int x = mTestPixels[j].x; |
| 252 | int y = mTestPixels[j].y; |
| 253 | uint8_t value = 128; |
| 254 | img[y*stride + x] = value; |
| 255 | } |
| 256 | |
| 257 | // Fill the buffer with gray. |
| 258 | for (int y = 0; y < texHeight; y++) { |
| 259 | for (int x = 0; x < texWidth; x++) { |
| 260 | img[yuvTexOffsetY + y*yuvTexStrideY + x] = 128; |
| 261 | img[yuvTexOffsetU + (y/2)*yuvTexStrideU + x/2] = 128; |
| 262 | img[yuvTexOffsetV + (y/2)*yuvTexStrideV + x/2] = 128; |
| 263 | } |
| 264 | } |
| 265 | |
| 266 | // Set the test pixels to either white or black. |
| 267 | for (int j = 0; j < numTestPixels; j++) { |
| 268 | int x = mTestPixels[j].x; |
| 269 | int y = mTestPixels[j].y; |
| 270 | uint8_t value = 0; |
| 271 | if (j == (i % numTestPixels)) { |
| 272 | value = 255; |
| 273 | } |
| 274 | img[y*stride + x] = value; |
| 275 | } |
| 276 | |
| 277 | buf->unlock(); |
| 278 | if (mANW->queueBuffer(mANW.get(), buf->getNativeBuffer(), -1) |
| 279 | != NO_ERROR) { |
| 280 | return false; |
| 281 | } |
| 282 | } |
| 283 | return false; |
| 284 | } |
| 285 | |
| 286 | sp<ANativeWindow> mANW; |
| 287 | const TestPixel* mTestPixels; |
| 288 | }; |
| 289 | |
| 290 | sp<Thread> pt(new ProducerThread(mANW, testPixels)); |
| 291 | pt->run(); |
| 292 | |
| 293 | glViewport(0, 0, texWidth, texHeight); |
| 294 | |
| 295 | glClearColor(0.2, 0.2, 0.2, 0.2); |
| 296 | glClear(GL_COLOR_BUFFER_BIT); |
| 297 | |
| 298 | // We wait for the first two frames up front so that the producer will be |
| 299 | // likely to dequeue the buffer that's currently being textured from. |
| 300 | mFW->waitForFrame(); |
| 301 | mFW->waitForFrame(); |
| 302 | |
| 303 | for (int i = 0; i < numFrames; i++) { |
| 304 | SCOPED_TRACE(String8::format("frame %d", i).string()); |
| 305 | |
| 306 | // We must wait for each frame to come in because if we ever do an |
| 307 | // updateTexImage call that doesn't consume a newly available buffer |
| 308 | // then the producer and consumer will get out of sync, which will cause |
| 309 | // a deadlock. |
| 310 | if (i > 1) { |
| 311 | mFW->waitForFrame(); |
| 312 | } |
| 313 | ASSERT_EQ(NO_ERROR, mST->updateTexImage()); |
| 314 | drawTexture(); |
| 315 | |
| 316 | for (int j = 0; j < numTestPixels; j++) { |
| 317 | int x = testPixels[j].x; |
| 318 | int y = testPixels[j].y; |
| 319 | uint8_t value = 0; |
| 320 | if (j == (i % numTestPixels)) { |
| 321 | // We must y-invert the texture coords |
| 322 | EXPECT_TRUE(checkPixel(x, texHeight-y-1, 255, 255, 255, 255)); |
| 323 | } else { |
| 324 | // We must y-invert the texture coords |
| 325 | EXPECT_TRUE(checkPixel(x, texHeight-y-1, 0, 0, 0, 255)); |
| 326 | } |
| 327 | } |
| 328 | } |
| 329 | |
| 330 | pt->requestExitAndWait(); |
| 331 | } |
| 332 | |
| 333 | TEST_F(SurfaceTextureGLTest, TexturingFromCpuFilledRGBABufferNpot) { |
| 334 | const int texWidth = 64; |
| 335 | const int texHeight = 66; |
| 336 | |
Dan Stoza | f8cebe5 | 2015-04-20 12:09:38 -0700 | [diff] [blame^] | 337 | ASSERT_EQ(NO_ERROR, native_window_set_buffers_dimensions(mANW.get(), |
| 338 | texWidth, texHeight)); |
| 339 | ASSERT_EQ(NO_ERROR, native_window_set_buffers_format(mANW.get(), |
| 340 | HAL_PIXEL_FORMAT_RGBA_8888)); |
Dan Stoza | cb1fcde | 2013-12-03 12:37:36 -0800 | [diff] [blame] | 341 | ASSERT_EQ(NO_ERROR, native_window_set_usage(mANW.get(), |
| 342 | GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN)); |
| 343 | |
| 344 | ASSERT_NO_FATAL_FAILURE(produceOneRGBA8Frame(mANW)); |
| 345 | |
| 346 | ASSERT_EQ(NO_ERROR, mST->updateTexImage()); |
| 347 | |
| 348 | glClearColor(0.2, 0.2, 0.2, 0.2); |
| 349 | glClear(GL_COLOR_BUFFER_BIT); |
| 350 | |
| 351 | glViewport(0, 0, texWidth, texHeight); |
| 352 | drawTexture(); |
| 353 | |
| 354 | EXPECT_TRUE(checkPixel( 0, 0, 35, 35, 35, 35)); |
| 355 | EXPECT_TRUE(checkPixel(63, 0, 231, 231, 231, 231)); |
| 356 | EXPECT_TRUE(checkPixel(63, 65, 231, 231, 231, 231)); |
| 357 | EXPECT_TRUE(checkPixel( 0, 65, 35, 35, 35, 35)); |
| 358 | |
| 359 | EXPECT_TRUE(checkPixel(15, 10, 35, 231, 231, 231)); |
| 360 | EXPECT_TRUE(checkPixel(23, 65, 231, 35, 231, 35)); |
| 361 | EXPECT_TRUE(checkPixel(19, 40, 35, 231, 35, 35)); |
| 362 | EXPECT_TRUE(checkPixel(38, 30, 231, 35, 35, 35)); |
| 363 | EXPECT_TRUE(checkPixel(42, 54, 35, 35, 35, 231)); |
| 364 | EXPECT_TRUE(checkPixel(37, 34, 35, 231, 231, 231)); |
| 365 | EXPECT_TRUE(checkPixel(31, 8, 231, 35, 35, 231)); |
| 366 | EXPECT_TRUE(checkPixel(37, 47, 231, 35, 231, 231)); |
| 367 | EXPECT_TRUE(checkPixel(25, 38, 35, 35, 35, 35)); |
| 368 | EXPECT_TRUE(checkPixel(49, 6, 35, 231, 35, 35)); |
| 369 | EXPECT_TRUE(checkPixel(54, 50, 35, 231, 231, 231)); |
| 370 | EXPECT_TRUE(checkPixel(27, 26, 231, 231, 231, 231)); |
| 371 | EXPECT_TRUE(checkPixel(10, 6, 35, 35, 231, 231)); |
| 372 | EXPECT_TRUE(checkPixel(29, 4, 35, 35, 35, 231)); |
| 373 | EXPECT_TRUE(checkPixel(55, 28, 35, 35, 231, 35)); |
| 374 | EXPECT_TRUE(checkPixel(58, 55, 35, 35, 231, 231)); |
| 375 | } |
| 376 | |
| 377 | TEST_F(SurfaceTextureGLTest, TexturingFromCpuFilledRGBABufferPow2) { |
| 378 | const int texWidth = 64; |
| 379 | const int texHeight = 64; |
| 380 | |
Dan Stoza | f8cebe5 | 2015-04-20 12:09:38 -0700 | [diff] [blame^] | 381 | ASSERT_EQ(NO_ERROR, native_window_set_buffers_dimensions(mANW.get(), |
| 382 | texWidth, texHeight)); |
| 383 | ASSERT_EQ(NO_ERROR, native_window_set_buffers_format(mANW.get(), |
| 384 | HAL_PIXEL_FORMAT_RGBA_8888)); |
Dan Stoza | cb1fcde | 2013-12-03 12:37:36 -0800 | [diff] [blame] | 385 | ASSERT_EQ(NO_ERROR, native_window_set_usage(mANW.get(), |
| 386 | GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN)); |
| 387 | |
| 388 | ASSERT_NO_FATAL_FAILURE(produceOneRGBA8Frame(mANW)); |
| 389 | |
| 390 | ASSERT_EQ(NO_ERROR, mST->updateTexImage()); |
| 391 | |
| 392 | glClearColor(0.2, 0.2, 0.2, 0.2); |
| 393 | glClear(GL_COLOR_BUFFER_BIT); |
| 394 | |
| 395 | glViewport(0, 0, texWidth, texHeight); |
| 396 | drawTexture(); |
| 397 | |
| 398 | EXPECT_TRUE(checkPixel( 0, 0, 231, 231, 231, 231)); |
| 399 | EXPECT_TRUE(checkPixel(63, 0, 35, 35, 35, 35)); |
| 400 | EXPECT_TRUE(checkPixel(63, 63, 231, 231, 231, 231)); |
| 401 | EXPECT_TRUE(checkPixel( 0, 63, 35, 35, 35, 35)); |
| 402 | |
| 403 | EXPECT_TRUE(checkPixel(12, 46, 231, 231, 231, 35)); |
| 404 | EXPECT_TRUE(checkPixel(16, 1, 231, 231, 35, 231)); |
| 405 | EXPECT_TRUE(checkPixel(21, 12, 231, 35, 35, 231)); |
| 406 | EXPECT_TRUE(checkPixel(26, 51, 231, 35, 231, 35)); |
| 407 | EXPECT_TRUE(checkPixel( 5, 32, 35, 231, 231, 35)); |
| 408 | EXPECT_TRUE(checkPixel(13, 8, 35, 231, 231, 231)); |
| 409 | EXPECT_TRUE(checkPixel(46, 3, 35, 35, 231, 35)); |
| 410 | EXPECT_TRUE(checkPixel(30, 33, 35, 35, 35, 35)); |
| 411 | EXPECT_TRUE(checkPixel( 6, 52, 231, 231, 35, 35)); |
| 412 | EXPECT_TRUE(checkPixel(55, 33, 35, 231, 35, 231)); |
| 413 | EXPECT_TRUE(checkPixel(16, 29, 35, 35, 231, 231)); |
| 414 | EXPECT_TRUE(checkPixel( 1, 30, 35, 35, 35, 231)); |
| 415 | EXPECT_TRUE(checkPixel(41, 37, 35, 35, 231, 231)); |
| 416 | EXPECT_TRUE(checkPixel(46, 29, 231, 231, 35, 35)); |
| 417 | EXPECT_TRUE(checkPixel(15, 25, 35, 231, 35, 231)); |
| 418 | EXPECT_TRUE(checkPixel( 3, 52, 35, 231, 35, 35)); |
| 419 | } |
| 420 | |
| 421 | // Tests if GLConsumer and BufferQueue are robust enough |
| 422 | // to handle a special case where updateTexImage is called |
| 423 | // in the middle of disconnect. This ordering is enforced |
| 424 | // by blocking in the disconnect callback. |
| 425 | TEST_F(SurfaceTextureGLTest, DisconnectStressTest) { |
| 426 | |
| 427 | class ProducerThread : public Thread { |
| 428 | public: |
| 429 | ProducerThread(const sp<ANativeWindow>& anw): |
| 430 | mANW(anw) { |
| 431 | } |
| 432 | |
| 433 | virtual ~ProducerThread() { |
| 434 | } |
| 435 | |
| 436 | virtual bool threadLoop() { |
| 437 | ANativeWindowBuffer* anb; |
| 438 | |
| 439 | native_window_api_connect(mANW.get(), NATIVE_WINDOW_API_EGL); |
| 440 | |
| 441 | for (int numFrames =0 ; numFrames < 2; numFrames ++) { |
| 442 | |
| 443 | if (native_window_dequeue_buffer_and_wait(mANW.get(), |
| 444 | &anb) != NO_ERROR) { |
| 445 | return false; |
| 446 | } |
| 447 | if (anb == NULL) { |
| 448 | return false; |
| 449 | } |
| 450 | if (mANW->queueBuffer(mANW.get(), anb, -1) |
| 451 | != NO_ERROR) { |
| 452 | return false; |
| 453 | } |
| 454 | } |
| 455 | |
| 456 | native_window_api_disconnect(mANW.get(), NATIVE_WINDOW_API_EGL); |
| 457 | |
| 458 | return false; |
| 459 | } |
| 460 | |
| 461 | private: |
| 462 | sp<ANativeWindow> mANW; |
| 463 | }; |
| 464 | |
| 465 | sp<DisconnectWaiter> dw(new DisconnectWaiter()); |
Dan Stoza | 5603a2f | 2014-04-07 13:41:37 -0700 | [diff] [blame] | 466 | mConsumer->consumerConnect(dw, false); |
Dan Stoza | cb1fcde | 2013-12-03 12:37:36 -0800 | [diff] [blame] | 467 | |
| 468 | |
| 469 | sp<Thread> pt(new ProducerThread(mANW)); |
| 470 | pt->run(); |
| 471 | |
| 472 | // eat a frame so GLConsumer will own an at least one slot |
| 473 | dw->waitForFrame(); |
| 474 | EXPECT_EQ(OK,mST->updateTexImage()); |
| 475 | |
| 476 | dw->waitForFrame(); |
| 477 | // Could fail here as GLConsumer thinks it still owns the slot |
| 478 | // but bufferQueue has released all slots |
| 479 | EXPECT_EQ(OK,mST->updateTexImage()); |
| 480 | |
| 481 | dw->finishDisconnect(); |
| 482 | } |
| 483 | |
| 484 | |
| 485 | // This test ensures that the GLConsumer clears the mCurrentTexture |
| 486 | // when it is disconnected and reconnected. Otherwise it will |
| 487 | // attempt to release a buffer that it does not owned |
| 488 | TEST_F(SurfaceTextureGLTest, DisconnectClearsCurrentTexture) { |
| 489 | ASSERT_EQ(OK, native_window_api_connect(mANW.get(), |
| 490 | NATIVE_WINDOW_API_EGL)); |
| 491 | |
| 492 | ANativeWindowBuffer *anb; |
| 493 | |
| 494 | EXPECT_EQ (OK, native_window_dequeue_buffer_and_wait(mANW.get(), &anb)); |
| 495 | EXPECT_EQ(OK, mANW->queueBuffer(mANW.get(), anb, -1)); |
| 496 | |
| 497 | EXPECT_EQ (OK, native_window_dequeue_buffer_and_wait(mANW.get(), &anb)); |
| 498 | EXPECT_EQ(OK, mANW->queueBuffer(mANW.get(), anb, -1)); |
| 499 | |
| 500 | EXPECT_EQ(OK,mST->updateTexImage()); |
| 501 | EXPECT_EQ(OK,mST->updateTexImage()); |
| 502 | |
| 503 | ASSERT_EQ(OK, native_window_api_disconnect(mANW.get(), |
| 504 | NATIVE_WINDOW_API_EGL)); |
| 505 | ASSERT_EQ(OK, native_window_api_connect(mANW.get(), |
| 506 | NATIVE_WINDOW_API_EGL)); |
| 507 | |
| 508 | EXPECT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &anb)); |
| 509 | EXPECT_EQ(OK, mANW->queueBuffer(mANW.get(), anb, -1)); |
| 510 | |
| 511 | // Will fail here if mCurrentTexture is not cleared properly |
| 512 | mFW->waitForFrame(); |
| 513 | EXPECT_EQ(OK,mST->updateTexImage()); |
| 514 | |
| 515 | ASSERT_EQ(OK, native_window_api_disconnect(mANW.get(), |
| 516 | NATIVE_WINDOW_API_EGL)); |
| 517 | } |
| 518 | |
| 519 | TEST_F(SurfaceTextureGLTest, ScaleToWindowMode) { |
| 520 | ASSERT_EQ(OK, native_window_set_scaling_mode(mANW.get(), |
| 521 | NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW)); |
| 522 | |
| 523 | // The producer image size |
| 524 | ASSERT_EQ(OK, native_window_set_buffers_dimensions(mANW.get(), 512, 512)); |
| 525 | |
| 526 | // The consumer image size (16 x 9) ratio |
| 527 | mST->setDefaultBufferSize(1280, 720); |
| 528 | |
| 529 | ASSERT_EQ(OK, native_window_api_connect(mANW.get(), |
| 530 | NATIVE_WINDOW_API_CPU)); |
| 531 | |
| 532 | ANativeWindowBuffer *anb; |
| 533 | |
| 534 | android_native_rect_t odd = {23, 78, 123, 477}; |
| 535 | ASSERT_EQ(OK, native_window_set_crop(mANW.get(), &odd)); |
| 536 | EXPECT_EQ (OK, native_window_dequeue_buffer_and_wait(mANW.get(), &anb)); |
| 537 | EXPECT_EQ(OK, mANW->queueBuffer(mANW.get(), anb, -1)); |
| 538 | mFW->waitForFrame(); |
| 539 | EXPECT_EQ(OK, mST->updateTexImage()); |
| 540 | Rect r = mST->getCurrentCrop(); |
| 541 | assertRectEq(Rect(23, 78, 123, 477), r); |
| 542 | |
| 543 | ASSERT_EQ(OK, native_window_api_disconnect(mANW.get(), |
| 544 | NATIVE_WINDOW_API_CPU)); |
| 545 | } |
| 546 | |
| 547 | // This test ensures the scaling mode does the right thing |
| 548 | // ie NATIVE_WINDOW_SCALING_MODE_CROP should crop |
| 549 | // the image such that it has the same aspect ratio as the |
| 550 | // default buffer size |
| 551 | TEST_F(SurfaceTextureGLTest, CroppedScalingMode) { |
| 552 | ASSERT_EQ(OK, native_window_set_scaling_mode(mANW.get(), |
| 553 | NATIVE_WINDOW_SCALING_MODE_SCALE_CROP)); |
| 554 | |
| 555 | // The producer image size |
| 556 | ASSERT_EQ(OK, native_window_set_buffers_dimensions(mANW.get(), 512, 512)); |
| 557 | |
| 558 | // The consumer image size (16 x 9) ratio |
| 559 | mST->setDefaultBufferSize(1280, 720); |
| 560 | |
| 561 | native_window_api_connect(mANW.get(), NATIVE_WINDOW_API_CPU); |
| 562 | |
| 563 | ANativeWindowBuffer *anb; |
| 564 | |
| 565 | // The crop is in the shape of (320, 180) === 16 x 9 |
| 566 | android_native_rect_t standard = {10, 20, 330, 200}; |
| 567 | ASSERT_EQ(OK, native_window_set_crop(mANW.get(), &standard)); |
| 568 | EXPECT_EQ (OK, native_window_dequeue_buffer_and_wait(mANW.get(), &anb)); |
| 569 | EXPECT_EQ(OK, mANW->queueBuffer(mANW.get(), anb, -1)); |
| 570 | mFW->waitForFrame(); |
| 571 | EXPECT_EQ(OK, mST->updateTexImage()); |
| 572 | Rect r = mST->getCurrentCrop(); |
| 573 | // crop should be the same as crop (same aspect ratio) |
| 574 | assertRectEq(Rect(10, 20, 330, 200), r); |
| 575 | |
| 576 | // make this wider then desired aspect 239 x 100 (2.39:1) |
| 577 | android_native_rect_t wide = {20, 30, 259, 130}; |
| 578 | ASSERT_EQ(OK, native_window_set_crop(mANW.get(), &wide)); |
| 579 | EXPECT_EQ (OK, native_window_dequeue_buffer_and_wait(mANW.get(), &anb)); |
| 580 | EXPECT_EQ(OK, mANW->queueBuffer(mANW.get(), anb, -1)); |
| 581 | mFW->waitForFrame(); |
| 582 | EXPECT_EQ(OK, mST->updateTexImage()); |
| 583 | r = mST->getCurrentCrop(); |
| 584 | // crop should be the same height, but have cropped left and right borders |
| 585 | // offset is 30.6 px L+, R- |
| 586 | assertRectEq(Rect(51, 30, 228, 130), r); |
| 587 | |
| 588 | // This image is taller then desired aspect 400 x 300 (4:3) |
| 589 | android_native_rect_t narrow = {0, 0, 400, 300}; |
| 590 | ASSERT_EQ(OK, native_window_set_crop(mANW.get(), &narrow)); |
| 591 | EXPECT_EQ (OK, native_window_dequeue_buffer_and_wait(mANW.get(), &anb)); |
| 592 | EXPECT_EQ(OK, mANW->queueBuffer(mANW.get(), anb, -1)); |
| 593 | mFW->waitForFrame(); |
| 594 | EXPECT_EQ(OK, mST->updateTexImage()); |
| 595 | r = mST->getCurrentCrop(); |
| 596 | // crop should be the same width, but have cropped top and bottom borders |
| 597 | // offset is 37.5 px |
| 598 | assertRectEq(Rect(0, 37, 400, 262), r); |
| 599 | |
| 600 | native_window_api_disconnect(mANW.get(), NATIVE_WINDOW_API_CPU); |
| 601 | } |
| 602 | |
| 603 | TEST_F(SurfaceTextureGLTest, AbandonUnblocksDequeueBuffer) { |
| 604 | class ProducerThread : public Thread { |
| 605 | public: |
| 606 | ProducerThread(const sp<ANativeWindow>& anw): |
| 607 | mANW(anw), |
| 608 | mDequeueError(NO_ERROR) { |
| 609 | } |
| 610 | |
| 611 | virtual ~ProducerThread() { |
| 612 | } |
| 613 | |
| 614 | virtual bool threadLoop() { |
| 615 | Mutex::Autolock lock(mMutex); |
| 616 | ANativeWindowBuffer* anb; |
| 617 | |
| 618 | // Frame 1 |
| 619 | if (native_window_dequeue_buffer_and_wait(mANW.get(), |
| 620 | &anb) != NO_ERROR) { |
| 621 | return false; |
| 622 | } |
| 623 | if (anb == NULL) { |
| 624 | return false; |
| 625 | } |
| 626 | if (mANW->queueBuffer(mANW.get(), anb, -1) |
| 627 | != NO_ERROR) { |
| 628 | return false; |
| 629 | } |
| 630 | |
| 631 | // Frame 2 |
| 632 | if (native_window_dequeue_buffer_and_wait(mANW.get(), |
| 633 | &anb) != NO_ERROR) { |
| 634 | return false; |
| 635 | } |
| 636 | if (anb == NULL) { |
| 637 | return false; |
| 638 | } |
| 639 | if (mANW->queueBuffer(mANW.get(), anb, -1) |
| 640 | != NO_ERROR) { |
| 641 | return false; |
| 642 | } |
| 643 | |
| 644 | // Frame 3 - error expected |
| 645 | mDequeueError = native_window_dequeue_buffer_and_wait(mANW.get(), |
| 646 | &anb); |
| 647 | return false; |
| 648 | } |
| 649 | |
| 650 | status_t getDequeueError() { |
| 651 | Mutex::Autolock lock(mMutex); |
| 652 | return mDequeueError; |
| 653 | } |
| 654 | |
| 655 | private: |
| 656 | sp<ANativeWindow> mANW; |
| 657 | status_t mDequeueError; |
| 658 | Mutex mMutex; |
| 659 | }; |
| 660 | |
| 661 | ASSERT_EQ(OK, mST->setDefaultMaxBufferCount(2)); |
| 662 | |
| 663 | sp<Thread> pt(new ProducerThread(mANW)); |
| 664 | pt->run(); |
| 665 | |
| 666 | mFW->waitForFrame(); |
| 667 | mFW->waitForFrame(); |
| 668 | |
| 669 | // Sleep for 100ms to allow the producer thread's dequeueBuffer call to |
| 670 | // block waiting for a buffer to become available. |
| 671 | usleep(100000); |
| 672 | |
| 673 | mST->abandon(); |
| 674 | |
| 675 | pt->requestExitAndWait(); |
| 676 | ASSERT_EQ(NO_INIT, |
| 677 | reinterpret_cast<ProducerThread*>(pt.get())->getDequeueError()); |
| 678 | } |
| 679 | |
| 680 | TEST_F(SurfaceTextureGLTest, InvalidWidthOrHeightFails) { |
| 681 | int texHeight = 16; |
| 682 | ANativeWindowBuffer* anb; |
| 683 | |
| 684 | GLint maxTextureSize; |
| 685 | glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxTextureSize); |
| 686 | |
| 687 | // make sure it works with small textures |
| 688 | mST->setDefaultBufferSize(16, texHeight); |
| 689 | EXPECT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(mANW.get(), |
| 690 | &anb)); |
| 691 | EXPECT_EQ(16, anb->width); |
| 692 | EXPECT_EQ(texHeight, anb->height); |
| 693 | EXPECT_EQ(NO_ERROR, mANW->queueBuffer(mANW.get(), anb, -1)); |
| 694 | EXPECT_EQ(NO_ERROR, mST->updateTexImage()); |
| 695 | |
| 696 | // make sure it works with GL_MAX_TEXTURE_SIZE |
| 697 | mST->setDefaultBufferSize(maxTextureSize, texHeight); |
| 698 | EXPECT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(mANW.get(), |
| 699 | &anb)); |
| 700 | EXPECT_EQ(maxTextureSize, anb->width); |
| 701 | EXPECT_EQ(texHeight, anb->height); |
| 702 | EXPECT_EQ(NO_ERROR, mANW->queueBuffer(mANW.get(), anb, -1)); |
| 703 | EXPECT_EQ(NO_ERROR, mST->updateTexImage()); |
| 704 | |
| 705 | // make sure it fails with GL_MAX_TEXTURE_SIZE+1 |
| 706 | mST->setDefaultBufferSize(maxTextureSize+1, texHeight); |
| 707 | EXPECT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(mANW.get(), |
| 708 | &anb)); |
| 709 | EXPECT_EQ(maxTextureSize+1, anb->width); |
| 710 | EXPECT_EQ(texHeight, anb->height); |
| 711 | EXPECT_EQ(NO_ERROR, mANW->queueBuffer(mANW.get(), anb, -1)); |
| 712 | ASSERT_NE(NO_ERROR, mST->updateTexImage()); |
| 713 | } |
| 714 | |
| 715 | } // namespace android |