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

Commit 2a6ef4e5 authored by Alec Mouri's avatar Alec Mouri
Browse files

Revert "Revert "Update Readback VTS to align with RenderEngine i..." 

Revert "Revert "Update WaylandRenderSurface to accomodate interf..."

Revert "Revert "Add ExternalTexture class into RenderEngine inte..."

Revert submission 14199598-revert-14086921-renderengine-external-tex-QJNBWQMQEU

Reason for revert: Prepare for relanding
Reverted Changes:
I01e65a7f4:Revert "Update WaylandRenderSurface to accomodate ...
I7d58118c1:Revert "Update Readback VTS to align with RenderEn...
I1501890f4:Revert "Add ExternalTexture class into RenderEngin...

Change-Id: Ic2ee9311d22658ac77c8a94f6070324cf07b601b
parent 51daee61

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);