1 /*
2 * Copyright (C) 2018 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 #include <errno.h>
18 #include <sys/types.h>
19 #include <sys/socket.h>
20 #include <sys/un.h>
21 #include <unistd.h>
22
23 #include <limits>
24 #include <sstream>
25 #include <string>
26
27 #include <android/hardware_buffer.h>
28 #include <android/log.h>
29 #include <gtest/gtest.h>
30 #include <gmock/gmock.h>
31
32 //#define LOG_NDEBUG 0
33
34 #define BAD_VALUE -EINVAL
35 #define INVALID_OPERATION -ENOSYS
36 #define NO_ERROR 0
37
38 #define LOG_TAG "AHBTest"
39 #define ALOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
40
41 namespace {
42
43 using testing::AnyOf;
44 using testing::Eq;
45 using testing::Ge;
46 using testing::NotNull;
47
48 #define FORMAT_CASE(x) case AHARDWAREBUFFER_FORMAT_ ## x: os << #x ; break
49
PrintAhbFormat(std::ostream & os,uint64_t format)50 void PrintAhbFormat(std::ostream& os, uint64_t format) {
51 switch (format) {
52 FORMAT_CASE(R8G8B8A8_UNORM);
53 FORMAT_CASE(R8G8B8X8_UNORM);
54 FORMAT_CASE(R8G8B8_UNORM);
55 FORMAT_CASE(R5G6B5_UNORM);
56 FORMAT_CASE(R16G16B16A16_FLOAT);
57 FORMAT_CASE(R10G10B10A2_UNORM);
58 FORMAT_CASE(BLOB);
59 FORMAT_CASE(D16_UNORM);
60 FORMAT_CASE(D24_UNORM);
61 FORMAT_CASE(D24_UNORM_S8_UINT);
62 FORMAT_CASE(D32_FLOAT);
63 FORMAT_CASE(D32_FLOAT_S8_UINT);
64 FORMAT_CASE(S8_UINT);
65 default: os << "unknown"; break;
66 }
67 }
68
69 #define BITS_CASE(x) case AHARDWAREBUFFER_USAGE_ ## x: os << #x ; break
70 #define PRINT_FLAG(x) \
71 do { if (usage & AHARDWAREBUFFER_USAGE_ ## x) { os << #x << " "; } } while (0)
72
PrintAhbUsage(std::ostream & os,uint64_t usage)73 void PrintAhbUsage(std::ostream& os, uint64_t usage) {
74 if (usage == 0) {
75 os << "none";
76 return;
77 }
78 switch (usage & AHARDWAREBUFFER_USAGE_CPU_READ_MASK) {
79 BITS_CASE(CPU_READ_NEVER);
80 BITS_CASE(CPU_READ_RARELY);
81 BITS_CASE(CPU_READ_OFTEN);
82 default: break;
83 }
84 switch (usage & AHARDWAREBUFFER_USAGE_CPU_WRITE_MASK) {
85 BITS_CASE(CPU_WRITE_NEVER);
86 BITS_CASE(CPU_WRITE_RARELY);
87 BITS_CASE(CPU_WRITE_OFTEN);
88 default: break;
89 }
90
91 PRINT_FLAG(GPU_SAMPLED_IMAGE);
92 PRINT_FLAG(GPU_COLOR_OUTPUT);
93 PRINT_FLAG(PROTECTED_CONTENT);
94 PRINT_FLAG(VIDEO_ENCODE);
95 PRINT_FLAG(SENSOR_DIRECT_DATA);
96 PRINT_FLAG(GPU_DATA_BUFFER);
97 PRINT_FLAG(GPU_CUBE_MAP);
98 PRINT_FLAG(GPU_MIPMAP_COMPLETE);
99
100 PRINT_FLAG(VENDOR_0);
101 PRINT_FLAG(VENDOR_1);
102 PRINT_FLAG(VENDOR_2);
103 PRINT_FLAG(VENDOR_3);
104 PRINT_FLAG(VENDOR_4);
105 PRINT_FLAG(VENDOR_5);
106 PRINT_FLAG(VENDOR_6);
107 PRINT_FLAG(VENDOR_7);
108 PRINT_FLAG(VENDOR_8);
109 PRINT_FLAG(VENDOR_9);
110 PRINT_FLAG(VENDOR_10);
111 PRINT_FLAG(VENDOR_11);
112 PRINT_FLAG(VENDOR_12);
113 PRINT_FLAG(VENDOR_13);
114 PRINT_FLAG(VENDOR_14);
115 PRINT_FLAG(VENDOR_15);
116 PRINT_FLAG(VENDOR_16);
117 PRINT_FLAG(VENDOR_17);
118 PRINT_FLAG(VENDOR_18);
119 PRINT_FLAG(VENDOR_19);
120 }
121
GetDescription(AHardwareBuffer * buffer)122 AHardwareBuffer_Desc GetDescription(AHardwareBuffer* buffer) {
123 AHardwareBuffer_Desc description;
124 AHardwareBuffer_describe(buffer, &description);
125 return description;
126 }
127
128 } // namespace
129
130 // GTest printer for AHardwareBuffer_Desc. Has to be in the global namespace.
PrintTo(const AHardwareBuffer_Desc & desc,::std::ostream * os)131 void PrintTo(const AHardwareBuffer_Desc& desc, ::std::ostream* os) {
132 *os << "AHardwareBuffer_Desc " << desc.width << "x" << desc.height;
133 if (desc.layers > 1) {
134 *os << ", " << desc.layers << " layers";
135 }
136 *os << ", usage = ";
137 PrintAhbUsage(*os, desc.usage);
138 *os << ", format = ";
139 PrintAhbFormat(*os, desc.format);
140 }
141
142 // Equality operators for AHardwareBuffer_Desc. Have to be in the global namespace.
operator ==(const AHardwareBuffer_Desc & a,const AHardwareBuffer_Desc & b)143 bool operator==(const AHardwareBuffer_Desc& a, const AHardwareBuffer_Desc& b) {
144 return a.width == b.width && a.height == b.height && a.layers == b.layers &&
145 a.usage == b.usage && a.format == b.format;
146 }
operator !=(const AHardwareBuffer_Desc & a,const AHardwareBuffer_Desc & b)147 bool operator!=(const AHardwareBuffer_Desc& a, const AHardwareBuffer_Desc& b) {
148 return !(a == b);
149 }
150
151 namespace android {
152
153 // Test that passing in NULL values to allocate works as expected.
TEST(AHardwareBufferTest,AllocateFailsWithNullInput)154 TEST(AHardwareBufferTest, AllocateFailsWithNullInput) {
155 AHardwareBuffer* buffer;
156 AHardwareBuffer_Desc desc;
157
158 memset(&desc, 0, sizeof(AHardwareBuffer_Desc));
159
160 int res = AHardwareBuffer_allocate(&desc, (AHardwareBuffer * * _Nonnull)NULL);
161 EXPECT_EQ(BAD_VALUE, res);
162 res = AHardwareBuffer_allocate((AHardwareBuffer_Desc* _Nonnull)NULL, &buffer);
163 EXPECT_EQ(BAD_VALUE, res);
164 res = AHardwareBuffer_allocate((AHardwareBuffer_Desc* _Nonnull)NULL,
165 (AHardwareBuffer * * _Nonnull)NULL);
166 EXPECT_EQ(BAD_VALUE, res);
167 }
168
169 // Test that passing in NULL values to allocate works as expected.
TEST(AHardwareBufferTest,BlobFormatRequiresHeight1)170 TEST(AHardwareBufferTest, BlobFormatRequiresHeight1) {
171 AHardwareBuffer* buffer;
172 AHardwareBuffer_Desc desc = {};
173
174 desc.width = 2;
175 desc.height = 4;
176 desc.layers = 1;
177 desc.usage = AHARDWAREBUFFER_USAGE_CPU_READ_RARELY;
178 desc.format = AHARDWAREBUFFER_FORMAT_BLOB;
179 int res = AHardwareBuffer_allocate(&desc, &buffer);
180 EXPECT_EQ(BAD_VALUE, res);
181
182 desc.height = 1;
183 res = AHardwareBuffer_allocate(&desc, &buffer);
184 EXPECT_EQ(NO_ERROR, res);
185 EXPECT_EQ(desc, GetDescription(buffer));
186 AHardwareBuffer_release(buffer);
187 buffer = NULL;
188 }
189
190 // Test that allocate can create an AHardwareBuffer correctly.
TEST(AHardwareBufferTest,AllocateSucceeds)191 TEST(AHardwareBufferTest, AllocateSucceeds) {
192 AHardwareBuffer* buffer = NULL;
193 AHardwareBuffer_Desc desc = {};
194
195 desc.width = 2;
196 desc.height = 4;
197 desc.layers = 1;
198 desc.usage = AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE;
199 desc.format = AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM;
200 int res = AHardwareBuffer_allocate(&desc, &buffer);
201 EXPECT_EQ(NO_ERROR, res);
202 EXPECT_EQ(desc, GetDescription(buffer));
203 AHardwareBuffer_release(buffer);
204 buffer = NULL;
205
206 desc.width = 4;
207 desc.height = 12;
208 desc.layers = 1;
209 desc.usage = AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE;
210 desc.format = AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM;
211 res = AHardwareBuffer_allocate(&desc, &buffer);
212 EXPECT_EQ(NO_ERROR, res);
213 EXPECT_EQ(desc, GetDescription(buffer));
214 AHardwareBuffer_release(buffer);
215 }
216
217 // Test that allocate can create YUV AHardwareBuffers correctly.
TEST(AHardwareBufferTest,YuvAllocateSucceeds)218 TEST(AHardwareBufferTest, YuvAllocateSucceeds) {
219 AHardwareBuffer* buffer = NULL;
220 AHardwareBuffer_Desc desc = {};
221
222 desc.width = 16;
223 desc.height = 16;
224 desc.layers = 1;
225 desc.usage = AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE;
226 desc.format = AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_420;
227 int res = AHardwareBuffer_allocate(&desc, &buffer);
228 EXPECT_EQ(NO_ERROR, res);
229 EXPECT_EQ(desc, GetDescription(buffer));
230 AHardwareBuffer_release(buffer);
231 buffer = NULL;
232 }
233
TEST(AHardwareBufferTest,DescribeSucceeds)234 TEST(AHardwareBufferTest, DescribeSucceeds) {
235 AHardwareBuffer* buffer = NULL;
236 AHardwareBuffer_Desc desc = {};
237
238 desc.width = 2;
239 desc.height = 4;
240 desc.layers = 1;
241 desc.usage = AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE;
242 desc.format = AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM;
243 int res = AHardwareBuffer_allocate(&desc, &buffer);
244 EXPECT_EQ(NO_ERROR, res);
245
246 // Description of a null buffer should be all zeros.
247 AHardwareBuffer_Desc scratch_desc;
248 memset(&scratch_desc, 0, sizeof(AHardwareBuffer_Desc));
249 AHardwareBuffer_describe((AHardwareBuffer* _Nonnull)NULL, &scratch_desc);
250 EXPECT_EQ(0U, scratch_desc.width);
251 EXPECT_EQ(0U, scratch_desc.height);
252
253 // This shouldn't crash.
254 AHardwareBuffer_describe(buffer, (AHardwareBuffer_Desc* _Nonnull)NULL);
255
256 // Description of created buffer should match requsted description.
257 EXPECT_EQ(desc, GetDescription(buffer));
258 AHardwareBuffer_release(buffer);
259 }
260
261 struct ClientData {
262 int fd;
263 AHardwareBuffer* buffer;
ClientDataandroid::ClientData264 ClientData(int fd_in, AHardwareBuffer* buffer_in)
265 : fd(fd_in), buffer(buffer_in) {}
266 };
267
clientFunction(void * data)268 static void* clientFunction(void* data) {
269 ClientData* pdata = reinterpret_cast<ClientData*>(data);
270 int err = AHardwareBuffer_sendHandleToUnixSocket(pdata->buffer, pdata->fd);
271 EXPECT_EQ(NO_ERROR, err);
272 close(pdata->fd);
273 return 0;
274 }
275
TEST(AHardwareBufferTest,SendAndRecvSucceeds)276 TEST(AHardwareBufferTest, SendAndRecvSucceeds) {
277 AHardwareBuffer* buffer = NULL;
278 AHardwareBuffer_Desc desc = {};
279
280 desc.width = 2;
281 desc.height = 4;
282 desc.layers = 1;
283 desc.usage = AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE;
284 desc.format = AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM;
285
286 // Test that an invalid buffer fails.
287 int err = AHardwareBuffer_sendHandleToUnixSocket((AHardwareBuffer* _Nonnull)NULL, 0);
288 EXPECT_EQ(BAD_VALUE, err);
289 err = 0;
290 err = AHardwareBuffer_sendHandleToUnixSocket(buffer, 0);
291 EXPECT_EQ(BAD_VALUE, err);
292
293 // Allocate the buffer.
294 err = AHardwareBuffer_allocate(&desc, &buffer);
295 EXPECT_EQ(NO_ERROR, err);
296
297 int fds[2];
298 err = socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, fds);
299
300 // Launch a client that will send the buffer back.
301 ClientData data(fds[1], buffer);
302 pthread_t thread;
303 EXPECT_EQ(0, pthread_create(&thread, NULL, clientFunction, &data));
304
305 // Receive the buffer.
306 err = AHardwareBuffer_recvHandleFromUnixSocket(fds[0], (AHardwareBuffer * * _Nonnull)NULL);
307 EXPECT_EQ(BAD_VALUE, err);
308
309 AHardwareBuffer* received = NULL;
310 err = AHardwareBuffer_recvHandleFromUnixSocket(fds[0], &received);
311 EXPECT_EQ(NO_ERROR, err);
312 EXPECT_TRUE(received != NULL);
313 EXPECT_EQ(desc, GetDescription(received));
314
315 void* ret_val;
316 EXPECT_EQ(0, pthread_join(thread, &ret_val));
317 EXPECT_EQ(NULL, ret_val);
318 close(fds[0]);
319
320 AHardwareBuffer_release(buffer);
321 AHardwareBuffer_release(received);
322 }
323
TEST(AHardwareBufferTest,LockAndGetInfoAndUnlockSucceed)324 TEST(AHardwareBufferTest, LockAndGetInfoAndUnlockSucceed) {
325 AHardwareBuffer* buffer = nullptr;
326 AHardwareBuffer_Desc desc = {};
327
328 desc.width = 2;
329 desc.height = 4;
330 desc.layers = 1;
331 desc.usage = AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE | AHARDWAREBUFFER_USAGE_CPU_READ_RARELY;
332 desc.format = AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM;
333
334 int32_t bytesPerPixel = std::numeric_limits<int32_t>::min();
335 int32_t bytesPerStride = std::numeric_limits<int32_t>::min();
336
337 // Test that an invalid buffer fails.
338 int err =
339 AHardwareBuffer_lockAndGetInfo((AHardwareBuffer* _Nonnull)NULL, 0, -1, NULL,
340 (void** _Nonnull)NULL, &bytesPerPixel, &bytesPerStride);
341 EXPECT_EQ(BAD_VALUE, err);
342
343 err = AHardwareBuffer_allocate(&desc, &buffer);
344 EXPECT_EQ(NO_ERROR, err);
345 void* bufferData = NULL;
346
347 // Test invalid usage flag
348 err = AHardwareBuffer_lockAndGetInfo(buffer, ~(AHARDWAREBUFFER_USAGE_CPU_WRITE_MASK | AHARDWAREBUFFER_USAGE_CPU_READ_MASK), -1, NULL, &bufferData, &bytesPerPixel, &bytesPerStride);
349 EXPECT_EQ(BAD_VALUE, err);
350
351 err = AHardwareBuffer_lockAndGetInfo(buffer, AHARDWAREBUFFER_USAGE_CPU_READ_RARELY, -1, NULL, &bufferData, &bytesPerPixel, &bytesPerStride);
352
353 if (bytesPerPixel == -1 || bytesPerStride == -1) {
354 EXPECT_EQ(INVALID_OPERATION, err);
355 } else {
356 EXPECT_EQ(NO_ERROR, err);
357 EXPECT_LE(0, bytesPerPixel);
358 EXPECT_LE(0, bytesPerStride);
359 EXPECT_TRUE(bufferData != NULL);
360
361 err = AHardwareBuffer_unlock(buffer, nullptr);
362 EXPECT_EQ(NO_ERROR, err);
363 }
364 AHardwareBuffer_release(buffer);
365 }
366
TEST(AHardwareBufferTest,LockAndUnlockSucceed)367 TEST(AHardwareBufferTest, LockAndUnlockSucceed) {
368 AHardwareBuffer* buffer = NULL;
369 AHardwareBuffer_Desc desc = {};
370
371 desc.width = 2;
372 desc.height = 4;
373 desc.layers = 1;
374 desc.usage = AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE | AHARDWAREBUFFER_USAGE_CPU_READ_RARELY;
375 desc.format = AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM;
376
377 // Test that an invalid buffer fails.
378 int err = AHardwareBuffer_lock((AHardwareBuffer* _Nonnull)NULL, 0, -1, NULL,
379 (void** _Nonnull)NULL);
380 EXPECT_EQ(BAD_VALUE, err);
381 err = 0;
382
383 // Allocate the buffer.
384 err = AHardwareBuffer_allocate(&desc, &buffer);
385 EXPECT_EQ(NO_ERROR, err);
386 void* bufferData = NULL;
387 err = AHardwareBuffer_lock(buffer, AHARDWAREBUFFER_USAGE_CPU_READ_RARELY, -1,
388 NULL, &bufferData);
389 EXPECT_EQ(NO_ERROR, err);
390 EXPECT_TRUE(bufferData != NULL);
391 err = AHardwareBuffer_unlock(buffer, nullptr);
392
393 AHardwareBuffer_release(buffer);
394 }
395
TEST(AHardwareBufferTest,PlanarLockAndUnlockYuvSucceed)396 TEST(AHardwareBufferTest, PlanarLockAndUnlockYuvSucceed) {
397 AHardwareBuffer* buffer = NULL;
398 AHardwareBuffer_Desc desc = {};
399
400 desc.width = 16;
401 desc.height = 32;
402 desc.layers = 1;
403 desc.usage = AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE | AHARDWAREBUFFER_USAGE_CPU_READ_RARELY;
404 desc.format = AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_420;
405
406 // Test that an invalid buffer fails.
407 int err = AHardwareBuffer_lock((AHardwareBuffer* _Nonnull)NULL, 0, -1, NULL,
408 (void** _Nonnull)NULL);
409 EXPECT_EQ(BAD_VALUE, err);
410 err = 0;
411
412 // Allocate the buffer.
413 err = AHardwareBuffer_allocate(&desc, &buffer);
414 EXPECT_EQ(NO_ERROR, err);
415
416 // Lock its planes
417 AHardwareBuffer_Planes planes;
418 err = AHardwareBuffer_lockPlanes(buffer, AHARDWAREBUFFER_USAGE_CPU_READ_RARELY, -1, NULL,
419 &planes);
420
421 // Make sure everything looks right
422 EXPECT_EQ(NO_ERROR, err);
423 EXPECT_EQ(3U, planes.planeCount);
424
425 EXPECT_TRUE(planes.planes[0].data != NULL);
426 EXPECT_EQ(1U, planes.planes[0].pixelStride);
427 EXPECT_TRUE(planes.planes[0].rowStride >= 16);
428
429 EXPECT_TRUE(planes.planes[1].data != NULL);
430 EXPECT_THAT(planes.planes[1].pixelStride, AnyOf(Eq(1U), Eq(2U)));
431 EXPECT_TRUE(planes.planes[1].rowStride >= 8);
432
433 EXPECT_TRUE(planes.planes[2].data != NULL);
434 EXPECT_THAT(planes.planes[2].pixelStride, AnyOf(Eq(1U), Eq(2U)));
435 EXPECT_TRUE(planes.planes[2].rowStride >= 8);
436
437 // Unlock
438 err = AHardwareBuffer_unlock(buffer, nullptr);
439 EXPECT_EQ(NO_ERROR, err);
440
441 AHardwareBuffer_release(buffer);
442 }
443
TEST(AHardwareBufferTest,PlanarLockAndUnlockYuvP010Succeed)444 TEST(AHardwareBufferTest, PlanarLockAndUnlockYuvP010Succeed) {
445 AHardwareBuffer* buffer = NULL;
446 AHardwareBuffer_Desc desc = {};
447
448 desc.width = 32;
449 desc.height = 32;
450 desc.layers = 1;
451 desc.usage = AHARDWAREBUFFER_USAGE_CPU_READ_RARELY;
452 desc.format = AHARDWAREBUFFER_FORMAT_YCbCr_P010;
453
454 if (!AHardwareBuffer_isSupported(&desc)) {
455 ALOGI("Test skipped: AHARDWAREBUFFER_FORMAT_YCbCr_P010 not supported.");
456 return;
457 }
458
459 // Allocate the buffer.
460 int err = AHardwareBuffer_allocate(&desc, &buffer);
461 EXPECT_EQ(NO_ERROR, err);
462
463 // Lock its planes
464 AHardwareBuffer_Planes planes;
465 err = AHardwareBuffer_lockPlanes(buffer, AHARDWAREBUFFER_USAGE_CPU_READ_RARELY, -1, NULL,
466 &planes);
467
468 // Make sure everything looks right
469 EXPECT_EQ(NO_ERROR, err);
470 EXPECT_EQ(3U, planes.planeCount);
471
472 const uint32_t yPlaneWidth = desc.width;
473 const uint32_t cPlaneWidth = desc.width / 2;
474 const uint32_t bytesPerPixel = 2;
475
476 EXPECT_THAT(planes.planes[0].data, NotNull());
477 EXPECT_THAT(planes.planes[0].pixelStride, Eq(bytesPerPixel));
478 EXPECT_THAT(planes.planes[0].rowStride, Ge(yPlaneWidth * bytesPerPixel));
479
480 EXPECT_THAT(planes.planes[1].data, NotNull());
481 EXPECT_THAT(planes.planes[1].pixelStride, Eq(bytesPerPixel * /*interleaved=*/2));
482 EXPECT_THAT(planes.planes[1].rowStride, Ge(cPlaneWidth * bytesPerPixel));
483
484 EXPECT_THAT(planes.planes[2].data, NotNull());
485 EXPECT_THAT(planes.planes[2].pixelStride, Eq(bytesPerPixel * /*interleaved=*/2));
486 EXPECT_THAT(planes.planes[2].rowStride, Ge(cPlaneWidth * bytesPerPixel));
487
488 // Unlock
489 err = AHardwareBuffer_unlock(buffer, nullptr);
490 EXPECT_EQ(NO_ERROR, err);
491
492 AHardwareBuffer_release(buffer);
493 }
494
TEST(AHardwareBufferTest,PlanarLockAndUnlockRgbaSucceed)495 TEST(AHardwareBufferTest, PlanarLockAndUnlockRgbaSucceed) {
496 AHardwareBuffer* buffer = NULL;
497 AHardwareBuffer_Desc desc = {};
498
499 desc.width = 16;
500 desc.height = 32;
501 desc.layers = 1;
502 desc.usage = AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE | AHARDWAREBUFFER_USAGE_CPU_READ_RARELY;
503 desc.format = AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM;
504
505 // Test that an invalid buffer fails.
506 int err = AHardwareBuffer_lock((AHardwareBuffer* _Nonnull)NULL, 0, -1, NULL,
507 (void** _Nonnull)NULL);
508 EXPECT_EQ(BAD_VALUE, err);
509 err = 0;
510
511 // Allocate the buffer.
512 err = AHardwareBuffer_allocate(&desc, &buffer);
513 EXPECT_EQ(NO_ERROR, err);
514
515 // Lock its planes
516 AHardwareBuffer_Planes planes;
517 err = AHardwareBuffer_lockPlanes(buffer, AHARDWAREBUFFER_USAGE_CPU_READ_RARELY, -1, NULL,
518 &planes);
519
520 // Make sure everything looks right
521 EXPECT_EQ(NO_ERROR, err);
522 EXPECT_EQ(1U, planes.planeCount);
523
524 EXPECT_TRUE(planes.planes[0].data != NULL);
525 EXPECT_EQ(4U, planes.planes[0].pixelStride);
526 EXPECT_TRUE(planes.planes[0].rowStride >= 64);
527
528 // Unlock
529 err = AHardwareBuffer_unlock(buffer, nullptr);
530 EXPECT_EQ(NO_ERROR, err);
531
532 AHardwareBuffer_release(buffer);
533 }
534
TEST(AHardwareBufferTest,ProtectedContentAndCpuReadIncompatible)535 TEST(AHardwareBufferTest, ProtectedContentAndCpuReadIncompatible) {
536 AHardwareBuffer* buffer = NULL;
537 AHardwareBuffer_Desc desc = {};
538 desc.width = 120;
539 desc.height = 240;
540 desc.layers = 1;
541 desc.usage = AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT | AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN;
542 desc.format = AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM;
543
544 // Allocation of a CPU-readable buffer should succeed...
545 int err = AHardwareBuffer_allocate(&desc, &buffer);
546 EXPECT_EQ(NO_ERROR, err);
547 AHardwareBuffer_release(buffer);
548 buffer = nullptr;
549
550 // ...but not if it's a protected buffer.
551 desc.usage =
552 AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT |
553 AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN |
554 AHARDWAREBUFFER_USAGE_PROTECTED_CONTENT;
555 err = AHardwareBuffer_allocate(&desc, &buffer);
556 EXPECT_NE(NO_ERROR, err);
557
558 desc.usage =
559 AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT |
560 AHARDWAREBUFFER_USAGE_CPU_READ_RARELY |
561 AHARDWAREBUFFER_USAGE_PROTECTED_CONTENT;
562 err = AHardwareBuffer_allocate(&desc, &buffer);
563 EXPECT_NE(NO_ERROR, err);
564 }
565
TEST(AHardwareBufferTest,GetIdSucceed)566 TEST(AHardwareBufferTest, GetIdSucceed) {
567 AHardwareBuffer* buffer1 = nullptr;
568 uint64_t id1 = 0;
569 const AHardwareBuffer_Desc desc = {
570 .width = 4,
571 .height = 4,
572 .layers = 1,
573 .format = AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM,
574 .usage = AHARDWAREBUFFER_USAGE_CPU_READ_RARELY,
575 };
576 int err = AHardwareBuffer_allocate(&desc, &buffer1);
577 EXPECT_EQ(NO_ERROR, err);
578 EXPECT_NE(nullptr, buffer1);
579 EXPECT_EQ(0, AHardwareBuffer_getId(buffer1, &id1));
580 EXPECT_NE(id1, 0ULL);
581
582 AHardwareBuffer* buffer2 = nullptr;
583 uint64_t id2 = 0;
584 err = AHardwareBuffer_allocate(&desc, &buffer2);
585 EXPECT_EQ(NO_ERROR, err);
586 EXPECT_NE(nullptr, buffer2);
587 EXPECT_EQ(0, AHardwareBuffer_getId(buffer2, &id2));
588 EXPECT_NE(id2, 0ULL);
589
590 EXPECT_NE(id1, id2);
591 }
592
593 } // namespace android
594