| /* |
| * Copyright 2016 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #define LOG_TAG "Gralloc2" |
| |
| #include <hidl/ServiceManagement.h> |
| #include <hwbinder/IPCThreadState.h> |
| #include <ui/Gralloc2.h> |
| |
| #include <inttypes.h> |
| #include <log/log.h> |
| #pragma clang diagnostic push |
| #pragma clang diagnostic ignored "-Wzero-length-array" |
| #include <sync/sync.h> |
| #pragma clang diagnostic pop |
| |
| namespace android { |
| |
| namespace Gralloc2 { |
| |
| namespace { |
| |
| static constexpr Error kTransactionError = Error::NO_RESOURCES; |
| |
| uint64_t getValid10UsageBits() { |
| static const uint64_t valid10UsageBits = []() -> uint64_t { |
| using hardware::graphics::common::V1_0::BufferUsage; |
| uint64_t bits = 0; |
| for (const auto bit : hardware::hidl_enum_range<BufferUsage>()) { |
| bits = bits | bit; |
| } |
| // TODO(b/72323293, b/72703005): Remove these additional bits |
| bits = bits | (1 << 10) | (1 << 13); |
| |
| return bits; |
| }(); |
| return valid10UsageBits; |
| } |
| |
| uint64_t getValid11UsageBits() { |
| static const uint64_t valid11UsageBits = []() -> uint64_t { |
| using hardware::graphics::common::V1_1::BufferUsage; |
| uint64_t bits = 0; |
| for (const auto bit : hardware::hidl_enum_range<BufferUsage>()) { |
| bits = bits | bit; |
| } |
| return bits; |
| }(); |
| return valid11UsageBits; |
| } |
| |
| } // anonymous namespace |
| |
| void Mapper::preload() { |
| android::hardware::preloadPassthroughService<hardware::graphics::mapper::V2_0::IMapper>(); |
| } |
| |
| Mapper::Mapper() |
| { |
| mMapper = hardware::graphics::mapper::V2_0::IMapper::getService(); |
| if (mMapper == nullptr) { |
| LOG_ALWAYS_FATAL("gralloc-mapper is missing"); |
| } |
| if (mMapper->isRemote()) { |
| LOG_ALWAYS_FATAL("gralloc-mapper must be in passthrough mode"); |
| } |
| |
| // IMapper 2.1 is optional |
| mMapperV2_1 = IMapper::castFrom(mMapper); |
| } |
| |
| Gralloc2::Error Mapper::validateBufferDescriptorInfo( |
| const IMapper::BufferDescriptorInfo& descriptorInfo) const { |
| uint64_t validUsageBits = getValid10UsageBits(); |
| if (mMapperV2_1 != nullptr) { |
| validUsageBits = validUsageBits | getValid11UsageBits(); |
| } |
| |
| if (descriptorInfo.usage & ~validUsageBits) { |
| ALOGE("buffer descriptor contains invalid usage bits 0x%" PRIx64, |
| descriptorInfo.usage & ~validUsageBits); |
| return Error::BAD_VALUE; |
| } |
| return Error::NONE; |
| } |
| |
| Error Mapper::createDescriptor( |
| const IMapper::BufferDescriptorInfo& descriptorInfo, |
| BufferDescriptor* outDescriptor) const |
| { |
| Error error = validateBufferDescriptorInfo(descriptorInfo); |
| if (error != Error::NONE) { |
| return error; |
| } |
| |
| auto hidl_cb = [&](const auto& tmpError, const auto& tmpDescriptor) |
| { |
| error = tmpError; |
| if (error != Error::NONE) { |
| return; |
| } |
| |
| *outDescriptor = tmpDescriptor; |
| }; |
| |
| hardware::Return<void> ret; |
| if (mMapperV2_1 != nullptr) { |
| ret = mMapperV2_1->createDescriptor_2_1(descriptorInfo, hidl_cb); |
| } else { |
| const hardware::graphics::mapper::V2_0::IMapper::BufferDescriptorInfo info = { |
| descriptorInfo.width, |
| descriptorInfo.height, |
| descriptorInfo.layerCount, |
| static_cast<hardware::graphics::common::V1_0::PixelFormat>(descriptorInfo.format), |
| descriptorInfo.usage, |
| }; |
| ret = mMapper->createDescriptor(info, hidl_cb); |
| } |
| |
| return (ret.isOk()) ? error : kTransactionError; |
| } |
| |
| Error Mapper::importBuffer(const hardware::hidl_handle& rawHandle, |
| buffer_handle_t* outBufferHandle) const |
| { |
| Error error; |
| auto ret = mMapper->importBuffer(rawHandle, |
| [&](const auto& tmpError, const auto& tmpBuffer) |
| { |
| error = tmpError; |
| if (error != Error::NONE) { |
| return; |
| } |
| |
| *outBufferHandle = static_cast<buffer_handle_t>(tmpBuffer); |
| }); |
| |
| return (ret.isOk()) ? error : kTransactionError; |
| } |
| |
| void Mapper::freeBuffer(buffer_handle_t bufferHandle) const |
| { |
| auto buffer = const_cast<native_handle_t*>(bufferHandle); |
| auto ret = mMapper->freeBuffer(buffer); |
| |
| auto error = (ret.isOk()) ? static_cast<Error>(ret) : kTransactionError; |
| ALOGE_IF(error != Error::NONE, "freeBuffer(%p) failed with %d", |
| buffer, error); |
| } |
| |
| Error Mapper::validateBufferSize(buffer_handle_t bufferHandle, |
| const IMapper::BufferDescriptorInfo& descriptorInfo, |
| uint32_t stride) const |
| { |
| if (mMapperV2_1 == nullptr) { |
| return Error::NONE; |
| } |
| |
| auto buffer = const_cast<native_handle_t*>(bufferHandle); |
| auto ret = mMapperV2_1->validateBufferSize(buffer, descriptorInfo, stride); |
| |
| return (ret.isOk()) ? static_cast<Error>(ret) : kTransactionError; |
| } |
| |
| void Mapper::getTransportSize(buffer_handle_t bufferHandle, |
| uint32_t* outNumFds, uint32_t* outNumInts) const |
| { |
| *outNumFds = uint32_t(bufferHandle->numFds); |
| *outNumInts = uint32_t(bufferHandle->numInts); |
| |
| if (mMapperV2_1 == nullptr) { |
| return; |
| } |
| |
| Error error; |
| auto buffer = const_cast<native_handle_t*>(bufferHandle); |
| auto ret = mMapperV2_1->getTransportSize(buffer, |
| [&](const auto& tmpError, const auto& tmpNumFds, const auto& tmpNumInts) { |
| error = tmpError; |
| if (error != Error::NONE) { |
| return; |
| } |
| |
| *outNumFds = tmpNumFds; |
| *outNumInts = tmpNumInts; |
| }); |
| |
| if (!ret.isOk()) { |
| error = kTransactionError; |
| } |
| ALOGE_IF(error != Error::NONE, "getTransportSize(%p) failed with %d", |
| buffer, error); |
| } |
| |
| Error Mapper::lock(buffer_handle_t bufferHandle, uint64_t usage, |
| const IMapper::Rect& accessRegion, |
| int acquireFence, void** outData) const |
| { |
| auto buffer = const_cast<native_handle_t*>(bufferHandle); |
| |
| // put acquireFence in a hidl_handle |
| hardware::hidl_handle acquireFenceHandle; |
| NATIVE_HANDLE_DECLARE_STORAGE(acquireFenceStorage, 1, 0); |
| if (acquireFence >= 0) { |
| auto h = native_handle_init(acquireFenceStorage, 1, 0); |
| h->data[0] = acquireFence; |
| acquireFenceHandle = h; |
| } |
| |
| Error error; |
| auto ret = mMapper->lock(buffer, usage, accessRegion, acquireFenceHandle, |
| [&](const auto& tmpError, const auto& tmpData) |
| { |
| error = tmpError; |
| if (error != Error::NONE) { |
| return; |
| } |
| |
| *outData = tmpData; |
| }); |
| |
| // we own acquireFence even on errors |
| if (acquireFence >= 0) { |
| close(acquireFence); |
| } |
| |
| return (ret.isOk()) ? error : kTransactionError; |
| } |
| |
| Error Mapper::lock(buffer_handle_t bufferHandle, uint64_t usage, |
| const IMapper::Rect& accessRegion, |
| int acquireFence, YCbCrLayout* outLayout) const |
| { |
| auto buffer = const_cast<native_handle_t*>(bufferHandle); |
| |
| // put acquireFence in a hidl_handle |
| hardware::hidl_handle acquireFenceHandle; |
| NATIVE_HANDLE_DECLARE_STORAGE(acquireFenceStorage, 1, 0); |
| if (acquireFence >= 0) { |
| auto h = native_handle_init(acquireFenceStorage, 1, 0); |
| h->data[0] = acquireFence; |
| acquireFenceHandle = h; |
| } |
| |
| Error error; |
| auto ret = mMapper->lockYCbCr(buffer, usage, accessRegion, |
| acquireFenceHandle, |
| [&](const auto& tmpError, const auto& tmpLayout) |
| { |
| error = tmpError; |
| if (error != Error::NONE) { |
| return; |
| } |
| |
| *outLayout = tmpLayout; |
| }); |
| |
| // we own acquireFence even on errors |
| if (acquireFence >= 0) { |
| close(acquireFence); |
| } |
| |
| return (ret.isOk()) ? error : kTransactionError; |
| } |
| |
| int Mapper::unlock(buffer_handle_t bufferHandle) const |
| { |
| auto buffer = const_cast<native_handle_t*>(bufferHandle); |
| |
| int releaseFence = -1; |
| Error error; |
| auto ret = mMapper->unlock(buffer, |
| [&](const auto& tmpError, const auto& tmpReleaseFence) |
| { |
| error = tmpError; |
| if (error != Error::NONE) { |
| return; |
| } |
| |
| auto fenceHandle = tmpReleaseFence.getNativeHandle(); |
| if (fenceHandle && fenceHandle->numFds == 1) { |
| int fd = dup(fenceHandle->data[0]); |
| if (fd >= 0) { |
| releaseFence = fd; |
| } else { |
| ALOGD("failed to dup unlock release fence"); |
| sync_wait(fenceHandle->data[0], -1); |
| } |
| } |
| }); |
| |
| if (!ret.isOk()) { |
| error = kTransactionError; |
| } |
| |
| if (error != Error::NONE) { |
| ALOGE("unlock(%p) failed with %d", buffer, error); |
| } |
| |
| return releaseFence; |
| } |
| |
| Allocator::Allocator(const Mapper& mapper) |
| : mMapper(mapper) |
| { |
| mAllocator = IAllocator::getService(); |
| if (mAllocator == nullptr) { |
| LOG_ALWAYS_FATAL("gralloc-alloc is missing"); |
| } |
| } |
| |
| std::string Allocator::dumpDebugInfo() const |
| { |
| std::string debugInfo; |
| |
| mAllocator->dumpDebugInfo([&](const auto& tmpDebugInfo) { |
| debugInfo = tmpDebugInfo.c_str(); |
| }); |
| |
| return debugInfo; |
| } |
| |
| Error Allocator::allocate(BufferDescriptor descriptor, uint32_t count, |
| uint32_t* outStride, buffer_handle_t* outBufferHandles) const |
| { |
| Error error; |
| auto ret = mAllocator->allocate(descriptor, count, |
| [&](const auto& tmpError, const auto& tmpStride, |
| const auto& tmpBuffers) { |
| error = tmpError; |
| if (tmpError != Error::NONE) { |
| return; |
| } |
| |
| // import buffers |
| for (uint32_t i = 0; i < count; i++) { |
| error = mMapper.importBuffer(tmpBuffers[i], |
| &outBufferHandles[i]); |
| if (error != Error::NONE) { |
| for (uint32_t j = 0; j < i; j++) { |
| mMapper.freeBuffer(outBufferHandles[j]); |
| outBufferHandles[j] = nullptr; |
| } |
| return; |
| } |
| } |
| |
| *outStride = tmpStride; |
| }); |
| |
| // make sure the kernel driver sees BC_FREE_BUFFER and closes the fds now |
| hardware::IPCThreadState::self()->flushCommands(); |
| |
| return (ret.isOk()) ? error : kTransactionError; |
| } |
| |
| } // namespace Gralloc2 |
| |
| } // namespace android |