1 /*
2 * Copyright (C) 2017 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 "AHardwareBuffer"
18
19 #include <android/hardware_buffer.h>
20 #include <android/hardware_buffer_aidl.h>
21 #include <android/binder_libbinder.h>
22 #include <vndk/hardware_buffer.h>
23
24 #include <errno.h>
25 #include <sys/socket.h>
26 #include <memory>
27
28 #include <cutils/native_handle.h>
29 #include <log/log.h>
30 #include <utils/StrongPointer.h>
31 #include <ui/GraphicBuffer.h>
32 #include <system/graphics.h>
33
34 #include <private/android/AHardwareBufferHelpers.h>
35 #include <android/hardware/graphics/common/1.1/types.h>
36 #include <aidl/android/hardware/graphics/common/PixelFormat.h>
37
38 static constexpr int kFdBufferSize = 128 * sizeof(int); // 128 ints
39
40 using namespace android;
41
42 // ----------------------------------------------------------------------------
43 // Public functions
44 // ----------------------------------------------------------------------------
45
AHardwareBuffer_allocate(const AHardwareBuffer_Desc * desc,AHardwareBuffer ** outBuffer)46 int AHardwareBuffer_allocate(const AHardwareBuffer_Desc* desc, AHardwareBuffer** outBuffer) {
47 if (!outBuffer || !desc) return BAD_VALUE;
48 if (!AHardwareBuffer_isValidDescription(desc, /*log=*/true)) return BAD_VALUE;
49
50 int format = AHardwareBuffer_convertToPixelFormat(desc->format);
51 uint64_t usage = AHardwareBuffer_convertToGrallocUsageBits(desc->usage);
52 sp<GraphicBuffer> gbuffer(new GraphicBuffer(
53 desc->width, desc->height, format, desc->layers, usage,
54 std::string("AHardwareBuffer pid [") + std::to_string(getpid()) + "]"));
55
56 status_t err = gbuffer->initCheck();
57 if (err != 0 || gbuffer->handle == nullptr) {
58 if (err == NO_MEMORY) {
59 GraphicBuffer::dumpAllocationsToSystemLog();
60 }
61 ALOGE("GraphicBuffer(w=%u, h=%u, lc=%u) failed (%s), handle=%p",
62 desc->width, desc->height, desc->layers, strerror(-err), gbuffer->handle);
63 return err == 0 ? UNKNOWN_ERROR : err;
64 }
65
66 *outBuffer = AHardwareBuffer_from_GraphicBuffer(gbuffer.get());
67
68 // Ensure the buffer doesn't get destroyed when the sp<> goes away.
69 AHardwareBuffer_acquire(*outBuffer);
70 return NO_ERROR;
71 }
72
AHardwareBuffer_acquire(AHardwareBuffer * buffer)73 void AHardwareBuffer_acquire(AHardwareBuffer* buffer) {
74 // incStrong/decStrong token must be the same, doesn't matter what it is
75 AHardwareBuffer_to_GraphicBuffer(buffer)->incStrong((void*)AHardwareBuffer_acquire);
76 }
77
AHardwareBuffer_release(AHardwareBuffer * buffer)78 void AHardwareBuffer_release(AHardwareBuffer* buffer) {
79 // incStrong/decStrong token must be the same, doesn't matter what it is
80 AHardwareBuffer_to_GraphicBuffer(buffer)->decStrong((void*)AHardwareBuffer_acquire);
81 }
82
AHardwareBuffer_describe(const AHardwareBuffer * buffer,AHardwareBuffer_Desc * outDesc)83 void AHardwareBuffer_describe(const AHardwareBuffer* buffer,
84 AHardwareBuffer_Desc* outDesc) {
85 if (!buffer || !outDesc) return;
86
87 const GraphicBuffer* gbuffer = AHardwareBuffer_to_GraphicBuffer(buffer);
88
89 outDesc->width = gbuffer->getWidth();
90 outDesc->height = gbuffer->getHeight();
91 outDesc->layers = gbuffer->getLayerCount();
92 outDesc->format = AHardwareBuffer_convertFromPixelFormat(uint32_t(gbuffer->getPixelFormat()));
93 outDesc->usage = AHardwareBuffer_convertFromGrallocUsageBits(gbuffer->getUsage());
94 outDesc->stride = gbuffer->getStride();
95 outDesc->rfu0 = 0;
96 outDesc->rfu1 = 0;
97 }
98
AHardwareBuffer_lockAndGetInfo(AHardwareBuffer * buffer,uint64_t usage,int32_t fence,const ARect * rect,void ** outVirtualAddress,int32_t * outBytesPerPixel,int32_t * outBytesPerStride)99 int AHardwareBuffer_lockAndGetInfo(AHardwareBuffer* buffer, uint64_t usage,
100 int32_t fence, const ARect* rect, void** outVirtualAddress,
101 int32_t* outBytesPerPixel, int32_t* outBytesPerStride) {
102 if (outBytesPerPixel) *outBytesPerPixel = -1;
103 if (outBytesPerStride) *outBytesPerStride = -1;
104
105 if (!buffer) {
106 return BAD_VALUE;
107 }
108
109 if (usage & ~(AHARDWAREBUFFER_USAGE_CPU_READ_MASK |
110 AHARDWAREBUFFER_USAGE_CPU_WRITE_MASK)) {
111 ALOGE("Invalid usage flags passed to AHardwareBuffer_lock; only "
112 "AHARDWAREBUFFER_USAGE_CPU_* flags are allowed");
113 return BAD_VALUE;
114 }
115
116 usage = AHardwareBuffer_convertToGrallocUsageBits(usage);
117 GraphicBuffer* gbuffer = AHardwareBuffer_to_GraphicBuffer(buffer);
118
119 //Mapper implementations before 3.0 will not return bytes per pixel or
120 //bytes per stride information.
121 if (gbuffer->getBufferMapperVersion() == GraphicBufferMapper::Version::GRALLOC_2) {
122 ALOGE("Mapper versions before 3.0 cannot retrieve bytes per pixel and bytes per stride info");
123 return INVALID_OPERATION;
124 }
125
126 if (gbuffer->getLayerCount() > 1) {
127 ALOGE("Buffer with multiple layers passed to AHardwareBuffer_lock; "
128 "only buffers with one layer are allowed");
129 return INVALID_OPERATION;
130 }
131
132 Rect bounds;
133 if (!rect) {
134 bounds.set(Rect(gbuffer->getWidth(), gbuffer->getHeight()));
135 } else {
136 bounds.set(Rect(rect->left, rect->top, rect->right, rect->bottom));
137 }
138 int32_t bytesPerPixel;
139 int32_t bytesPerStride;
140 int result = gbuffer->lockAsync(usage, usage, bounds, outVirtualAddress, fence, &bytesPerPixel, &bytesPerStride);
141
142 // if hardware returns -1 for bytes per pixel or bytes per stride, we fail
143 // and unlock the buffer
144 if (bytesPerPixel == -1 || bytesPerStride == -1) {
145 gbuffer->unlock();
146 return INVALID_OPERATION;
147 }
148
149 if (outBytesPerPixel) *outBytesPerPixel = bytesPerPixel;
150 if (outBytesPerStride) *outBytesPerStride = bytesPerStride;
151 return result;
152 }
153
AHardwareBuffer_lock(AHardwareBuffer * buffer,uint64_t usage,int32_t fence,const ARect * rect,void ** outVirtualAddress)154 int AHardwareBuffer_lock(AHardwareBuffer* buffer, uint64_t usage,
155 int32_t fence, const ARect* rect, void** outVirtualAddress) {
156 int32_t bytesPerPixel;
157 int32_t bytesPerStride;
158
159 if (!buffer) return BAD_VALUE;
160
161 if (usage & ~(AHARDWAREBUFFER_USAGE_CPU_READ_MASK |
162 AHARDWAREBUFFER_USAGE_CPU_WRITE_MASK)) {
163 ALOGE("Invalid usage flags passed to AHardwareBuffer_lock; only "
164 "AHARDWAREBUFFER_USAGE_CPU_* flags are allowed");
165 return BAD_VALUE;
166 }
167
168 usage = AHardwareBuffer_convertToGrallocUsageBits(usage);
169 GraphicBuffer* gbuffer = AHardwareBuffer_to_GraphicBuffer(buffer);
170
171 if (gbuffer->getLayerCount() > 1) {
172 ALOGE("Buffer with multiple layers passed to AHardwareBuffer_lock; "
173 "only buffers with one layer are allowed");
174 return INVALID_OPERATION;
175 }
176
177 Rect bounds;
178 if (!rect) {
179 bounds.set(Rect(gbuffer->getWidth(), gbuffer->getHeight()));
180 } else {
181 bounds.set(Rect(rect->left, rect->top, rect->right, rect->bottom));
182 }
183 return gbuffer->lockAsync(usage, usage, bounds, outVirtualAddress, fence, &bytesPerPixel, &bytesPerStride);
184 }
185
AHardwareBuffer_lockPlanes(AHardwareBuffer * buffer,uint64_t usage,int32_t fence,const ARect * rect,AHardwareBuffer_Planes * outPlanes)186 int AHardwareBuffer_lockPlanes(AHardwareBuffer* buffer, uint64_t usage,
187 int32_t fence, const ARect* rect, AHardwareBuffer_Planes* outPlanes) {
188 if (!buffer || !outPlanes) return BAD_VALUE;
189
190 if (usage & ~(AHARDWAREBUFFER_USAGE_CPU_READ_MASK |
191 AHARDWAREBUFFER_USAGE_CPU_WRITE_MASK)) {
192 ALOGE("Invalid usage flags passed to AHardwareBuffer_lock; only "
193 " AHARDWAREBUFFER_USAGE_CPU_* flags are allowed");
194 return BAD_VALUE;
195 }
196
197 usage = AHardwareBuffer_convertToGrallocUsageBits(usage);
198 GraphicBuffer* gBuffer = AHardwareBuffer_to_GraphicBuffer(buffer);
199 Rect bounds;
200 if (!rect) {
201 bounds.set(Rect(gBuffer->getWidth(), gBuffer->getHeight()));
202 } else {
203 bounds.set(Rect(rect->left, rect->top, rect->right, rect->bottom));
204 }
205 int format = AHardwareBuffer_convertFromPixelFormat(uint32_t(gBuffer->getPixelFormat()));
206 memset(outPlanes->planes, 0, sizeof(outPlanes->planes));
207 if (AHardwareBuffer_formatIsYuv(format)) {
208 android_ycbcr yuvData;
209 int result = gBuffer->lockAsyncYCbCr(usage, bounds, &yuvData, fence);
210 if (result == 0) {
211 outPlanes->planeCount = 3;
212 outPlanes->planes[0].data = yuvData.y;
213 if (format == AHARDWAREBUFFER_FORMAT_YCbCr_P010) {
214 outPlanes->planes[0].pixelStride = 2;
215 } else {
216 outPlanes->planes[0].pixelStride = 1;
217 }
218 outPlanes->planes[0].rowStride = yuvData.ystride;
219 outPlanes->planes[1].data = yuvData.cb;
220 outPlanes->planes[1].pixelStride = yuvData.chroma_step;
221 outPlanes->planes[1].rowStride = yuvData.cstride;
222 outPlanes->planes[2].data = yuvData.cr;
223 outPlanes->planes[2].pixelStride = yuvData.chroma_step;
224 outPlanes->planes[2].rowStride = yuvData.cstride;
225 } else {
226 outPlanes->planeCount = 0;
227 }
228 return result;
229 } else {
230 const uint32_t pixelStride = AHardwareBuffer_bytesPerPixel(format);
231 outPlanes->planeCount = 1;
232 outPlanes->planes[0].pixelStride = pixelStride;
233 outPlanes->planes[0].rowStride = gBuffer->getStride() * pixelStride;
234 return gBuffer->lockAsync(usage, usage, bounds, &outPlanes->planes[0].data, fence);
235 }
236 }
237
AHardwareBuffer_unlock(AHardwareBuffer * buffer,int32_t * fence)238 int AHardwareBuffer_unlock(AHardwareBuffer* buffer, int32_t* fence) {
239 if (!buffer) return BAD_VALUE;
240
241 GraphicBuffer* gBuffer = AHardwareBuffer_to_GraphicBuffer(buffer);
242 if (fence == nullptr)
243 return gBuffer->unlock();
244 else
245 return gBuffer->unlockAsync(fence);
246 }
247
AHardwareBuffer_sendHandleToUnixSocket(const AHardwareBuffer * buffer,int socketFd)248 int AHardwareBuffer_sendHandleToUnixSocket(const AHardwareBuffer* buffer, int socketFd) {
249 if (!buffer) return BAD_VALUE;
250 const GraphicBuffer* gBuffer = AHardwareBuffer_to_GraphicBuffer(buffer);
251
252 size_t flattenedSize = gBuffer->getFlattenedSize();
253 size_t fdCount = gBuffer->getFdCount();
254
255 std::unique_ptr<uint8_t[]> data(new uint8_t[flattenedSize]);
256 std::unique_ptr<int[]> fds(new int[fdCount]);
257
258 // Make copies of needed items since flatten modifies them, and we don't
259 // want to send anything if there's an error during flatten.
260 size_t flattenedSizeCopy = flattenedSize;
261 size_t fdCountCopy = fdCount;
262 void* dataStart = data.get();
263 int* fdsStart = fds.get();
264 status_t err = gBuffer->flatten(dataStart, flattenedSizeCopy, fdsStart,
265 fdCountCopy);
266 if (err != NO_ERROR) {
267 return err;
268 }
269
270 struct iovec iov[1];
271 iov[0].iov_base = data.get();
272 iov[0].iov_len = flattenedSize;
273
274 char buf[CMSG_SPACE(kFdBufferSize)];
275 struct msghdr msg = {
276 .msg_iov = &iov[0],
277 .msg_iovlen = 1,
278 .msg_control = buf,
279 .msg_controllen = sizeof(buf),
280 };
281
282 struct cmsghdr* cmsg = CMSG_FIRSTHDR(&msg);
283 cmsg->cmsg_level = SOL_SOCKET;
284 cmsg->cmsg_type = SCM_RIGHTS;
285 cmsg->cmsg_len = CMSG_LEN(sizeof(int) * fdCount);
286 int* fdData = reinterpret_cast<int*>(CMSG_DATA(cmsg));
287 memcpy(fdData, fds.get(), sizeof(int) * fdCount);
288 msg.msg_controllen = cmsg->cmsg_len;
289
290 int result;
291 do {
292 result = sendmsg(socketFd, &msg, 0);
293 } while (result == -1 && errno == EINTR);
294 if (result == -1) {
295 result = errno;
296 ALOGE("Error writing AHardwareBuffer to socket: error %#x (%s)",
297 result, strerror(result));
298 return -result;
299 }
300
301 return NO_ERROR;
302 }
303
AHardwareBuffer_recvHandleFromUnixSocket(int socketFd,AHardwareBuffer ** outBuffer)304 int AHardwareBuffer_recvHandleFromUnixSocket(int socketFd, AHardwareBuffer** outBuffer) {
305 if (!outBuffer) return BAD_VALUE;
306
307 static constexpr int kMessageBufferSize = 4096 * sizeof(int);
308
309 std::unique_ptr<char[]> dataBuf(new char[kMessageBufferSize]);
310 char fdBuf[CMSG_SPACE(kFdBufferSize)];
311 struct iovec iov[1];
312 iov[0].iov_base = dataBuf.get();
313 iov[0].iov_len = kMessageBufferSize;
314
315 struct msghdr msg = {
316 .msg_iov = &iov[0],
317 .msg_iovlen = 1,
318 .msg_control = fdBuf,
319 .msg_controllen = sizeof(fdBuf),
320 };
321
322 int result;
323 do {
324 result = recvmsg(socketFd, &msg, 0);
325 } while (result == -1 && errno == EINTR);
326 if (result == -1) {
327 result = errno;
328 ALOGE("Error reading AHardwareBuffer from socket: error %#x (%s)",
329 result, strerror(result));
330 return -result;
331 }
332
333 if (msg.msg_iovlen != 1) {
334 ALOGE("Error reading AHardwareBuffer from socket: bad data length");
335 return INVALID_OPERATION;
336 }
337
338 if (msg.msg_controllen % sizeof(int) != 0) {
339 ALOGE("Error reading AHardwareBuffer from socket: bad fd length");
340 return INVALID_OPERATION;
341 }
342
343 size_t dataLen = msg.msg_iov[0].iov_len;
344 const void* data = static_cast<const void*>(msg.msg_iov[0].iov_base);
345 if (!data) {
346 ALOGE("Error reading AHardwareBuffer from socket: no buffer data");
347 return INVALID_OPERATION;
348 }
349
350 struct cmsghdr* cmsg = CMSG_FIRSTHDR(&msg);
351 if (!cmsg) {
352 ALOGE("Error reading AHardwareBuffer from socket: no fd header");
353 return INVALID_OPERATION;
354 }
355
356 size_t fdCount = msg.msg_controllen >> 2;
357 const int* fdData = reinterpret_cast<const int*>(CMSG_DATA(cmsg));
358 if (!fdData) {
359 ALOGE("Error reading AHardwareBuffer from socket: no fd data");
360 return INVALID_OPERATION;
361 }
362
363 sp<GraphicBuffer> gBuffer(new GraphicBuffer());
364 status_t err = gBuffer->unflatten(data, dataLen, fdData, fdCount);
365 if (err != NO_ERROR) {
366 return err;
367 }
368 *outBuffer = AHardwareBuffer_from_GraphicBuffer(gBuffer.get());
369 // Ensure the buffer has a positive ref-count.
370 AHardwareBuffer_acquire(*outBuffer);
371
372 return NO_ERROR;
373 }
374
AHardwareBuffer_isSupported(const AHardwareBuffer_Desc * desc)375 int AHardwareBuffer_isSupported(const AHardwareBuffer_Desc* desc) {
376 if (!desc) return 0;
377 if (!AHardwareBuffer_isValidDescription(desc, /*log=*/false)) return 0;
378
379 bool supported = false;
380 sp<GraphicBuffer> gBuffer(new GraphicBuffer());
381 status_t err = gBuffer->isSupported(desc->width, desc->height, desc->format, desc->layers,
382 desc->usage, &supported);
383
384 if (err == NO_ERROR) {
385 return supported;
386 }
387
388 // function isSupported is not implemented on device or an error occurred during HAL
389 // query. Make a trial allocation.
390 AHardwareBuffer_Desc trialDesc = *desc;
391 trialDesc.width = 4;
392 trialDesc.height = desc->format == AHARDWAREBUFFER_FORMAT_BLOB ? 1 : 4;
393 if (desc->usage & AHARDWAREBUFFER_USAGE_GPU_CUBE_MAP) {
394 trialDesc.layers = desc->layers == 6 ? 6 : 12;
395 } else {
396 trialDesc.layers = desc->layers == 1 ? 1 : 2;
397 }
398 AHardwareBuffer* trialBuffer = nullptr;
399 int result = AHardwareBuffer_allocate(&trialDesc, &trialBuffer);
400 if (result == NO_ERROR) {
401 AHardwareBuffer_release(trialBuffer);
402 return 1;
403 }
404 return 0;
405 }
406
AHardwareBuffer_getId(const AHardwareBuffer * buffer,uint64_t * outId)407 int AHardwareBuffer_getId(const AHardwareBuffer* buffer, uint64_t* outId) {
408 if (!buffer || !outId) return BAD_VALUE;
409
410 const GraphicBuffer* gb = AHardwareBuffer_to_GraphicBuffer(buffer);
411 if (!gb) return BAD_VALUE;
412
413 *outId = gb->getId();
414
415 return OK;
416 }
417
AHardwareBuffer_readFromParcel(const AParcel * _Nonnull parcel,AHardwareBuffer * _Nullable * _Nonnull outBuffer)418 binder_status_t AHardwareBuffer_readFromParcel(const AParcel* _Nonnull parcel,
419 AHardwareBuffer* _Nullable* _Nonnull outBuffer) {
420 if (!parcel || !outBuffer) return STATUS_BAD_VALUE;
421 auto buffer = sp<GraphicBuffer>::make();
422 status_t status = AParcel_viewPlatformParcel(parcel)->read(*buffer);
423 if (status != STATUS_OK) return status;
424 *outBuffer = AHardwareBuffer_from_GraphicBuffer(buffer.get());
425 AHardwareBuffer_acquire(*outBuffer);
426 return STATUS_OK;
427 }
428
AHardwareBuffer_writeToParcel(const AHardwareBuffer * _Nonnull buffer,AParcel * _Nonnull parcel)429 binder_status_t AHardwareBuffer_writeToParcel(const AHardwareBuffer* _Nonnull buffer,
430 AParcel* _Nonnull parcel) {
431 const GraphicBuffer* gb = AHardwareBuffer_to_GraphicBuffer(buffer);
432 if (!gb) return STATUS_BAD_VALUE;
433 if (!parcel) return STATUS_BAD_VALUE;
434 return AParcel_viewPlatformParcel(parcel)->write(*gb);
435 }
436
437 // ----------------------------------------------------------------------------
438 // VNDK functions
439 // ----------------------------------------------------------------------------
440
AHardwareBuffer_getNativeHandle(const AHardwareBuffer * buffer)441 const native_handle_t* AHardwareBuffer_getNativeHandle(
442 const AHardwareBuffer* buffer) {
443 if (!buffer) return nullptr;
444 const GraphicBuffer* gbuffer = AHardwareBuffer_to_GraphicBuffer(buffer);
445 return gbuffer->handle;
446 }
447
AHardwareBuffer_createFromHandle(const AHardwareBuffer_Desc * desc,const native_handle_t * handle,int32_t method,AHardwareBuffer ** outBuffer)448 int AHardwareBuffer_createFromHandle(const AHardwareBuffer_Desc* desc,
449 const native_handle_t* handle, int32_t method,
450 AHardwareBuffer** outBuffer) {
451 static_assert(static_cast<int32_t>(AHARDWAREBUFFER_CREATE_FROM_HANDLE_METHOD_REGISTER) ==
452 static_cast<int32_t>(GraphicBuffer::TAKE_UNREGISTERED_HANDLE));
453 static_assert(static_cast<int32_t>(AHARDWAREBUFFER_CREATE_FROM_HANDLE_METHOD_CLONE) ==
454 static_cast<int32_t>(GraphicBuffer::CLONE_HANDLE));
455
456 if (!desc || !handle || !outBuffer) return BAD_VALUE;
457 if (!(method == AHARDWAREBUFFER_CREATE_FROM_HANDLE_METHOD_REGISTER ||
458 method == AHARDWAREBUFFER_CREATE_FROM_HANDLE_METHOD_CLONE))
459 return BAD_VALUE;
460 if (desc->rfu0 != 0 || desc->rfu1 != 0) return BAD_VALUE;
461 if (desc->format == AHARDWAREBUFFER_FORMAT_BLOB && desc->height != 1) return BAD_VALUE;
462
463 const int format = AHardwareBuffer_convertToPixelFormat(desc->format);
464 const uint64_t usage = AHardwareBuffer_convertToGrallocUsageBits(desc->usage);
465 const auto wrapMethod = static_cast<GraphicBuffer::HandleWrapMethod>(method);
466 sp<GraphicBuffer> gbuffer(new GraphicBuffer(handle, wrapMethod, desc->width, desc->height,
467 format, desc->layers, usage, desc->stride));
468 status_t err = gbuffer->initCheck();
469 if (err != 0 || gbuffer->handle == 0) return err;
470
471 *outBuffer = AHardwareBuffer_from_GraphicBuffer(gbuffer.get());
472 // Ensure the buffer doesn't get destroyed when the sp<> goes away.
473 AHardwareBuffer_acquire(*outBuffer);
474
475 return NO_ERROR;
476 }
477
478 // ----------------------------------------------------------------------------
479 // Helpers implementation
480 // ----------------------------------------------------------------------------
481
482 namespace android {
483
AHardwareBuffer_isValidDescription(const AHardwareBuffer_Desc * desc,bool log)484 bool AHardwareBuffer_isValidDescription(const AHardwareBuffer_Desc* desc, bool log) {
485 if (desc->width == 0 || desc->height == 0 || desc->layers == 0) {
486 ALOGE_IF(log, "Width, height and layers must all be nonzero");
487 return false;
488 }
489
490 if (!AHardwareBuffer_isValidPixelFormat(desc->format)) {
491 ALOGE_IF(log, "Invalid AHardwareBuffer pixel format %u (%#x))",
492 desc->format, desc->format);
493 return false;
494 }
495
496 if (desc->rfu0 != 0 || desc->rfu1 != 0) {
497 ALOGE_IF(log, "AHardwareBuffer_Desc::rfu fields must be 0");
498 return false;
499 }
500
501 if (desc->format == AHARDWAREBUFFER_FORMAT_BLOB) {
502 if (desc->height != 1 || desc->layers != 1) {
503 ALOGE_IF(log, "Height and layers must be 1 for AHARDWAREBUFFER_FORMAT_BLOB");
504 return false;
505 }
506 const uint64_t blobInvalidGpuMask =
507 AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE |
508 AHARDWAREBUFFER_USAGE_GPU_FRAMEBUFFER |
509 AHARDWAREBUFFER_USAGE_GPU_MIPMAP_COMPLETE |
510 AHARDWAREBUFFER_USAGE_GPU_CUBE_MAP;
511 if (desc->usage & blobInvalidGpuMask) {
512 ALOGE_IF(log, "Invalid GPU usage flag for AHARDWAREBUFFER_FORMAT_BLOB; "
513 "only AHARDWAREBUFFER_USAGE_GPU_DATA_BUFFER is allowed");
514 return false;
515 }
516 if (desc->usage & AHARDWAREBUFFER_USAGE_VIDEO_ENCODE) {
517 ALOGE_IF(log, "AHARDWAREBUFFER_FORMAT_BLOB cannot be encoded as video");
518 return false;
519 }
520 } else if (AHardwareBuffer_formatIsYuv(desc->format)) {
521 if (desc->layers != 1) {
522 ALOGE_IF(log, "Layers must be 1 for YUV formats.");
523 return false;
524 }
525 const uint64_t yuvInvalidGpuMask =
526 AHARDWAREBUFFER_USAGE_GPU_MIPMAP_COMPLETE |
527 AHARDWAREBUFFER_USAGE_GPU_CUBE_MAP;
528 if (desc->usage & yuvInvalidGpuMask) {
529 ALOGE_IF(log, "Invalid usage flags specified for YUV format; "
530 "mip-mapping and cube-mapping are not allowed.");
531 return false;
532 }
533 } else {
534 if (desc->usage & AHARDWAREBUFFER_USAGE_SENSOR_DIRECT_DATA) {
535 ALOGE_IF(log, "AHARDWAREBUFFER_USAGE_SENSOR_DIRECT_DATA requires AHARDWAREBUFFER_FORMAT_BLOB");
536 return false;
537 }
538 }
539
540 if ((desc->usage & (AHARDWAREBUFFER_USAGE_CPU_READ_MASK | AHARDWAREBUFFER_USAGE_CPU_WRITE_MASK)) &&
541 (desc->usage & AHARDWAREBUFFER_USAGE_PROTECTED_CONTENT)) {
542 ALOGE_IF(log, "AHARDWAREBUFFER_USAGE_PROTECTED_CONTENT requires AHARDWAREBUFFER_USAGE_CPU_READ_NEVER "
543 "and AHARDWAREBUFFER_USAGE_CPU_WRITE_NEVER");
544 return false;
545 }
546
547 if (desc->usage & AHARDWAREBUFFER_USAGE_GPU_CUBE_MAP) {
548 if (desc->width != desc->height) {
549 ALOGE_IF(log, "Cube maps must be square");
550 return false;
551 }
552 if (desc->layers % 6 != 0) {
553 ALOGE_IF(log, "Cube map layers must be a multiple of 6");
554 return false;
555 }
556 }
557 return true;
558 }
559
AHardwareBuffer_isValidPixelFormat(uint32_t format)560 bool AHardwareBuffer_isValidPixelFormat(uint32_t format) {
561 static_assert(HAL_PIXEL_FORMAT_RGBA_8888 == AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM,
562 "HAL and AHardwareBuffer pixel format don't match");
563 static_assert(HAL_PIXEL_FORMAT_RGBX_8888 == AHARDWAREBUFFER_FORMAT_R8G8B8X8_UNORM,
564 "HAL and AHardwareBuffer pixel format don't match");
565 static_assert(HAL_PIXEL_FORMAT_RGB_565 == AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM,
566 "HAL and AHardwareBuffer pixel format don't match");
567 static_assert(HAL_PIXEL_FORMAT_RGB_888 == AHARDWAREBUFFER_FORMAT_R8G8B8_UNORM,
568 "HAL and AHardwareBuffer pixel format don't match");
569 static_assert(HAL_PIXEL_FORMAT_RGBA_FP16 == AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT,
570 "HAL and AHardwareBuffer pixel format don't match");
571 static_assert(HAL_PIXEL_FORMAT_RGBA_1010102 == AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM,
572 "HAL and AHardwareBuffer pixel format don't match");
573 static_assert(HAL_PIXEL_FORMAT_BLOB == AHARDWAREBUFFER_FORMAT_BLOB,
574 "HAL and AHardwareBuffer pixel format don't match");
575 static_assert(HAL_PIXEL_FORMAT_DEPTH_16 == AHARDWAREBUFFER_FORMAT_D16_UNORM,
576 "HAL and AHardwareBuffer pixel format don't match");
577 static_assert(HAL_PIXEL_FORMAT_DEPTH_24 == AHARDWAREBUFFER_FORMAT_D24_UNORM,
578 "HAL and AHardwareBuffer pixel format don't match");
579 static_assert(HAL_PIXEL_FORMAT_DEPTH_24_STENCIL_8 == AHARDWAREBUFFER_FORMAT_D24_UNORM_S8_UINT,
580 "HAL and AHardwareBuffer pixel format don't match");
581 static_assert(HAL_PIXEL_FORMAT_DEPTH_32F == AHARDWAREBUFFER_FORMAT_D32_FLOAT,
582 "HAL and AHardwareBuffer pixel format don't match");
583 static_assert(HAL_PIXEL_FORMAT_DEPTH_32F_STENCIL_8 == AHARDWAREBUFFER_FORMAT_D32_FLOAT_S8_UINT,
584 "HAL and AHardwareBuffer pixel format don't match");
585 static_assert(HAL_PIXEL_FORMAT_STENCIL_8 == AHARDWAREBUFFER_FORMAT_S8_UINT,
586 "HAL and AHardwareBuffer pixel format don't match");
587 static_assert(HAL_PIXEL_FORMAT_BGRA_8888 == AHARDWAREBUFFER_FORMAT_B8G8R8A8_UNORM,
588 "HAL and AHardwareBuffer pixel format don't match");
589 static_assert(HAL_PIXEL_FORMAT_YV12 == AHARDWAREBUFFER_FORMAT_YV12,
590 "HAL and AHardwareBuffer pixel format don't match");
591 static_assert(HAL_PIXEL_FORMAT_Y8 == AHARDWAREBUFFER_FORMAT_Y8,
592 "HAL and AHardwareBuffer pixel format don't match");
593 static_assert(HAL_PIXEL_FORMAT_Y16 == AHARDWAREBUFFER_FORMAT_Y16,
594 "HAL and AHardwareBuffer pixel format don't match");
595 static_assert(HAL_PIXEL_FORMAT_RAW16 == AHARDWAREBUFFER_FORMAT_RAW16,
596 "HAL and AHardwareBuffer pixel format don't match");
597 static_assert(HAL_PIXEL_FORMAT_RAW10 == AHARDWAREBUFFER_FORMAT_RAW10,
598 "HAL and AHardwareBuffer pixel format don't match");
599 static_assert(HAL_PIXEL_FORMAT_RAW12 == AHARDWAREBUFFER_FORMAT_RAW12,
600 "HAL and AHardwareBuffer pixel format don't match");
601 static_assert(HAL_PIXEL_FORMAT_RAW_OPAQUE == AHARDWAREBUFFER_FORMAT_RAW_OPAQUE,
602 "HAL and AHardwareBuffer pixel format don't match");
603 static_assert(HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED == AHARDWAREBUFFER_FORMAT_IMPLEMENTATION_DEFINED,
604 "HAL and AHardwareBuffer pixel format don't match");
605 static_assert(HAL_PIXEL_FORMAT_YCBCR_420_888 == AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_420,
606 "HAL and AHardwareBuffer pixel format don't match");
607 static_assert(HAL_PIXEL_FORMAT_YCBCR_422_SP == AHARDWAREBUFFER_FORMAT_YCbCr_422_SP,
608 "HAL and AHardwareBuffer pixel format don't match");
609 static_assert(HAL_PIXEL_FORMAT_YCRCB_420_SP == AHARDWAREBUFFER_FORMAT_YCrCb_420_SP,
610 "HAL and AHardwareBuffer pixel format don't match");
611 static_assert(HAL_PIXEL_FORMAT_YCBCR_422_I == AHARDWAREBUFFER_FORMAT_YCbCr_422_I,
612 "HAL and AHardwareBuffer pixel format don't match");
613 static_assert(HAL_PIXEL_FORMAT_YCBCR_P010 == AHARDWAREBUFFER_FORMAT_YCbCr_P010,
614 "HAL and AHardwareBuffer pixel format don't match");
615 static_assert(static_cast<int>(aidl::android::hardware::graphics::common::PixelFormat::R_8) ==
616 AHARDWAREBUFFER_FORMAT_R8_UNORM,
617 "HAL and AHardwareBuffer pixel format don't match");
618 static_assert(static_cast<int>(aidl::android::hardware::graphics::common::PixelFormat::R_16_UINT) ==
619 AHARDWAREBUFFER_FORMAT_R16_UINT,
620 "HAL and AHardwareBuffer pixel format don't match");
621 static_assert(static_cast<int>(aidl::android::hardware::graphics::common::PixelFormat::RG_1616_UINT) ==
622 AHARDWAREBUFFER_FORMAT_R16G16_UINT,
623 "HAL and AHardwareBuffer pixel format don't match");
624 static_assert(static_cast<int>(aidl::android::hardware::graphics::common::PixelFormat::RGBA_10101010) ==
625 AHARDWAREBUFFER_FORMAT_R10G10B10A10_UNORM,
626 "HAL and AHardwareBuffer pixel format don't match");
627
628 switch (format) {
629 case AHARDWAREBUFFER_FORMAT_R8_UNORM:
630 case AHARDWAREBUFFER_FORMAT_R16_UINT:
631 case AHARDWAREBUFFER_FORMAT_R16G16_UINT:
632 case AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM:
633 case AHARDWAREBUFFER_FORMAT_R8G8B8X8_UNORM:
634 case AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM:
635 case AHARDWAREBUFFER_FORMAT_R8G8B8_UNORM:
636 case AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT:
637 case AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM:
638 case AHARDWAREBUFFER_FORMAT_R10G10B10A10_UNORM:
639 case AHARDWAREBUFFER_FORMAT_BLOB:
640 case AHARDWAREBUFFER_FORMAT_D16_UNORM:
641 case AHARDWAREBUFFER_FORMAT_D24_UNORM:
642 case AHARDWAREBUFFER_FORMAT_D24_UNORM_S8_UINT:
643 case AHARDWAREBUFFER_FORMAT_D32_FLOAT:
644 case AHARDWAREBUFFER_FORMAT_D32_FLOAT_S8_UINT:
645 case AHARDWAREBUFFER_FORMAT_S8_UINT:
646 case AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_420:
647 // VNDK formats only -- unfortunately we can't differentiate from where we're called
648 case AHARDWAREBUFFER_FORMAT_B8G8R8A8_UNORM:
649 case AHARDWAREBUFFER_FORMAT_YV12:
650 case AHARDWAREBUFFER_FORMAT_Y8:
651 case AHARDWAREBUFFER_FORMAT_Y16:
652 case AHARDWAREBUFFER_FORMAT_RAW16:
653 case AHARDWAREBUFFER_FORMAT_RAW10:
654 case AHARDWAREBUFFER_FORMAT_RAW12:
655 case AHARDWAREBUFFER_FORMAT_RAW_OPAQUE:
656 case AHARDWAREBUFFER_FORMAT_IMPLEMENTATION_DEFINED:
657 case AHARDWAREBUFFER_FORMAT_YCbCr_422_SP:
658 case AHARDWAREBUFFER_FORMAT_YCrCb_420_SP:
659 case AHARDWAREBUFFER_FORMAT_YCbCr_422_I:
660 case AHARDWAREBUFFER_FORMAT_YCbCr_P010:
661 return true;
662
663 default:
664 return false;
665 }
666 }
667
AHardwareBuffer_formatIsYuv(uint32_t format)668 bool AHardwareBuffer_formatIsYuv(uint32_t format) {
669 switch (format) {
670 case AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_420:
671 case AHARDWAREBUFFER_FORMAT_YV12:
672 case AHARDWAREBUFFER_FORMAT_Y8:
673 case AHARDWAREBUFFER_FORMAT_Y16:
674 case AHARDWAREBUFFER_FORMAT_YCbCr_422_SP:
675 case AHARDWAREBUFFER_FORMAT_YCrCb_420_SP:
676 case AHARDWAREBUFFER_FORMAT_YCbCr_422_I:
677 case AHARDWAREBUFFER_FORMAT_YCbCr_P010:
678 return true;
679 default:
680 return false;
681 }
682 }
683
AHardwareBuffer_bytesPerPixel(uint32_t format)684 uint32_t AHardwareBuffer_bytesPerPixel(uint32_t format) {
685 switch (format) {
686 case AHARDWAREBUFFER_FORMAT_R8_UNORM:
687 return 1;
688 case AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM:
689 case AHARDWAREBUFFER_FORMAT_D16_UNORM:
690 case AHARDWAREBUFFER_FORMAT_R16_UINT:
691 return 2;
692 case AHARDWAREBUFFER_FORMAT_R8G8B8_UNORM:
693 case AHARDWAREBUFFER_FORMAT_D24_UNORM:
694 return 3;
695 case AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM:
696 case AHARDWAREBUFFER_FORMAT_R8G8B8X8_UNORM:
697 case AHARDWAREBUFFER_FORMAT_D32_FLOAT:
698 case AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM:
699 case AHARDWAREBUFFER_FORMAT_D24_UNORM_S8_UINT:
700 case AHARDWAREBUFFER_FORMAT_R16G16_UINT:
701 return 4;
702 case AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT:
703 case AHARDWAREBUFFER_FORMAT_R10G10B10A10_UNORM:
704 return 8;
705 default:
706 return 0;
707 }
708 }
709
AHardwareBuffer_convertFromPixelFormat(uint32_t hal_format)710 uint32_t AHardwareBuffer_convertFromPixelFormat(uint32_t hal_format) {
711 return hal_format;
712 }
713
AHardwareBuffer_convertToPixelFormat(uint32_t ahardwarebuffer_format)714 uint32_t AHardwareBuffer_convertToPixelFormat(uint32_t ahardwarebuffer_format) {
715 return ahardwarebuffer_format;
716 }
717
AHardwareBuffer_getDataSpace(AHardwareBuffer * buffer)718 int32_t AHardwareBuffer_getDataSpace(AHardwareBuffer* buffer) {
719 GraphicBuffer* gb = AHardwareBuffer_to_GraphicBuffer(buffer);
720 auto& mapper = GraphicBufferMapper::get();
721 ui::Dataspace dataspace = ui::Dataspace::UNKNOWN;
722 mapper.getDataspace(gb->handle, &dataspace);
723 return static_cast<int32_t>(dataspace);
724 }
725
AHardwareBuffer_convertToGrallocUsageBits(uint64_t usage)726 uint64_t AHardwareBuffer_convertToGrallocUsageBits(uint64_t usage) {
727 using android::hardware::graphics::common::V1_1::BufferUsage;
728 static_assert(AHARDWAREBUFFER_USAGE_CPU_READ_NEVER == (uint64_t)BufferUsage::CPU_READ_NEVER,
729 "gralloc and AHardwareBuffer flags don't match");
730 static_assert(AHARDWAREBUFFER_USAGE_CPU_READ_RARELY == (uint64_t)BufferUsage::CPU_READ_RARELY,
731 "gralloc and AHardwareBuffer flags don't match");
732 static_assert(AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN == (uint64_t)BufferUsage::CPU_READ_OFTEN,
733 "gralloc and AHardwareBuffer flags don't match");
734 static_assert(AHARDWAREBUFFER_USAGE_CPU_WRITE_NEVER == (uint64_t)BufferUsage::CPU_WRITE_NEVER,
735 "gralloc and AHardwareBuffer flags don't match");
736 static_assert(AHARDWAREBUFFER_USAGE_CPU_WRITE_RARELY == (uint64_t)BufferUsage::CPU_WRITE_RARELY,
737 "gralloc and AHardwareBuffer flags don't match");
738 static_assert(AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN == (uint64_t)BufferUsage::CPU_WRITE_OFTEN,
739 "gralloc and AHardwareBuffer flags don't match");
740 static_assert(AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE == (uint64_t)BufferUsage::GPU_TEXTURE,
741 "gralloc and AHardwareBuffer flags don't match");
742 static_assert(AHARDWAREBUFFER_USAGE_GPU_FRAMEBUFFER == (uint64_t)BufferUsage::GPU_RENDER_TARGET,
743 "gralloc and AHardwareBuffer flags don't match");
744 static_assert(AHARDWAREBUFFER_USAGE_PROTECTED_CONTENT == (uint64_t)BufferUsage::PROTECTED,
745 "gralloc and AHardwareBuffer flags don't match");
746 static_assert(AHARDWAREBUFFER_USAGE_VIDEO_ENCODE == (uint64_t)BufferUsage::VIDEO_ENCODER,
747 "gralloc and AHardwareBuffer flags don't match");
748 static_assert(AHARDWAREBUFFER_USAGE_GPU_DATA_BUFFER == (uint64_t)BufferUsage::GPU_DATA_BUFFER,
749 "gralloc and AHardwareBuffer flags don't match");
750 static_assert(AHARDWAREBUFFER_USAGE_SENSOR_DIRECT_DATA == (uint64_t)BufferUsage::SENSOR_DIRECT_DATA,
751 "gralloc and AHardwareBuffer flags don't match");
752 static_assert(AHARDWAREBUFFER_USAGE_GPU_CUBE_MAP == (uint64_t)BufferUsage::GPU_CUBE_MAP,
753 "gralloc and AHardwareBuffer flags don't match");
754 static_assert(AHARDWAREBUFFER_USAGE_GPU_MIPMAP_COMPLETE == (uint64_t)BufferUsage::GPU_MIPMAP_COMPLETE,
755 "gralloc and AHardwareBuffer flags don't match");
756 static_assert(AHARDWAREBUFFER_USAGE_CAMERA_WRITE == (uint64_t)BufferUsage::CAMERA_OUTPUT,
757 "gralloc and AHardwareBuffer flags don't match");
758 static_assert(AHARDWAREBUFFER_USAGE_CAMERA_READ == (uint64_t)BufferUsage::CAMERA_INPUT,
759 "gralloc and AHardwareBuffer flags don't match");
760 return usage;
761 }
762
AHardwareBuffer_convertFromGrallocUsageBits(uint64_t usage)763 uint64_t AHardwareBuffer_convertFromGrallocUsageBits(uint64_t usage) {
764 return usage;
765 }
766
AHardwareBuffer_to_GraphicBuffer(const AHardwareBuffer * buffer)767 const GraphicBuffer* AHardwareBuffer_to_GraphicBuffer(const AHardwareBuffer* buffer) {
768 return GraphicBuffer::fromAHardwareBuffer(buffer);
769 }
770
AHardwareBuffer_to_GraphicBuffer(AHardwareBuffer * buffer)771 GraphicBuffer* AHardwareBuffer_to_GraphicBuffer(AHardwareBuffer* buffer) {
772 return GraphicBuffer::fromAHardwareBuffer(buffer);
773 }
774
AHardwareBuffer_to_ANativeWindowBuffer(const AHardwareBuffer * buffer)775 const ANativeWindowBuffer* AHardwareBuffer_to_ANativeWindowBuffer(const AHardwareBuffer* buffer) {
776 return AHardwareBuffer_to_GraphicBuffer(buffer)->getNativeBuffer();
777 }
778
AHardwareBuffer_to_ANativeWindowBuffer(AHardwareBuffer * buffer)779 ANativeWindowBuffer* AHardwareBuffer_to_ANativeWindowBuffer(AHardwareBuffer* buffer) {
780 return AHardwareBuffer_to_GraphicBuffer(buffer)->getNativeBuffer();
781 }
782
AHardwareBuffer_from_GraphicBuffer(GraphicBuffer * buffer)783 AHardwareBuffer* AHardwareBuffer_from_GraphicBuffer(GraphicBuffer* buffer) {
784 return buffer->toAHardwareBuffer();
785 }
786
787 } // namespace android
788