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