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

Commit 51daee61 authored by Alec Mouri's avatar Alec Mouri
Browse files

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

Revert "Update WaylandRenderSurface to accomodate interface change"

Revert "Add ExternalTexture class into RenderEngine interface"

Revert submission 14086921-renderengine-external-tex

Reason for revert: Potential culprit for b/185361988
Reverted Changes:
I7796764e2:Update WaylandRenderSurface to accomodate interfac...
I13904eec4:Update Readback VTS to align with RenderEngine int...
I222c71e6e:Add ExternalTexture class into RenderEngine interf...

Change-Id: I7d58118c1c2284a04eb52e992e901d82faaf5bb0
parent bdd7e7e5

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

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



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

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

#include "renderengine/ExternalTexture.h"



namespace android {

namespace hardware {
@@ -259,11 +257,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,

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

                                 int32_t width, int32_t height, PixelFormat format,

                                 IComposerClient::Composition composition)

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

    : TestLayer{client, display} {

    mGralloc = gralloc;

    mComposition = composition;

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


LayerSettings TestBufferLayer::toRenderEngineLayerSettings() {

    LayerSettings layerSettings = TestLayer::toRenderEngineLayerSettings();

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

    layerSettings.source.buffer.buffer =

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

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

            mRenderEngine.getInternalRenderEngine(),

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

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



    layerSettings.source.buffer.usePremultipliedAlpha =

            mBlendMode == IComposerClient::BlendMode::PREMULTIPLIED;

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

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

                       return &settings;

                   });

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

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

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

    mRenderEngine->drawLayers(mDisplaySettings, compositionLayerPointers, mGraphicBuffer, 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

+1 −5
Original line number Diff line number Diff line
@@ -50,8 +50,6 @@ 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)
@@ -112,8 +110,7 @@ class TestBufferLayer : public TestLayer { 
  public:

    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,

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

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



    ~TestBufferLayer();
@@ -141,7 +138,6 @@ 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

+0 −6
Original line number Diff line number Diff line
@@ -14,12 +14,9 @@ 
 * 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>
@@ -54,15 +51,12 @@ 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, *mTestRenderEngine, mPrimaryDisplay, mDisplayWidth,

                mDisplayHeight, PixelFormat::RGBA_8888);

        auto layer = std::make_shared<TestBufferLayer>(mComposerClient, mGralloc, 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, *mTestRenderEngine, mPrimaryDisplay, mDisplayWidth,

                mDisplayHeight, PixelFormat::RGBA_FP16);

        auto layer = std::make_shared<TestBufferLayer>(mComposerClient, mGralloc, 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, *mTestRenderEngine, mPrimaryDisplay, mDisplayWidth,

                mDisplayHeight / 2, PixelFormat::RGBA_8888);

                mComposerClient, mGralloc, 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, *mTestRenderEngine, mPrimaryDisplay, clientWidth,

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

                mComposerClient, mGralloc, 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, *mTestRenderEngine, mPrimaryDisplay, mDisplayWidth,

                mDisplayHeight, PixelFormat::RGBA_8888);

        auto layer = std::make_shared<TestBufferLayer>(mComposerClient, mGralloc, 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, *mTestRenderEngine, mPrimaryDisplay, mDisplayWidth,

                mDisplayHeight, PixelFormat::RGBA_8888);

        auto layer = std::make_shared<TestBufferLayer>(mComposerClient, mGralloc, 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, *mTestRenderEngine, mPrimaryDisplay, mDisplayWidth,

                mDisplayHeight, PixelFormat::RGBA_8888);

        auto layer = std::make_shared<TestBufferLayer>(mComposerClient, mGralloc, 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, *mTestRenderEngine,

                                                   mPrimaryDisplay, mSideLength, mSideLength,

                                                   PixelFormat::RGBA_8888);

        mLayer =

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

                                              mSideLength, mSideLength, PixelFormat::RGBA_8888);

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

        mLayer->setZOrder(10);