AHardwareBuffer.cpp revision ec3717413332336c7b86545eebcfce8c0681b2dc 
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#include <hardware/gralloc1.h>
31#include <grallocusage/GrallocUsageConversion.h>
32
33#include <private/android/AHardwareBufferHelpers.h>
34
35
36static constexpr int kFdBufferSize = 128 * sizeof(int);  // 128 ints
37
38using namespace android;
39
40// ----------------------------------------------------------------------------
41// Public functions
42// ----------------------------------------------------------------------------
43
44int AHardwareBuffer_allocate(const AHardwareBuffer_Desc* desc, AHardwareBuffer** outBuffer) {
45    if (!outBuffer || !desc)
46        return BAD_VALUE;
47
48    int format = AHardwareBuffer_convertToPixelFormat(desc->format);
49    if (format == 0) {
50        ALOGE("Invalid pixel format %u", desc->format);
51        return BAD_VALUE;
52    }
53
54    if (desc->format == AHARDWAREBUFFER_FORMAT_BLOB && desc->height != 1) {
55        ALOGE("Height must be 1 when using the AHARDWAREBUFFER_FORMAT_BLOB format");
56        return BAD_VALUE;
57    }
58
59    uint64_t producerUsage = 0;
60    uint64_t consumerUsage = 0;
61    AHardwareBuffer_convertToGrallocUsageBits(&producerUsage, &consumerUsage, desc->usage0,
62            desc->usage1);
63
64    sp<GraphicBuffer> gbuffer(new GraphicBuffer(
65            desc->width, desc->height, format, desc->layers, producerUsage, consumerUsage,
66            std::string("AHardwareBuffer pid [") + std::to_string(getpid()) + "]"));
67
68    status_t err = gbuffer->initCheck();
69    if (err != 0 || gbuffer->handle == 0) {
70        if (err == NO_MEMORY) {
71            GraphicBuffer::dumpAllocationsToSystemLog();
72        }
73        ALOGE("GraphicBuffer(w=%u, h=%u, lc=%u) failed (%s), handle=%p",
74                desc->width, desc->height, desc->layers, strerror(-err), gbuffer->handle);
75        return err;
76    }
77
78    *outBuffer = AHardwareBuffer_from_GraphicBuffer(gbuffer.get());
79
80    // Ensure the buffer doesn't get destroyed when the sp<> goes away.
81    AHardwareBuffer_acquire(*outBuffer);
82    return NO_ERROR;
83}
84
85void 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}
89
90void AHardwareBuffer_release(AHardwareBuffer* buffer) {
91    // incStrong/decStrong token must be the same, doesn't matter what it is
92    AHardwareBuffer_to_GraphicBuffer(buffer)->decStrong((void*)AHardwareBuffer_acquire);
93}
94
95void AHardwareBuffer_describe(const AHardwareBuffer* buffer,
96        AHardwareBuffer_Desc* outDesc) {
97    if (!buffer || !outDesc) return;
98
99    const GraphicBuffer* gbuffer = AHardwareBuffer_to_GraphicBuffer(buffer);
100
101    outDesc->width = gbuffer->getWidth();
102    outDesc->height = gbuffer->getHeight();
103    outDesc->layers = gbuffer->getLayerCount();
104
105    uint64_t producerUsage = 0;
106    uint64_t consumerUsage = 0;
107    android_convertGralloc0To1Usage(gbuffer->getUsage(), &producerUsage, &consumerUsage);
108    AHardwareBuffer_convertFromGrallocUsageBits(&outDesc->usage0, &outDesc->usage1,
109            producerUsage, consumerUsage);
110    outDesc->format = AHardwareBuffer_convertFromPixelFormat(
111            static_cast<uint32_t>(gbuffer->getPixelFormat()));
112}
113
114int AHardwareBuffer_lock(AHardwareBuffer* buffer, uint64_t usage0,
115        int32_t fence, const ARect* rect, void** outVirtualAddress) {
116    if (!buffer) return BAD_VALUE;
117
118    if (usage0 & ~(AHARDWAREBUFFER_USAGE0_CPU_READ_OFTEN |
119                   AHARDWAREBUFFER_USAGE0_CPU_WRITE_OFTEN)) {
120        ALOGE("Invalid usage flags passed to AHardwareBuffer_lock; only "
121                " AHARDWAREBUFFER_USAGE0_CPU_* flags are allowed");
122        return BAD_VALUE;
123    }
124
125    uint64_t producerUsage = 0;
126    uint64_t consumerUsage = 0;
127    AHardwareBuffer_convertToGrallocUsageBits(&producerUsage, &consumerUsage, usage0, 0);
128    GraphicBuffer* gBuffer = AHardwareBuffer_to_GraphicBuffer(buffer);
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    return gBuffer->lockAsync(producerUsage, consumerUsage, bounds,
136            outVirtualAddress, fence);
137}
138
139int AHardwareBuffer_unlock(AHardwareBuffer* buffer, int32_t* fence) {
140    if (!buffer) return BAD_VALUE;
141
142    GraphicBuffer* gBuffer = AHardwareBuffer_to_GraphicBuffer(buffer);
143    return gBuffer->unlockAsync(fence);
144}
145
146int AHardwareBuffer_sendHandleToUnixSocket(const AHardwareBuffer* buffer, int socketFd) {
147    if (!buffer) return BAD_VALUE;
148    const GraphicBuffer* gBuffer = AHardwareBuffer_to_GraphicBuffer(buffer);
149
150    size_t flattenedSize = gBuffer->getFlattenedSize();
151    size_t fdCount = gBuffer->getFdCount();
152
153    std::unique_ptr<uint8_t[]> data(new uint8_t[flattenedSize]);
154    std::unique_ptr<int[]> fds(new int[fdCount]);
155
156    // Make copies of needed items since flatten modifies them, and we don't
157    // want to send anything if there's an error during flatten.
158    size_t flattenedSizeCopy = flattenedSize;
159    size_t fdCountCopy = fdCount;
160    void* dataStart = data.get();
161    int* fdsStart = fds.get();
162    status_t err = gBuffer->flatten(dataStart, flattenedSizeCopy, fdsStart,
163            fdCountCopy);
164    if (err != NO_ERROR) {
165        return err;
166    }
167
168    struct iovec iov[1];
169    iov[0].iov_base = data.get();
170    iov[0].iov_len = flattenedSize;
171
172    char buf[CMSG_SPACE(kFdBufferSize)];
173    struct msghdr msg = {
174            .msg_control = buf,
175            .msg_controllen = sizeof(buf),
176            .msg_iov = &iov[0],
177            .msg_iovlen = 1,
178    };
179
180    struct cmsghdr* cmsg = CMSG_FIRSTHDR(&msg);
181    cmsg->cmsg_level = SOL_SOCKET;
182    cmsg->cmsg_type = SCM_RIGHTS;
183    cmsg->cmsg_len = CMSG_LEN(sizeof(int) * fdCount);
184    int* fdData = reinterpret_cast<int*>(CMSG_DATA(cmsg));
185    memcpy(fdData, fds.get(), sizeof(int) * fdCount);
186    msg.msg_controllen = cmsg->cmsg_len;
187
188    int result = sendmsg(socketFd, &msg, 0);
189    if (result <= 0) {
190        ALOGE("Error writing AHardwareBuffer to socket: error %#x (%s)",
191                result, strerror(errno));
192        return result;
193    }
194    return NO_ERROR;
195}
196
197int AHardwareBuffer_recvHandleFromUnixSocket(int socketFd, AHardwareBuffer** outBuffer) {
198    if (!outBuffer) return BAD_VALUE;
199
200    static constexpr int kMessageBufferSize = 4096 * sizeof(int);
201
202    std::unique_ptr<char[]> dataBuf(new char[kMessageBufferSize]);
203    char fdBuf[CMSG_SPACE(kFdBufferSize)];
204    struct iovec iov[1];
205    iov[0].iov_base = dataBuf.get();
206    iov[0].iov_len = kMessageBufferSize;
207
208    struct msghdr msg = {
209            .msg_control = fdBuf,
210            .msg_controllen = sizeof(fdBuf),
211            .msg_iov = &iov[0],
212            .msg_iovlen = 1,
213    };
214
215    int result = recvmsg(socketFd, &msg, 0);
216    if (result <= 0) {
217        ALOGE("Error reading AHardwareBuffer from socket: error %#x (%s)",
218                result, strerror(errno));
219        return result;
220    }
221
222    if (msg.msg_iovlen != 1) {
223        ALOGE("Error reading AHardwareBuffer from socket: bad data length");
224        return INVALID_OPERATION;
225    }
226
227    if (msg.msg_controllen % sizeof(int) != 0) {
228        ALOGE("Error reading AHardwareBuffer from socket: bad fd length");
229        return INVALID_OPERATION;
230    }
231
232    size_t dataLen = msg.msg_iov[0].iov_len;
233    const void* data = static_cast<const void*>(msg.msg_iov[0].iov_base);
234    if (!data) {
235        ALOGE("Error reading AHardwareBuffer from socket: no buffer data");
236        return INVALID_OPERATION;
237    }
238
239    struct cmsghdr* cmsg = CMSG_FIRSTHDR(&msg);
240    if (!cmsg) {
241        ALOGE("Error reading AHardwareBuffer from socket: no fd header");
242        return INVALID_OPERATION;
243    }
244
245    size_t fdCount = msg.msg_controllen >> 2;
246    const int* fdData = reinterpret_cast<const int*>(CMSG_DATA(cmsg));
247    if (!fdData) {
248        ALOGE("Error reading AHardwareBuffer from socket: no fd data");
249        return INVALID_OPERATION;
250    }
251
252    GraphicBuffer* gBuffer = new GraphicBuffer();
253    status_t err = gBuffer->unflatten(data, dataLen, fdData, fdCount);
254    if (err != NO_ERROR) {
255        return err;
256    }
257    *outBuffer = AHardwareBuffer_from_GraphicBuffer(gBuffer);
258    // Ensure the buffer has a positive ref-count.
259    AHardwareBuffer_acquire(*outBuffer);
260
261    return NO_ERROR;
262}
263
264
265// ----------------------------------------------------------------------------
266// VNDK functions
267// ----------------------------------------------------------------------------
268
269const native_handle_t* AHardwareBuffer_getNativeHandle(
270        const AHardwareBuffer* buffer) {
271    if (!buffer) return nullptr;
272    const GraphicBuffer* gbuffer = AHardwareBuffer_to_GraphicBuffer(buffer);
273    return gbuffer->handle;
274}
275
276
277// ----------------------------------------------------------------------------
278// Helpers implementation
279// ----------------------------------------------------------------------------
280
281namespace android {
282
283// A 1:1 mapping of AHardwaqreBuffer bitmasks to gralloc1 bitmasks.
284struct UsageMaskMapping {
285    uint64_t hardwareBufferMask;
286    uint64_t grallocMask;
287};
288
289static constexpr UsageMaskMapping kUsage0ProducerMapping[] = {
290    { AHARDWAREBUFFER_USAGE0_CPU_WRITE, GRALLOC1_PRODUCER_USAGE_CPU_WRITE },
291    { AHARDWAREBUFFER_USAGE0_CPU_WRITE_OFTEN, GRALLOC1_PRODUCER_USAGE_CPU_WRITE_OFTEN },
292    { AHARDWAREBUFFER_USAGE0_GPU_COLOR_OUTPUT, GRALLOC1_PRODUCER_USAGE_GPU_RENDER_TARGET },
293    { AHARDWAREBUFFER_USAGE0_PROTECTED_CONTENT, GRALLOC1_PRODUCER_USAGE_PROTECTED },
294    { AHARDWAREBUFFER_USAGE0_SENSOR_DIRECT_DATA, GRALLOC1_PRODUCER_USAGE_SENSOR_DIRECT_DATA },
295};
296
297static constexpr UsageMaskMapping kUsage1ProducerMapping[] = {
298    { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_0, GRALLOC1_PRODUCER_USAGE_PRIVATE_0 },
299    { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_1, GRALLOC1_PRODUCER_USAGE_PRIVATE_1 },
300    { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_2, GRALLOC1_PRODUCER_USAGE_PRIVATE_2 },
301    { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_3, GRALLOC1_PRODUCER_USAGE_PRIVATE_3 },
302    { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_4, GRALLOC1_PRODUCER_USAGE_PRIVATE_4 },
303    { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_5, GRALLOC1_PRODUCER_USAGE_PRIVATE_5 },
304    { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_6, GRALLOC1_PRODUCER_USAGE_PRIVATE_6 },
305    { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_7, GRALLOC1_PRODUCER_USAGE_PRIVATE_7 },
306    { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_8, GRALLOC1_PRODUCER_USAGE_PRIVATE_8 },
307    { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_9, GRALLOC1_PRODUCER_USAGE_PRIVATE_9 },
308    { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_10, GRALLOC1_PRODUCER_USAGE_PRIVATE_10 },
309    { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_11, GRALLOC1_PRODUCER_USAGE_PRIVATE_11 },
310    { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_12, GRALLOC1_PRODUCER_USAGE_PRIVATE_12 },
311    { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_13, GRALLOC1_PRODUCER_USAGE_PRIVATE_13 },
312    { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_14, GRALLOC1_PRODUCER_USAGE_PRIVATE_14 },
313    { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_15, GRALLOC1_PRODUCER_USAGE_PRIVATE_15 },
314    { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_16, GRALLOC1_PRODUCER_USAGE_PRIVATE_16 },
315    { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_17, GRALLOC1_PRODUCER_USAGE_PRIVATE_17 },
316    { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_18, GRALLOC1_PRODUCER_USAGE_PRIVATE_18 },
317    { AHARDWAREBUFFER_USAGE1_PRODUCER_PRIVATE_19, GRALLOC1_PRODUCER_USAGE_PRIVATE_19 },
318};
319
320static constexpr UsageMaskMapping kUsage0ConsumerMapping[] = {
321    { AHARDWAREBUFFER_USAGE0_CPU_READ, GRALLOC1_CONSUMER_USAGE_CPU_READ },
322    { AHARDWAREBUFFER_USAGE0_CPU_READ_OFTEN, GRALLOC1_CONSUMER_USAGE_CPU_READ_OFTEN },
323    { AHARDWAREBUFFER_USAGE0_GPU_SAMPLED_IMAGE, GRALLOC1_CONSUMER_USAGE_GPU_TEXTURE },
324    { AHARDWAREBUFFER_USAGE0_GPU_DATA_BUFFER, GRALLOC1_CONSUMER_USAGE_GPU_DATA_BUFFER },
325    { AHARDWAREBUFFER_USAGE0_VIDEO_ENCODE, GRALLOC1_CONSUMER_USAGE_VIDEO_ENCODER },
326};
327
328static constexpr UsageMaskMapping kUsage1ConsumerMapping[] = {
329    { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_0, GRALLOC1_CONSUMER_USAGE_PRIVATE_0 },
330    { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_1, GRALLOC1_CONSUMER_USAGE_PRIVATE_1 },
331    { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_2, GRALLOC1_CONSUMER_USAGE_PRIVATE_2 },
332    { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_3, GRALLOC1_CONSUMER_USAGE_PRIVATE_3 },
333    { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_4, GRALLOC1_CONSUMER_USAGE_PRIVATE_4 },
334    { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_5, GRALLOC1_CONSUMER_USAGE_PRIVATE_5 },
335    { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_6, GRALLOC1_CONSUMER_USAGE_PRIVATE_6 },
336    { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_7, GRALLOC1_CONSUMER_USAGE_PRIVATE_7 },
337    { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_8, GRALLOC1_CONSUMER_USAGE_PRIVATE_8 },
338    { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_9, GRALLOC1_CONSUMER_USAGE_PRIVATE_9 },
339    { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_10, GRALLOC1_CONSUMER_USAGE_PRIVATE_10 },
340    { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_11, GRALLOC1_CONSUMER_USAGE_PRIVATE_11 },
341    { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_12, GRALLOC1_CONSUMER_USAGE_PRIVATE_12 },
342    { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_13, GRALLOC1_CONSUMER_USAGE_PRIVATE_13 },
343    { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_14, GRALLOC1_CONSUMER_USAGE_PRIVATE_14 },
344    { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_15, GRALLOC1_CONSUMER_USAGE_PRIVATE_15 },
345    { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_16, GRALLOC1_CONSUMER_USAGE_PRIVATE_16 },
346    { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_17, GRALLOC1_CONSUMER_USAGE_PRIVATE_17 },
347    { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_18, GRALLOC1_CONSUMER_USAGE_PRIVATE_18 },
348    { AHARDWAREBUFFER_USAGE1_CONSUMER_PRIVATE_19, GRALLOC1_CONSUMER_USAGE_PRIVATE_19 },
349};
350
351static inline bool containsBits(uint64_t mask, uint64_t bitsToCheck) {
352    return (mask & bitsToCheck) == bitsToCheck && bitsToCheck;
353}
354
355uint32_t AHardwareBuffer_convertFromPixelFormat(uint32_t format) {
356    switch (format) {
357        case HAL_PIXEL_FORMAT_RGBA_8888:    return AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM;
358        case HAL_PIXEL_FORMAT_RGBX_8888:    return AHARDWAREBUFFER_FORMAT_R8G8B8X8_UNORM;
359        case HAL_PIXEL_FORMAT_RGB_565:      return AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM;
360        case HAL_PIXEL_FORMAT_RGB_888:      return AHARDWAREBUFFER_FORMAT_R8G8B8_UNORM;
361        case HAL_PIXEL_FORMAT_RGBA_FP16:    return AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT;
362        case HAL_PIXEL_FORMAT_RGBA_1010102: return AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM;
363        case HAL_PIXEL_FORMAT_BLOB:         return AHARDWAREBUFFER_FORMAT_BLOB;
364        default:ALOGE("Unknown pixel format %u", format);
365            return 0;
366    }
367}
368
369uint32_t AHardwareBuffer_convertToPixelFormat(uint32_t format) {
370    switch (format) {
371        case AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM:         return HAL_PIXEL_FORMAT_RGBA_8888;
372        case AHARDWAREBUFFER_FORMAT_R8G8B8X8_UNORM:         return HAL_PIXEL_FORMAT_RGBX_8888;
373        case AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM:           return HAL_PIXEL_FORMAT_RGB_565;
374        case AHARDWAREBUFFER_FORMAT_R8G8B8_UNORM:           return HAL_PIXEL_FORMAT_RGB_888;
375        case AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT:     return HAL_PIXEL_FORMAT_RGBA_FP16;
376        case AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM:      return HAL_PIXEL_FORMAT_RGBA_1010102;
377        case AHARDWAREBUFFER_FORMAT_BLOB:                   return HAL_PIXEL_FORMAT_BLOB;
378        default:ALOGE("Unknown AHardwareBuffer format %u", format);
379            return 0;
380    }
381}
382
383void AHardwareBuffer_convertToGrallocUsageBits(uint64_t* outProducerUsage,
384    uint64_t* outConsumerUsage, uint64_t usage0, uint64_t usage1) {
385    *outProducerUsage = 0;
386    *outConsumerUsage = 0;
387    for (const UsageMaskMapping& mapping : kUsage0ProducerMapping) {
388        if (containsBits(usage0, mapping.hardwareBufferMask)) {
389            *outProducerUsage |= mapping.grallocMask;
390        }
391    }
392    for (const UsageMaskMapping& mapping : kUsage1ProducerMapping) {
393        if (containsBits(usage1, mapping.hardwareBufferMask)) {
394            *outProducerUsage |= mapping.grallocMask;
395        }
396    }
397    for (const UsageMaskMapping& mapping : kUsage0ConsumerMapping) {
398        if (containsBits(usage0, mapping.hardwareBufferMask)) {
399            *outConsumerUsage |= mapping.grallocMask;
400        }
401    }
402    for (const UsageMaskMapping& mapping : kUsage1ConsumerMapping) {
403        if (containsBits(usage1, mapping.hardwareBufferMask)) {
404            *outConsumerUsage |= mapping.grallocMask;
405        }
406    }
407}
408
409void AHardwareBuffer_convertFromGrallocUsageBits(uint64_t* outUsage0, uint64_t* outUsage1,
410        uint64_t producerUsage, uint64_t consumerUsage) {
411    *outUsage0 = 0;
412    *outUsage1 = 0;
413    for (const UsageMaskMapping& mapping : kUsage0ProducerMapping) {
414        if (containsBits(producerUsage, mapping.grallocMask)) {
415            *outUsage0 |= mapping.hardwareBufferMask;
416        }
417    }
418    for (const UsageMaskMapping& mapping : kUsage1ProducerMapping) {
419        if (containsBits(producerUsage, mapping.grallocMask)) {
420            *outUsage1 |= mapping.hardwareBufferMask;
421        }
422    }
423    for (const UsageMaskMapping& mapping : kUsage0ConsumerMapping) {
424        if (containsBits(consumerUsage, mapping.grallocMask)) {
425            *outUsage0 |= mapping.hardwareBufferMask;
426        }
427    }
428    for (const UsageMaskMapping& mapping : kUsage1ConsumerMapping) {
429        if (containsBits(consumerUsage, mapping.grallocMask)) {
430            *outUsage1 |= mapping.hardwareBufferMask;
431        }
432    }
433}
434
435const GraphicBuffer* AHardwareBuffer_to_GraphicBuffer(const AHardwareBuffer* buffer) {
436    return reinterpret_cast<const GraphicBuffer*>(buffer);
437}
438
439GraphicBuffer* AHardwareBuffer_to_GraphicBuffer(AHardwareBuffer* buffer) {
440    return reinterpret_cast<GraphicBuffer*>(buffer);
441}
442
443const ANativeWindowBuffer* AHardwareBuffer_to_ANativeWindowBuffer(const AHardwareBuffer* buffer) {
444    return AHardwareBuffer_to_GraphicBuffer(buffer)->getNativeBuffer();
445}
446
447ANativeWindowBuffer* AHardwareBuffer_to_ANativeWindowBuffer(AHardwareBuffer* buffer) {
448    return AHardwareBuffer_to_GraphicBuffer(buffer)->getNativeBuffer();
449}
450
451AHardwareBuffer* AHardwareBuffer_from_GraphicBuffer(GraphicBuffer* buffer) {
452    return reinterpret_cast<AHardwareBuffer*>(buffer);
453}
454
455} // namespace android
456