From 8eafdd86e7b6dffdfaf21d25219d27b86835d95e Mon Sep 17 00:00:00 2001 From: koron393 Date: Mon, 30 Nov 2020 02:51:05 +0900 Subject: shinano-common: libshim_camera: Update GraphicBuffer sources to Android 11 Signed-off-by: koron393 Change-Id: I25387250e4369a2bd0a097a32a85258e0951db10 --- libshims/ui/GraphicBuffer.cpp | 3 - libshims/ui/GraphicBufferAllocator.cpp | 166 +++++++++++++++--------- libshims/ui/GraphicBufferMapper.cpp | 227 +++++++++++++++++++++++++++++++-- 3 files changed, 327 insertions(+), 69 deletions(-) (limited to 'libshims/ui') diff --git a/libshims/ui/GraphicBuffer.cpp b/libshims/ui/GraphicBuffer.cpp index d70701d..c0423aa 100644 --- a/libshims/ui/GraphicBuffer.cpp +++ b/libshims/ui/GraphicBuffer.cpp @@ -23,7 +23,6 @@ #include -#include #include #include #include @@ -450,8 +449,6 @@ status_t GraphicBuffer::unflatten(void const*& buffer, size_t& size, int const*& } else if (buf[0] == 'GBFR') { // old version, when usage bits were 32-bits flattenWordCount = 12; - } else if (buf[0] == 'BHBB') { // BufferHub backed buffer. - return BAD_TYPE; } else { return BAD_TYPE; } diff --git a/libshims/ui/GraphicBufferAllocator.cpp b/libshims/ui/GraphicBufferAllocator.cpp index 9543fd7..943d13e 100644 --- a/libshims/ui/GraphicBufferAllocator.cpp +++ b/libshims/ui/GraphicBufferAllocator.cpp @@ -20,6 +20,7 @@ #include +#include #include #include @@ -32,6 +33,7 @@ #include #include #include +#include #include namespace android { @@ -45,43 +47,49 @@ Mutex GraphicBufferAllocator::sLock; KeyedVector GraphicBufferAllocator::sAllocList; -GraphicBufferAllocator::GraphicBufferAllocator() - : mAllocDev(0) -{ - hw_module_t const* module; - int err = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module); - ALOGE_IF(err, "FATAL: can't find the %s module", GRALLOC_HARDWARE_MODULE_ID); - if (err == 0) { - gralloc_open(module, &mAllocDev); +GraphicBufferAllocator::GraphicBufferAllocator() : mMapper(GraphicBufferMapper::getInstance()) { + mAllocator = std::make_unique( + reinterpret_cast(mMapper.getGrallocMapper())); + if (mAllocator->isLoaded()) { + return; + } + mAllocator = std::make_unique( + reinterpret_cast(mMapper.getGrallocMapper())); + if (mAllocator->isLoaded()) { + return; + } + mAllocator = std::make_unique( + reinterpret_cast(mMapper.getGrallocMapper())); + if (mAllocator->isLoaded()) { + return; } -} -GraphicBufferAllocator::~GraphicBufferAllocator() -{ - gralloc_close(mAllocDev); + LOG_ALWAYS_FATAL("gralloc-allocator is missing"); } -size_t GraphicBufferAllocator::getTotalSize() const { +GraphicBufferAllocator::~GraphicBufferAllocator() {} + +uint64_t GraphicBufferAllocator::getTotalSize() const { Mutex::Autolock _l(sLock); - size_t total = 0; + uint64_t total = 0; for (size_t i = 0; i < sAllocList.size(); ++i) { total += sAllocList.valueAt(i).size; } return total; } -void GraphicBufferAllocator::dump(std::string& result) const { +void GraphicBufferAllocator::dump(std::string& result, bool less) const { Mutex::Autolock _l(sLock); KeyedVector& list(sAllocList); - size_t total = 0; - result.append("Allocated buffers:\n"); + uint64_t total = 0; + result.append("GraphicBufferAllocator buffers:\n"); const size_t c = list.size(); for (size_t i=0 ; i(rec.size) / 1024.0, rec.width, rec.stride, rec.height, rec.layerCount, rec.format, rec.usage, rec.requestorName.c_str()); } else { StringAppendF(&result, @@ -91,23 +99,22 @@ void GraphicBufferAllocator::dump(std::string& result) const { } total += rec.size; } - StringAppendF(&result, "Total allocated (estimate): %.2f KB\n", total / 1024.0); + StringAppendF(&result, "Total allocated by GraphicBufferAllocator (estimate): %.2f KB\n", + static_cast(total) / 1024.0); - result.append(mAllocator->dumpDebugInfo()); + result.append(mAllocator->dumpDebugInfo(less)); } -void GraphicBufferAllocator::dumpToSystemLog() -{ +void GraphicBufferAllocator::dumpToSystemLog(bool less) { std::string s; - GraphicBufferAllocator::getInstance().dump(s); + GraphicBufferAllocator::getInstance().dump(s, less); ALOGD("%s", s.c_str()); } -status_t GraphicBufferAllocator::allocate(uint32_t width, uint32_t height, - PixelFormat format, uint32_t layerCount, uint64_t usage, - buffer_handle_t* handle, uint32_t* stride, - uint64_t /*graphicBufferId*/, std::string requestorName) -{ +status_t GraphicBufferAllocator::allocateHelper(uint32_t width, uint32_t height, PixelFormat format, + uint32_t layerCount, uint64_t usage, + buffer_handle_t* handle, uint32_t* stride, + std::string requestorName, bool importBuffer) { ATRACE_CALL(); // make sure to not allocate a N x 0 or 0 x N buffer, since this is @@ -115,6 +122,14 @@ status_t GraphicBufferAllocator::allocate(uint32_t width, uint32_t height, if (!width || !height) width = height = 1; + const uint32_t bpp = bytesPerPixel(format); + if (std::numeric_limits::max() / width / height < static_cast(bpp)) { + ALOGE("Failed to allocate (%u x %u) layerCount %u format %d " + "usage %" PRIx64 ": Requesting too large a buffer size", + width, height, layerCount, format, usage); + return BAD_VALUE; + } + // Ensure that layerCount is valid. if (layerCount < 1) layerCount = 1; @@ -122,47 +137,82 @@ status_t GraphicBufferAllocator::allocate(uint32_t width, uint32_t height, // TODO(b/72323293, b/72703005): Remove these invalid bits from callers usage &= ~static_cast((1 << 10) | (1 << 13)); - status_t error = - mAllocator->allocate(width, height, format, layerCount, usage, 1, stride, handle); - if (error == NO_ERROR) { - Mutex::Autolock _l(sLock); - KeyedVector& list(sAllocList); - uint32_t bpp = bytesPerPixel(format); - alloc_rec_t rec; - rec.width = width; - rec.height = height; - rec.stride = *stride; - rec.format = format; - rec.layerCount = layerCount; - rec.usage = usage; - rec.size = static_cast(height * (*stride) * bpp); - rec.requestorName = std::move(requestorName); - list.add(*handle, rec); + status_t error = mAllocator->allocate(requestorName, width, height, format, layerCount, usage, + 1, stride, handle, importBuffer); + if (error != NO_ERROR) { + ALOGE("Failed to allocate (%u x %u) layerCount %u format %d " + "usage %" PRIx64 ": %d", + width, height, layerCount, format, usage, error); + return NO_MEMORY; + } + if (!importBuffer) { return NO_ERROR; + } + size_t bufSize; + + // if stride has no meaning or is too large, + // approximate size with the input width instead + if ((*stride) != 0 && + std::numeric_limits::max() / height / (*stride) < static_cast(bpp)) { + bufSize = static_cast(width) * height * bpp; } else { - ALOGE("Failed to allocate (%u x %u) layerCount %u format %d " - "usage %" PRIx64 ": %d", - width, height, layerCount, format, usage, - error); - return NO_MEMORY; + bufSize = static_cast((*stride)) * height * bpp; } + + Mutex::Autolock _l(sLock); + KeyedVector& list(sAllocList); + alloc_rec_t rec; + rec.width = width; + rec.height = height; + rec.stride = *stride; + rec.format = format; + rec.layerCount = layerCount; + rec.usage = usage; + rec.size = bufSize; + rec.requestorName = std::move(requestorName); + list.add(*handle, rec); + + return NO_ERROR; +} +status_t GraphicBufferAllocator::allocate(uint32_t width, uint32_t height, PixelFormat format, + uint32_t layerCount, uint64_t usage, + buffer_handle_t* handle, uint32_t* stride, + std::string requestorName) { + return allocateHelper(width, height, format, layerCount, usage, handle, stride, requestorName, + true); +} + +status_t GraphicBufferAllocator::allocateRawHandle(uint32_t width, uint32_t height, + PixelFormat format, uint32_t layerCount, + uint64_t usage, buffer_handle_t* handle, + uint32_t* stride, std::string requestorName) { + return allocateHelper(width, height, format, layerCount, usage, handle, stride, requestorName, + false); +} + +// DEPRECATED +status_t GraphicBufferAllocator::allocate(uint32_t width, uint32_t height, PixelFormat format, + uint32_t layerCount, uint64_t usage, + buffer_handle_t* handle, uint32_t* stride, + uint64_t /*graphicBufferId*/, std::string requestorName) { + return allocateHelper(width, height, format, layerCount, usage, handle, stride, requestorName, + true); } status_t GraphicBufferAllocator::free(buffer_handle_t handle) { - status_t err; + ATRACE_CALL(); - err = mAllocDev->free(mAllocDev, handle); + // We allocated a buffer from the allocator and imported it into the + // mapper to get the handle. We just need to free the handle now. + mMapper.freeBuffer(handle); - ALOGW_IF(err, "free(...) failed %d (%s)", err, strerror(-err)); - if (err == NO_ERROR) { - Mutex::Autolock _l(sLock); - KeyedVector& list(sAllocList); - list.removeItem(handle); - } + Mutex::Autolock _l(sLock); + KeyedVector& list(sAllocList); + list.removeItem(handle); - return err; + return NO_ERROR; } // --------------------------------------------------------------------------- diff --git a/libshims/ui/GraphicBufferMapper.cpp b/libshims/ui/GraphicBufferMapper.cpp index 1efad90..95dc12c 100644 --- a/libshims/ui/GraphicBufferMapper.cpp +++ b/libshims/ui/GraphicBufferMapper.cpp @@ -35,6 +35,7 @@ #include #include #include +#include #include #include @@ -47,20 +48,38 @@ ANDROID_SINGLETON_STATIC_INSTANCE( GraphicBufferMapper ) void GraphicBufferMapper::preloadHal() { Gralloc2Mapper::preload(); Gralloc3Mapper::preload(); + Gralloc4Mapper::preload(); } GraphicBufferMapper::GraphicBufferMapper() { + mMapper = std::make_unique(); + if (mMapper->isLoaded()) { + mMapperVersion = Version::GRALLOC_4; + return; + } mMapper = std::make_unique(); - if (!mMapper->isLoaded()) { - mMapper = std::make_unique(); - mMapperVersion = Version::GRALLOC_2; - } else { + if (mMapper->isLoaded()) { mMapperVersion = Version::GRALLOC_3; + return; } - - if (!mMapper->isLoaded()) { - LOG_ALWAYS_FATAL("gralloc-mapper is missing"); + mMapper = std::make_unique(); + if (mMapper->isLoaded()) { + mMapperVersion = Version::GRALLOC_2; + return; } + + LOG_ALWAYS_FATAL("gralloc-mapper is missing"); +} + +void GraphicBufferMapper::dumpBuffer(buffer_handle_t bufferHandle, std::string& result, + bool less) const { + result.append(mMapper->dumpBuffer(bufferHandle, less)); +} + +void GraphicBufferMapper::dumpBufferToSystemLog(buffer_handle_t bufferHandle, bool less) { + std::string s; + GraphicBufferMapper::getInstance().dumpBuffer(bufferHandle, s, less); + ALOGD("%s", s.c_str()); } status_t GraphicBufferMapper::importBuffer(buffer_handle_t rawHandle, @@ -115,7 +134,7 @@ status_t GraphicBufferMapper::lock(buffer_handle_t handle, uint32_t usage, const status_t GraphicBufferMapper::lock(buffer_handle_t handle, uint32_t usage, const Rect& bounds, void** vaddr) { - return lock(handle, usage, bounds, vaddr, 0, 0); + return lockAsync(handle, usage, bounds, vaddr, -1, nullptr, nullptr); } status_t GraphicBufferMapper::lockYCbCr(buffer_handle_t handle, uint32_t usage, @@ -176,5 +195,197 @@ status_t GraphicBufferMapper::isSupported(uint32_t width, uint32_t height, uint64_t usage, bool* outSupported) { return mMapper->isSupported(width, height, format, layerCount, usage, outSupported); } + +status_t GraphicBufferMapper::getBufferId(buffer_handle_t bufferHandle, uint64_t* outBufferId) { + return mMapper->getBufferId(bufferHandle, outBufferId); +} + +status_t GraphicBufferMapper::getName(buffer_handle_t bufferHandle, std::string* outName) { + return mMapper->getName(bufferHandle, outName); +} + +status_t GraphicBufferMapper::getWidth(buffer_handle_t bufferHandle, uint64_t* outWidth) { + return mMapper->getWidth(bufferHandle, outWidth); +} + +status_t GraphicBufferMapper::getHeight(buffer_handle_t bufferHandle, uint64_t* outHeight) { + return mMapper->getHeight(bufferHandle, outHeight); +} + +status_t GraphicBufferMapper::getLayerCount(buffer_handle_t bufferHandle, uint64_t* outLayerCount) { + return mMapper->getLayerCount(bufferHandle, outLayerCount); +} + +status_t GraphicBufferMapper::getPixelFormatRequested(buffer_handle_t bufferHandle, + ui::PixelFormat* outPixelFormatRequested) { + return mMapper->getPixelFormatRequested(bufferHandle, outPixelFormatRequested); +} + +status_t GraphicBufferMapper::getPixelFormatFourCC(buffer_handle_t bufferHandle, + uint32_t* outPixelFormatFourCC) { + return mMapper->getPixelFormatFourCC(bufferHandle, outPixelFormatFourCC); +} + +status_t GraphicBufferMapper::getPixelFormatModifier(buffer_handle_t bufferHandle, + uint64_t* outPixelFormatModifier) { + return mMapper->getPixelFormatModifier(bufferHandle, outPixelFormatModifier); +} + +status_t GraphicBufferMapper::getUsage(buffer_handle_t bufferHandle, uint64_t* outUsage) { + return mMapper->getUsage(bufferHandle, outUsage); +} + +status_t GraphicBufferMapper::getAllocationSize(buffer_handle_t bufferHandle, + uint64_t* outAllocationSize) { + return mMapper->getAllocationSize(bufferHandle, outAllocationSize); +} + +status_t GraphicBufferMapper::getProtectedContent(buffer_handle_t bufferHandle, + uint64_t* outProtectedContent) { + return mMapper->getProtectedContent(bufferHandle, outProtectedContent); +} + +status_t GraphicBufferMapper::getCompression( + buffer_handle_t bufferHandle, + aidl::android::hardware::graphics::common::ExtendableType* outCompression) { + return mMapper->getCompression(bufferHandle, outCompression); +} + +status_t GraphicBufferMapper::getCompression(buffer_handle_t bufferHandle, + ui::Compression* outCompression) { + return mMapper->getCompression(bufferHandle, outCompression); +} + +status_t GraphicBufferMapper::getInterlaced( + buffer_handle_t bufferHandle, + aidl::android::hardware::graphics::common::ExtendableType* outInterlaced) { + return mMapper->getInterlaced(bufferHandle, outInterlaced); +} + +status_t GraphicBufferMapper::getInterlaced(buffer_handle_t bufferHandle, + ui::Interlaced* outInterlaced) { + return mMapper->getInterlaced(bufferHandle, outInterlaced); +} + +status_t GraphicBufferMapper::getChromaSiting( + buffer_handle_t bufferHandle, + aidl::android::hardware::graphics::common::ExtendableType* outChromaSiting) { + return mMapper->getChromaSiting(bufferHandle, outChromaSiting); +} + +status_t GraphicBufferMapper::getChromaSiting(buffer_handle_t bufferHandle, + ui::ChromaSiting* outChromaSiting) { + return mMapper->getChromaSiting(bufferHandle, outChromaSiting); +} + +status_t GraphicBufferMapper::getPlaneLayouts(buffer_handle_t bufferHandle, + std::vector* outPlaneLayouts) { + return mMapper->getPlaneLayouts(bufferHandle, outPlaneLayouts); +} + +status_t GraphicBufferMapper::getDataspace(buffer_handle_t bufferHandle, + ui::Dataspace* outDataspace) { + return mMapper->getDataspace(bufferHandle, outDataspace); +} + +status_t GraphicBufferMapper::getBlendMode(buffer_handle_t bufferHandle, + ui::BlendMode* outBlendMode) { + return mMapper->getBlendMode(bufferHandle, outBlendMode); +} + +status_t GraphicBufferMapper::getSmpte2086(buffer_handle_t bufferHandle, + std::optional* outSmpte2086) { + return mMapper->getSmpte2086(bufferHandle, outSmpte2086); +} + +status_t GraphicBufferMapper::getCta861_3(buffer_handle_t bufferHandle, + std::optional* outCta861_3) { + return mMapper->getCta861_3(bufferHandle, outCta861_3); +} + +status_t GraphicBufferMapper::getSmpte2094_40( + buffer_handle_t bufferHandle, std::optional>* outSmpte2094_40) { + return mMapper->getSmpte2094_40(bufferHandle, outSmpte2094_40); +} + +status_t GraphicBufferMapper::getDefaultPixelFormatFourCC(uint32_t width, uint32_t height, + PixelFormat format, uint32_t layerCount, + uint64_t usage, + uint32_t* outPixelFormatFourCC) { + return mMapper->getDefaultPixelFormatFourCC(width, height, format, layerCount, usage, + outPixelFormatFourCC); +} + +status_t GraphicBufferMapper::getDefaultPixelFormatModifier(uint32_t width, uint32_t height, + PixelFormat format, uint32_t layerCount, + uint64_t usage, + uint64_t* outPixelFormatModifier) { + return mMapper->getDefaultPixelFormatModifier(width, height, format, layerCount, usage, + outPixelFormatModifier); +} + +status_t GraphicBufferMapper::getDefaultAllocationSize(uint32_t width, uint32_t height, + PixelFormat format, uint32_t layerCount, + uint64_t usage, + uint64_t* outAllocationSize) { + return mMapper->getDefaultAllocationSize(width, height, format, layerCount, usage, + outAllocationSize); +} + +status_t GraphicBufferMapper::getDefaultProtectedContent(uint32_t width, uint32_t height, + PixelFormat format, uint32_t layerCount, + uint64_t usage, + uint64_t* outProtectedContent) { + return mMapper->getDefaultProtectedContent(width, height, format, layerCount, usage, + outProtectedContent); +} + +status_t GraphicBufferMapper::getDefaultCompression( + uint32_t width, uint32_t height, PixelFormat format, uint32_t layerCount, uint64_t usage, + aidl::android::hardware::graphics::common::ExtendableType* outCompression) { + return mMapper->getDefaultCompression(width, height, format, layerCount, usage, outCompression); +} + +status_t GraphicBufferMapper::getDefaultCompression(uint32_t width, uint32_t height, + PixelFormat format, uint32_t layerCount, + uint64_t usage, + ui::Compression* outCompression) { + return mMapper->getDefaultCompression(width, height, format, layerCount, usage, outCompression); +} + +status_t GraphicBufferMapper::getDefaultInterlaced( + uint32_t width, uint32_t height, PixelFormat format, uint32_t layerCount, uint64_t usage, + aidl::android::hardware::graphics::common::ExtendableType* outInterlaced) { + return mMapper->getDefaultInterlaced(width, height, format, layerCount, usage, outInterlaced); +} + +status_t GraphicBufferMapper::getDefaultInterlaced(uint32_t width, uint32_t height, + PixelFormat format, uint32_t layerCount, + uint64_t usage, ui::Interlaced* outInterlaced) { + return mMapper->getDefaultInterlaced(width, height, format, layerCount, usage, outInterlaced); +} + +status_t GraphicBufferMapper::getDefaultChromaSiting( + uint32_t width, uint32_t height, PixelFormat format, uint32_t layerCount, uint64_t usage, + aidl::android::hardware::graphics::common::ExtendableType* outChromaSiting) { + return mMapper->getDefaultChromaSiting(width, height, format, layerCount, usage, + outChromaSiting); +} + +status_t GraphicBufferMapper::getDefaultChromaSiting(uint32_t width, uint32_t height, + PixelFormat format, uint32_t layerCount, + uint64_t usage, + ui::ChromaSiting* outChromaSiting) { + return mMapper->getDefaultChromaSiting(width, height, format, layerCount, usage, + outChromaSiting); +} + +status_t GraphicBufferMapper::getDefaultPlaneLayouts( + uint32_t width, uint32_t height, PixelFormat format, uint32_t layerCount, uint64_t usage, + std::vector* outPlaneLayouts) { + return mMapper->getDefaultPlaneLayouts(width, height, format, layerCount, usage, + outPlaneLayouts); +} + // --------------------------------------------------------------------------- }; // namespace android -- cgit v1.2.3