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 #define CPU_CONSUMER_TEST_FORMAT_RAW 0
37 #define CPU_CONSUMER_TEST_FORMAT_Y8 0
38 #define CPU_CONSUMER_TEST_FORMAT_Y16 0
39 #define CPU_CONSUMER_TEST_FORMAT_RGBA_8888 1
40
41 namespace android {
42
43 struct CpuConsumerTestParams {
44 uint32_t width;
45 uint32_t height;
46 int maxLockedBuffers;
47 PixelFormat format;
48 };
49
operator <<(::std::ostream & os,const CpuConsumerTestParams & p)50 ::std::ostream& operator<<(::std::ostream& os, const CpuConsumerTestParams& p) {
51 return os << "[ (" << p.width << ", " << p.height << "), B:"
52 << p.maxLockedBuffers << ", F:0x"
53 << ::std::hex << p.format << "]";
54 }
55
56 class CpuConsumerTest : public ::testing::TestWithParam<CpuConsumerTestParams> {
57 protected:
58
SetUp()59 virtual void SetUp() {
60 const ::testing::TestInfo* const test_info =
61 ::testing::UnitTest::GetInstance()->current_test_info();
62 CpuConsumerTestParams params = GetParam();
63 ALOGV("** Starting test %s (%d x %d, %d, 0x%x)",
64 test_info->name(),
65 params.width, params.height,
66 params.maxLockedBuffers, params.format);
67 sp<IGraphicBufferProducer> producer;
68 sp<IGraphicBufferConsumer> consumer;
69 BufferQueue::createBufferQueue(&producer, &consumer);
70 mCC = new CpuConsumer(consumer, params.maxLockedBuffers);
71 String8 name("CpuConsumer_Under_Test");
72 mCC->setName(name);
73 mSTC = new Surface(producer);
74 mANW = mSTC;
75 }
76
TearDown()77 virtual void TearDown() {
78 mANW.clear();
79 mSTC.clear();
80 mCC.clear();
81 }
82
83 class FrameWaiter : public CpuConsumer::FrameAvailableListener {
84 public:
FrameWaiter()85 FrameWaiter():
86 mPendingFrames(0) {
87 }
88
waitForFrame()89 void waitForFrame() {
90 Mutex::Autolock lock(mMutex);
91 while (mPendingFrames == 0) {
92 mCondition.wait(mMutex);
93 }
94 mPendingFrames--;
95 }
96
onFrameAvailable()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:
DisconnectWaiter()115 DisconnectWaiter () :
116 mWaitForDisconnect(false),
117 mPendingFrames(0) {
118 }
119
waitForFrame()120 void waitForFrame() {
121 Mutex::Autolock lock(mMutex);
122 while (mPendingFrames == 0) {
123 mFrameCondition.wait(mMutex);
124 }
125 mPendingFrames--;
126 }
127
onFrameAvailable()128 virtual void onFrameAvailable() {
129 Mutex::Autolock lock(mMutex);
130 mPendingFrames++;
131 mFrameCondition.signal();
132 }
133
onBuffersReleased()134 virtual void onBuffersReleased() {
135 Mutex::Autolock lock(mMutex);
136 while (!mWaitForDisconnect) {
137 mDisconnectCondition.wait(mMutex);
138 }
139 }
140
finishDisconnect()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
checkPixel(const CpuConsumer::LockedBuffer & buf,uint32_t x,uint32_t y,uint32_t r,uint32_t g=0,uint32_t b=0)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
fillGreyscaleBuffer(T * buf,int w,int h,int stride,int bpp)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
chooseColorRgba8888(int blockX,int blockY,uint8_t channel)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
fillRgba8888Buffer(uint8_t * buf,int w,int h,int stride)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]
fillBayerRawBuffer(uint8_t * buf,int w,int h,int stride)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
checkGreyscaleBuffer(const CpuConsumer::LockedBuffer & buf)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
checkRgba8888Buffer(const CpuConsumer::LockedBuffer & buf)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
checkBayerRawBuffer(const CpuConsumer::LockedBuffer & buf)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
checkAnyBuffer(const CpuConsumer::LockedBuffer & buf,int format)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
configureANW(const sp<ANativeWindow> & anw,const CpuConsumerTestParams & params,int maxBufferSlack)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.
produceOneFrame(const sp<ANativeWindow> & anw,const CpuConsumerTestParams & params,int64_t timestamp,uint32_t * stride)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.
TEST_P(CpuConsumerTest,FromCpuSingle)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.
TEST_P(CpuConsumerTest,FromCpuManyInQueue)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.
TEST_P(CpuConsumerTest,FromCpuLockMax)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 == NOT_ENOUGH_DATA) << "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