Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 82c666bd authored by John Reck's avatar John Reck
Browse files

Remove mapper from composer2.2 VTS 

Test: make VtsHalGraphicsComposerV2_2TargetTest
Bug: 292584923
Change-Id: Id281c732535ace4a36750d759b59db7aa6e5cb3a
parent 650fe3ed

graphics/composer/2.2/utils/vts/Android.bp

+0 −6
Original line number Diff line number Diff line
@@ -42,7 +42,6 @@ cc_library_static { 
    static_libs: [

        "android.hardware.graphics.composer@2.1-vts",

        "android.hardware.graphics.composer@2.2",

        "android.hardware.graphics.mapper@2.1-vts",

        "libarect",

        "libgtest",

        "libmath",
@@ -50,15 +49,10 @@ cc_library_static { 
        "librenderengine",

        "libshaders",

        "libtonemap",

        "android.hardware.graphics.mapper@3.0",

        "android.hardware.graphics.mapper@3.0-vts",

        "android.hardware.graphics.mapper@4.0",

        "android.hardware.graphics.mapper@4.0-vts",

    ],

    export_static_lib_headers: [

        "android.hardware.graphics.composer@2.1-vts",

        "android.hardware.graphics.composer@2.2",

        "android.hardware.graphics.mapper@2.1-vts",

    ],

    header_libs: [

        "android.hardware.graphics.composer@2.2-command-buffer",

graphics/composer/2.2/utils/vts/ComposerVts.cpp

+0 −60
Original line number Diff line number Diff line
@@ -179,66 +179,6 @@ std::array<float, 16> ComposerClient::getDataspaceSaturationMatrix(Dataspace dat 
    return matrix;

}



Gralloc::Gralloc() {

    [this] {

        ALOGD("Attempting to initialize gralloc4");

        ASSERT_NO_FATAL_FAILURE(mGralloc4 = std::make_shared<Gralloc4>(

                                        /*aidlAllocatorServiceName*/ IAllocator::descriptor +

                                                std::string("/default"),

                                        /*hidlAllocatorServiceName*/ "default",

                                        /*mapperServiceName*/ "default",

                                        /*errOnFailure=*/false));

        if (mGralloc4->getMapper() == nullptr || !mGralloc4->hasAllocator()) {

            mGralloc4 = nullptr;

            ALOGD("Failed to initialize gralloc4, initializing gralloc3");

            ASSERT_NO_FATAL_FAILURE(mGralloc3 = std::make_shared<Gralloc3>("default", "default",

                                                                           /*errOnFailure=*/false));

            if (mGralloc3->getMapper() == nullptr || mGralloc3->getAllocator() == nullptr) {

                mGralloc3 = nullptr;

                ALOGD("Failed to initialize gralloc3, initializing gralloc2_1");

                mGralloc2_1 = std::make_shared<Gralloc2_1>(/*errOnFailure*/ false);

                if (!mGralloc2_1->getMapper()) {

                    mGralloc2_1 = nullptr;

                    ALOGD("Failed to initialize gralloc2_1, initializing gralloc2");

                    ASSERT_NO_FATAL_FAILURE(mGralloc2 = std::make_shared<Gralloc2>());

                }

            }

        }

    }();

}



bool Gralloc::validateBufferSize(const native_handle_t* bufferHandle, uint32_t width,

                                 uint32_t height, uint32_t layerCount, PixelFormat format,

                                 uint64_t usage, uint32_t stride) {

    if (mGralloc4) {

        IMapper4::BufferDescriptorInfo info{};

        info.width = width;

        info.height = height;

        info.layerCount = layerCount;

        info.format = static_cast<android::hardware::graphics::common::V1_2::PixelFormat>(format);

        info.usage = usage;

        return mGralloc4->validateBufferSize(bufferHandle, info, stride);

    } else if (mGralloc3) {

        IMapper3::BufferDescriptorInfo info{};

        info.width = width;

        info.height = height;

        info.layerCount = layerCount;

        info.format = static_cast<android::hardware::graphics::common::V1_2::PixelFormat>(format);

        info.usage = usage;

        return mGralloc3->validateBufferSize(bufferHandle, info, stride);

    } else if (mGralloc2_1) {

        IMapper2_1::BufferDescriptorInfo info{};

        info.width = width;

        info.height = height;

        info.layerCount = layerCount;

        info.format = static_cast<android::hardware::graphics::common::V1_1::PixelFormat>(format);

        info.usage = usage;

        return mGralloc2_1->validateBufferSize(bufferHandle, info, stride);

    } else {

        return true;

    }

}



}  // namespace vts

}  // namespace V2_2

}  // namespace composer

