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