diff --git a/sensors/1.0/vts/functional/Android.bp b/sensors/1.0/vts/functional/Android.bp index 444797d4d0..7bb992bf23 100644 --- a/sensors/1.0/vts/functional/Android.bp +++ b/sensors/1.0/vts/functional/Android.bp @@ -24,7 +24,10 @@ cc_test { ], static_libs: [ "android.hardware.graphics.allocator@2.0", + "android.hardware.graphics.allocator@3.0", "android.hardware.graphics.mapper@2.0", + "android.hardware.graphics.mapper@2.1", + "android.hardware.graphics.mapper@3.0", "android.hardware.sensors@1.0", "VtsHalSensorsTargetTestUtils", ], diff --git a/sensors/2.0/vts/functional/Android.bp b/sensors/2.0/vts/functional/Android.bp index 98f0eacae9..4765fa2797 100644 --- a/sensors/2.0/vts/functional/Android.bp +++ b/sensors/2.0/vts/functional/Android.bp @@ -24,7 +24,10 @@ cc_test { ], static_libs: [ "android.hardware.graphics.allocator@2.0", + "android.hardware.graphics.allocator@3.0", "android.hardware.graphics.mapper@2.0", + "android.hardware.graphics.mapper@2.1", + "android.hardware.graphics.mapper@3.0", "android.hardware.sensors@1.0", "android.hardware.sensors@2.0", "libfmq", diff --git a/sensors/common/vts/utils/Android.bp b/sensors/common/vts/utils/Android.bp index 8da554aa40..02dc608858 100644 --- a/sensors/common/vts/utils/Android.bp +++ b/sensors/common/vts/utils/Android.bp @@ -31,7 +31,10 @@ cc_library_static { ], static_libs: [ "android.hardware.graphics.allocator@2.0", + "android.hardware.graphics.allocator@3.0", "android.hardware.graphics.mapper@2.0", + "android.hardware.graphics.mapper@2.1", + "android.hardware.graphics.mapper@3.0", "android.hardware.sensors@1.0", "VtsHalHidlTargetTestBase", ], diff --git a/sensors/common/vts/utils/GrallocWrapper.cpp b/sensors/common/vts/utils/GrallocWrapper.cpp index 222ef9611a..1cad9135b7 100644 --- a/sensors/common/vts/utils/GrallocWrapper.cpp +++ b/sensors/common/vts/utils/GrallocWrapper.cpp @@ -16,206 +16,262 @@ #include "GrallocWrapper.h" +#include +#include +#include +#include +#include + #include +#include +#include + +using IAllocator2 = ::android::hardware::graphics::allocator::V2_0::IAllocator; +using IAllocator3 = ::android::hardware::graphics::allocator::V3_0::IAllocator; +using IMapper2 = ::android::hardware::graphics::mapper::V2_0::IMapper; +using IMapper2_1 = ::android::hardware::graphics::mapper::V2_1::IMapper; +using IMapper3 = ::android::hardware::graphics::mapper::V3_0::IMapper; + +using Error2 = ::android::hardware::graphics::mapper::V2_0::Error; +using Error3 = ::android::hardware::graphics::mapper::V3_0::Error; + +using ::android::hardware::graphics::common::V1_0::BufferUsage; +using ::android::hardware::graphics::common::V1_0::PixelFormat; + +// This is a typedef to the same underlying type across v2.0 and v3.0 +using ::android::hardware::graphics::mapper::V2_0::BufferDescriptor; + +using ::android::hardware::hidl_handle; +using ::android::hardware::hidl_string; +using ::android::hardware::hidl_vec; + namespace android { -GrallocWrapper::GrallocWrapper() { - init(); +// Since we use the same APIs across allocator/mapper HALs but they have major +// version differences (meaning they are not related through inheritance), we +// create a common interface abstraction for the IAllocator + IMapper combination +// (major versions need to match in the current HALs, e.g. IAllocator 3.0 needs to +// be paired with IMapper 3.0, so these are tied together) +class IGrallocHalWrapper { + public: + virtual ~IGrallocHalWrapper() = default; + + // IAllocator + virtual std::string dumpDebugInfo() = 0; + virtual native_handle_t* allocate(uint32_t size) = 0; + virtual void freeBuffer(native_handle_t* bufferHandle) = 0; + + // IMapper + virtual void* lock(native_handle_t* bufferHandle) = 0; + virtual void unlock(native_handle_t* bufferHandle) = 0; +}; + +namespace { + +bool failed(Error2 error) { + return (error != Error2::NONE); +} +bool failed(Error3 error) { + return (error != Error3::NONE); } -void GrallocWrapper::init() { - mAllocator = allocator2::IAllocator::getService(); - if (mAllocator == nullptr) { - ALOGE("Failed to get allocator service"); - } - - mMapper = mapper2::IMapper::getService(); - if (mMapper == nullptr) { - ALOGE("Failed to get mapper service"); - } else if (mMapper->isRemote()) { - ALOGE("Mapper is not in passthrough mode"); - } -} - -GrallocWrapper::~GrallocWrapper() { - for (auto bufferHandle : mClonedBuffers) { - auto buffer = const_cast(bufferHandle); - native_handle_close(buffer); - native_handle_delete(buffer); - } - mClonedBuffers.clear(); - - for (auto bufferHandle : mImportedBuffers) { - auto buffer = const_cast(bufferHandle); - if (mMapper->freeBuffer(buffer) != mapper2::Error::NONE) { - ALOGE("Failed to free buffer %p", buffer); +// Since all the type and function names are the same for the things we use across the major HAL +// versions, we use template magic to avoid repeating ourselves. +template +class GrallocHalWrapper : public IGrallocHalWrapper { + public: + GrallocHalWrapper(const sp& allocator, const sp& mapper) + : mAllocator(allocator), mMapper(mapper) { + if (mapper->isRemote()) { + ALOGE("Mapper is in passthrough mode"); } } - mImportedBuffers.clear(); -} -sp GrallocWrapper::getAllocator() const { - return mAllocator; -} + virtual std::string dumpDebugInfo() override; + virtual native_handle_t* allocate(uint32_t size) override; + virtual void freeBuffer(native_handle_t* bufferHandle) override; -std::string GrallocWrapper::dumpDebugInfo() { + virtual void* lock(native_handle_t* bufferHandle) override; + virtual void unlock(native_handle_t* bufferHandle) override; + + private: + static constexpr uint64_t kBufferUsage = + static_cast(BufferUsage::SENSOR_DIRECT_DATA | BufferUsage::CPU_READ_OFTEN); + sp mAllocator; + sp mMapper; + + BufferDescriptor getDescriptor(uint32_t size); + native_handle_t* importBuffer(const hidl_handle& rawHandle); +}; + +template +std::string GrallocHalWrapper::dumpDebugInfo() { std::string debugInfo; - mAllocator->dumpDebugInfo([&](const auto& tmpDebugInfo) { debugInfo = tmpDebugInfo.c_str(); }); - + mAllocator->dumpDebugInfo([&](const hidl_string& tmpDebugInfo) { debugInfo = tmpDebugInfo; }); return debugInfo; } -const native_handle_t* GrallocWrapper::cloneBuffer(const hardware::hidl_handle& rawHandle) { - const native_handle_t* bufferHandle = native_handle_clone(rawHandle.getNativeHandle()); +template +native_handle_t* GrallocHalWrapper::allocate(uint32_t size) { + constexpr uint32_t kBufferCount = 1; + BufferDescriptor descriptor = getDescriptor(size); + native_handle_t* bufferHandle = nullptr; - if (bufferHandle) { - mClonedBuffers.insert(bufferHandle); - } + auto callback = [&](auto error, uint32_t /*stride*/, const hidl_vec& buffers) { + if (failed(error)) { + ALOGE("Failed to allocate buffer: %" PRId32, static_cast(error)); + } else if (buffers.size() != kBufferCount) { + ALOGE("Invalid buffer array size (got %zu, expected %" PRIu32 ")", buffers.size(), + kBufferCount); + } else { + bufferHandle = importBuffer(buffers[0]); + } + }; + + mAllocator->allocate(descriptor, kBufferCount, callback); return bufferHandle; } -std::vector GrallocWrapper::allocate( - const mapper2::BufferDescriptor& descriptor, uint32_t count, bool import, uint32_t* outStride) { - std::vector bufferHandles; - bufferHandles.reserve(count); - mAllocator->allocate(descriptor, count, - [&](const auto& tmpError, const auto& tmpStride, const auto& tmpBuffers) { - if (mapper2::Error::NONE != tmpError) { - ALOGE("Failed to allocate buffers"); - } - if (count != tmpBuffers.size()) { - ALOGE("Invalid buffer array"); - } - - for (uint32_t i = 0; i < count; i++) { - if (import) { - bufferHandles.push_back(importBuffer(tmpBuffers[i])); - } else { - bufferHandles.push_back(cloneBuffer(tmpBuffers[i])); - } - } - - if (outStride) { - *outStride = tmpStride; - } - }); - - return bufferHandles; +template +void GrallocHalWrapper::freeBuffer(native_handle_t* bufferHandle) { + auto error = mMapper->freeBuffer(bufferHandle); + if (!error.isOk() || failed(error)) { + ALOGE("Failed to free buffer %p", bufferHandle); + } } -const native_handle_t* GrallocWrapper::allocate( - const mapper2::IMapper::BufferDescriptorInfo& descriptorInfo, bool import, - uint32_t* outStride) { - mapper2::BufferDescriptor descriptor = createDescriptor(descriptorInfo); - auto buffers = allocate(descriptor, 1, import, outStride); - return buffers[0]; -} +template +BufferDescriptor GrallocHalWrapper::getDescriptor(uint32_t size) { + typename MapperT::BufferDescriptorInfo descriptorInfo = { + .width = size, + .height = 1, + .layerCount = 1, + .usage = kBufferUsage, + .format = static_cast(PixelFormat::BLOB), + }; -sp GrallocWrapper::getMapper() const { - return mMapper; -} - -mapper2::BufferDescriptor GrallocWrapper::createDescriptor( - const mapper2::IMapper::BufferDescriptorInfo& descriptorInfo) { - mapper2::BufferDescriptor descriptor; - mMapper->createDescriptor(descriptorInfo, [&](const auto& tmpError, const auto& tmpDescriptor) { - if (tmpError != mapper2::Error::NONE) { - ALOGE("Failed to create descriptor"); + BufferDescriptor descriptor; + auto callback = [&](auto error, const BufferDescriptor& tmpDescriptor) { + if (failed(error)) { + ALOGE("Failed to create descriptor: %" PRId32, static_cast(error)); + } else { + descriptor = tmpDescriptor; } - descriptor = tmpDescriptor; - }); + }; + mMapper->createDescriptor(descriptorInfo, callback); return descriptor; } -const native_handle_t* GrallocWrapper::importBuffer(const hardware::hidl_handle& rawHandle) { - const native_handle_t* bufferHandle = nullptr; - mMapper->importBuffer(rawHandle, [&](const auto& tmpError, const auto& tmpBuffer) { - if (tmpError != mapper2::Error::NONE) { - ALOGE("Failed to import buffer %p", rawHandle.getNativeHandle()); - } - bufferHandle = static_cast(tmpBuffer); - }); +template +native_handle_t* GrallocHalWrapper::importBuffer( + const hidl_handle& rawHandle) { + native_handle_t* bufferHandle = nullptr; - if (bufferHandle) { - mImportedBuffers.insert(bufferHandle); - } + mMapper->importBuffer(rawHandle, [&](auto error, void* tmpBuffer) { + if (failed(error)) { + ALOGE("Failed to import buffer %p: %" PRId32, rawHandle.getNativeHandle(), + static_cast(error)); + } else { + bufferHandle = static_cast(tmpBuffer); + } + }); return bufferHandle; } -void GrallocWrapper::freeBuffer(const native_handle_t* bufferHandle) { - auto buffer = const_cast(bufferHandle); - - if (mImportedBuffers.erase(bufferHandle)) { - mapper2::Error error = mMapper->freeBuffer(buffer); - if (error != mapper2::Error::NONE) { - ALOGE("Failed to free %p", buffer); - } - } else { - mClonedBuffers.erase(bufferHandle); - native_handle_close(buffer); - native_handle_delete(buffer); - } -} - -void* GrallocWrapper::lock(const native_handle_t* bufferHandle, uint64_t cpuUsage, - const mapper2::IMapper::Rect& accessRegion, int acquireFence) { - auto buffer = const_cast(bufferHandle); - - NATIVE_HANDLE_DECLARE_STORAGE(acquireFenceStorage, 1, 0); - hardware::hidl_handle acquireFenceHandle; - if (acquireFence >= 0) { - auto h = native_handle_init(acquireFenceStorage, 1, 0); - h->data[0] = acquireFence; - acquireFenceHandle = h; - } +template +void* GrallocHalWrapper::lock(native_handle_t* bufferHandle) { + // Per the HAL, all-zeros Rect means the entire buffer + typename MapperT::Rect accessRegion = {}; + hidl_handle acquireFenceHandle; // No fence needed, already safe to lock void* data = nullptr; - mMapper->lock(buffer, cpuUsage, accessRegion, acquireFenceHandle, - [&](const auto& tmpError, const auto& tmpData) { - if (tmpError != mapper2::Error::NONE) { - ALOGE("Failed to lock buffer %p", buffer); + mMapper->lock(bufferHandle, kBufferUsage, accessRegion, acquireFenceHandle, + [&](auto error, void* tmpData, ...) { // V3_0 passes extra args we don't use + if (failed(error)) { + ALOGE("Failed to lock buffer %p: %" PRId32, bufferHandle, + static_cast(error)); + } else { + data = tmpData; } - data = tmpData; }); - if (acquireFence >= 0) { - close(acquireFence); - } - return data; } -int GrallocWrapper::unlock(const native_handle_t* bufferHandle) { - auto buffer = const_cast(bufferHandle); - - int releaseFence = -1; - mMapper->unlock(buffer, [&](const auto& tmpError, const auto& tmpReleaseFence) { - if (tmpError != mapper2::Error::NONE) { - ALOGE("Failed to unlock buffer %p", buffer); - } - - auto fenceHandle = tmpReleaseFence.getNativeHandle(); - if (fenceHandle) { - if (fenceHandle->numInts != 0) { - ALOGE("Invalid fence handle %p", fenceHandle); - } - if (fenceHandle->numFds == 1) { - releaseFence = dup(fenceHandle->data[0]); - if (releaseFence < 0) { - ALOGE("Failed to dup fence fd"); - } - } else { - if (fenceHandle->numFds != 0) { - ALOGE("Invalid fence handle %p", fenceHandle); - } - } +template +void GrallocHalWrapper::unlock(native_handle_t* bufferHandle) { + mMapper->unlock(bufferHandle, [&](auto error, const hidl_handle& /*releaseFence*/) { + if (failed(error)) { + ALOGE("Failed to unlock buffer %p: %" PRId32, bufferHandle, + static_cast(error)); } }); +} - return releaseFence; +} // anonymous namespace + +GrallocWrapper::GrallocWrapper() { + sp allocator3 = IAllocator3::getService(); + sp mapper3 = IMapper3::getService(); + + if (allocator3 != nullptr && mapper3 != nullptr) { + mGrallocHal = std::unique_ptr( + new GrallocHalWrapper(allocator3, mapper3)); + } else { + ALOGD("Graphics HALs 3.0 not found (allocator %d mapper %d), falling back to 2.x", + (allocator3 != nullptr), (mapper3 != nullptr)); + + sp allocator2 = IAllocator2::getService(); + sp mapper2 = IMapper2_1::getService(); + if (mapper2 == nullptr) { + mapper2 = IMapper2::getService(); + } + + if (allocator2 != nullptr && mapper2 != nullptr) { + mGrallocHal = std::unique_ptr( + new GrallocHalWrapper(allocator2, mapper2)); + } else { + ALOGE("Couldn't open 2.x/3.0 graphics HALs (2.x allocator %d mapper %d)", + (allocator2 != nullptr), (mapper2 != nullptr)); + } + } +} + +GrallocWrapper::~GrallocWrapper() { + for (auto bufferHandle : mAllocatedBuffers) { + mGrallocHal->unlock(bufferHandle); + mGrallocHal->freeBuffer(bufferHandle); + } + mAllocatedBuffers.clear(); +} + +std::string GrallocWrapper::dumpDebugInfo() { + return mGrallocHal->dumpDebugInfo(); +} + +std::pair GrallocWrapper::allocate(uint32_t size) { + native_handle_t* bufferHandle = mGrallocHal->allocate(size); + void* buffer = nullptr; + if (bufferHandle) { + buffer = mGrallocHal->lock(bufferHandle); + if (buffer) { + mAllocatedBuffers.insert(bufferHandle); + } else { + mGrallocHal->freeBuffer(bufferHandle); + bufferHandle = nullptr; + } + } + return std::make_pair<>(bufferHandle, buffer); +} + +void GrallocWrapper::freeBuffer(native_handle_t* bufferHandle) { + if (mAllocatedBuffers.erase(bufferHandle)) { + mGrallocHal->unlock(bufferHandle); + mGrallocHal->freeBuffer(bufferHandle); + } } } // namespace android diff --git a/sensors/common/vts/utils/SensorsTestSharedMemory.cpp b/sensors/common/vts/utils/SensorsTestSharedMemory.cpp index 819e2974f7..3b068bd5c5 100644 --- a/sensors/common/vts/utils/SensorsTestSharedMemory.cpp +++ b/sensors/common/vts/utils/SensorsTestSharedMemory.cpp @@ -119,32 +119,13 @@ SensorsTestSharedMemory::SensorsTestSharedMemory(SharedMemType type, size_t size } case SharedMemType::GRALLOC: { mGrallocWrapper = std::make_unique<::android::GrallocWrapper>(); - if (mGrallocWrapper->getAllocator() == nullptr || - mGrallocWrapper->getMapper() == nullptr) { + if (!mGrallocWrapper->isInitialized()) { break; } - using android::hardware::graphics::common::V1_0::BufferUsage; - using android::hardware::graphics::common::V1_0::PixelFormat; - mapper2::IMapper::BufferDescriptorInfo buf_desc_info = { - .width = static_cast(size), - .height = 1, - .layerCount = 1, - .usage = static_cast(BufferUsage::SENSOR_DIRECT_DATA | - BufferUsage::CPU_READ_OFTEN), - .format = PixelFormat::BLOB}; - handle = const_cast(mGrallocWrapper->allocate(buf_desc_info)); - if (handle != nullptr) { - mapper2::IMapper::Rect region{0, 0, static_cast(buf_desc_info.width), - static_cast(buf_desc_info.height)}; - buffer = static_cast( - mGrallocWrapper->lock(handle, buf_desc_info.usage, region, /*fence=*/-1)); - if (buffer != nullptr) { - break; - } - mGrallocWrapper->freeBuffer(handle); - handle = nullptr; - } + std::pair buf = mGrallocWrapper->allocate(size); + handle = buf.first; + buffer = static_cast(buf.second); break; } default: @@ -175,9 +156,7 @@ SensorsTestSharedMemory::~SensorsTestSharedMemory() { } case SharedMemType::GRALLOC: { if (mSize != 0) { - mGrallocWrapper->unlock(mNativeHandle); mGrallocWrapper->freeBuffer(mNativeHandle); - mNativeHandle = nullptr; mSize = 0; } diff --git a/sensors/common/vts/utils/include/sensors-vts-utils/GrallocWrapper.h b/sensors/common/vts/utils/include/sensors-vts-utils/GrallocWrapper.h index 3bd73c36e0..41e6334893 100644 --- a/sensors/common/vts/utils/include/sensors-vts-utils/GrallocWrapper.h +++ b/sensors/common/vts/utils/include/sensors-vts-utils/GrallocWrapper.h @@ -14,66 +14,47 @@ * limitations under the License. */ -#ifndef GRALLO_WRAPPER_H_ -#define GRALLO_WRAPPER_H_ +#pragma once +#include + +#include +#include #include - -#include -#include - -namespace allocator2 = ::android::hardware::graphics::allocator::V2_0; -namespace mapper2 = ::android::hardware::graphics::mapper::V2_0; +#include namespace android { -// Modified from hardware/interfaces/graphics/mapper/2.0/vts/functional/ +class IGrallocHalWrapper; + +// Reference: hardware/interfaces/graphics/mapper/2.0/vts/functional/ class GrallocWrapper { public: GrallocWrapper(); ~GrallocWrapper(); - sp getAllocator() const; - sp getMapper() const; + // After constructing this object, this function must be called to check the result. If it + // returns false, other methods are not safe to call. + bool isInitialized() const { return (mGrallocHal != nullptr); }; std::string dumpDebugInfo(); - // When import is false, this simply calls IAllocator::allocate. When import - // is true, the returned buffers are also imported into the mapper. - // - // Either case, the returned buffers must be freed with freeBuffer. - std::vector allocate(const mapper2::BufferDescriptor& descriptor, - uint32_t count, bool import = true, - uint32_t* outStride = nullptr); - const native_handle_t* allocate(const mapper2::IMapper::BufferDescriptorInfo& descriptorInfo, - bool import = true, uint32_t* outStride = nullptr); + // Allocates a gralloc buffer suitable for direct channel sensors usage with the given size. + // The buffer should be freed using freeBuffer when it's not needed anymore; otherwise it'll + // be freed when this object is destroyed. + // Returns a handle to the buffer, and a CPU-accessible pointer for reading. On failure, both + // will be set to nullptr. + std::pair allocate(uint32_t size); - mapper2::BufferDescriptor createDescriptor( - const mapper2::IMapper::BufferDescriptorInfo& descriptorInfo); + // Releases a gralloc buffer previously returned by allocate() + void freeBuffer(native_handle_t* bufferHandle); - const native_handle_t* importBuffer(const hardware::hidl_handle& rawHandle); - void freeBuffer(const native_handle_t* bufferHandle); - - // We use fd instead of hardware::hidl_handle in these functions to pass fences - // in and out of the mapper. The ownership of the fd is always transferred - // with each of these functions. - void* lock(const native_handle_t* bufferHandle, uint64_t cpuUsage, - const mapper2::IMapper::Rect& accessRegion, int acquireFence); - - int unlock(const native_handle_t* bufferHandle); - - private: - void init(); - const native_handle_t* cloneBuffer(const hardware::hidl_handle& rawHandle); - - sp mAllocator; - sp mMapper; + private: + std::unique_ptr mGrallocHal; // Keep track of all cloned and imported handles. When a test fails with // ASSERT_*, the destructor will free the handles for the test. - std::unordered_set mClonedBuffers; - std::unordered_set mImportedBuffers; + std::unordered_set mAllocatedBuffers; }; } // namespace android -#endif // GRALLO_WRAPPER_H_