From 25416b5a1d017e210276aca8ba9bf86bb223153e Mon Sep 17 00:00:00 2001 From: Chia-I Wu Date: Tue, 23 Jan 2018 14:14:13 -0800 Subject: [PATCH] graphics: add createDescriptor_2_1 to mapper With new formats and buffer usage bits, we need new createDescriptor. Test: VTS Change-Id: I87e39297f9c1c53377fcc62fb086629779409c16 --- graphics/mapper/2.1/IMapper.hal | 69 ++++++++++++++++++- .../VtsHalGraphicsMapperV2_1TargetTest.cpp | 68 +++++++++++++++++- 2 files changed, 132 insertions(+), 5 deletions(-) diff --git a/graphics/mapper/2.1/IMapper.hal b/graphics/mapper/2.1/IMapper.hal index a23656d455..6047e96c50 100644 --- a/graphics/mapper/2.1/IMapper.hal +++ b/graphics/mapper/2.1/IMapper.hal @@ -16,10 +16,47 @@ package android.hardware.graphics.mapper@2.1; -import android.hardware.graphics.mapper@2.0::Error; -import android.hardware.graphics.mapper@2.0::IMapper; +import android.hardware.graphics.common@1.1::BufferUsage; +import android.hardware.graphics.common@1.1::PixelFormat; +import @2.0::BufferDescriptor; +import @2.0::Error; +import @2.0::IMapper; + +interface IMapper extends @2.0::IMapper { + /** + * This is the same as @2.0::IMapper::BufferDescriptorInfo except that it + * accepts @1.1::PixelFormat and @1.1::BufferUsage. + */ + struct BufferDescriptorInfo { + /** + * The width specifies how many columns of pixels must be in the + * allocated buffer, but does not necessarily represent the offset in + * columns between the same column in adjacent rows. The rows may be + * padded. + */ + uint32_t width; + + /** + * The height specifies how many rows of pixels must be in the + * allocated buffer. + */ + uint32_t height; + + /** + * The number of image layers that must be in the allocated buffer. + */ + uint32_t layerCount; + + /** Buffer pixel format. */ + PixelFormat format; + + /** + * Buffer usage mask; valid flags can be found in the definition of + * BufferUsage. + */ + bitfield usage; + }; -interface IMapper extends android.hardware.graphics.mapper@2.0::IMapper { /** * Validate that the buffer can be safely accessed by a caller who assumes * the specified descriptorInfo and stride. This must at least validate @@ -58,4 +95,30 @@ interface IMapper extends android.hardware.graphics.mapper@2.0::IMapper { generates (Error error, uint32_t numFds, uint32_t numInts); + + /** + * This is the same as @2.0::IMapper::createDescriptor except that it + * accepts @2.1::IMapper::BufferDescriptorInfo. + * + * Creates a buffer descriptor. The descriptor can be used with IAllocator + * to allocate buffers. + * + * Since the buffer descriptor fully describes a buffer, any device + * dependent or device independent checks must be performed here whenever + * possible. Specifically, when layered buffers are not supported, this + * function must return UNSUPPORTED if layerCount is great than 1. + * + * @param descriptorInfo specifies the attributes of the descriptor. + * @return error is NONE upon success. Otherwise, + * BAD_VALUE when any of the specified attributes is + * invalid or conflicting. + * NO_RESOURCES when the creation cannot be fullfilled at + * this time. + * UNSUPPORTED when any of the specified attributes is + * not supported. + * @return descriptor is the newly created buffer descriptor. + */ + createDescriptor_2_1(BufferDescriptorInfo descriptorInfo) + generates (Error error, + BufferDescriptor descriptor); }; diff --git a/graphics/mapper/2.1/vts/functional/VtsHalGraphicsMapperV2_1TargetTest.cpp b/graphics/mapper/2.1/vts/functional/VtsHalGraphicsMapperV2_1TargetTest.cpp index 4067c8d3ac..88b96ae165 100644 --- a/graphics/mapper/2.1/vts/functional/VtsHalGraphicsMapperV2_1TargetTest.cpp +++ b/graphics/mapper/2.1/vts/functional/VtsHalGraphicsMapperV2_1TargetTest.cpp @@ -30,10 +30,27 @@ namespace V2_1 { namespace tests { namespace { +using android::hardware::graphics::mapper::V2_0::BufferDescriptor; using android::hardware::graphics::mapper::V2_0::Error; -using android::hardware::graphics::common::V1_0::BufferUsage; -using android::hardware::graphics::common::V1_0::PixelFormat; +using android::hardware::graphics::common::V1_1::BufferUsage; +using android::hardware::graphics::common::V1_1::PixelFormat; + +// abuse VTS to check binary compatibility between BufferDescriptorInfos +using OldBufferDescriptorInfo = + android::hardware::graphics::mapper::V2_0::IMapper::BufferDescriptorInfo; +static_assert(sizeof(OldBufferDescriptorInfo) == sizeof(IMapper::BufferDescriptorInfo) && + offsetof(OldBufferDescriptorInfo, width) == + offsetof(IMapper::BufferDescriptorInfo, width) && + offsetof(OldBufferDescriptorInfo, height) == + offsetof(IMapper::BufferDescriptorInfo, height) && + offsetof(OldBufferDescriptorInfo, layerCount) == + offsetof(IMapper::BufferDescriptorInfo, layerCount) && + offsetof(OldBufferDescriptorInfo, format) == + offsetof(IMapper::BufferDescriptorInfo, format) && + offsetof(OldBufferDescriptorInfo, usage) == + offsetof(IMapper::BufferDescriptorInfo, usage), + ""); class Gralloc : public V2_0::tests::Gralloc { public: @@ -72,6 +89,32 @@ class Gralloc : public V2_0::tests::Gralloc { }); } + BufferDescriptor createDescriptor(const IMapper::BufferDescriptorInfo& descriptorInfo) { + BufferDescriptor descriptor; + mMapper->createDescriptor_2_1( + descriptorInfo, [&](const auto& tmpError, const auto& tmpDescriptor) { + ASSERT_EQ(Error::NONE, tmpError) << "failed to create descriptor"; + descriptor = tmpDescriptor; + }); + + return descriptor; + } + + const native_handle_t* allocate(const IMapper::BufferDescriptorInfo& descriptorInfo, + bool import, uint32_t* outStride = nullptr) { + BufferDescriptor descriptor = createDescriptor(descriptorInfo); + if (::testing::Test::HasFatalFailure()) { + return nullptr; + } + + auto buffers = V2_0::tests::Gralloc::allocate(descriptor, 1, import, outStride); + if (::testing::Test::HasFatalFailure()) { + return nullptr; + } + + return buffers[0]; + } + private: void init() { mMapper = IMapper::castFrom(V2_0::tests::Gralloc::getMapper()); @@ -229,6 +272,24 @@ TEST_F(GraphicsMapperHidlTest, GetTransportSizeBadBuffer) { native_handle_delete(rawBufferHandle); } +/** + * Test IMapper::createDescriptor with valid descriptor info. + */ +TEST_F(GraphicsMapperHidlTest, CreateDescriptor_2_1Basic) { + ASSERT_NO_FATAL_FAILURE(mGralloc->createDescriptor(mDummyDescriptorInfo)); +} + +/** + * Test IMapper::createDescriptor with invalid descriptor info. + */ +TEST_F(GraphicsMapperHidlTest, CreateDescriptor_2_1Negative) { + auto info = mDummyDescriptorInfo; + info.width = 0; + mGralloc->getMapper()->createDescriptor_2_1(info, [&](const auto& tmpError, const auto&) { + EXPECT_EQ(Error::BAD_VALUE, tmpError) << "createDescriptor did not fail with BAD_VALUE"; + }); +} + } // namespace } // namespace tests } // namespace V2_1 @@ -238,7 +299,10 @@ TEST_F(GraphicsMapperHidlTest, GetTransportSizeBadBuffer) { } // namespace android int main(int argc, char** argv) { + using android::hardware::graphics::mapper::V2_0::tests::GraphicsMapperHidlEnvironment; + ::testing::AddGlobalTestEnvironment(GraphicsMapperHidlEnvironment::Instance()); ::testing::InitGoogleTest(&argc, argv); + GraphicsMapperHidlEnvironment::Instance()->init(&argc, argv); int status = RUN_ALL_TESTS(); LOG(INFO) << "Test result = " << status;