diff options
Diffstat (limited to 'gralloc4/src/4.x/GrallocMapper.cpp')
| -rw-r--r-- | gralloc4/src/4.x/GrallocMapper.cpp | 154 |
1 files changed, 129 insertions, 25 deletions
diff --git a/gralloc4/src/4.x/GrallocMapper.cpp b/gralloc4/src/4.x/GrallocMapper.cpp index c0b5f5f..11ee90b 100644 --- a/gralloc4/src/4.x/GrallocMapper.cpp +++ b/gralloc4/src/4.x/GrallocMapper.cpp @@ -18,6 +18,7 @@ #include "GrallocMapper.h" #include "hidl_common/BufferDescriptor.h" #include "hidl_common/MapperMetadata.h" +#include "hidl_common/Mapper.h" #include "allocator/mali_gralloc_ion.h" @@ -26,7 +27,9 @@ namespace arm namespace mapper { +namespace hidl { using android::hardware::graphics::mapper::V4_0::Error; +} // namespace hidl using android::hardware::graphics::mapper::V4_0::BufferDescriptor; using android::hardware::graphics::mapper::V4_0::IMapper; using android::hardware::Return; @@ -34,7 +37,6 @@ using android::hardware::hidl_handle; using android::hardware::hidl_vec; using android::hardware::Void; - GrallocMapper::GrallocMapper() {} GrallocMapper::~GrallocMapper() {} @@ -43,12 +45,12 @@ Return<void> GrallocMapper::createDescriptor(const BufferDescriptorInfo &descrip { if (common::validateDescriptorInfo(descriptorInfo)) { - hidl_cb(Error::NONE, common::grallocEncodeBufferDescriptor<uint8_t>(descriptorInfo)); + hidl_cb(hidl::Error::NONE, common::grallocEncodeBufferDescriptor<uint8_t>(descriptorInfo)); } else { MALI_GRALLOC_LOGE("Invalid attributes to create descriptor for Mapper 3.0"); - hidl_cb(Error::BAD_VALUE, BufferDescriptor()); + hidl_cb(hidl::Error::BAD_VALUE, BufferDescriptor()); } return Void(); @@ -56,73 +58,156 @@ Return<void> GrallocMapper::createDescriptor(const BufferDescriptorInfo &descrip Return<void> GrallocMapper::importBuffer(const hidl_handle &rawHandle, importBuffer_cb hidl_cb) { - common::importBuffer(rawHandle, hidl_cb); + if (!rawHandle.getNativeHandle()) { + hidl_cb(hidl::Error::BAD_BUFFER, nullptr); + return Void(); + } + + auto *inHandle = const_cast<native_handle_t *>(rawHandle.getNativeHandle()); + buffer_handle_t outHandle = nullptr; + + hidl::Error err = static_cast<hidl::Error>( + common::importBuffer(inHandle, &outHandle)); + + hidl_cb(err, static_cast<void*>(const_cast<native_handle_t*>(outHandle))); return Void(); } -Return<Error> GrallocMapper::freeBuffer(void *buffer) +Return<hidl::Error> GrallocMapper::freeBuffer(void *buffer) { - return common::freeBuffer(buffer); + buffer_handle_t handle = common::getBuffer(buffer); + if (handle == nullptr) return hidl::Error::BAD_BUFFER; + return static_cast<hidl::Error>(common::freeBuffer(handle)); } -Return<Error> GrallocMapper::validateBufferSize(void *buffer, const BufferDescriptorInfo &descriptorInfo, +Return<hidl::Error> GrallocMapper::validateBufferSize(void *buffer, const BufferDescriptorInfo &descriptorInfo, uint32_t in_stride) { /* All Gralloc allocated buffers must be conform to local descriptor validation */ if (!common::validateDescriptorInfo<BufferDescriptorInfo>(descriptorInfo)) { MALI_GRALLOC_LOGE("Invalid descriptor attributes for validating buffer size"); - return Error::BAD_VALUE; + return hidl::Error::BAD_VALUE; } - return common::validateBufferSize(buffer, descriptorInfo, in_stride); + return static_cast<hidl::Error>(common::validateBufferSize(buffer, descriptorInfo, in_stride)); +} + +static bool getFenceFd(const hidl_handle &fenceHandle, int *outFenceFd) { + auto const handle = fenceHandle.getNativeHandle(); + if (handle && handle->numFds > 1) { + MALI_GRALLOC_LOGE("Invalid fence handle with %d fds", + handle->numFds); + return false; + } + + *outFenceFd = (handle && handle->numFds == 1) ? handle->data[0] : -1; + return true; } Return<void> GrallocMapper::lock(void *buffer, uint64_t cpuUsage, const IMapper::Rect &accessRegion, const hidl_handle &acquireFence, lock_cb hidl_cb) { - common::lock(buffer, cpuUsage, accessRegion, acquireFence, hidl_cb); + void *outData = nullptr; + int fenceFd; + if (!getFenceFd(acquireFence, &fenceFd)) { + hidl_cb(hidl::Error::BAD_VALUE, nullptr); + return Void(); + } + + hidl::Error err = static_cast<hidl::Error>( + common::lock(static_cast<buffer_handle_t>(buffer), cpuUsage, + common::GrallocRect(accessRegion), fenceFd, &outData)); + if (err != hidl::Error::NONE) outData = nullptr; + hidl_cb(err, outData); return Void(); } +/* + * Populates the HIDL fence handle for the given fence object + * + * @param fenceFd [in] Fence file descriptor + * @param handleStorage [in] HIDL handle storage for fence + * + * @return HIDL fence handle + */ +static hidl_handle buildFenceHandle(int fenceFd, char *handleStorage) { + native_handle_t *handle = nullptr; + if (fenceFd >= 0) { + handle = native_handle_init(handleStorage, 1, 0); + handle->data[0] = fenceFd; + } + + return hidl_handle(handle); +} + Return<void> GrallocMapper::unlock(void *buffer, unlock_cb hidl_cb) { - common::unlock(buffer, hidl_cb); + int fenceFd = -1; + const native_handle_t *handle = common::getBuffer(buffer); + + if (handle == nullptr) { + hidl_cb(hidl::Error::BAD_BUFFER, nullptr); + } + + hidl::Error err = + static_cast<hidl::Error>(common::unlock(handle, &fenceFd)); + if (err == hidl::Error::NONE) { + NATIVE_HANDLE_DECLARE_STORAGE(fenceStorage, 1, 0); + hidl_cb(err, buildFenceHandle(fenceFd, fenceStorage)); + + if (fenceFd >= 0) { + close(fenceFd); + } + } else { + hidl_cb(err, nullptr); + } return Void(); } Return<void> GrallocMapper::flushLockedBuffer(void *buffer, flushLockedBuffer_cb hidl_cb) { - common::flushLockedBuffer(buffer, hidl_cb); + hidl::Error err = static_cast<hidl::Error>(common::flushLockedBuffer(static_cast<buffer_handle_t>(buffer))); + hidl_cb(err, hidl_handle{}); return Void(); } -Return<Error> GrallocMapper::rereadLockedBuffer(void *buffer) +Return<hidl::Error> GrallocMapper::rereadLockedBuffer(void *buffer) { - return common::rereadLockedBuffer(buffer); + return static_cast<hidl::Error>(common::rereadLockedBuffer(common::getBuffer(buffer))); } Return<void> GrallocMapper::get(void *buffer, const MetadataType &metadataType, IMapper::get_cb hidl_cb) { - common::get(buffer, metadataType, hidl_cb); + std::vector<uint8_t> vec; + hidl::Error err = static_cast<hidl::Error>( + common::get(common::getBuffer(buffer), common::MetadataType(metadataType), vec)); + hidl_cb(err, hidl_vec(vec)); return Void(); } -Return<Error> GrallocMapper::set(void *buffer, const MetadataType &metadataType, const hidl_vec<uint8_t> &metadata) +Return<hidl::Error> GrallocMapper::set(void *buffer, const MetadataType &metadataType, const hidl_vec<uint8_t> &metadata) { - return common::set(buffer, metadataType, metadata); + buffer_handle_t bufferHandle = common::getBuffer(buffer); + return static_cast<hidl::Error>(common::set(bufferHandle, common::MetadataType(metadataType), metadata)); } Return<void> GrallocMapper::getFromBufferDescriptorInfo(const BufferDescriptorInfo &description, const MetadataType &metadataType, getFromBufferDescriptorInfo_cb hidl_cb) { - common::getFromBufferDescriptorInfo(description, metadataType, hidl_cb); + std::vector<uint8_t> vec; + hidl::Error err = static_cast<hidl::Error>(common::getFromBufferDescriptorInfo( + description, common::MetadataType(metadataType), vec)); + hidl_cb(err, vec); return Void(); } Return<void> GrallocMapper::getTransportSize(void *buffer, getTransportSize_cb hidl_cb) { - common::getTransportSize(buffer, hidl_cb); + uint32_t outNumFds = 0, outNumInts = 0; + buffer_handle_t bufferHandle = common::getBuffer(buffer); + hidl::Error err = static_cast<hidl::Error>(common::getTransportSize(bufferHandle, &outNumFds, &outNumInts)); + hidl_cb(err, outNumFds, outNumInts); return Void(); } @@ -131,33 +216,52 @@ Return<void> GrallocMapper::isSupported(const IMapper::BufferDescriptorInfo &des if (!common::validateDescriptorInfo<BufferDescriptorInfo>(description)) { MALI_GRALLOC_LOGE("Invalid descriptor attributes for validating buffer size"); - hidl_cb(Error::BAD_VALUE, false); + hidl_cb(hidl::Error::BAD_VALUE, false); } - common::isSupported(description, hidl_cb); + hidl_cb(hidl::Error::NONE, common::isSupported(description)); return Void(); } Return<void> GrallocMapper::listSupportedMetadataTypes(listSupportedMetadataTypes_cb hidl_cb) { - common::listSupportedMetadataTypes(hidl_cb); + std::vector<common::MetadataTypeDescription> desc = common::listSupportedMetadataTypes(); + std::vector<IMapper::MetadataTypeDescription> hidl_description(desc.size()); + std::copy(desc.begin(), desc.end(), hidl_description.begin()); + hidl_cb(hidl::Error::NONE, hidl_vec(hidl_description)); return Void(); } Return<void> GrallocMapper::dumpBuffer(void *buffer, dumpBuffer_cb hidl_cb) { - common::dumpBuffer(buffer, hidl_cb); + common::BufferDump out; + hidl::Error err = static_cast<hidl::Error>(common::dumpBuffer(common::getBuffer(buffer), out)); + hidl_cb(err, static_cast<IMapper::BufferDump>(out)); return Void(); } Return<void> GrallocMapper::dumpBuffers(dumpBuffers_cb hidl_cb) { - common::dumpBuffers(hidl_cb); + auto bufferDump = common::dumpBuffers(); + std::vector<IMapper::BufferDump> outBufDump; + for (auto dump : bufferDump) { + outBufDump.push_back(static_cast<IMapper::BufferDump>(dump)); + } + hidl_cb(hidl::Error::NONE, hidl_vec(outBufDump)); return Void(); } Return<void> GrallocMapper::getReservedRegion(void *buffer, getReservedRegion_cb hidl_cb) { - common::getReservedRegion(buffer, hidl_cb); + void *reservedRegion = nullptr; + uint64_t reservedSize = 0; + hidl::Error err = static_cast<hidl::Error>( + common::getReservedRegion(static_cast<buffer_handle_t>(buffer), + &reservedRegion, reservedSize)); + if (err != hidl::Error::NONE) { + reservedRegion = nullptr; + reservedSize = 0; + } + hidl_cb(err, reservedRegion, reservedSize); return Void(); } |