graphics/composer/2.2/utils/vts/ReadbackVts.cpp

+21 −46
Original line number Diff line number Diff line
@@ -187,12 +187,11 @@ void ReadbackHelper::compareColorBuffers(std::vector<IComposerClient::Color>& ex 
}



ReadbackBuffer::ReadbackBuffer(Display display, const std::shared_ptr<ComposerClient>& client,

                               const std::shared_ptr<Gralloc>& gralloc, uint32_t width,

                               uint32_t height, PixelFormat pixelFormat, Dataspace dataspace) {

                               uint32_t width, uint32_t height, PixelFormat pixelFormat,

                               Dataspace dataspace) {

    mDisplay = display;



    mComposerClient = client;

    mGralloc = gralloc;



    mPixelFormat = pixelFormat;

    mDataspace = dataspace;
@@ -202,20 +201,12 @@ ReadbackBuffer::ReadbackBuffer(Display display, const std::shared_ptr<ComposerCl 
    mLayerCount = 1;

    mFormat = mPixelFormat;

    mUsage = static_cast<uint64_t>(BufferUsage::CPU_READ_OFTEN | BufferUsage::GPU_TEXTURE);



    mAccessRegion.top = 0;

    mAccessRegion.left = 0;

    mAccessRegion.width = width;

    mAccessRegion.height = height;

}



void ReadbackBuffer::setReadbackBuffer() {

    mBufferHandle.reset(new Gralloc::NativeHandleWrapper(

            mGralloc->allocate(mWidth, mHeight, mLayerCount, mFormat, mUsage,

                               /*import*/ true, &mStride)));

    ASSERT_NE(false, mGralloc->validateBufferSize(mBufferHandle->get(), mWidth, mHeight,

                                                  mLayerCount, mFormat, mUsage, mStride));

    ASSERT_NO_FATAL_FAILURE(mComposerClient->setReadbackBuffer(mDisplay, mBufferHandle->get(), -1));

    mBuffer = sp<GraphicBuffer>::make(mWidth, mHeight, (int32_t)mFormat, mLayerCount, mUsage);

    ASSERT_EQ(STATUS_OK, mBuffer->initCheck());

    ASSERT_NO_FATAL_FAILURE(mComposerClient->setReadbackBuffer(mDisplay, mBuffer->handle, -1));

}



void ReadbackBuffer::checkReadbackBuffer(std::vector<IComposerClient::Color> expectedColors) {
@@ -223,15 +214,14 @@ void ReadbackBuffer::checkReadbackBuffer(std::vector<IComposerClient::Color> exp 
    int32_t fenceHandle;

    ASSERT_NO_FATAL_FAILURE(mComposerClient->getReadbackBufferFence(mDisplay, &fenceHandle));



    void* bufData = mGralloc->lock(mBufferHandle->get(), mUsage, mAccessRegion, fenceHandle);

    void* bufData = nullptr;

    int32_t stride = mBuffer->stride;

    status_t status = mBuffer->lockAsync(mUsage, &bufData, fenceHandle);

    ASSERT_EQ(STATUS_OK, status);

    ASSERT_TRUE(mPixelFormat == PixelFormat::RGB_888 || mPixelFormat == PixelFormat::RGBA_8888);

    ReadbackHelper::compareColorBuffers(expectedColors, bufData, mStride, mWidth, mHeight,

    ReadbackHelper::compareColorBuffers(expectedColors, bufData, stride, mWidth, mHeight,

                                        mPixelFormat);

    int32_t unlockFence = mGralloc->unlock(mBufferHandle->get());

    if (unlockFence != -1) {

        sync_wait(unlockFence, -1);

        close(unlockFence);

    }

    EXPECT_EQ(STATUS_OK, mBuffer->unlock());

}



void TestColorLayer::write(const std::shared_ptr<CommandWriterBase>& writer) {
@@ -251,12 +241,10 @@ LayerSettings TestColorLayer::toRenderEngineLayerSettings() { 
}



TestBufferLayer::TestBufferLayer(const std::shared_ptr<ComposerClient>& client,

                                 const std::shared_ptr<Gralloc>& gralloc,

                                 TestRenderEngine& renderEngine, Display display, int32_t width,

                                 int32_t height, PixelFormat format,

                                 IComposerClient::Composition composition)

    : TestLayer{client, display}, mRenderEngine(renderEngine) {

    mGralloc = gralloc;

    mComposition = composition;

    mWidth = width;

    mHeight = height;
@@ -265,11 +253,6 @@ TestBufferLayer::TestBufferLayer(const std::shared_ptr<ComposerClient>& client, 
    mUsage = static_cast<uint64_t>(BufferUsage::CPU_READ_OFTEN | BufferUsage::CPU_WRITE_OFTEN |

                                   BufferUsage::COMPOSER_OVERLAY | BufferUsage::GPU_TEXTURE);



    mAccessRegion.top = 0;

    mAccessRegion.left = 0;

    mAccessRegion.width = width;

    mAccessRegion.height = height;



    setSourceCrop({0, 0, (float)width, (float)height});

}
@@ -277,15 +260,13 @@ void TestBufferLayer::write(const std::shared_ptr<CommandWriterBase>& writer) { 
    TestLayer::write(writer);

    writer->setLayerCompositionType(mComposition);

    writer->setLayerVisibleRegion(std::vector<IComposerClient::Rect>(1, mDisplayFrame));

    if (mBufferHandle != nullptr) writer->setLayerBuffer(0, mBufferHandle->get(), mFillFence);

    if (mBuffer) writer->setLayerBuffer(0, mBuffer->handle, -1);

}



LayerSettings TestBufferLayer::toRenderEngineLayerSettings() {

    LayerSettings layerSettings = TestLayer::toRenderEngineLayerSettings();

    layerSettings.source.buffer.buffer = std::make_shared<renderengine::impl::ExternalTexture>(

            new GraphicBuffer(mBufferHandle->get(), GraphicBuffer::CLONE_HANDLE, mWidth, mHeight,

                              static_cast<int32_t>(mFormat), 1, mUsage, mStride),

            mRenderEngine.getInternalRenderEngine(),

            mBuffer, mRenderEngine.getInternalRenderEngine(),

            renderengine::impl::ExternalTexture::Usage::READABLE);



    layerSettings.source.buffer.usePremultipliedAlpha =
@@ -304,24 +285,18 @@ LayerSettings TestBufferLayer::toRenderEngineLayerSettings() { 
}



void TestBufferLayer::fillBuffer(std::vector<IComposerClient::Color> expectedColors) {

    void* bufData = mGralloc->lock(mBufferHandle->get(), mUsage, mAccessRegion, -1);

    ASSERT_NO_FATAL_FAILURE(

            ReadbackHelper::fillBuffer(mWidth, mHeight, mStride, bufData, mFormat, expectedColors));

    mFillFence = mGralloc->unlock(mBufferHandle->get());

    if (mFillFence != -1) {

        sync_wait(mFillFence, -1);

        close(mFillFence);

    }

    void* bufData = nullptr;

    status_t status = mBuffer->lock(mUsage, &bufData);

    ASSERT_EQ(STATUS_OK, status);

    ASSERT_NO_FATAL_FAILURE(ReadbackHelper::fillBuffer(mWidth, mHeight, mBuffer->stride, bufData,

                                                       mFormat, expectedColors));

    EXPECT_EQ(STATUS_OK, mBuffer->unlock());

}



void TestBufferLayer::setBuffer(std::vector<IComposerClient::Color> colors) {

    mBufferHandle.reset(new Gralloc::NativeHandleWrapper(

            mGralloc->allocate(mWidth, mHeight, mLayerCount, mFormat, mUsage,

                               /*import*/ true, &mStride)));

    ASSERT_NE(nullptr, mBufferHandle->get());

    mBuffer = sp<GraphicBuffer>::make(mWidth, mHeight, (int32_t)mFormat, mLayerCount, mUsage);

    ASSERT_EQ(STATUS_OK, mBuffer->initCheck());

    ASSERT_NO_FATAL_FAILURE(fillBuffer(colors));

    ASSERT_NE(false, mGralloc->validateBufferSize(mBufferHandle->get(), mWidth, mHeight,

                                                  mLayerCount, mFormat, mUsage, mStride));

}



void TestBufferLayer::setDataspace(Dataspace dataspace,

graphics/composer/2.2/utils/vts/RenderEngineVts.cpp

+0 −1
Original line number Diff line number Diff line
@@ -24,7 +24,6 @@ namespace composer { 
namespace V2_2 {

namespace vts {



using mapper::V2_1::IMapper;

using renderengine::DisplaySettings;

using renderengine::LayerSettings;

using renderengine::RenderEngineCreationArgs;

graphics/composer/2.2/utils/vts/include/composer-vts/2.2/ComposerVts.h

+0 −31
Original line number Diff line number Diff line
@@ -26,7 +26,6 @@ 
#include <android/hardware/graphics/composer/2.2/IComposerClient.h>

#include <composer-command-buffer/2.2/ComposerCommandBuffer.h>

#include <composer-vts/2.1/ComposerVts.h>

#include <mapper-vts/2.1/MapperVts.h>

#include <utils/StrongPointer.h>



namespace android {
@@ -41,14 +40,6 @@ using common::V1_1::ColorMode; 
using common::V1_1::Dataspace;

using common::V1_1::PixelFormat;

using common::V1_1::RenderIntent;

using IMapper2_1 = android::hardware::graphics::mapper::V2_1::IMapper;

using IMapper3 = android::hardware::graphics::mapper::V3_0::IMapper;

using IMapper4 = android::hardware::graphics::mapper::V4_0::IMapper;

using Gralloc2 = android::hardware::graphics::mapper::V2_0::vts::Gralloc;

using Gralloc2_1 = android::hardware::graphics::mapper::V2_1::vts::Gralloc;

using Gralloc3 = android::hardware::graphics::mapper::V3_0::vts::Gralloc;

using Gralloc4 = android::hardware::graphics::mapper::V4_0::vts::Gralloc;

using IAllocator = aidl::android::hardware::graphics::allocator::IAllocator;



class ComposerClient;
@@ -92,28 +83,6 @@ class ComposerClient : public V2_1::vts::ComposerClient { 
    const sp<IComposerClient> mClient;

};



class Gralloc : public V2_1::vts::Gralloc {

  public:

    using NativeHandleWrapper = V2_1::vts::NativeHandleWrapper;



    Gralloc();

    const NativeHandleWrapper allocate(uint32_t width, uint32_t height, uint32_t layerCount,

                                       PixelFormat format, uint64_t usage, bool import = true,

                                       uint32_t* outStride = nullptr) {

        return V2_1::vts::Gralloc::allocate(

                width, height, layerCount,

                static_cast<android::hardware::graphics::common::V1_0::PixelFormat>(format), usage,

                import, outStride);

    }



    bool validateBufferSize(const native_handle_t* bufferHandle, uint32_t width, uint32_t height,

                            uint32_t layerCount, PixelFormat format, uint64_t usage,

                            uint32_t stride);



  protected:

    std::shared_ptr<Gralloc2_1> mGralloc2_1 = nullptr;

};



}  // namespace vts

}  // namespace V2_2

}  // namespace composer