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 #define LOG_TAG "AHardwareBuffer"
17
18 #include <android/hardware_buffer.h>
19 #include <vndk/hardware_buffer.h>
20 #include <errno.h>
21 #include <sys/socket.h>
22 #include <memory>
23 #include <cutils/native_handle.h>
24 #include <log/log.h>
25 #include <utils/StrongPointer.h>
26 #include <ui/GraphicBuffer.h>
27 #include <system/graphics.h>
28 #include <system/graphics-base.h>
29 #include <system/graphics-base-v1.0.h>
30 #include <system/graphics-base-v1.1.h>
31 #include <android/AHardwareBufferHelpers.h>
32 // #include <android/hardware/graphics/common/1.1/types.h>
33
34 static constexpr int kFdBufferSize = 128 * sizeof(int); // 128 ints
35 using namespace android;
36
37 void AHardwareBuffer_acquire(AHardwareBuffer* buffer);
38
39 const Rect Rect::INVALID_RECT { (-1), (-1) };
40 const Rect Rect::EMPTY_RECT { 0, 0 };
41
42 // ----------------------------------------------------------------------------
43 // Public functions
44 // ----------------------------------------------------------------------------
AHardwareBuffer_allocate(const AHardwareBuffer_Desc * desc,AHardwareBuffer ** outBuffer)45 int AHardwareBuffer_allocate(const AHardwareBuffer_Desc* desc, AHardwareBuffer** outBuffer) {
46 if (!outBuffer || !desc)
47 return BAD_VALUE;
48 if (!AHardwareBuffer_isValidPixelFormat(desc->format)) {
49 ALOGE("Invalid AHardwareBuffer pixel format %u (%#x))", desc->format, desc->format);
50 return BAD_VALUE;
51 }
52 int format = AHardwareBuffer_convertToPixelFormat(desc->format);
53 if (desc->rfu0 != 0 || desc->rfu1 != 0) {
54 ALOGE("AHardwareBuffer_Desc::rfu fields must be 0");
55 return BAD_VALUE;
56 }
57 if (desc->format == AHARDWAREBUFFER_FORMAT_BLOB && desc->height != 1) {
58 ALOGE("Height must be 1 when using the AHARDWAREBUFFER_FORMAT_BLOB format");
59 return BAD_VALUE;
60 }
61 if ((desc->usage & (AHARDWAREBUFFER_USAGE_CPU_READ_MASK | AHARDWAREBUFFER_USAGE_CPU_WRITE_MASK)) &&
62 (desc->usage & AHARDWAREBUFFER_USAGE_PROTECTED_CONTENT)) {
63 ALOGE("AHARDWAREBUFFER_USAGE_PROTECTED_CONTENT requires AHARDWAREBUFFER_USAGE_CPU_READ_NEVER "
64 "and AHARDWAREBUFFER_USAGE_CPU_WRITE_NEVER");
65 return BAD_VALUE;
66 }
67 uint64_t usage = AHardwareBuffer_convertToGrallocUsageBits(desc->usage);
68 sp<GraphicBuffer> gbuffer(new GraphicBuffer(
69 desc->width, desc->height, format, desc->layers, usage,
70 std::string("AHardwareBuffer pid [") + std::to_string(getpid()) + "]"));
71 status_t err = gbuffer->initCheck();
72 if (err != 0 || gbuffer->handle == 0) {
73 if (err == NO_MEMORY) {
74 GraphicBuffer::dumpAllocationsToSystemLog();
75 }
76 ALOGE("GraphicBuffer(w=%u, h=%u, lc=%u) failed (%s), handle=%p",
77 desc->width, desc->height, desc->layers, strerror(-err), gbuffer->handle);
78 return err;
79 }
80 *outBuffer = AHardwareBuffer_from_GraphicBuffer(gbuffer.get());
81 // Ensure the buffer doesn't get destroyed when the sp<> goes away.
82 AHardwareBuffer_acquire(*outBuffer);
83 return NO_ERROR;
84 }
AHardwareBuffer_acquire(AHardwareBuffer * buffer)85 void AHardwareBuffer_acquire(AHardwareBuffer* buffer) {
86 // incStrong/decStrong token must be the same, doesn't matter what it is
87 AHardwareBuffer_to_GraphicBuffer(buffer)->incStrong((void*)AHardwareBuffer_acquire);
88 }
AHardwareBuffer_release(AHardwareBuffer * buffer)89 void AHardwareBuffer_release(AHardwareBuffer* buffer) {
90 // incStrong/decStrong token must be the same, doesn't matter what it is
91 AHardwareBuffer_to_GraphicBuffer(buffer)->decStrong((void*)AHardwareBuffer_acquire);
92 }
AHardwareBuffer_describe(const AHardwareBuffer * buffer,AHardwareBuffer_Desc * outDesc)93 void AHardwareBuffer_describe(const AHardwareBuffer* buffer,
94 AHardwareBuffer_Desc* outDesc) {
95 if (!buffer || !outDesc) return;
96 const GraphicBuffer* gbuffer = AHardwareBuffer_to_GraphicBuffer(buffer);
97 outDesc->width = gbuffer->getWidth();
98 outDesc->height = gbuffer->getHeight();
99 outDesc->layers = gbuffer->getLayerCount();
100 outDesc->format = AHardwareBuffer_convertFromPixelFormat(uint32_t(gbuffer->getPixelFormat()));
101 outDesc->usage = AHardwareBuffer_convertFromGrallocUsageBits(gbuffer->getUsage());
102 outDesc->stride = gbuffer->getStride();
103 outDesc->rfu0 = 0;
104 outDesc->rfu1 = 0;
105 }
AHardwareBuffer_lock(AHardwareBuffer * buffer,uint64_t usage,int32_t fence,const ARect * rect,void ** outVirtualAddress)106 int AHardwareBuffer_lock(AHardwareBuffer* buffer, uint64_t usage,
107 int32_t fence, const ARect* rect, void** outVirtualAddress) {
108 if (!buffer) return BAD_VALUE;
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 usage = AHardwareBuffer_convertToGrallocUsageBits(usage);
116 GraphicBuffer* gBuffer = AHardwareBuffer_to_GraphicBuffer(buffer);
117 Rect bounds;
118 if (!rect) {
119 bounds.set(Rect(gBuffer->getWidth(), gBuffer->getHeight()));
120 } else {
121 bounds.set(Rect(rect->left, rect->top, rect->right, rect->bottom));
122 }
123 return gBuffer->lockAsync(usage, usage, bounds, outVirtualAddress, fence);
124 }
AHardwareBuffer_unlock(AHardwareBuffer * buffer,int32_t * fence)125 int AHardwareBuffer_unlock(AHardwareBuffer* buffer, int32_t* fence) {
126 if (!buffer) return BAD_VALUE;
127 GraphicBuffer* gBuffer = AHardwareBuffer_to_GraphicBuffer(buffer);
128 if (fence == nullptr)
129 return gBuffer->unlock();
130 else
131 return gBuffer->unlockAsync(fence);
132 }
AHardwareBuffer_sendHandleToUnixSocket(const AHardwareBuffer * buffer,int socketFd)133 int AHardwareBuffer_sendHandleToUnixSocket(const AHardwareBuffer* buffer, int socketFd) {
134 if (!buffer) return BAD_VALUE;
135 const GraphicBuffer* gBuffer = AHardwareBuffer_to_GraphicBuffer(buffer);
136 size_t flattenedSize = gBuffer->getFlattenedSize();
137 size_t fdCount = gBuffer->getFdCount();
138 std::unique_ptr<uint8_t[]> data(new uint8_t[flattenedSize]);
139 std::unique_ptr<int[]> fds(new int[fdCount]);
140 // Make copies of needed items since flatten modifies them, and we don't
141 // want to send anything if there's an error during flatten.
142 size_t flattenedSizeCopy = flattenedSize;
143 size_t fdCountCopy = fdCount;
144 void* dataStart = data.get();
145 int* fdsStart = fds.get();
146 status_t err = gBuffer->flatten(dataStart, flattenedSizeCopy, fdsStart,
147 fdCountCopy);
148 if (err != NO_ERROR) {
149 return err;
150 }
151 struct iovec iov[1];
152 iov[0].iov_base = data.get();
153 iov[0].iov_len = flattenedSize;
154 char buf[CMSG_SPACE(kFdBufferSize)];
155 struct msghdr msg = {
156 .msg_iov = &iov[0],
157 .msg_iovlen = 1,
158 .msg_control = buf,
159 .msg_controllen = sizeof(buf),
160 };
161 struct cmsghdr* cmsg = CMSG_FIRSTHDR(&msg);
162 cmsg->cmsg_level = SOL_SOCKET;
163 cmsg->cmsg_type = SCM_RIGHTS;
164 cmsg->cmsg_len = CMSG_LEN(sizeof(int) * fdCount);
165 int* fdData = reinterpret_cast<int*>(CMSG_DATA(cmsg));
166 memcpy(fdData, fds.get(), sizeof(int) * fdCount);
167 msg.msg_controllen = cmsg->cmsg_len;
168 int result;
169 do {
170 result = sendmsg(socketFd, &msg, 0);
171 } while (result == -1 && errno == EINTR);
172 if (result == -1) {
173 result = errno;
174 ALOGE("Error writing AHardwareBuffer to socket: error %#x (%s)",
175 result, strerror(result));
176 return -result;
177 }
178 return NO_ERROR;
179 }
AHardwareBuffer_recvHandleFromUnixSocket(int socketFd,AHardwareBuffer ** outBuffer)180 int AHardwareBuffer_recvHandleFromUnixSocket(int socketFd, AHardwareBuffer** outBuffer) {
181 if (!outBuffer) return BAD_VALUE;
182 static constexpr int kMessageBufferSize = 4096 * sizeof(int);
183 std::unique_ptr<char[]> dataBuf(new char[kMessageBufferSize]);
184 char fdBuf[CMSG_SPACE(kFdBufferSize)];
185 struct iovec iov[1];
186 iov[0].iov_base = dataBuf.get();
187 iov[0].iov_len = kMessageBufferSize;
188 struct msghdr msg = {
189 .msg_iov = &iov[0],
190 .msg_iovlen = 1,
191 .msg_control = fdBuf,
192 .msg_controllen = sizeof(fdBuf),
193 };
194 int result;
195 do {
196 result = recvmsg(socketFd, &msg, 0);
197 } while (result == -1 && errno == EINTR);
198 if (result == -1) {
199 result = errno;
200 ALOGE("Error reading AHardwareBuffer from socket: error %#x (%s)",
201 result, strerror(result));
202 return -result;
203 }
204 if (msg.msg_iovlen != 1) {
205 ALOGE("Error reading AHardwareBuffer from socket: bad data length");
206 return INVALID_OPERATION;
207 }
208 if (msg.msg_controllen % sizeof(int) != 0) {
209 ALOGE("Error reading AHardwareBuffer from socket: bad fd length");
210 return INVALID_OPERATION;
211 }
212 size_t dataLen = msg.msg_iov[0].iov_len;
213 const void* data = static_cast<const void*>(msg.msg_iov[0].iov_base);
214 if (!data) {
215 ALOGE("Error reading AHardwareBuffer from socket: no buffer data");
216 return INVALID_OPERATION;
217 }
218 struct cmsghdr* cmsg = CMSG_FIRSTHDR(&msg);
219 if (!cmsg) {
220 ALOGE("Error reading AHardwareBuffer from socket: no fd header");
221 return INVALID_OPERATION;
222 }
223 size_t fdCount = msg.msg_controllen >> 2;
224 const int* fdData = reinterpret_cast<const int*>(CMSG_DATA(cmsg));
225 if (!fdData) {
226 ALOGE("Error reading AHardwareBuffer from socket: no fd data");
227 return INVALID_OPERATION;
228 }
229 GraphicBuffer* gBuffer = new GraphicBuffer();
230 status_t err = gBuffer->unflatten(data, dataLen, fdData, fdCount);
231 if (err != NO_ERROR) {
232 return err;
233 }
234 *outBuffer = AHardwareBuffer_from_GraphicBuffer(gBuffer);
235 // Ensure the buffer has a positive ref-count.
236 AHardwareBuffer_acquire(*outBuffer);
237 return NO_ERROR;
238 }
239 // ----------------------------------------------------------------------------
240 // VNDK functions
241 // ----------------------------------------------------------------------------
AHardwareBuffer_getNativeHandle(const AHardwareBuffer * buffer)242 const native_handle_t* AHardwareBuffer_getNativeHandle(
243 const AHardwareBuffer* buffer) {
244 if (!buffer) return nullptr;
245 const GraphicBuffer* gbuffer = AHardwareBuffer_to_GraphicBuffer(buffer);
246 return gbuffer->handle;
247 }
AHardwareBuffer_createFromHandle(const AHardwareBuffer_Desc * desc,const native_handle_t * handle,int32_t method,AHardwareBuffer ** outBuffer)248 int AHardwareBuffer_createFromHandle(const AHardwareBuffer_Desc* desc,
249 const native_handle_t* handle, int32_t method,
250 AHardwareBuffer** outBuffer) {
251 static_assert(static_cast<int32_t>(AHARDWAREBUFFER_CREATE_FROM_HANDLE_METHOD_REGISTER) ==
252 static_cast<int32_t>(GraphicBuffer::TAKE_UNREGISTERED_HANDLE),
253 "AHARDWAREBUFFER_CREATE_FROM_HANDLE_METHOD_REGISTER does not match "
254 "GraphicBuffer::TAKE_UNREGISTERED_HANDLE");
255 static_assert(static_cast<int32_t>(AHARDWAREBUFFER_CREATE_FROM_HANDLE_METHOD_CLONE) ==
256 static_cast<int32_t>(GraphicBuffer::CLONE_HANDLE),
257 "AHARDWAREBUFFER_CREATE_FROM_HANDLE_METHOD_CLONE does not match "
258 "GraphicBuffer::CLONE_HANDLE");
259 if (!desc || !handle || !outBuffer) return BAD_VALUE;
260 if (!(method == AHARDWAREBUFFER_CREATE_FROM_HANDLE_METHOD_REGISTER ||
261 method == AHARDWAREBUFFER_CREATE_FROM_HANDLE_METHOD_CLONE))
262 return BAD_VALUE;
263 if (desc->rfu0 != 0 || desc->rfu1 != 0) return BAD_VALUE;
264 if (desc->format == AHARDWAREBUFFER_FORMAT_BLOB && desc->height != 1) return BAD_VALUE;
265 const int format = AHardwareBuffer_convertToPixelFormat(desc->format);
266 const uint64_t usage = AHardwareBuffer_convertToGrallocUsageBits(desc->usage);
267 const auto wrapMethod = static_cast<GraphicBuffer::HandleWrapMethod>(method);
268 sp<GraphicBuffer> gbuffer(new GraphicBuffer(handle, wrapMethod, desc->width, desc->height,
269 format, desc->layers, usage, desc->stride));
270 status_t err = gbuffer->initCheck();
271 if (err != 0 || gbuffer->handle == 0) return err;
272 *outBuffer = AHardwareBuffer_from_GraphicBuffer(gbuffer.get());
273 // Ensure the buffer doesn't get destroyed when the sp<> goes away.
274 AHardwareBuffer_acquire(*outBuffer);
275 return NO_ERROR;
276 }
277 // ----------------------------------------------------------------------------
278 // Helpers implementation
279 // ----------------------------------------------------------------------------
280 namespace android {
281 // A 1:1 mapping of AHardwaqreBuffer bitmasks to gralloc1 bitmasks.
282 struct UsageMaskMapping {
283 uint64_t hardwareBufferMask;
284 uint64_t grallocMask;
285 };
containsBits(uint64_t mask,uint64_t bitsToCheck)286 static inline bool containsBits(uint64_t mask, uint64_t bitsToCheck) {
287 return (mask & bitsToCheck) == bitsToCheck && bitsToCheck;
288 }
AHardwareBuffer_isValidPixelFormat(uint32_t format)289 bool AHardwareBuffer_isValidPixelFormat(uint32_t format) {
290 // static_assert(HAL_PIXEL_FORMAT_RGBA_8888 == AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM,
291 // "HAL and AHardwareBuffer pixel format don't match");
292 // static_assert(HAL_PIXEL_FORMAT_RGBX_8888 == AHARDWAREBUFFER_FORMAT_R8G8B8X8_UNORM,
293 // "HAL and AHardwareBuffer pixel format don't match");
294 // static_assert(HAL_PIXEL_FORMAT_RGB_565 == AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM,
295 // "HAL and AHardwareBuffer pixel format don't match");
296 // static_assert(HAL_PIXEL_FORMAT_RGB_888 == AHARDWAREBUFFER_FORMAT_R8G8B8_UNORM,
297 // "HAL and AHardwareBuffer pixel format don't match");
298 // static_assert(HAL_PIXEL_FORMAT_RGBA_FP16 == AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT,
299 // "HAL and AHardwareBuffer pixel format don't match");
300 // static_assert(HAL_PIXEL_FORMAT_RGBA_1010102 == AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM,
301 // "HAL and AHardwareBuffer pixel format don't match");
302 // static_assert(HAL_PIXEL_FORMAT_BLOB == AHARDWAREBUFFER_FORMAT_BLOB,
303 // "HAL and AHardwareBuffer pixel format don't match");
304 // static_assert(HAL_PIXEL_FORMAT_DEPTH_16 == AHARDWAREBUFFER_FORMAT_D16_UNORM,
305 // "HAL and AHardwareBuffer pixel format don't match");
306 // static_assert(HAL_PIXEL_FORMAT_DEPTH_24 == AHARDWAREBUFFER_FORMAT_D24_UNORM,
307 // "HAL and AHardwareBuffer pixel format don't match");
308 // static_assert(HAL_PIXEL_FORMAT_DEPTH_24_STENCIL_8 == AHARDWAREBUFFER_FORMAT_D24_UNORM_S8_UINT,
309 // "HAL and AHardwareBuffer pixel format don't match");
310 // static_assert(HAL_PIXEL_FORMAT_DEPTH_32F == AHARDWAREBUFFER_FORMAT_D32_FLOAT,
311 // "HAL and AHardwareBuffer pixel format don't match");
312 // static_assert(HAL_PIXEL_FORMAT_DEPTH_32F_STENCIL_8 == AHARDWAREBUFFER_FORMAT_D32_FLOAT_S8_UINT,
313 // "HAL and AHardwareBuffer pixel format don't match");
314 // static_assert(HAL_PIXEL_FORMAT_STENCIL_8 == AHARDWAREBUFFER_FORMAT_S8_UINT,
315 // "HAL and AHardwareBuffer pixel format don't match");
316 // static_assert(HAL_PIXEL_FORMAT_BGRA_8888 == AHARDWAREBUFFER_FORMAT_B8G8R8A8_UNORM,
317 // "HAL and AHardwareBuffer pixel format don't match");
318 // static_assert(HAL_PIXEL_FORMAT_YV12 == AHARDWAREBUFFER_FORMAT_YV12,
319 // "HAL and AHardwareBuffer pixel format don't match");
320 // static_assert(HAL_PIXEL_FORMAT_Y8 == AHARDWAREBUFFER_FORMAT_Y8,
321 // "HAL and AHardwareBuffer pixel format don't match");
322 // static_assert(HAL_PIXEL_FORMAT_Y16 == AHARDWAREBUFFER_FORMAT_Y16,
323 // "HAL and AHardwareBuffer pixel format don't match");
324 // static_assert(HAL_PIXEL_FORMAT_RAW16 == AHARDWAREBUFFER_FORMAT_RAW16,
325 // "HAL and AHardwareBuffer pixel format don't match");
326 // static_assert(HAL_PIXEL_FORMAT_RAW10 == AHARDWAREBUFFER_FORMAT_RAW10,
327 // "HAL and AHardwareBuffer pixel format don't match");
328 // static_assert(HAL_PIXEL_FORMAT_RAW12 == AHARDWAREBUFFER_FORMAT_RAW12,
329 // "HAL and AHardwareBuffer pixel format don't match");
330 // static_assert(HAL_PIXEL_FORMAT_RAW_OPAQUE == AHARDWAREBUFFER_FORMAT_RAW_OPAQUE,
331 // "HAL and AHardwareBuffer pixel format don't match");
332 // static_assert(HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED == AHARDWAREBUFFER_FORMAT_IMPLEMENTATION_DEFINED,
333 // "HAL and AHardwareBuffer pixel format don't match");
334 // static_assert(HAL_PIXEL_FORMAT_YCBCR_420_888 == AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_420,
335 // "HAL and AHardwareBuffer pixel format don't match");
336 // static_assert(HAL_PIXEL_FORMAT_YCBCR_422_SP == AHARDWAREBUFFER_FORMAT_YCbCr_422_SP,
337 // "HAL and AHardwareBuffer pixel format don't match");
338 // static_assert(HAL_PIXEL_FORMAT_YCRCB_420_SP == AHARDWAREBUFFER_FORMAT_YCrCb_420_SP,
339 // "HAL and AHardwareBuffer pixel format don't match");
340 // static_assert(HAL_PIXEL_FORMAT_YCBCR_422_I == AHARDWAREBUFFER_FORMAT_YCbCr_422_I,
341 // "HAL and AHardwareBuffer pixel format don't match");
342 switch (format) {
343 case AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM:
344 case AHARDWAREBUFFER_FORMAT_R8G8B8X8_UNORM:
345 case AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM:
346 case AHARDWAREBUFFER_FORMAT_R8G8B8_UNORM:
347 case AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT:
348 case AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM:
349 case AHARDWAREBUFFER_FORMAT_BLOB:
350 case AHARDWAREBUFFER_FORMAT_D16_UNORM:
351 case AHARDWAREBUFFER_FORMAT_D24_UNORM:
352 case AHARDWAREBUFFER_FORMAT_D24_UNORM_S8_UINT:
353 case AHARDWAREBUFFER_FORMAT_D32_FLOAT:
354 case AHARDWAREBUFFER_FORMAT_D32_FLOAT_S8_UINT:
355 case AHARDWAREBUFFER_FORMAT_S8_UINT:
356 // VNDK formats only -- unfortunately we can't differentiate from where we're called
357 case AHARDWAREBUFFER_FORMAT_B8G8R8A8_UNORM:
358 case AHARDWAREBUFFER_FORMAT_YV12:
359 case AHARDWAREBUFFER_FORMAT_Y8:
360 case AHARDWAREBUFFER_FORMAT_Y16:
361 case AHARDWAREBUFFER_FORMAT_RAW16:
362 case AHARDWAREBUFFER_FORMAT_RAW10:
363 case AHARDWAREBUFFER_FORMAT_RAW12:
364 case AHARDWAREBUFFER_FORMAT_RAW_OPAQUE:
365 case AHARDWAREBUFFER_FORMAT_IMPLEMENTATION_DEFINED:
366 case AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_420:
367 case AHARDWAREBUFFER_FORMAT_YCbCr_422_SP:
368 case AHARDWAREBUFFER_FORMAT_YCrCb_420_SP:
369 case AHARDWAREBUFFER_FORMAT_YCbCr_422_I:
370 return true;
371 default:
372 return false;
373 }
374 }
AHardwareBuffer_convertFromPixelFormat(uint32_t hal_format)375 uint32_t AHardwareBuffer_convertFromPixelFormat(uint32_t hal_format) {
376 return hal_format;
377 }
AHardwareBuffer_convertToPixelFormat(uint32_t ahardwarebuffer_format)378 uint32_t AHardwareBuffer_convertToPixelFormat(uint32_t ahardwarebuffer_format) {
379 return ahardwarebuffer_format;
380 }
AHardwareBuffer_convertToGrallocUsageBits(uint64_t usage)381 uint64_t AHardwareBuffer_convertToGrallocUsageBits(uint64_t usage) {
382 // using android::hardware::graphics::common::V1_1::BufferUsage;
383 // static_assert(AHARDWAREBUFFER_USAGE_CPU_READ_NEVER == (uint64_t)BufferUsage::CPU_READ_NEVER,
384 // "gralloc and AHardwareBuffer flags don't match");
385 // static_assert(AHARDWAREBUFFER_USAGE_CPU_READ_RARELY == (uint64_t)BufferUsage::CPU_READ_RARELY,
386 // "gralloc and AHardwareBuffer flags don't match");
387 // static_assert(AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN == (uint64_t)BufferUsage::CPU_READ_OFTEN,
388 // "gralloc and AHardwareBuffer flags don't match");
389 // static_assert(AHARDWAREBUFFER_USAGE_CPU_WRITE_NEVER == (uint64_t)BufferUsage::CPU_WRITE_NEVER,
390 // "gralloc and AHardwareBuffer flags don't match");
391 // static_assert(AHARDWAREBUFFER_USAGE_CPU_WRITE_RARELY == (uint64_t)BufferUsage::CPU_WRITE_RARELY,
392 // "gralloc and AHardwareBuffer flags don't match");
393 // static_assert(AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN == (uint64_t)BufferUsage::CPU_WRITE_OFTEN,
394 // "gralloc and AHardwareBuffer flags don't match");
395 // static_assert(AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE == (uint64_t)BufferUsage::GPU_TEXTURE,
396 // "gralloc and AHardwareBuffer flags don't match");
397 // static_assert(AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT == (uint64_t)BufferUsage::GPU_RENDER_TARGET,
398 // "gralloc and AHardwareBuffer flags don't match");
399 // static_assert(AHARDWAREBUFFER_USAGE_PROTECTED_CONTENT == (uint64_t)BufferUsage::PROTECTED,
400 // "gralloc and AHardwareBuffer flags don't match");
401 // static_assert(AHARDWAREBUFFER_USAGE_VIDEO_ENCODE == (uint64_t)BufferUsage::VIDEO_ENCODER,
402 // "gralloc and AHardwareBuffer flags don't match");
403 // static_assert(AHARDWAREBUFFER_USAGE_GPU_DATA_BUFFER == (uint64_t)BufferUsage::GPU_DATA_BUFFER,
404 // "gralloc and AHardwareBuffer flags don't match");
405 // static_assert(AHARDWAREBUFFER_USAGE_SENSOR_DIRECT_DATA == (uint64_t)BufferUsage::SENSOR_DIRECT_DATA,
406 // "gralloc and AHardwareBuffer flags don't match");
407 // static_assert(AHARDWAREBUFFER_USAGE_GPU_CUBE_MAP == (uint64_t)BufferUsage::GPU_CUBE_MAP,
408 // "gralloc and AHardwareBuffer flags don't match");
409 // static_assert(AHARDWAREBUFFER_USAGE_GPU_MIPMAP_COMPLETE == (uint64_t)BufferUsage::GPU_MIPMAP_COMPLETE,
410 // "gralloc and AHardwareBuffer flags don't match");
411 return usage;
412 }
AHardwareBuffer_convertFromGrallocUsageBits(uint64_t usage)413 uint64_t AHardwareBuffer_convertFromGrallocUsageBits(uint64_t usage) {
414 return usage;
415 }
AHardwareBuffer_to_GraphicBuffer(const AHardwareBuffer * buffer)416 const GraphicBuffer* AHardwareBuffer_to_GraphicBuffer(const AHardwareBuffer* buffer) {
417 return reinterpret_cast<const GraphicBuffer*>(buffer);
418 }
AHardwareBuffer_to_GraphicBuffer(AHardwareBuffer * buffer)419 GraphicBuffer* AHardwareBuffer_to_GraphicBuffer(AHardwareBuffer* buffer) {
420 return reinterpret_cast<GraphicBuffer*>(buffer);
421 }
AHardwareBuffer_to_ANativeWindowBuffer(const AHardwareBuffer * buffer)422 const ANativeWindowBuffer* AHardwareBuffer_to_ANativeWindowBuffer(const AHardwareBuffer* buffer) {
423 return AHardwareBuffer_to_GraphicBuffer(buffer)->getNativeBuffer();
424 }
AHardwareBuffer_to_ANativeWindowBuffer(AHardwareBuffer * buffer)425 ANativeWindowBuffer* AHardwareBuffer_to_ANativeWindowBuffer(AHardwareBuffer* buffer) {
426 return AHardwareBuffer_to_GraphicBuffer(buffer)->getNativeBuffer();
427 }
AHardwareBuffer_from_GraphicBuffer(GraphicBuffer * buffer)428 AHardwareBuffer* AHardwareBuffer_from_GraphicBuffer(GraphicBuffer* buffer) {
429 return reinterpret_cast<AHardwareBuffer*>(buffer);
430 }
431
432 } // namespace android
433