1 /*
2  * Copyright 2016 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 #undef LOG_TAG
18 #define LOG_TAG "Gralloc1On0Adapter"
19 //#define LOG_NDEBUG 0
20 
21 #include "Gralloc1On0Adapter.h"
22 #include "gralloc1-adapter.h"
23 
24 #include <grallocusage/GrallocUsageConversion.h>
25 
26 #include <hardware/gralloc.h>
27 
28 #include <log/log.h>
29 #include <sync/sync.h>
30 
31 #include <inttypes.h>
32 
33 template <typename PFN, typename T>
asFP(T function)34 static gralloc1_function_pointer_t asFP(T function)
35 {
36     static_assert(std::is_same<PFN, T>::value, "Incompatible function pointer");
37     return reinterpret_cast<gralloc1_function_pointer_t>(function);
38 }
39 
40 namespace android {
41 namespace hardware {
42 
Gralloc1On0Adapter(const hw_module_t * module)43 Gralloc1On0Adapter::Gralloc1On0Adapter(const hw_module_t* module)
44   : gralloc1_device_t(),
45     mModule(reinterpret_cast<const gralloc_module_t*>(module)),
46     mDevice(nullptr)
47 {
48     ALOGV("Constructing");
49 
50     int minor = 0;
51     mModule->perform(mModule,
52             GRALLOC1_ADAPTER_PERFORM_GET_REAL_MODULE_API_VERSION_MINOR,
53             &minor);
54     mMinorVersion = minor;
55 
56     common.tag = HARDWARE_DEVICE_TAG,
57     common.version = HARDWARE_DEVICE_API_VERSION(0, 0),
58     common.module = const_cast<struct hw_module_t*>(module),
59     common.close = closeHook,
60 
61     getCapabilities = getCapabilitiesHook;
62     getFunction = getFunctionHook;
63     int error = ::gralloc_open(&(mModule->common), &mDevice);
64     if (error) {
65         ALOGE("Failed to open gralloc0 module: %d", error);
66     }
67     ALOGV("Opened gralloc0 device %p", mDevice);
68 }
69 
~Gralloc1On0Adapter()70 Gralloc1On0Adapter::~Gralloc1On0Adapter()
71 {
72     ALOGV("Destructing");
73     if (mDevice) {
74         ALOGV("Closing gralloc0 device %p", mDevice);
75         ::gralloc_close(mDevice);
76     }
77 }
78 
doGetCapabilities(uint32_t * outCount,int32_t *)79 void Gralloc1On0Adapter::doGetCapabilities(uint32_t* outCount,
80                                            int32_t* /*outCapabilities*/) {
81     *outCount = 0;
82 }
83 
doGetFunction(int32_t intDescriptor)84 gralloc1_function_pointer_t Gralloc1On0Adapter::doGetFunction(
85         int32_t intDescriptor)
86 {
87     constexpr auto lastDescriptor =
88             static_cast<int32_t>(GRALLOC1_LAST_FUNCTION);
89     if (intDescriptor < 0 || intDescriptor > lastDescriptor) {
90         ALOGE("Invalid function descriptor");
91         return nullptr;
92     }
93 
94     auto descriptor =
95             static_cast<gralloc1_function_descriptor_t>(intDescriptor);
96     switch (descriptor) {
97         case GRALLOC1_FUNCTION_DUMP:
98             return asFP<GRALLOC1_PFN_DUMP>(dumpHook);
99         case GRALLOC1_FUNCTION_CREATE_DESCRIPTOR:
100             return asFP<GRALLOC1_PFN_CREATE_DESCRIPTOR>(createDescriptorHook);
101         case GRALLOC1_FUNCTION_DESTROY_DESCRIPTOR:
102             return asFP<GRALLOC1_PFN_DESTROY_DESCRIPTOR>(destroyDescriptorHook);
103         case GRALLOC1_FUNCTION_SET_CONSUMER_USAGE:
104             return asFP<GRALLOC1_PFN_SET_CONSUMER_USAGE>(setConsumerUsageHook);
105         case GRALLOC1_FUNCTION_SET_DIMENSIONS:
106             return asFP<GRALLOC1_PFN_SET_DIMENSIONS>(setDimensionsHook);
107         case GRALLOC1_FUNCTION_SET_FORMAT:
108             return asFP<GRALLOC1_PFN_SET_FORMAT>(setFormatHook);
109         case GRALLOC1_FUNCTION_SET_LAYER_COUNT:
110             return asFP<GRALLOC1_PFN_SET_LAYER_COUNT>(setLayerCountHook);
111         case GRALLOC1_FUNCTION_SET_PRODUCER_USAGE:
112             return asFP<GRALLOC1_PFN_SET_PRODUCER_USAGE>(setProducerUsageHook);
113         case GRALLOC1_FUNCTION_GET_BACKING_STORE:
114             return asFP<GRALLOC1_PFN_GET_BACKING_STORE>(
115                     bufferHook<decltype(&Buffer::getBackingStore),
116                     &Buffer::getBackingStore, gralloc1_backing_store_t*>);
117         case GRALLOC1_FUNCTION_GET_CONSUMER_USAGE:
118             return asFP<GRALLOC1_PFN_GET_CONSUMER_USAGE>(getConsumerUsageHook);
119         case GRALLOC1_FUNCTION_GET_DIMENSIONS:
120             return asFP<GRALLOC1_PFN_GET_DIMENSIONS>(
121                     bufferHook<decltype(&Buffer::getDimensions),
122                     &Buffer::getDimensions, uint32_t*, uint32_t*>);
123         case GRALLOC1_FUNCTION_GET_FORMAT:
124             return asFP<GRALLOC1_PFN_GET_FORMAT>(
125                     bufferHook<decltype(&Buffer::getFormat),
126                     &Buffer::getFormat, int32_t*>);
127         case GRALLOC1_FUNCTION_GET_LAYER_COUNT:
128             return asFP<GRALLOC1_PFN_GET_LAYER_COUNT>(
129                     bufferHook<decltype(&Buffer::getLayerCount),
130                     &Buffer::getLayerCount, uint32_t*>);
131         case GRALLOC1_FUNCTION_GET_PRODUCER_USAGE:
132             return asFP<GRALLOC1_PFN_GET_PRODUCER_USAGE>(getProducerUsageHook);
133         case GRALLOC1_FUNCTION_GET_STRIDE:
134             return asFP<GRALLOC1_PFN_GET_STRIDE>(
135                     bufferHook<decltype(&Buffer::getStride),
136                     &Buffer::getStride, uint32_t*>);
137         case GRALLOC1_FUNCTION_ALLOCATE:
138             if (mDevice != nullptr) {
139                 return asFP<GRALLOC1_PFN_ALLOCATE>(allocateHook);
140             } else {
141                 return nullptr;
142             }
143         case GRALLOC1_FUNCTION_RETAIN:
144             return asFP<GRALLOC1_PFN_RETAIN>(retainHook);
145         case GRALLOC1_FUNCTION_RELEASE:
146             return asFP<GRALLOC1_PFN_RELEASE>(releaseHook);
147         case GRALLOC1_FUNCTION_GET_NUM_FLEX_PLANES:
148             return asFP<GRALLOC1_PFN_GET_NUM_FLEX_PLANES>(
149                     bufferHook<decltype(&Buffer::getNumFlexPlanes),
150                     &Buffer::getNumFlexPlanes, uint32_t*>);
151         case GRALLOC1_FUNCTION_LOCK:
152             return asFP<GRALLOC1_PFN_LOCK>(
153                     lockHook<void*, &Gralloc1On0Adapter::lock>);
154         case GRALLOC1_FUNCTION_LOCK_FLEX:
155             return asFP<GRALLOC1_PFN_LOCK_FLEX>(
156                     lockHook<struct android_flex_layout,
157                     &Gralloc1On0Adapter::lockFlex>);
158         case GRALLOC1_FUNCTION_UNLOCK:
159             return asFP<GRALLOC1_PFN_UNLOCK>(unlockHook);
160         case GRALLOC1_FUNCTION_INVALID:
161             ALOGE("Invalid function descriptor");
162             return nullptr;
163     }
164 
165     ALOGE("Unknown function descriptor: %d", intDescriptor);
166     return nullptr;
167 }
168 
dump(uint32_t * outSize,char * outBuffer)169 void Gralloc1On0Adapter::dump(uint32_t* outSize, char* outBuffer)
170 {
171     ALOGV("dump(%u (%p), %p", outSize ? *outSize : 0, outSize, outBuffer);
172 
173     if (!mDevice->dump) {
174         // dump is optional on gralloc0 implementations
175         *outSize = 0;
176         return;
177     }
178 
179     if (!outBuffer) {
180         constexpr int32_t BUFFER_LENGTH = 4096;
181         char buffer[BUFFER_LENGTH] = {};
182         mDevice->dump(mDevice, buffer, BUFFER_LENGTH);
183         buffer[BUFFER_LENGTH - 1] = 0; // Ensure the buffer is null-terminated
184         size_t actualLength = std::strlen(buffer);
185         mCachedDump.resize(actualLength);
186         std::copy_n(buffer, actualLength, mCachedDump.begin());
187         *outSize = static_cast<uint32_t>(actualLength);
188     } else {
189         *outSize = std::min(*outSize,
190                 static_cast<uint32_t>(mCachedDump.size()));
191         outBuffer = std::copy_n(mCachedDump.cbegin(), *outSize, outBuffer);
192     }
193 }
194 
createDescriptor(gralloc1_buffer_descriptor_t * outDescriptor)195 gralloc1_error_t Gralloc1On0Adapter::createDescriptor(
196         gralloc1_buffer_descriptor_t* outDescriptor)
197 {
198     auto descriptorId = sNextBufferDescriptorId++;
199     std::lock_guard<std::mutex> lock(mDescriptorMutex);
200     mDescriptors.emplace(descriptorId, std::make_shared<Descriptor>());
201 
202     ALOGV("Created descriptor %" PRIu64, descriptorId);
203 
204     *outDescriptor = descriptorId;
205     return GRALLOC1_ERROR_NONE;
206 }
207 
destroyDescriptor(gralloc1_buffer_descriptor_t descriptor)208 gralloc1_error_t Gralloc1On0Adapter::destroyDescriptor(
209         gralloc1_buffer_descriptor_t descriptor)
210 {
211     ALOGV("Destroying descriptor %" PRIu64, descriptor);
212 
213     std::lock_guard<std::mutex> lock(mDescriptorMutex);
214     if (mDescriptors.count(descriptor) == 0) {
215         return GRALLOC1_ERROR_BAD_DESCRIPTOR;
216     }
217 
218     mDescriptors.erase(descriptor);
219     return GRALLOC1_ERROR_NONE;
220 }
221 
Buffer(buffer_handle_t handle,gralloc1_backing_store_t store,const Descriptor & descriptor,uint32_t stride,uint32_t numFlexPlanes,bool wasAllocated)222 Gralloc1On0Adapter::Buffer::Buffer(buffer_handle_t handle,
223         gralloc1_backing_store_t store, const Descriptor& descriptor,
224         uint32_t stride, uint32_t numFlexPlanes, bool wasAllocated)
225   : mHandle(handle),
226     mReferenceCount(1),
227     mStore(store),
228     mDescriptor(descriptor),
229     mStride(stride),
230     mNumFlexPlanes(numFlexPlanes),
231     mWasAllocated(wasAllocated) {}
232 
allocate(gralloc1_buffer_descriptor_t id,const std::shared_ptr<Descriptor> & descriptor,buffer_handle_t * outBufferHandle)233 gralloc1_error_t Gralloc1On0Adapter::allocate(
234         gralloc1_buffer_descriptor_t id,
235         const std::shared_ptr<Descriptor>& descriptor,
236         buffer_handle_t* outBufferHandle)
237 {
238     ALOGV("allocate(%" PRIu64 ")", id);
239 
240     // If this function is being called, it's because we handed out its function
241     // pointer, which only occurs when mDevice has been loaded successfully and
242     // we are permitted to allocate
243 
244     int usage = android_convertGralloc1To0Usage(
245             descriptor->producerUsage, descriptor->consumerUsage);
246     buffer_handle_t handle = nullptr;
247     int stride = 0;
248     ALOGV("Calling alloc(%p, %u, %u, %i, %u)", mDevice, descriptor->width,
249             descriptor->height, descriptor->format, usage);
250     auto error = mDevice->alloc(mDevice,
251             static_cast<int>(descriptor->width),
252             static_cast<int>(descriptor->height), descriptor->format,
253             usage, &handle, &stride);
254     if (error != 0) {
255         ALOGE("gralloc0 allocation failed: %d (%s)", error,
256                 strerror(-error));
257         return GRALLOC1_ERROR_NO_RESOURCES;
258     }
259 
260     mModule->perform(mModule, GRALLOC1_ADAPTER_PERFORM_SET_USAGES,
261             handle,
262             static_cast<int>(descriptor->producerUsage),
263             static_cast<int>(descriptor->consumerUsage));
264 
265     uint64_t backingStore = 0;
266     mModule->perform(mModule, GRALLOC1_ADAPTER_PERFORM_GET_BACKING_STORE,
267             handle, &backingStore);
268     int numFlexPlanes = 0;
269     mModule->perform(mModule, GRALLOC1_ADAPTER_PERFORM_GET_NUM_FLEX_PLANES,
270             handle, &numFlexPlanes);
271 
272     *outBufferHandle = handle;
273     auto buffer = std::make_shared<Buffer>(handle, backingStore,
274             *descriptor, stride, numFlexPlanes, true);
275 
276     std::lock_guard<std::mutex> lock(mBufferMutex);
277     mBuffers.emplace(handle, std::move(buffer));
278 
279     return GRALLOC1_ERROR_NONE;
280 }
281 
allocateHook(gralloc1_device * device,uint32_t numDescriptors,const gralloc1_buffer_descriptor_t * descriptors,buffer_handle_t * outBuffers)282 int32_t Gralloc1On0Adapter::allocateHook(gralloc1_device* device,
283         uint32_t numDescriptors,
284         const gralloc1_buffer_descriptor_t* descriptors,
285         buffer_handle_t* outBuffers)
286 {
287     if (!outBuffers) {
288         return GRALLOC1_ERROR_UNDEFINED;
289     }
290 
291     auto adapter = getAdapter(device);
292 
293     gralloc1_error_t error = GRALLOC1_ERROR_NONE;
294     uint32_t i;
295     for (i = 0; i < numDescriptors; i++) {
296         auto descriptor = adapter->getDescriptor(descriptors[i]);
297         if (!descriptor) {
298             error = GRALLOC1_ERROR_BAD_DESCRIPTOR;
299             break;
300         }
301 
302         buffer_handle_t bufferHandle = nullptr;
303         error = adapter->allocate(descriptors[i], descriptor, &bufferHandle);
304         if (error != GRALLOC1_ERROR_NONE) {
305             break;
306         }
307 
308         outBuffers[i] = bufferHandle;
309     }
310 
311     if (error == GRALLOC1_ERROR_NONE) {
312         if (numDescriptors > 1) {
313             error = GRALLOC1_ERROR_NOT_SHARED;
314         }
315     } else {
316         for (uint32_t j = 0; j < i; j++) {
317             adapter->release(adapter->getBuffer(outBuffers[j]));
318             outBuffers[j] = nullptr;
319         }
320     }
321 
322     return error;
323 }
324 
retain(const std::shared_ptr<Buffer> & buffer)325 gralloc1_error_t Gralloc1On0Adapter::retain(
326         const std::shared_ptr<Buffer>& buffer)
327 {
328     std::lock_guard<std::mutex> lock(mBufferMutex);
329     buffer->retain();
330     return GRALLOC1_ERROR_NONE;
331 }
332 
release(const std::shared_ptr<Buffer> & buffer)333 gralloc1_error_t Gralloc1On0Adapter::release(
334         const std::shared_ptr<Buffer>& buffer)
335 {
336     std::lock_guard<std::mutex> lock(mBufferMutex);
337     if (!buffer->release()) {
338         return GRALLOC1_ERROR_NONE;
339     }
340 
341     buffer_handle_t handle = buffer->getHandle();
342     if (buffer->wasAllocated()) {
343         ALOGV("Calling free(%p)", handle);
344         int result = mDevice->free(mDevice, handle);
345         if (result != 0) {
346             ALOGE("gralloc0 free failed: %d", result);
347         }
348     } else {
349         ALOGV("Calling unregisterBuffer(%p)", handle);
350         int result = mModule->unregisterBuffer(mModule, handle);
351         if (result != 0) {
352             ALOGE("gralloc0 unregister failed: %d", result);
353         }
354     }
355 
356     mBuffers.erase(handle);
357     return GRALLOC1_ERROR_NONE;
358 }
359 
retain(buffer_handle_t bufferHandle)360 gralloc1_error_t Gralloc1On0Adapter::retain(buffer_handle_t bufferHandle)
361 {
362     ALOGV("retain(%p)", bufferHandle);
363 
364     std::lock_guard<std::mutex> lock(mBufferMutex);
365 
366     if (mBuffers.count(bufferHandle) != 0) {
367         mBuffers[bufferHandle]->retain();
368         return GRALLOC1_ERROR_NONE;
369     }
370 
371     ALOGV("Calling registerBuffer(%p)", bufferHandle);
372     int result = mModule->registerBuffer(mModule, bufferHandle);
373     if (result != 0) {
374         ALOGE("gralloc0 register failed: %d", result);
375         return GRALLOC1_ERROR_NO_RESOURCES;
376     }
377 
378     uint64_t backingStore = 0;
379     mModule->perform(mModule, GRALLOC1_ADAPTER_PERFORM_GET_BACKING_STORE,
380             bufferHandle, &backingStore);
381 
382     int numFlexPlanes = 0;
383     mModule->perform(mModule, GRALLOC1_ADAPTER_PERFORM_GET_NUM_FLEX_PLANES,
384             bufferHandle, &numFlexPlanes);
385 
386     int stride = 0;
387     mModule->perform(mModule, GRALLOC1_ADAPTER_PERFORM_GET_STRIDE,
388             bufferHandle, &stride);
389 
390     int width = 0;
391     int height = 0;
392     int format = HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED;
393     int producerUsage = 0;
394     int consumerUsage = 0;
395     mModule->perform(mModule, GRALLOC1_ADAPTER_PERFORM_GET_DIMENSIONS,
396             bufferHandle, &width, &height);
397     mModule->perform(mModule, GRALLOC1_ADAPTER_PERFORM_GET_FORMAT,
398             bufferHandle, &format);
399     mModule->perform(mModule, GRALLOC1_ADAPTER_PERFORM_GET_PRODUCER_USAGE,
400             bufferHandle, &producerUsage);
401     mModule->perform(mModule, GRALLOC1_ADAPTER_PERFORM_GET_CONSUMER_USAGE,
402             bufferHandle, &consumerUsage);
403 
404     Descriptor descriptor;
405     descriptor.setDimensions(width, height);
406     descriptor.setFormat(format);
407     descriptor.setProducerUsage(
408             static_cast<gralloc1_producer_usage_t>(producerUsage));
409     descriptor.setConsumerUsage(
410             static_cast<gralloc1_consumer_usage_t>(consumerUsage));
411 
412     auto buffer = std::make_shared<Buffer>(bufferHandle, backingStore,
413             descriptor, stride, numFlexPlanes, false);
414     mBuffers.emplace(bufferHandle, std::move(buffer));
415     return GRALLOC1_ERROR_NONE;
416 }
417 
syncWaitForever(int fd,const char * logname)418 static void syncWaitForever(int fd, const char* logname)
419 {
420     if (fd < 0) {
421         return;
422     }
423 
424     const int warningTimeout = 3500;
425     const int error = sync_wait(fd, warningTimeout);
426     if (error < 0 && errno == ETIME) {
427         ALOGE("%s: fence %d didn't signal in %u ms", logname, fd,
428                 warningTimeout);
429         sync_wait(fd, -1);
430     }
431 }
432 
lock(const std::shared_ptr<Buffer> & buffer,gralloc1_producer_usage_t producerUsage,gralloc1_consumer_usage_t consumerUsage,const gralloc1_rect_t & accessRegion,void ** outData,int acquireFence)433 gralloc1_error_t Gralloc1On0Adapter::lock(
434         const std::shared_ptr<Buffer>& buffer,
435         gralloc1_producer_usage_t producerUsage,
436         gralloc1_consumer_usage_t consumerUsage,
437         const gralloc1_rect_t& accessRegion, void** outData,
438         int acquireFence)
439 {
440     if (mMinorVersion >= 3) {
441         int result = mModule->lockAsync(mModule, buffer->getHandle(),
442                 android_convertGralloc1To0Usage(producerUsage, consumerUsage),
443                 accessRegion.left, accessRegion.top, accessRegion.width,
444                 accessRegion.height, outData, acquireFence);
445         if (result != 0) {
446             return GRALLOC1_ERROR_UNSUPPORTED;
447         }
448     } else {
449         syncWaitForever(acquireFence, "Gralloc1On0Adapter::lock");
450 
451         int result = mModule->lock(mModule, buffer->getHandle(),
452                 android_convertGralloc1To0Usage(producerUsage, consumerUsage),
453                 accessRegion.left, accessRegion.top, accessRegion.width,
454                 accessRegion.height, outData);
455         ALOGV("gralloc0 lock returned %d", result);
456         if (result != 0) {
457             return GRALLOC1_ERROR_UNSUPPORTED;
458         } else if (acquireFence >= 0) {
459             close(acquireFence);
460         }
461     }
462     return GRALLOC1_ERROR_NONE;
463 }
464 
lockFlex(const std::shared_ptr<Buffer> & buffer,gralloc1_producer_usage_t producerUsage,gralloc1_consumer_usage_t consumerUsage,const gralloc1_rect_t & accessRegion,struct android_flex_layout * outFlex,int acquireFence)465 gralloc1_error_t Gralloc1On0Adapter::lockFlex(
466         const std::shared_ptr<Buffer>& buffer,
467         gralloc1_producer_usage_t producerUsage,
468         gralloc1_consumer_usage_t consumerUsage,
469         const gralloc1_rect_t& accessRegion,
470         struct android_flex_layout* outFlex,
471         int acquireFence)
472 {
473     if (mMinorVersion >= 3) {
474         int result = mModule->perform(mModule,
475                 GRALLOC1_ADAPTER_PERFORM_LOCK_FLEX,
476                 buffer->getHandle(),
477                 static_cast<int>(producerUsage),
478                 static_cast<int>(consumerUsage),
479                 accessRegion.left,
480                 accessRegion.top,
481                 accessRegion.width,
482                 accessRegion.height,
483                 outFlex, acquireFence);
484         if (result != 0) {
485             return GRALLOC1_ERROR_UNSUPPORTED;
486         }
487     } else {
488         syncWaitForever(acquireFence, "Gralloc1On0Adapter::lockFlex");
489 
490         int result = mModule->perform(mModule,
491                 GRALLOC1_ADAPTER_PERFORM_LOCK_FLEX,
492                 buffer->getHandle(),
493                 static_cast<int>(producerUsage),
494                 static_cast<int>(consumerUsage),
495                 accessRegion.left,
496                 accessRegion.top,
497                 accessRegion.width,
498                 accessRegion.height,
499                 outFlex, -1);
500         if (result != 0) {
501             return GRALLOC1_ERROR_UNSUPPORTED;
502         } else if (acquireFence >= 0) {
503             close(acquireFence);
504         }
505     }
506 
507     return GRALLOC1_ERROR_NONE;
508 }
509 
unlock(const std::shared_ptr<Buffer> & buffer,int * outReleaseFence)510 gralloc1_error_t Gralloc1On0Adapter::unlock(
511         const std::shared_ptr<Buffer>& buffer,
512         int* outReleaseFence)
513 {
514     if (mMinorVersion >= 3) {
515         int fenceFd = -1;
516         int result = mModule->unlockAsync(mModule, buffer->getHandle(),
517                 &fenceFd);
518         if (result != 0) {
519             close(fenceFd);
520             ALOGE("gralloc0 unlockAsync failed: %d", result);
521         } else {
522             *outReleaseFence = fenceFd;
523         }
524     } else {
525         int result = mModule->unlock(mModule, buffer->getHandle());
526         if (result != 0) {
527             ALOGE("gralloc0 unlock failed: %d", result);
528         } else {
529             *outReleaseFence = -1;
530         }
531     }
532     return GRALLOC1_ERROR_NONE;
533 }
534 
535 std::shared_ptr<Gralloc1On0Adapter::Descriptor>
getDescriptor(gralloc1_buffer_descriptor_t descriptorId)536 Gralloc1On0Adapter::getDescriptor(gralloc1_buffer_descriptor_t descriptorId)
537 {
538     std::lock_guard<std::mutex> lock(mDescriptorMutex);
539     if (mDescriptors.count(descriptorId) == 0) {
540         return nullptr;
541     }
542 
543     return mDescriptors[descriptorId];
544 }
545 
getBuffer(buffer_handle_t bufferHandle)546 std::shared_ptr<Gralloc1On0Adapter::Buffer> Gralloc1On0Adapter::getBuffer(
547         buffer_handle_t bufferHandle)
548 {
549     std::lock_guard<std::mutex> lock(mBufferMutex);
550     if (mBuffers.count(bufferHandle) == 0) {
551         return nullptr;
552     }
553 
554     return mBuffers[bufferHandle];
555 }
556 
557 std::atomic<gralloc1_buffer_descriptor_t>
558         Gralloc1On0Adapter::sNextBufferDescriptorId(1);
559 
560 } // namespace hardware
561 } // namespace android
562