1 /* 2 * Copyright (C) 2012 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 "CpuConsumer_test" 18 //#define LOG_NDEBUG 0 19 //#define LOG_NNDEBUG 0 20 21 #ifdef LOG_NNDEBUG 22 #define ALOGVV(...) ALOGV(__VA_ARGS__) 23 #else 24 #define ALOGVV(...) ((void)0) 25 #endif 26 27 #include <gtest/gtest.h> 28 #include <gui/CpuConsumer.h> 29 #include <gui/Surface.h> 30 #include <ui/GraphicBuffer.h> 31 #include <utils/String8.h> 32 #include <utils/Thread.h> 33 #include <utils/Mutex.h> 34 #include <utils/Condition.h> 35 36 #include <ui/FramebufferNativeWindow.h> 37 38 #define CPU_CONSUMER_TEST_FORMAT_RAW 0 39 #define CPU_CONSUMER_TEST_FORMAT_Y8 0 40 #define CPU_CONSUMER_TEST_FORMAT_Y16 0 41 #define CPU_CONSUMER_TEST_FORMAT_RGBA_8888 1 42 43 namespace android { 44 45 struct CpuConsumerTestParams { 46 uint32_t width; 47 uint32_t height; 48 int maxLockedBuffers; 49 PixelFormat format; 50 }; 51 52 ::std::ostream& operator<<(::std::ostream& os, const CpuConsumerTestParams& p) { 53 return os << "[ (" << p.width << ", " << p.height << "), B:" 54 << p.maxLockedBuffers << ", F:0x" 55 << ::std::hex << p.format << "]"; 56 } 57 58 class CpuConsumerTest : public ::testing::TestWithParam<CpuConsumerTestParams> { 59 protected: 60 61 virtual void SetUp() { 62 const ::testing::TestInfo* const test_info = 63 ::testing::UnitTest::GetInstance()->current_test_info(); 64 CpuConsumerTestParams params = GetParam(); 65 ALOGV("** Starting test %s (%d x %d, %d, 0x%x)", 66 test_info->name(), 67 params.width, params.height, 68 params.maxLockedBuffers, params.format); 69 sp<BufferQueue> bq = new BufferQueue(); 70 mCC = new CpuConsumer(bq, params.maxLockedBuffers); 71 String8 name("CpuConsumer_Under_Test"); 72 mCC->setName(name); 73 mSTC = new Surface(bq); 74 mANW = mSTC; 75 } 76 77 virtual void TearDown() { 78 mANW.clear(); 79 mSTC.clear(); 80 mCC.clear(); 81 } 82 83 class FrameWaiter : public CpuConsumer::FrameAvailableListener { 84 public: 85 FrameWaiter(): 86 mPendingFrames(0) { 87 } 88 89 void waitForFrame() { 90 Mutex::Autolock lock(mMutex); 91 while (mPendingFrames == 0) { 92 mCondition.wait(mMutex); 93 } 94 mPendingFrames--; 95 } 96 97 virtual void onFrameAvailable() { 98 Mutex::Autolock lock(mMutex); 99 mPendingFrames++; 100 mCondition.signal(); 101 } 102 103 int mPendingFrames; 104 Mutex mMutex; 105 Condition mCondition; 106 }; 107 108 // Note that SurfaceTexture will lose the notifications 109 // onBuffersReleased and onFrameAvailable as there is currently 110 // no way to forward the events. This DisconnectWaiter will not let the 111 // disconnect finish until finishDisconnect() is called. It will 112 // also block until a disconnect is called 113 class DisconnectWaiter : public BufferQueue::ConsumerListener { 114 public: 115 DisconnectWaiter () : 116 mWaitForDisconnect(false), 117 mPendingFrames(0) { 118 } 119 120 void waitForFrame() { 121 Mutex::Autolock lock(mMutex); 122 while (mPendingFrames == 0) { 123 mFrameCondition.wait(mMutex); 124 } 125 mPendingFrames--; 126 } 127 128 virtual void onFrameAvailable() { 129 Mutex::Autolock lock(mMutex); 130 mPendingFrames++; 131 mFrameCondition.signal(); 132 } 133 134 virtual void onBuffersReleased() { 135 Mutex::Autolock lock(mMutex); 136 while (!mWaitForDisconnect) { 137 mDisconnectCondition.wait(mMutex); 138 } 139 } 140 141 void finishDisconnect() { 142 Mutex::Autolock lock(mMutex); 143 mWaitForDisconnect = true; 144 mDisconnectCondition.signal(); 145 } 146 147 private: 148 Mutex mMutex; 149 150 bool mWaitForDisconnect; 151 Condition mDisconnectCondition; 152 153 int mPendingFrames; 154 Condition mFrameCondition; 155 }; 156 157 sp<CpuConsumer> mCC; 158 sp<Surface> mSTC; 159 sp<ANativeWindow> mANW; 160 }; 161 162 #define ASSERT_NO_ERROR(err, msg) \ 163 ASSERT_EQ(NO_ERROR, err) << msg << strerror(-err) 164 165 void checkPixel(const CpuConsumer::LockedBuffer &buf, 166 uint32_t x, uint32_t y, uint32_t r, uint32_t g=0, uint32_t b=0) { 167 // Ignores components that don't exist for given pixel 168 switch(buf.format) { 169 case HAL_PIXEL_FORMAT_RAW_SENSOR: { 170 String8 msg; 171 uint16_t *bPtr = (uint16_t*)buf.data; 172 bPtr += y * buf.stride + x; 173 // GRBG Bayer mosaic; only check the matching channel 174 switch( ((y & 1) << 1) | (x & 1) ) { 175 case 0: // G 176 case 3: // G 177 EXPECT_EQ(g, *bPtr); 178 break; 179 case 1: // R 180 EXPECT_EQ(r, *bPtr); 181 break; 182 case 2: // B 183 EXPECT_EQ(b, *bPtr); 184 break; 185 } 186 break; 187 } 188 // ignores g,b 189 case HAL_PIXEL_FORMAT_Y8: { 190 uint8_t *bPtr = (uint8_t*)buf.data; 191 bPtr += y * buf.stride + x; 192 EXPECT_EQ(r, *bPtr) << "at x = " << x << " y = " << y; 193 break; 194 } 195 // ignores g,b 196 case HAL_PIXEL_FORMAT_Y16: { 197 // stride is in pixels, not in bytes 198 uint16_t *bPtr = ((uint16_t*)buf.data) + y * buf.stride + x; 199 200 EXPECT_EQ(r, *bPtr) << "at x = " << x << " y = " << y; 201 break; 202 } 203 case HAL_PIXEL_FORMAT_RGBA_8888: { 204 const int bytesPerPixel = 4; 205 uint8_t *bPtr = (uint8_t*)buf.data; 206 bPtr += (y * buf.stride + x) * bytesPerPixel; 207 208 EXPECT_EQ(r, bPtr[0]) << "at x = " << x << " y = " << y; 209 EXPECT_EQ(g, bPtr[1]) << "at x = " << x << " y = " << y; 210 EXPECT_EQ(b, bPtr[2]) << "at x = " << x << " y = " << y; 211 break; 212 } 213 default: { 214 ADD_FAILURE() << "Unknown format for check:" << buf.format; 215 break; 216 } 217 } 218 } 219 220 // Fill a YV12 buffer with a multi-colored checkerboard pattern 221 void fillYV12Buffer(uint8_t* buf, int w, int h, int stride); 222 223 // Fill a Y8/Y16 buffer with a multi-colored checkerboard pattern 224 template <typename T> // T == uint8_t or uint16_t 225 void fillGreyscaleBuffer(T* buf, int w, int h, int stride, int bpp) { 226 const int blockWidth = w > 16 ? w / 16 : 1; 227 const int blockHeight = h > 16 ? h / 16 : 1; 228 const int yuvTexOffsetY = 0; 229 230 ASSERT_TRUE(bpp == 8 || bpp == 16); 231 ASSERT_TRUE(sizeof(T)*8 == bpp); 232 233 // stride is in pixels, not in bytes 234 int yuvTexStrideY = stride; 235 for (int x = 0; x < w; x++) { 236 for (int y = 0; y < h; y++) { 237 int parityX = (x / blockWidth) & 1; 238 int parityY = (y / blockHeight) & 1; 239 T intensity = (parityX ^ parityY) ? 63 : 191; 240 buf[yuvTexOffsetY + (y * yuvTexStrideY) + x] = intensity; 241 } 242 } 243 } 244 245 inline uint8_t chooseColorRgba8888(int blockX, int blockY, uint8_t channel) { 246 const int colorVariations = 3; 247 uint8_t color = ((blockX % colorVariations) + (blockY % colorVariations)) 248 % (colorVariations) == channel ? 191: 63; 249 250 return color; 251 } 252 253 // Fill a RGBA8888 buffer with a multi-colored checkerboard pattern 254 void fillRgba8888Buffer(uint8_t* buf, int w, int h, int stride) 255 { 256 const int blockWidth = w > 16 ? w / 16 : 1; 257 const int blockHeight = h > 16 ? h / 16 : 1; 258 const int bytesPerPixel = 4; 259 260 // stride is in pixels, not in bytes 261 for (int x = 0; x < w; ++x) { 262 for (int y = 0; y < h; ++y) { 263 int blockX = (x / blockWidth); 264 int blockY = (y / blockHeight); 265 266 uint8_t r = chooseColorRgba8888(blockX, blockY, 0); 267 uint8_t g = chooseColorRgba8888(blockX, blockY, 1); 268 uint8_t b = chooseColorRgba8888(blockX, blockY, 2); 269 270 buf[(y*stride + x)*bytesPerPixel + 0] = r; 271 buf[(y*stride + x)*bytesPerPixel + 1] = g; 272 buf[(y*stride + x)*bytesPerPixel + 2] = b; 273 buf[(y*stride + x)*bytesPerPixel + 3] = 255; 274 } 275 } 276 } 277 278 // Fill a RAW sensor buffer with a multi-colored checkerboard pattern. 279 // Assumes GRBG mosaic ordering. Result should be a grid in a 2x2 pattern 280 // of [ R, B; G, W] 281 void fillBayerRawBuffer(uint8_t* buf, int w, int h, int stride) { 282 ALOGVV("fillBayerRawBuffer: %p with %d x %d, stride %d", buf, w, h ,stride); 283 // Blocks need to be even-width/height, aim for 8-wide otherwise 284 const int blockWidth = (w > 16 ? w / 8 : 2) & ~0x1; 285 const int blockHeight = (h > 16 ? h / 8 : 2) & ~0x1; 286 for (int y = 0; y < h; y+=2) { 287 uint16_t *bPtr1 = ((uint16_t*)buf) + stride*y; 288 uint16_t *bPtr2 = bPtr1 + stride; 289 for (int x = 0; x < w; x+=2) { 290 int blockX = (x / blockWidth ) & 1; 291 int blockY = (y / blockHeight) & 1; 292 unsigned short r = (blockX == blockY) ? 1000 : 200; 293 unsigned short g = blockY ? 1000: 200; 294 unsigned short b = blockX ? 1000: 200; 295 // GR row 296 *bPtr1++ = g; 297 *bPtr1++ = r; 298 // BG row 299 *bPtr2++ = b; 300 *bPtr2++ = g; 301 } 302 } 303 304 } 305 306 template<typename T> // uint8_t or uint16_t 307 void checkGreyscaleBuffer(const CpuConsumer::LockedBuffer &buf) { 308 uint32_t w = buf.width; 309 uint32_t h = buf.height; 310 const int blockWidth = w > 16 ? w / 16 : 1; 311 const int blockHeight = h > 16 ? h / 16 : 1; 312 const int blockRows = h / blockHeight; 313 const int blockCols = w / blockWidth; 314 315 // Top-left square is bright 316 checkPixel(buf, 0, 0, 191); 317 checkPixel(buf, 1, 0, 191); 318 checkPixel(buf, 0, 1, 191); 319 checkPixel(buf, 1, 1, 191); 320 321 // One-right square is dark 322 checkPixel(buf, blockWidth, 0, 63); 323 checkPixel(buf, blockWidth + 1, 0, 63); 324 checkPixel(buf, blockWidth, 1, 63); 325 checkPixel(buf, blockWidth + 1, 1, 63); 326 327 // One-down square is dark 328 checkPixel(buf, 0, blockHeight, 63); 329 checkPixel(buf, 1, blockHeight, 63); 330 checkPixel(buf, 0, blockHeight + 1, 63); 331 checkPixel(buf, 1, blockHeight + 1, 63); 332 333 // One-diag square is bright 334 checkPixel(buf, blockWidth, blockHeight, 191); 335 checkPixel(buf, blockWidth + 1, blockHeight, 191); 336 checkPixel(buf, blockWidth, blockHeight + 1, 191); 337 checkPixel(buf, blockWidth + 1, blockHeight + 1, 191); 338 339 // Test bottom-right pixel 340 const int maxBlockX = ((w-1 + (blockWidth-1)) / blockWidth) & 0x1; 341 const int maxBlockY = ((h-1 + (blockHeight-1)) / blockHeight) & 0x1; 342 uint32_t pixelValue = ((maxBlockX % 2) == (maxBlockY % 2)) ? 191 : 63; 343 checkPixel(buf, w-1, h-1, pixelValue); 344 } 345 346 void checkRgba8888Buffer(const CpuConsumer::LockedBuffer &buf) { 347 uint32_t w = buf.width; 348 uint32_t h = buf.height; 349 const int blockWidth = w > 16 ? w / 16 : 1; 350 const int blockHeight = h > 16 ? h / 16 : 1; 351 const int blockRows = h / blockHeight; 352 const int blockCols = w / blockWidth; 353 354 // Top-left square is bright red 355 checkPixel(buf, 0, 0, 191, 63, 63); 356 checkPixel(buf, 1, 0, 191, 63, 63); 357 checkPixel(buf, 0, 1, 191, 63, 63); 358 checkPixel(buf, 1, 1, 191, 63, 63); 359 360 // One-right square is bright green 361 checkPixel(buf, blockWidth, 0, 63, 191, 63); 362 checkPixel(buf, blockWidth + 1, 0, 63, 191, 63); 363 checkPixel(buf, blockWidth, 1, 63, 191, 63); 364 checkPixel(buf, blockWidth + 1, 1, 63, 191, 63); 365 366 // One-down square is bright green 367 checkPixel(buf, 0, blockHeight, 63, 191, 63); 368 checkPixel(buf, 1, blockHeight, 63, 191, 63); 369 checkPixel(buf, 0, blockHeight + 1, 63, 191, 63); 370 checkPixel(buf, 1, blockHeight + 1, 63, 191, 63); 371 372 // One-diag square is bright blue 373 checkPixel(buf, blockWidth, blockHeight, 63, 63, 191); 374 checkPixel(buf, blockWidth + 1, blockHeight, 63, 63, 191); 375 checkPixel(buf, blockWidth, blockHeight + 1, 63, 63, 191); 376 checkPixel(buf, blockWidth + 1, blockHeight + 1, 63, 63, 191); 377 378 // Test bottom-right pixel 379 { 380 const int maxBlockX = ((w-1) / blockWidth); 381 const int maxBlockY = ((h-1) / blockHeight); 382 uint8_t r = chooseColorRgba8888(maxBlockX, maxBlockY, 0); 383 uint8_t g = chooseColorRgba8888(maxBlockX, maxBlockY, 1); 384 uint8_t b = chooseColorRgba8888(maxBlockX, maxBlockY, 2); 385 checkPixel(buf, w-1, h-1, r, g, b); 386 } 387 } 388 389 void checkBayerRawBuffer(const CpuConsumer::LockedBuffer &buf) { 390 uint32_t w = buf.width; 391 uint32_t h = buf.height; 392 const int blockWidth = (w > 16 ? w / 8 : 2) & ~0x1; 393 const int blockHeight = (h > 16 ? h / 8 : 2) & ~0x1; 394 const int blockRows = h / blockHeight; 395 const int blockCols = w / blockWidth; 396 397 // Top-left square is red 398 checkPixel(buf, 0, 0, 1000, 200, 200); 399 checkPixel(buf, 1, 0, 1000, 200, 200); 400 checkPixel(buf, 0, 1, 1000, 200, 200); 401 checkPixel(buf, 1, 1, 1000, 200, 200); 402 403 // One-right square is blue 404 checkPixel(buf, blockWidth, 0, 200, 200, 1000); 405 checkPixel(buf, blockWidth + 1, 0, 200, 200, 1000); 406 checkPixel(buf, blockWidth, 1, 200, 200, 1000); 407 checkPixel(buf, blockWidth + 1, 1, 200, 200, 1000); 408 409 // One-down square is green 410 checkPixel(buf, 0, blockHeight, 200, 1000, 200); 411 checkPixel(buf, 1, blockHeight, 200, 1000, 200); 412 checkPixel(buf, 0, blockHeight + 1, 200, 1000, 200); 413 checkPixel(buf, 1, blockHeight + 1, 200, 1000, 200); 414 415 // One-diag square is white 416 checkPixel(buf, blockWidth, blockHeight, 1000, 1000, 1000); 417 checkPixel(buf, blockWidth + 1, blockHeight, 1000, 1000, 1000); 418 checkPixel(buf, blockWidth, blockHeight + 1, 1000, 1000, 1000); 419 checkPixel(buf, blockWidth + 1, blockHeight + 1, 1000, 1000, 1000); 420 421 // Test bottom-right pixel 422 const int maxBlockX = ((w-1) / blockWidth) & 0x1; 423 const int maxBlockY = ((w-1) / blockHeight) & 0x1; 424 unsigned short maxR = (maxBlockX == maxBlockY) ? 1000 : 200; 425 unsigned short maxG = maxBlockY ? 1000: 200; 426 unsigned short maxB = maxBlockX ? 1000: 200; 427 checkPixel(buf, w-1, h-1, maxR, maxG, maxB); 428 } 429 430 void checkAnyBuffer(const CpuConsumer::LockedBuffer &buf, int format) { 431 switch (format) { 432 case HAL_PIXEL_FORMAT_RAW_SENSOR: 433 checkBayerRawBuffer(buf); 434 break; 435 case HAL_PIXEL_FORMAT_Y8: 436 checkGreyscaleBuffer<uint8_t>(buf); 437 break; 438 case HAL_PIXEL_FORMAT_Y16: 439 checkGreyscaleBuffer<uint16_t>(buf); 440 break; 441 case HAL_PIXEL_FORMAT_RGBA_8888: 442 checkRgba8888Buffer(buf); 443 break; 444 } 445 } 446 447 void fillYV12BufferRect(uint8_t* buf, int w, int h, int stride, 448 const android_native_rect_t& rect); 449 450 void fillRGBA8Buffer(uint8_t* buf, int w, int h, int stride); 451 452 void fillRGBA8BufferSolid(uint8_t* buf, int w, int h, int stride, uint8_t r, 453 uint8_t g, uint8_t b, uint8_t a); 454 455 // Configures the ANativeWindow producer-side interface based on test parameters 456 void configureANW(const sp<ANativeWindow>& anw, 457 const CpuConsumerTestParams& params, 458 int maxBufferSlack) { 459 status_t err; 460 err = native_window_set_buffers_geometry(anw.get(), 461 params.width, params.height, params.format); 462 ASSERT_NO_ERROR(err, "set_buffers_geometry error: "); 463 464 err = native_window_set_usage(anw.get(), 465 GRALLOC_USAGE_SW_WRITE_OFTEN); 466 ASSERT_NO_ERROR(err, "set_usage error: "); 467 468 int minUndequeuedBuffers; 469 err = anw.get()->query(anw.get(), 470 NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, 471 &minUndequeuedBuffers); 472 ASSERT_NO_ERROR(err, "query error: "); 473 474 ALOGVV("Setting buffer count to %d", 475 maxBufferSlack + 1 + minUndequeuedBuffers); 476 err = native_window_set_buffer_count(anw.get(), 477 maxBufferSlack + 1 + minUndequeuedBuffers); 478 ASSERT_NO_ERROR(err, "set_buffer_count error: "); 479 480 } 481 482 // Produce one frame of image data; assumes format and resolution configuration 483 // is already done. 484 void produceOneFrame(const sp<ANativeWindow>& anw, 485 const CpuConsumerTestParams& params, 486 int64_t timestamp, uint32_t *stride) { 487 status_t err; 488 ANativeWindowBuffer* anb; 489 ALOGVV("Dequeue buffer from %p", anw.get()); 490 err = native_window_dequeue_buffer_and_wait(anw.get(), &anb); 491 ASSERT_NO_ERROR(err, "dequeueBuffer error: "); 492 493 ASSERT_TRUE(anb != NULL); 494 495 sp<GraphicBuffer> buf(new GraphicBuffer(anb, false)); 496 497 *stride = buf->getStride(); 498 uint8_t* img = NULL; 499 500 ALOGVV("Lock buffer from %p for write", anw.get()); 501 err = buf->lock(GRALLOC_USAGE_SW_WRITE_OFTEN, (void**)(&img)); 502 ASSERT_NO_ERROR(err, "lock error: "); 503 504 switch (params.format) { 505 case HAL_PIXEL_FORMAT_YV12: 506 fillYV12Buffer(img, params.width, params.height, *stride); 507 break; 508 case HAL_PIXEL_FORMAT_RAW_SENSOR: 509 fillBayerRawBuffer(img, params.width, params.height, buf->getStride()); 510 break; 511 case HAL_PIXEL_FORMAT_Y8: 512 fillGreyscaleBuffer<uint8_t>(img, params.width, params.height, 513 buf->getStride(), /*bpp*/8); 514 break; 515 case HAL_PIXEL_FORMAT_Y16: 516 fillGreyscaleBuffer<uint16_t>((uint16_t*)img, params.width, 517 params.height, buf->getStride(), 518 /*bpp*/16); 519 break; 520 case HAL_PIXEL_FORMAT_RGBA_8888: 521 fillRgba8888Buffer(img, params.width, params.height, buf->getStride()); 522 break; 523 default: 524 FAIL() << "Unknown pixel format under test!"; 525 break; 526 } 527 ALOGVV("Unlock buffer from %p", anw.get()); 528 err = buf->unlock(); 529 ASSERT_NO_ERROR(err, "unlock error: "); 530 531 ALOGVV("Set timestamp to %p", anw.get()); 532 err = native_window_set_buffers_timestamp(anw.get(), timestamp); 533 ASSERT_NO_ERROR(err, "set_buffers_timestamp error: "); 534 535 ALOGVV("Queue buffer to %p", anw.get()); 536 err = anw->queueBuffer(anw.get(), buf->getNativeBuffer(), -1); 537 ASSERT_NO_ERROR(err, "queueBuffer error:"); 538 }; 539 540 // This test is disabled because the HAL_PIXEL_FORMAT_RAW_SENSOR format is not 541 // supported on all devices. 542 TEST_P(CpuConsumerTest, FromCpuSingle) { 543 status_t err; 544 CpuConsumerTestParams params = GetParam(); 545 546 // Set up 547 548 ASSERT_NO_FATAL_FAILURE(configureANW(mANW, params, 1)); 549 550 // Produce 551 552 const int64_t time = 12345678L; 553 uint32_t stride; 554 ASSERT_NO_FATAL_FAILURE(produceOneFrame(mANW, params, time, 555 &stride)); 556 557 // Consume 558 559 CpuConsumer::LockedBuffer b; 560 err = mCC->lockNextBuffer(&b); 561 ASSERT_NO_ERROR(err, "getNextBuffer error: "); 562 563 ASSERT_TRUE(b.data != NULL); 564 EXPECT_EQ(params.width, b.width); 565 EXPECT_EQ(params.height, b.height); 566 EXPECT_EQ(params.format, b.format); 567 EXPECT_EQ(stride, b.stride); 568 EXPECT_EQ(time, b.timestamp); 569 570 checkAnyBuffer(b, GetParam().format); 571 mCC->unlockBuffer(b); 572 } 573 574 // This test is disabled because the HAL_PIXEL_FORMAT_RAW_SENSOR format is not 575 // supported on all devices. 576 TEST_P(CpuConsumerTest, FromCpuManyInQueue) { 577 status_t err; 578 CpuConsumerTestParams params = GetParam(); 579 580 const int numInQueue = 5; 581 // Set up 582 583 ASSERT_NO_FATAL_FAILURE(configureANW(mANW, params, numInQueue)); 584 585 // Produce 586 587 const int64_t time[numInQueue] = { 1L, 2L, 3L, 4L, 5L}; 588 uint32_t stride[numInQueue]; 589 590 for (int i = 0; i < numInQueue; i++) { 591 ALOGV("Producing frame %d", i); 592 ASSERT_NO_FATAL_FAILURE(produceOneFrame(mANW, params, time[i], 593 &stride[i])); 594 } 595 596 // Consume 597 598 for (int i = 0; i < numInQueue; i++) { 599 ALOGV("Consuming frame %d", i); 600 CpuConsumer::LockedBuffer b; 601 err = mCC->lockNextBuffer(&b); 602 ASSERT_NO_ERROR(err, "getNextBuffer error: "); 603 604 ASSERT_TRUE(b.data != NULL); 605 EXPECT_EQ(params.width, b.width); 606 EXPECT_EQ(params.height, b.height); 607 EXPECT_EQ(params.format, b.format); 608 EXPECT_EQ(stride[i], b.stride); 609 EXPECT_EQ(time[i], b.timestamp); 610 611 checkAnyBuffer(b, GetParam().format); 612 613 mCC->unlockBuffer(b); 614 } 615 } 616 617 // This test is disabled because the HAL_PIXEL_FORMAT_RAW_SENSOR format is not 618 // supported on all devices. 619 TEST_P(CpuConsumerTest, FromCpuLockMax) { 620 status_t err; 621 CpuConsumerTestParams params = GetParam(); 622 623 // Set up 624 625 ASSERT_NO_FATAL_FAILURE(configureANW(mANW, params, params.maxLockedBuffers + 1)); 626 627 // Produce 628 629 const int64_t time = 1234L; 630 uint32_t stride; 631 632 for (int i = 0; i < params.maxLockedBuffers + 1; i++) { 633 ALOGV("Producing frame %d", i); 634 ASSERT_NO_FATAL_FAILURE(produceOneFrame(mANW, params, time, 635 &stride)); 636 } 637 638 // Consume 639 640 CpuConsumer::LockedBuffer *b = new CpuConsumer::LockedBuffer[params.maxLockedBuffers]; 641 for (int i = 0; i < params.maxLockedBuffers; i++) { 642 ALOGV("Locking frame %d", i); 643 err = mCC->lockNextBuffer(&b[i]); 644 ASSERT_NO_ERROR(err, "getNextBuffer error: "); 645 646 ASSERT_TRUE(b[i].data != NULL); 647 EXPECT_EQ(params.width, b[i].width); 648 EXPECT_EQ(params.height, b[i].height); 649 EXPECT_EQ(params.format, b[i].format); 650 EXPECT_EQ(stride, b[i].stride); 651 EXPECT_EQ(time, b[i].timestamp); 652 653 checkAnyBuffer(b[i], GetParam().format); 654 } 655 656 ALOGV("Locking frame %d (too many)", params.maxLockedBuffers); 657 CpuConsumer::LockedBuffer bTooMuch; 658 err = mCC->lockNextBuffer(&bTooMuch); 659 ASSERT_TRUE(err == INVALID_OPERATION) << "Allowing too many locks"; 660 661 ALOGV("Unlocking frame 0"); 662 err = mCC->unlockBuffer(b[0]); 663 ASSERT_NO_ERROR(err, "Could not unlock buffer 0: "); 664 665 ALOGV("Locking frame %d (should work now)", params.maxLockedBuffers); 666 err = mCC->lockNextBuffer(&bTooMuch); 667 ASSERT_NO_ERROR(err, "Did not allow new lock after unlock"); 668 669 ASSERT_TRUE(bTooMuch.data != NULL); 670 EXPECT_EQ(params.width, bTooMuch.width); 671 EXPECT_EQ(params.height, bTooMuch.height); 672 EXPECT_EQ(params.format, bTooMuch.format); 673 EXPECT_EQ(stride, bTooMuch.stride); 674 EXPECT_EQ(time, bTooMuch.timestamp); 675 676 checkAnyBuffer(bTooMuch, GetParam().format); 677 678 ALOGV("Unlocking extra buffer"); 679 err = mCC->unlockBuffer(bTooMuch); 680 ASSERT_NO_ERROR(err, "Could not unlock extra buffer: "); 681 682 ALOGV("Locking frame %d (no more available)", params.maxLockedBuffers + 1); 683 err = mCC->lockNextBuffer(&b[0]); 684 ASSERT_EQ(BAD_VALUE, err) << "Not out of buffers somehow"; 685 686 for (int i = 1; i < params.maxLockedBuffers; i++) { 687 mCC->unlockBuffer(b[i]); 688 } 689 690 delete[] b; 691 692 } 693 694 CpuConsumerTestParams y8TestSets[] = { 695 { 512, 512, 1, HAL_PIXEL_FORMAT_Y8}, 696 { 512, 512, 3, HAL_PIXEL_FORMAT_Y8}, 697 { 2608, 1960, 1, HAL_PIXEL_FORMAT_Y8}, 698 { 2608, 1960, 3, HAL_PIXEL_FORMAT_Y8}, 699 { 100, 100, 1, HAL_PIXEL_FORMAT_Y8}, 700 { 100, 100, 3, HAL_PIXEL_FORMAT_Y8}, 701 }; 702 703 CpuConsumerTestParams y16TestSets[] = { 704 { 512, 512, 1, HAL_PIXEL_FORMAT_Y16}, 705 { 512, 512, 3, HAL_PIXEL_FORMAT_Y16}, 706 { 2608, 1960, 1, HAL_PIXEL_FORMAT_Y16}, 707 { 2608, 1960, 3, HAL_PIXEL_FORMAT_Y16}, 708 { 100, 100, 1, HAL_PIXEL_FORMAT_Y16}, 709 { 100, 100, 3, HAL_PIXEL_FORMAT_Y16}, 710 }; 711 712 CpuConsumerTestParams rawTestSets[] = { 713 { 512, 512, 1, HAL_PIXEL_FORMAT_RAW_SENSOR}, 714 { 512, 512, 3, HAL_PIXEL_FORMAT_RAW_SENSOR}, 715 { 2608, 1960, 1, HAL_PIXEL_FORMAT_RAW_SENSOR}, 716 { 2608, 1960, 3, HAL_PIXEL_FORMAT_RAW_SENSOR}, 717 { 100, 100, 1, HAL_PIXEL_FORMAT_RAW_SENSOR}, 718 { 100, 100, 3, HAL_PIXEL_FORMAT_RAW_SENSOR}, 719 }; 720 721 CpuConsumerTestParams rgba8888TestSets[] = { 722 { 512, 512, 1, HAL_PIXEL_FORMAT_RGBA_8888}, 723 { 512, 512, 3, HAL_PIXEL_FORMAT_RGBA_8888}, 724 { 2608, 1960, 1, HAL_PIXEL_FORMAT_RGBA_8888}, 725 { 2608, 1960, 3, HAL_PIXEL_FORMAT_RGBA_8888}, 726 { 100, 100, 1, HAL_PIXEL_FORMAT_RGBA_8888}, 727 { 100, 100, 3, HAL_PIXEL_FORMAT_RGBA_8888}, 728 }; 729 730 #if CPU_CONSUMER_TEST_FORMAT_Y8 731 INSTANTIATE_TEST_CASE_P(Y8Tests, 732 CpuConsumerTest, 733 ::testing::ValuesIn(y8TestSets)); 734 #endif 735 736 #if CPU_CONSUMER_TEST_FORMAT_Y16 737 INSTANTIATE_TEST_CASE_P(Y16Tests, 738 CpuConsumerTest, 739 ::testing::ValuesIn(y16TestSets)); 740 #endif 741 742 #if CPU_CONSUMER_TEST_FORMAT_RAW 743 INSTANTIATE_TEST_CASE_P(RawTests, 744 CpuConsumerTest, 745 ::testing::ValuesIn(rawTestSets)); 746 #endif 747 748 #if CPU_CONSUMER_TEST_FORMAT_RGBA_8888 749 INSTANTIATE_TEST_CASE_P(Rgba8888Tests, 750 CpuConsumerTest, 751 ::testing::ValuesIn(rgba8888TestSets)); 752 #endif 753 754 755 756 } // namespace android 757