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