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

Commit bdd7e7e5 authored by Alec Mouri's avatar Alec Mouri
Browse files

Update Readback VTS to align with RenderEngine interface change 

RenderEngine no longer directly takes in GraphicBuffer objects. Instead,
it takes in ExternalTexture types that manage resources associated with
a GraphicBuffer.

Bug: 180767535
Test: builds
Change-Id: I13904eec491fce223b6178fa5571589b67402865
parent 33b849c0

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

+10 −5
Original line number Diff line number Diff line
@@ -15,6 +15,8 @@ 
 */



#include <composer-vts/2.2/ReadbackVts.h>

#include <composer-vts/2.2/RenderEngineVts.h>

#include "renderengine/ExternalTexture.h"



namespace android {

namespace hardware {
@@ -257,10 +259,11 @@ LayerSettings TestColorLayer::toRenderEngineLayerSettings() { 
}



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

                                 const std::shared_ptr<Gralloc>& gralloc, Display display,

                                 int32_t width, int32_t height, PixelFormat format,

                                 const std::shared_ptr<Gralloc>& gralloc,

                                 TestRenderEngine& renderEngine, Display display, int32_t width,

                                 int32_t height, PixelFormat format,

                                 IComposerClient::Composition composition)

    : TestLayer{client, display} {

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

    mGralloc = gralloc;

    mComposition = composition;

    mWidth = width;
@@ -293,9 +296,11 @@ void TestBufferLayer::write(const std::shared_ptr<CommandWriterBase>& writer) { 


LayerSettings TestBufferLayer::toRenderEngineLayerSettings() {

    LayerSettings layerSettings = TestLayer::toRenderEngineLayerSettings();

    layerSettings.source.buffer.buffer =

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

            new GraphicBuffer(mBufferHandle, GraphicBuffer::CLONE_HANDLE, mWidth, mHeight,

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

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

            mRenderEngine.getInternalRenderEngine(),

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



    layerSettings.source.buffer.usePremultipliedAlpha =

            mBlendMode == IComposerClient::BlendMode::PREMULTIPLIED;

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

+3 −1
Original line number Diff line number Diff line
@@ -69,7 +69,9 @@ void TestRenderEngine::drawLayers() { 
                   [](renderengine::LayerSettings& settings) -> renderengine::LayerSettings* {

                       return &settings;

                   });

    mRenderEngine->drawLayers(mDisplaySettings, compositionLayerPointers, mGraphicBuffer, true,

    auto texture = std::make_shared<renderengine::ExternalTexture>(

            mGraphicBuffer, *mRenderEngine, renderengine::ExternalTexture::Usage::WRITEABLE);

    mRenderEngine->drawLayers(mDisplaySettings, compositionLayerPointers, texture, true,

                              std::move(bufferFence), &readyFence);

    int fd = readyFence.release();

    if (fd != -1) {

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

+5 −1
Original line number Diff line number Diff line
@@ -50,6 +50,8 @@ static const IComposerClient::Color TRANSLUCENT_RED = {0xff, 0, 0, 0x33}; 
static const IComposerClient::Color GREEN = {0, 0xff, 0, 0xff};

static const IComposerClient::Color BLUE = {0, 0, 0xff, 0xff};



class TestRenderEngine;



class TestLayer {

  public:

    TestLayer(const std::shared_ptr<ComposerClient>& client, Display display)
@@ -110,7 +112,8 @@ class TestBufferLayer : public TestLayer { 
  public:

    TestBufferLayer(

            const std::shared_ptr<ComposerClient>& client, const std::shared_ptr<Gralloc>& gralloc,

            Display display, int32_t width, int32_t height, PixelFormat format,

            TestRenderEngine& renderEngine, Display display, int32_t width, int32_t height,

            PixelFormat format,

            IComposerClient::Composition composition = IComposerClient::Composition::DEVICE);



    ~TestBufferLayer();
@@ -138,6 +141,7 @@ class TestBufferLayer : public TestLayer { 
  protected:

    IComposerClient::Composition mComposition;

    std::shared_ptr<Gralloc> mGralloc;

    TestRenderEngine& mRenderEngine;

    int32_t mFillFence;

    const native_handle_t* mBufferHandle = nullptr;

};

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

+6 −0
Original line number Diff line number Diff line
@@ -14,9 +14,12 @@ 
 * limitations under the License.

 */



#pragma once



#include <composer-vts/2.2/ReadbackVts.h>

#include <math/half.h>

#include <math/vec3.h>

#include <renderengine/ExternalTexture.h>

#include <renderengine/RenderEngine.h>

#include <ui/GraphicBuffer.h>

#include <ui/GraphicBufferAllocator.h>
@@ -51,12 +54,15 @@ class TestRenderEngine { 
    void drawLayers();

    void checkColorBuffer(std::vector<V2_2::IComposerClient::Color>& expectedColors);



    renderengine::RenderEngine& getInternalRenderEngine() { return *mRenderEngine; }



  private:

    common::V1_1::PixelFormat mFormat;

    std::vector<renderengine::LayerSettings> mCompositionLayers;

    std::unique_ptr<renderengine::RenderEngine> mRenderEngine;

    std::vector<renderengine::LayerSettings> mRenderLayers;

    sp<GraphicBuffer> mGraphicBuffer;



    DisplaySettings mDisplaySettings;

};

graphics/composer/2.2/vts/functional/VtsHalGraphicsComposerV2_2ReadbackTest.cpp

+22 −22
Original line number Diff line number Diff line
@@ -288,9 +288,9 @@ TEST_P(GraphicsCompositionTest, SetLayerBuffer) { 
                                       {0, mDisplayHeight / 2, mDisplayWidth, mDisplayHeight},

                                       BLUE);



        auto layer = std::make_shared<TestBufferLayer>(mComposerClient, mGralloc, mPrimaryDisplay,

                                                       mDisplayWidth, mDisplayHeight,

                                                       PixelFormat::RGBA_8888);

        auto layer = std::make_shared<TestBufferLayer>(

                mComposerClient, mGralloc, *mTestRenderEngine, mPrimaryDisplay, mDisplayWidth,

                mDisplayHeight, PixelFormat::RGBA_8888);

        layer->setDisplayFrame({0, 0, mDisplayWidth, mDisplayHeight});

        layer->setZOrder(10);

        layer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode), mWriter);
@@ -422,9 +422,9 @@ TEST_P(GraphicsCompositionTest, ClientComposition) { 
                                       {0, mDisplayHeight / 2, mDisplayWidth, mDisplayHeight},

                                       BLUE);



        auto layer = std::make_shared<TestBufferLayer>(mComposerClient, mGralloc, mPrimaryDisplay,

                                                       mDisplayWidth, mDisplayHeight,

                                                       PixelFormat::RGBA_FP16);

        auto layer = std::make_shared<TestBufferLayer>(

                mComposerClient, mGralloc, *mTestRenderEngine, mPrimaryDisplay, mDisplayWidth,

                mDisplayHeight, PixelFormat::RGBA_FP16);

        layer->setDisplayFrame({0, 0, mDisplayWidth, mDisplayHeight});

        layer->setZOrder(10);

        layer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode), mWriter);
@@ -538,8 +538,8 @@ TEST_P(GraphicsCompositionTest, DeviceAndClientComposition) { 
        ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());



        auto deviceLayer = std::make_shared<TestBufferLayer>(

                mComposerClient, mGralloc, mPrimaryDisplay, mDisplayWidth, mDisplayHeight / 2,

                PixelFormat::RGBA_8888);

                mComposerClient, mGralloc, *mTestRenderEngine, mPrimaryDisplay, mDisplayWidth,

                mDisplayHeight / 2, PixelFormat::RGBA_8888);

        std::vector<IComposerClient::Color> deviceColors(deviceLayer->mWidth *

                                                         deviceLayer->mHeight);

        ReadbackHelper::fillColorsArea(deviceColors, deviceLayer->mWidth,
@@ -575,8 +575,8 @@ TEST_P(GraphicsCompositionTest, DeviceAndClientComposition) { 
        }



        auto clientLayer = std::make_shared<TestBufferLayer>(

                mComposerClient, mGralloc, mPrimaryDisplay, clientWidth, clientHeight,

                PixelFormat::RGBA_FP16, IComposerClient::Composition::DEVICE);

                mComposerClient, mGralloc, *mTestRenderEngine, mPrimaryDisplay, clientWidth,

                clientHeight, PixelFormat::RGBA_FP16, IComposerClient::Composition::DEVICE);

        IComposerClient::Rect clientFrame = {0, mDisplayHeight / 2, mDisplayWidth, mDisplayHeight};

        clientLayer->setDisplayFrame(clientFrame);

        clientLayer->setZOrder(0);
@@ -657,9 +657,9 @@ TEST_P(GraphicsCompositionTest, SetLayerDamage) { 
        std::vector<IComposerClient::Color> expectedColors(mDisplayWidth * mDisplayHeight);

        ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth, redRect, RED);



        auto layer = std::make_shared<TestBufferLayer>(mComposerClient, mGralloc, mPrimaryDisplay,

                                                       mDisplayWidth, mDisplayHeight,

                                                       PixelFormat::RGBA_8888);

        auto layer = std::make_shared<TestBufferLayer>(

                mComposerClient, mGralloc, *mTestRenderEngine, mPrimaryDisplay, mDisplayWidth,

                mDisplayHeight, PixelFormat::RGBA_8888);

        layer->setDisplayFrame({0, 0, mDisplayWidth, mDisplayHeight});

        layer->setZOrder(10);

        layer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode), mWriter);
@@ -805,9 +805,9 @@ TEST_P(GraphicsCompositionTest, SetLayerSourceCrop) { 
                                       {0, mDisplayHeight / 2, mDisplayWidth, mDisplayHeight},

                                       BLUE);



        auto layer = std::make_shared<TestBufferLayer>(mComposerClient, mGralloc, mPrimaryDisplay,

                                                       mDisplayWidth, mDisplayHeight,

                                                       PixelFormat::RGBA_8888);

        auto layer = std::make_shared<TestBufferLayer>(

                mComposerClient, mGralloc, *mTestRenderEngine, mPrimaryDisplay, mDisplayWidth,

                mDisplayHeight, PixelFormat::RGBA_8888);

        layer->setDisplayFrame({0, 0, mDisplayWidth, mDisplayHeight});

        layer->setZOrder(10);

        layer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode), mWriter);
