diff options
Diffstat (limited to 'libshims/ui')
-rw-r--r-- | libshims/ui/GraphicBuffer.cpp | 3 | ||||
-rw-r--r-- | libshims/ui/GraphicBufferAllocator.cpp | 166 | ||||
-rw-r--r-- | libshims/ui/GraphicBufferMapper.cpp | 227 |
3 files changed, 327 insertions, 69 deletions
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 <grallocusage/GrallocUsageConversion.h> -#include <ui/Gralloc2.h> #include <ui/GraphicBufferAllocator.h> #include <ui/GraphicBufferMapper.h> #include <utils/Trace.h> @@ -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 <ui/GraphicBufferAllocator.h> +#include <limits.h> #include <stdio.h> #include <grallocusage/GrallocUsageConversion.h> @@ -32,6 +33,7 @@ #include <ui/Gralloc.h> #include <ui/Gralloc2.h> #include <ui/Gralloc3.h> +#include <ui/Gralloc4.h> #include <ui/GraphicBufferMapper.h> namespace android { @@ -45,43 +47,49 @@ Mutex GraphicBufferAllocator::sLock; KeyedVector<buffer_handle_t, GraphicBufferAllocator::alloc_rec_t> 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<const Gralloc4Allocator>( + reinterpret_cast<const Gralloc4Mapper&>(mMapper.getGrallocMapper())); + if (mAllocator->isLoaded()) { + return; + } + mAllocator = std::make_unique<const Gralloc3Allocator>( + reinterpret_cast<const Gralloc3Mapper&>(mMapper.getGrallocMapper())); + if (mAllocator->isLoaded()) { + return; + } + mAllocator = std::make_unique<const Gralloc2Allocator>( + reinterpret_cast<const Gralloc2Mapper&>(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<buffer_handle_t, alloc_rec_t>& 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<c ; i++) { const alloc_rec_t& rec(list.valueAt(i)); if (rec.size) { StringAppendF(&result, "%10p: %7.2f KiB | %4u (%4u) x %4u | %4u | %8X | 0x%" PRIx64 " | %s\n", - list.keyAt(i), rec.size / 1024.0, rec.width, rec.stride, rec.height, + list.keyAt(i), static_cast<double>(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<double>(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<size_t>::max() / width / height < static_cast<size_t>(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<uint64_t>((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<buffer_handle_t, alloc_rec_t>& 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<size_t>(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<size_t>::max() / height / (*stride) < static_cast<size_t>(bpp)) { + bufSize = static_cast<size_t>(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<size_t>((*stride)) * height * bpp; } + + Mutex::Autolock _l(sLock); + KeyedVector<buffer_handle_t, alloc_rec_t>& 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<buffer_handle_t, alloc_rec_t>& list(sAllocList); - list.removeItem(handle); - } + Mutex::Autolock _l(sLock); + KeyedVector<buffer_handle_t, alloc_rec_t>& 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 <ui/Gralloc.h> #include <ui/Gralloc2.h> #include <ui/Gralloc3.h> +#include <ui/Gralloc4.h> #include <ui/GraphicBuffer.h> #include <system/graphics.h> @@ -47,20 +48,38 @@ ANDROID_SINGLETON_STATIC_INSTANCE( GraphicBufferMapper ) void GraphicBufferMapper::preloadHal() { Gralloc2Mapper::preload(); Gralloc3Mapper::preload(); + Gralloc4Mapper::preload(); } GraphicBufferMapper::GraphicBufferMapper() { + mMapper = std::make_unique<const Gralloc4Mapper>(); + if (mMapper->isLoaded()) { + mMapperVersion = Version::GRALLOC_4; + return; + } mMapper = std::make_unique<const Gralloc3Mapper>(); - if (!mMapper->isLoaded()) { - mMapper = std::make_unique<const Gralloc2Mapper>(); - 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<const Gralloc2Mapper>(); + 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<ui::PlaneLayout>* 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<ui::Smpte2086>* outSmpte2086) { + return mMapper->getSmpte2086(bufferHandle, outSmpte2086); +} + +status_t GraphicBufferMapper::getCta861_3(buffer_handle_t bufferHandle, + std::optional<ui::Cta861_3>* outCta861_3) { + return mMapper->getCta861_3(bufferHandle, outCta861_3); +} + +status_t GraphicBufferMapper::getSmpte2094_40( + buffer_handle_t bufferHandle, std::optional<std::vector<uint8_t>>* 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<ui::PlaneLayout>* outPlaneLayouts) { + return mMapper->getDefaultPlaneLayouts(width, height, format, layerCount, usage, + outPlaneLayouts); +} + // --------------------------------------------------------------------------- }; // namespace android |