Home | History | Annotate | Download | only in ui 
      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 <hardware/gralloc.h>
     22 
     23 #include <ui/Gralloc1On0Adapter.h>
     24 
     25 #include <utils/Log.h>
     26 
     27 #include <inttypes.h>
     28 
     29 template <typename PFN, typename T>
     30 static gralloc1_function_pointer_t asFP(T function)
     31 {
     32     static_assert(std::is_same<PFN, T>::value, "Incompatible function pointer");
     33     return reinterpret_cast<gralloc1_function_pointer_t>(function);
     34 }
     35 
     36 namespace android {
     37 
     38 Gralloc1On0Adapter::Gralloc1On0Adapter(const hw_module_t* module)
     39   : mModule(reinterpret_cast<const gralloc_module_t*>(module)),
     40     mMinorVersion(mModule->common.module_api_version & 0xFF),
     41     mDevice(nullptr)
     42 {
     43     ALOGV("Constructing");
     44     getCapabilities = getCapabilitiesHook;
     45     getFunction = getFunctionHook;
     46     int error = ::gralloc_open(&(mModule->common), &mDevice);
     47     if (error) {
     48         ALOGE("Failed to open gralloc0 module: %d", error);
     49     }
     50     ALOGV("Opened gralloc0 device %p", mDevice);
     51 }
     52 
     53 Gralloc1On0Adapter::~Gralloc1On0Adapter()
     54 {
     55     ALOGV("Destructing");
     56     if (mDevice) {
     57         ALOGV("Closing gralloc0 device %p", mDevice);
     58         ::gralloc_close(mDevice);
     59     }
     60 }
     61 
     62 void Gralloc1On0Adapter::doGetCapabilities(uint32_t* outCount,
     63         int32_t* outCapabilities)
     64 {
     65     if (outCapabilities == nullptr) {
     66         *outCount = 1;
     67         return;
     68     }
     69     if (*outCount >= 1) {
     70         *outCapabilities = GRALLOC1_CAPABILITY_ON_ADAPTER;
     71         *outCount = 1;
     72     }
     73 }
     74 
     75 gralloc1_function_pointer_t Gralloc1On0Adapter::doGetFunction(
     76         int32_t intDescriptor)
     77 {
     78     constexpr auto lastDescriptor =
     79             static_cast<int32_t>(GRALLOC1_LAST_ADAPTER_FUNCTION);
     80     if (intDescriptor < 0 || intDescriptor > lastDescriptor) {
     81         ALOGE("Invalid function descriptor");
     82         return nullptr;
     83     }
     84 
     85     auto descriptor =
     86             static_cast<gralloc1_function_descriptor_t>(intDescriptor);
     87     switch (descriptor) {
     88         case GRALLOC1_FUNCTION_DUMP:
     89             return asFP<GRALLOC1_PFN_DUMP>(dumpHook);
     90         case GRALLOC1_FUNCTION_CREATE_DESCRIPTOR:
     91             return asFP<GRALLOC1_PFN_CREATE_DESCRIPTOR>(createDescriptorHook);
     92         case GRALLOC1_FUNCTION_DESTROY_DESCRIPTOR:
     93             return asFP<GRALLOC1_PFN_DESTROY_DESCRIPTOR>(destroyDescriptorHook);
     94         case GRALLOC1_FUNCTION_SET_CONSUMER_USAGE:
     95             return asFP<GRALLOC1_PFN_SET_CONSUMER_USAGE>(setConsumerUsageHook);
     96         case GRALLOC1_FUNCTION_SET_DIMENSIONS:
     97             return asFP<GRALLOC1_PFN_SET_DIMENSIONS>(setDimensionsHook);
     98         case GRALLOC1_FUNCTION_SET_FORMAT:
     99             return asFP<GRALLOC1_PFN_SET_FORMAT>(setFormatHook);
    100         case GRALLOC1_FUNCTION_SET_PRODUCER_USAGE:
    101             return asFP<GRALLOC1_PFN_SET_PRODUCER_USAGE>(setProducerUsageHook);
    102         case GRALLOC1_FUNCTION_GET_BACKING_STORE:
    103             return asFP<GRALLOC1_PFN_GET_BACKING_STORE>(
    104                     bufferHook<decltype(&Buffer::getBackingStore),
    105                     &Buffer::getBackingStore, gralloc1_backing_store_t*>);
    106         case GRALLOC1_FUNCTION_GET_CONSUMER_USAGE:
    107             return asFP<GRALLOC1_PFN_GET_CONSUMER_USAGE>(getConsumerUsageHook);
    108         case GRALLOC1_FUNCTION_GET_DIMENSIONS:
    109             return asFP<GRALLOC1_PFN_GET_DIMENSIONS>(
    110                     bufferHook<decltype(&Buffer::getDimensions),
    111                     &Buffer::getDimensions, uint32_t*, uint32_t*>);
    112         case GRALLOC1_FUNCTION_GET_FORMAT:
    113             return asFP<GRALLOC1_PFN_GET_FORMAT>(
    114                     bufferHook<decltype(&Buffer::getFormat),
    115                     &Buffer::getFormat, int32_t*>);
    116         case GRALLOC1_FUNCTION_GET_PRODUCER_USAGE:
    117             return asFP<GRALLOC1_PFN_GET_PRODUCER_USAGE>(getProducerUsageHook);
    118         case GRALLOC1_FUNCTION_GET_STRIDE:
    119             return asFP<GRALLOC1_PFN_GET_STRIDE>(
    120                     bufferHook<decltype(&Buffer::getStride),
    121                     &Buffer::getStride, uint32_t*>);
    122         case GRALLOC1_FUNCTION_ALLOCATE:
    123             // Not provided, since we'll use ALLOCATE_WITH_ID
    124             return nullptr;
    125         case GRALLOC1_FUNCTION_ALLOCATE_WITH_ID:
    126             if (mDevice != nullptr) {
    127                 return asFP<GRALLOC1_PFN_ALLOCATE_WITH_ID>(allocateWithIdHook);
    128             } else {
    129                 return nullptr;
    130             }
    131         case GRALLOC1_FUNCTION_RETAIN:
    132             return asFP<GRALLOC1_PFN_RETAIN>(
    133                     managementHook<&Gralloc1On0Adapter::retain>);
    134         case GRALLOC1_FUNCTION_RELEASE:
    135             return asFP<GRALLOC1_PFN_RELEASE>(
    136                     managementHook<&Gralloc1On0Adapter::release>);
    137         case GRALLOC1_FUNCTION_RETAIN_GRAPHIC_BUFFER:
    138             return asFP<GRALLOC1_PFN_RETAIN_GRAPHIC_BUFFER>(
    139                     retainGraphicBufferHook);
    140         case GRALLOC1_FUNCTION_GET_NUM_FLEX_PLANES:
    141             return asFP<GRALLOC1_PFN_GET_NUM_FLEX_PLANES>(
    142                     bufferHook<decltype(&Buffer::getNumFlexPlanes),
    143                     &Buffer::getNumFlexPlanes, uint32_t*>);
    144         case GRALLOC1_FUNCTION_LOCK:
    145             return asFP<GRALLOC1_PFN_LOCK>(
    146                     lockHook<void*, &Gralloc1On0Adapter::lock>);
    147         case GRALLOC1_FUNCTION_LOCK_FLEX:
    148             return asFP<GRALLOC1_PFN_LOCK_FLEX>(
    149                     lockHook<struct android_flex_layout,
    150                     &Gralloc1On0Adapter::lockFlex>);
    151         case GRALLOC1_FUNCTION_LOCK_YCBCR:
    152             return asFP<GRALLOC1_PFN_LOCK_YCBCR>(
    153                     lockHook<struct android_ycbcr,
    154                     &Gralloc1On0Adapter::lockYCbCr>);
    155         case GRALLOC1_FUNCTION_UNLOCK:
    156             return asFP<GRALLOC1_PFN_UNLOCK>(unlockHook);
    157         case GRALLOC1_FUNCTION_INVALID:
    158             ALOGE("Invalid function descriptor");
    159             return nullptr;
    160     }
    161 
    162     ALOGE("Unknown function descriptor: %d", intDescriptor);
    163     return nullptr;
    164 }
    165 
    166 void Gralloc1On0Adapter::dump(uint32_t* outSize, char* outBuffer)
    167 {
    168     ALOGV("dump(%u (%p), %p", outSize ? *outSize : 0, outSize, outBuffer);
    169 
    170     if (!mDevice->dump) {
    171         // dump is optional on gralloc0 implementations
    172         *outSize = 0;
    173         return;
    174     }
    175 
    176     if (!outBuffer) {
    177         constexpr int32_t BUFFER_LENGTH = 4096;
    178         char buffer[BUFFER_LENGTH] = {};
    179         mDevice->dump(mDevice, buffer, BUFFER_LENGTH);
    180         buffer[BUFFER_LENGTH - 1] = 0; // Ensure the buffer is null-terminated
    181         size_t actualLength = std::strlen(buffer);
    182         mCachedDump.resize(actualLength);
    183         std::copy_n(buffer, actualLength, mCachedDump.begin());
    184         *outSize = static_cast<uint32_t>(actualLength);
    185     } else {
    186         *outSize = std::min(*outSize,
    187                 static_cast<uint32_t>(mCachedDump.size()));
    188         outBuffer = std::copy_n(mCachedDump.cbegin(), *outSize, outBuffer);
    189     }
    190 }
    191 
    192 gralloc1_error_t Gralloc1On0Adapter::createDescriptor(
    193         gralloc1_buffer_descriptor_t* outDescriptor)
    194 {
    195     auto descriptorId = sNextBufferDescriptorId++;
    196     std::lock_guard<std::mutex> lock(mDescriptorMutex);
    197     mDescriptors.emplace(descriptorId,
    198             std::make_shared<Descriptor>(this, descriptorId));
    199 
    200     ALOGV("Created descriptor %" PRIu64, descriptorId);
    201 
    202     *outDescriptor = descriptorId;
    203     return GRALLOC1_ERROR_NONE;
    204 }
    205 
    206 gralloc1_error_t Gralloc1On0Adapter::destroyDescriptor(
    207         gralloc1_buffer_descriptor_t descriptor)
    208 {
    209     ALOGV("Destroying descriptor %" PRIu64, descriptor);
    210 
    211     std::lock_guard<std::mutex> lock(mDescriptorMutex);
    212     if (mDescriptors.count(descriptor) == 0) {
    213         return GRALLOC1_ERROR_BAD_DESCRIPTOR;
    214     }
    215 
    216     mDescriptors.erase(descriptor);
    217     return GRALLOC1_ERROR_NONE;
    218 }
    219 
    220 Gralloc1On0Adapter::Buffer::Buffer(buffer_handle_t handle,
    221         gralloc1_backing_store_t store, const Descriptor& descriptor,
    222         uint32_t stride, bool wasAllocated)
    223   : mHandle(handle),
    224     mReferenceCount(1),
    225     mStore(store),
    226     mDescriptor(descriptor),
    227     mStride(stride),
    228     mWasAllocated(wasAllocated) {}
    229 
    230 gralloc1_error_t Gralloc1On0Adapter::allocate(
    231         const std::shared_ptr<Descriptor>& descriptor,
    232         gralloc1_backing_store_t store,
    233         buffer_handle_t* outBufferHandle)
    234 {
    235     ALOGV("allocate(%" PRIu64 ", %#" PRIx64 ")", descriptor->id, store);
    236 
    237     // If this function is being called, it's because we handed out its function
    238     // pointer, which only occurs when mDevice has been loaded successfully and
    239     // we are permitted to allocate
    240 
    241     int usage = static_cast<int>(descriptor->producerUsage) |
    242             static_cast<int>(descriptor->consumerUsage);
    243     buffer_handle_t handle = nullptr;
    244     int stride = 0;
    245     ALOGV("Calling alloc(%p, %u, %u, %i, %u)", mDevice, descriptor->width,
    246             descriptor->height, descriptor->format, usage);
    247     auto error = mDevice->alloc(mDevice,
    248             static_cast<int>(descriptor->width),
    249             static_cast<int>(descriptor->height), descriptor->format,
    250             usage, &handle, &stride);
    251     if (error != 0) {
    252         ALOGE("gralloc0 allocation failed: %d (%s)", error,
    253                 strerror(-error));
    254         return GRALLOC1_ERROR_NO_RESOURCES;
    255     }
    256 
    257     *outBufferHandle = handle;
    258     auto buffer = std::make_shared<Buffer>(handle, store, *descriptor, stride,
    259             true);
    260 
    261     std::lock_guard<std::mutex> lock(mBufferMutex);
    262     mBuffers.emplace(handle, std::move(buffer));
    263 
    264     return GRALLOC1_ERROR_NONE;
    265 }
    266 
    267 gralloc1_error_t Gralloc1On0Adapter::allocateWithIdHook(
    268         gralloc1_device_t* device, gralloc1_buffer_descriptor_t descriptorId,
    269         gralloc1_backing_store_t store, buffer_handle_t* outBuffer)
    270 {
    271     auto adapter = getAdapter(device);
    272 
    273     auto descriptor = adapter->getDescriptor(descriptorId);
    274     if (!descriptor) {
    275         return GRALLOC1_ERROR_BAD_DESCRIPTOR;
    276     }
    277 
    278     buffer_handle_t bufferHandle = nullptr;
    279     auto error = adapter->allocate(descriptor, store, &bufferHandle);
    280     if (error != GRALLOC1_ERROR_NONE) {
    281         return error;
    282     }
    283 
    284     *outBuffer = bufferHandle;
    285     return error;
    286 }
    287 
    288 gralloc1_error_t Gralloc1On0Adapter::retain(
    289         const std::shared_ptr<Buffer>& buffer)
    290 {
    291     buffer->retain();
    292     return GRALLOC1_ERROR_NONE;
    293 }
    294 
    295 gralloc1_error_t Gralloc1On0Adapter::release(
    296         const std::shared_ptr<Buffer>& buffer)
    297 {
    298     if (!buffer->release()) {
    299         return GRALLOC1_ERROR_NONE;
    300     }
    301 
    302     buffer_handle_t handle = buffer->getHandle();
    303     if (buffer->wasAllocated()) {
    304         ALOGV("Calling free(%p)", handle);
    305         int result = mDevice->free(mDevice, handle);
    306         if (result != 0) {
    307             ALOGE("gralloc0 free failed: %d", result);
    308         }
    309     } else {
    310         ALOGV("Calling unregisterBuffer(%p)", handle);
    311         int result = mModule->unregisterBuffer(mModule, handle);
    312         if (result != 0) {
    313             ALOGE("gralloc0 unregister failed: %d", result);
    314         }
    315     }
    316 
    317     std::lock_guard<std::mutex> lock(mBufferMutex);
    318     mBuffers.erase(handle);
    319     return GRALLOC1_ERROR_NONE;
    320 }
    321 
    322 gralloc1_error_t Gralloc1On0Adapter::retain(
    323         const android::GraphicBuffer* graphicBuffer)
    324 {
    325     ALOGV("retainGraphicBuffer(%p, %#" PRIx64 ")",
    326             graphicBuffer->getNativeBuffer()->handle, graphicBuffer->getId());
    327 
    328     buffer_handle_t handle = graphicBuffer->getNativeBuffer()->handle;
    329     std::lock_guard<std::mutex> lock(mBufferMutex);
    330     if (mBuffers.count(handle) != 0) {
    331         mBuffers[handle]->retain();
    332         return GRALLOC1_ERROR_NONE;
    333     }
    334 
    335     ALOGV("Calling registerBuffer(%p)", handle);
    336     int result = mModule->registerBuffer(mModule, handle);
    337     if (result != 0) {
    338         ALOGE("gralloc0 register failed: %d", result);
    339         return GRALLOC1_ERROR_NO_RESOURCES;
    340     }
    341 
    342     Descriptor descriptor{this, sNextBufferDescriptorId++};
    343     descriptor.setDimensions(graphicBuffer->getWidth(),
    344             graphicBuffer->getHeight());
    345     descriptor.setFormat(graphicBuffer->getPixelFormat());
    346     descriptor.setProducerUsage(
    347             static_cast<gralloc1_producer_usage_t>(graphicBuffer->getUsage()));
    348     descriptor.setConsumerUsage(
    349             static_cast<gralloc1_consumer_usage_t>(graphicBuffer->getUsage()));
    350     auto buffer = std::make_shared<Buffer>(handle,
    351             static_cast<gralloc1_backing_store_t>(graphicBuffer->getId()),
    352             descriptor, graphicBuffer->getStride(), false);
    353     mBuffers.emplace(handle, std::move(buffer));
    354     return GRALLOC1_ERROR_NONE;
    355 }
    356 
    357 gralloc1_error_t Gralloc1On0Adapter::lock(
    358         const std::shared_ptr<Buffer>& buffer,
    359         gralloc1_producer_usage_t producerUsage,
    360         gralloc1_consumer_usage_t consumerUsage,
    361         const gralloc1_rect_t& accessRegion, void** outData,
    362         const sp<Fence>& acquireFence)
    363 {
    364     if (mMinorVersion >= 3) {
    365         int result = mModule->lockAsync(mModule, buffer->getHandle(),
    366                 static_cast<int32_t>(producerUsage | consumerUsage),
    367                 accessRegion.left, accessRegion.top, accessRegion.width,
    368                 accessRegion.height, outData, acquireFence->dup());
    369         if (result != 0) {
    370             return GRALLOC1_ERROR_UNSUPPORTED;
    371         }
    372     } else {
    373         acquireFence->waitForever("Gralloc1On0Adapter::lock");
    374         int result = mModule->lock(mModule, buffer->getHandle(),
    375                 static_cast<int32_t>(producerUsage | consumerUsage),
    376                 accessRegion.left, accessRegion.top, accessRegion.width,
    377                 accessRegion.height, outData);
    378         ALOGV("gralloc0 lock returned %d", result);
    379         if (result != 0) {
    380             return GRALLOC1_ERROR_UNSUPPORTED;
    381         }
    382     }
    383     return GRALLOC1_ERROR_NONE;
    384 }
    385 
    386 gralloc1_error_t Gralloc1On0Adapter::lockFlex(
    387         const std::shared_ptr<Buffer>& /*buffer*/,
    388         gralloc1_producer_usage_t /*producerUsage*/,
    389         gralloc1_consumer_usage_t /*consumerUsage*/,
    390         const gralloc1_rect_t& /*accessRegion*/,
    391         struct android_flex_layout* /*outData*/,
    392         const sp<Fence>& /*acquireFence*/)
    393 {
    394     // TODO
    395     return GRALLOC1_ERROR_UNSUPPORTED;
    396 }
    397 
    398 gralloc1_error_t Gralloc1On0Adapter::lockYCbCr(
    399         const std::shared_ptr<Buffer>& buffer,
    400         gralloc1_producer_usage_t producerUsage,
    401         gralloc1_consumer_usage_t consumerUsage,
    402         const gralloc1_rect_t& accessRegion, struct android_ycbcr* outData,
    403         const sp<Fence>& acquireFence)
    404 {
    405     if (mMinorVersion >= 3 && mModule->lockAsync_ycbcr) {
    406         int result = mModule->lockAsync_ycbcr(mModule, buffer->getHandle(),
    407                 static_cast<int>(producerUsage | consumerUsage),
    408                 accessRegion.left, accessRegion.top, accessRegion.width,
    409                 accessRegion.height, outData, acquireFence->dup());
    410         if (result != 0) {
    411             return GRALLOC1_ERROR_UNSUPPORTED;
    412         }
    413     } else if (mModule->lock_ycbcr) {
    414         acquireFence->waitForever("Gralloc1On0Adapter::lockYCbCr");
    415         int result = mModule->lock_ycbcr(mModule, buffer->getHandle(),
    416                 static_cast<int>(producerUsage | consumerUsage),
    417                 accessRegion.left, accessRegion.top, accessRegion.width,
    418                 accessRegion.height, outData);
    419         ALOGV("gralloc0 lockYCbCr returned %d", result);
    420         if (result != 0) {
    421             return GRALLOC1_ERROR_UNSUPPORTED;
    422         }
    423     } else {
    424         return GRALLOC1_ERROR_UNSUPPORTED;
    425     }
    426 
    427     return GRALLOC1_ERROR_NONE;
    428 }
    429 
    430 gralloc1_error_t Gralloc1On0Adapter::unlock(
    431         const std::shared_ptr<Buffer>& buffer,
    432         sp<Fence>* outReleaseFence)
    433 {
    434     if (mMinorVersion >= 3) {
    435         int fenceFd = -1;
    436         int result = mModule->unlockAsync(mModule, buffer->getHandle(),
    437                 &fenceFd);
    438         if (result != 0) {
    439             close(fenceFd);
    440             ALOGE("gralloc0 unlockAsync failed: %d", result);
    441         } else {
    442             *outReleaseFence = new Fence(fenceFd);
    443         }
    444     } else {
    445         int result = mModule->unlock(mModule, buffer->getHandle());
    446         if (result != 0) {
    447             ALOGE("gralloc0 unlock failed: %d", result);
    448         }
    449     }
    450     return GRALLOC1_ERROR_NONE;
    451 }
    452 
    453 std::shared_ptr<Gralloc1On0Adapter::Descriptor>
    454 Gralloc1On0Adapter::getDescriptor(gralloc1_buffer_descriptor_t descriptorId)
    455 {
    456     std::lock_guard<std::mutex> lock(mDescriptorMutex);
    457     if (mDescriptors.count(descriptorId) == 0) {
    458         return nullptr;
    459     }
    460 
    461     return mDescriptors[descriptorId];
    462 }
    463 
    464 std::shared_ptr<Gralloc1On0Adapter::Buffer> Gralloc1On0Adapter::getBuffer(
    465         buffer_handle_t bufferHandle)
    466 {
    467     std::lock_guard<std::mutex> lock(mBufferMutex);
    468     if (mBuffers.count(bufferHandle) == 0) {
    469         return nullptr;
    470     }
    471 
    472     return mBuffers[bufferHandle];
    473 }
    474 
    475 std::atomic<gralloc1_buffer_descriptor_t>
    476         Gralloc1On0Adapter::sNextBufferDescriptorId(1);
    477 
    478 } // namespace android
    479