@@ -957,9 +957,9 @@ class GraphicsBlendModeCompositionTest 
        backgroundLayer->setZOrder(0);

        backgroundLayer->setColor(mBackgroundColor);



        auto layer = std::make_shared<TestBufferLayer>(mComposerClient, mGralloc, mPrimaryDisplay,

                                                       mDisplayWidth, mDisplayHeight,

                                                       PixelFormat::RGBA_8888);

        auto layer = std::make_shared<TestBufferLayer>(

                mComposerClient, mGralloc, *mTestRenderEngine, mPrimaryDisplay, mDisplayWidth,

                mDisplayHeight, PixelFormat::RGBA_8888);

        layer->setDisplayFrame({0, 0, mDisplayWidth, mDisplayHeight});

        layer->setZOrder(10);

        layer->setDataspace(Dataspace::UNKNOWN, mWriter);
@@ -1195,9 +1195,9 @@ class GraphicsTransformCompositionTest : public GraphicsCompositionTest { 
        IComposerClient::Rect blueRect = {mSideLength / 2, mSideLength / 2, mSideLength,

                                          mSideLength};



        mLayer =

            std::make_shared<TestBufferLayer>(mComposerClient, mGralloc, mPrimaryDisplay,

                                              mSideLength, mSideLength, PixelFormat::RGBA_8888);

        mLayer = std::make_shared<TestBufferLayer>(mComposerClient, mGralloc, *mTestRenderEngine,

                                                   mPrimaryDisplay, mSideLength, mSideLength,

                                                   PixelFormat::RGBA_8888);

        mLayer->setDisplayFrame({0, 0, mSideLength, mSideLength});

        mLayer->setZOrder(10);