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

Commit f11f39b4 authored by Peiyong Lin's avatar Peiyong Lin
Browse files

[RenderEngine] Move GLES20RenderEngine creation code to GLES20RenderEngine. 

Previously, impl::RenderEngine serves as an abstract of GLES specific render
engine instance, which manages the creation and destruction. However, as public
interface, it should be implementationa agnostic. This patch moves EGL
environment set up code to GLES20RenderEngine.

BUG: 112585051
Test: Build, flash, boot and run part of display verification.
Change-Id: Ie87d96c30999706eaa14c28e0e456300848176d5
parent 0eb5bf9a

services/surfaceflinger/RenderEngine/RenderEngine.cpp

+6 −298
Original line number Diff line number Diff line
@@ -37,131 +37,18 @@ extern "C" EGLAPI const char* eglQueryStringImplementationANDROID(EGLDisplay dpy 
namespace android {

namespace renderengine {



RenderEngine::~RenderEngine() = default;



namespace impl {



std::unique_ptr<RenderEngine> RenderEngine::create(int hwcFormat, uint32_t featureFlags) {

    // initialize EGL for the default display

    EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);

    if (!eglInitialize(display, nullptr, nullptr)) {

        LOG_ALWAYS_FATAL("failed to initialize EGL");

    }



    GLExtensions& extensions = GLExtensions::getInstance();

    extensions.initWithEGLStrings(eglQueryStringImplementationANDROID(display, EGL_VERSION),

                                  eglQueryStringImplementationANDROID(display, EGL_EXTENSIONS));



    // The code assumes that ES2 or later is available if this extension is

    // supported.

    EGLConfig config = EGL_NO_CONFIG;

    if (!extensions.hasNoConfigContext()) {

        config = chooseEglConfig(display, hwcFormat, /*logConfig*/ true);

    }



    EGLint renderableType = 0;

    if (config == EGL_NO_CONFIG) {

        renderableType = EGL_OPENGL_ES2_BIT;

    } else if (!eglGetConfigAttrib(display, config, EGL_RENDERABLE_TYPE, &renderableType)) {

        LOG_ALWAYS_FATAL("can't query EGLConfig RENDERABLE_TYPE");

    }

    EGLint contextClientVersion = 0;

    if (renderableType & EGL_OPENGL_ES2_BIT) {

        contextClientVersion = 2;

    } else if (renderableType & EGL_OPENGL_ES_BIT) {

        contextClientVersion = 1;

    } else {

        LOG_ALWAYS_FATAL("no supported EGL_RENDERABLE_TYPEs");

    }



    std::vector<EGLint> contextAttributes;

    contextAttributes.reserve(6);

    contextAttributes.push_back(EGL_CONTEXT_CLIENT_VERSION);

    contextAttributes.push_back(contextClientVersion);

    bool useContextPriority = extensions.hasContextPriority() &&

                              (featureFlags & RenderEngine::USE_HIGH_PRIORITY_CONTEXT);

    if (useContextPriority) {

        contextAttributes.push_back(EGL_CONTEXT_PRIORITY_LEVEL_IMG);

        contextAttributes.push_back(EGL_CONTEXT_PRIORITY_HIGH_IMG);

    }

    contextAttributes.push_back(EGL_NONE);



    EGLContext ctxt = eglCreateContext(display, config, nullptr, contextAttributes.data());



    // if can't create a GL context, we can only abort.

    LOG_ALWAYS_FATAL_IF(ctxt == EGL_NO_CONTEXT, "EGLContext creation failed");



    // now figure out what version of GL did we actually get

    // NOTE: a dummy surface is not needed if KHR_create_context is supported



    EGLConfig dummyConfig = config;

    if (dummyConfig == EGL_NO_CONFIG) {

        dummyConfig = chooseEglConfig(display, hwcFormat, /*logConfig*/ true);

    }

    EGLint attribs[] = {EGL_WIDTH, 1, EGL_HEIGHT, 1, EGL_NONE, EGL_NONE};

    EGLSurface dummy = eglCreatePbufferSurface(display, dummyConfig, attribs);

    LOG_ALWAYS_FATAL_IF(dummy == EGL_NO_SURFACE, "can't create dummy pbuffer");

    EGLBoolean success = eglMakeCurrent(display, dummy, dummy, ctxt);

    LOG_ALWAYS_FATAL_IF(!success, "can't make dummy pbuffer current");



    extensions.initWithGLStrings(glGetString(GL_VENDOR), glGetString(GL_RENDERER),

                                 glGetString(GL_VERSION), glGetString(GL_EXTENSIONS));



    GlesVersion version = parseGlesVersion(extensions.getVersion());



    // initialize the renderer while GL is current



    std::unique_ptr<RenderEngine> engine;

    switch (version) {

        case GLES_VERSION_1_0:

        case GLES_VERSION_1_1:

            LOG_ALWAYS_FATAL("SurfaceFlinger requires OpenGL ES 2.0 minimum to run.");

            break;

        case GLES_VERSION_2_0:

        case GLES_VERSION_3_0:

            engine = std::make_unique<GLES20RenderEngine>(featureFlags);

            break;

std::unique_ptr<impl::RenderEngine> RenderEngine::create(int hwcFormat, uint32_t featureFlags) {

    return renderengine::gl::GLES20RenderEngine::create(hwcFormat, featureFlags);

}

    engine->setEGLHandles(display, config, ctxt);



    ALOGI("OpenGL ES informations:");

    ALOGI("vendor    : %s", extensions.getVendor());

    ALOGI("renderer  : %s", extensions.getRenderer());

    ALOGI("version   : %s", extensions.getVersion());

    ALOGI("extensions: %s", extensions.getExtensions());

    ALOGI("GL_MAX_TEXTURE_SIZE = %zu", engine->getMaxTextureSize());

    ALOGI("GL_MAX_VIEWPORT_DIMS = %zu", engine->getMaxViewportDims());



    eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);

    eglDestroySurface(display, dummy);

RenderEngine::~RenderEngine() = default;



    return engine;

}

namespace impl {



RenderEngine::RenderEngine(uint32_t featureFlags)

      : mEGLDisplay(EGL_NO_DISPLAY),

        mEGLConfig(nullptr),

        mEGLContext(EGL_NO_CONTEXT),

        mFeatureFlags(featureFlags) {}

      : mFeatureFlags(featureFlags) {}



RenderEngine::~RenderEngine() {

    eglMakeCurrent(mEGLDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);

    eglTerminate(mEGLDisplay);

}



void RenderEngine::setEGLHandles(EGLDisplay display, EGLConfig config, EGLContext ctxt) {

    mEGLDisplay = display;

    mEGLConfig = config;

    mEGLContext = ctxt;

}



EGLDisplay RenderEngine::getEGLDisplay() const {

    return mEGLDisplay;

}



EGLConfig RenderEngine::getEGLConfig() const {

    return mEGLConfig;

}

RenderEngine::~RenderEngine() = default;



bool RenderEngine::useNativeFenceSync() const {

    return SyncFeatures::getInstance().useNativeFenceSync();
@@ -171,185 +58,6 @@ bool RenderEngine::useWaitSync() const { 
    return SyncFeatures::getInstance().useWaitSync();

}



RenderEngine::GlesVersion RenderEngine::parseGlesVersion(const char* str) {

    int major, minor;

    if (sscanf(str, "OpenGL ES-CM %d.%d", &major, &minor) != 2) {

        if (sscanf(str, "OpenGL ES %d.%d", &major, &minor) != 2) {

            ALOGW("Unable to parse GL_VERSION string: \"%s\"", str);

            return GLES_VERSION_1_0;

        }

    }



    if (major == 1 && minor == 0) return GLES_VERSION_1_0;

    if (major == 1 && minor >= 1) return GLES_VERSION_1_1;

    if (major == 2 && minor >= 0) return GLES_VERSION_2_0;

    if (major == 3 && minor >= 0) return GLES_VERSION_3_0;



    ALOGW("Unrecognized OpenGL ES version: %d.%d", major, minor);

    return GLES_VERSION_1_0;

}



void RenderEngine::dump(String8& result) {

    const GLExtensions& extensions = GLExtensions::getInstance();



    result.appendFormat("EGL implementation : %s\n", extensions.getEGLVersion());

    result.appendFormat("%s\n", extensions.getEGLExtensions());



    result.appendFormat("GLES: %s, %s, %s\n", extensions.getVendor(), extensions.getRenderer(),

                        extensions.getVersion());

    result.appendFormat("%s\n", extensions.getExtensions());

}



static status_t selectConfigForAttribute(EGLDisplay dpy, EGLint const* attrs, EGLint attribute,

                                         EGLint wanted, EGLConfig* outConfig) {

    EGLint numConfigs = -1, n = 0;

    eglGetConfigs(dpy, nullptr, 0, &numConfigs);

    EGLConfig* const configs = new EGLConfig[numConfigs];

    eglChooseConfig(dpy, attrs, configs, numConfigs, &n);



    if (n) {

        if (attribute != EGL_NONE) {

            for (int i = 0; i < n; i++) {

                EGLint value = 0;

                eglGetConfigAttrib(dpy, configs[i], attribute, &value);

                if (wanted == value) {

                    *outConfig = configs[i];

                    delete[] configs;

                    return NO_ERROR;

                }

            }

        } else {

            // just pick the first one

            *outConfig = configs[0];

            delete[] configs;

            return NO_ERROR;

        }

    }

    delete[] configs;

    return NAME_NOT_FOUND;

}



class EGLAttributeVector {

    struct Attribute;

    class Adder;

    friend class Adder;

    KeyedVector<Attribute, EGLint> mList;

    struct Attribute {

        Attribute() : v(0){};

        explicit Attribute(EGLint v) : v(v) {}

        EGLint v;

        bool operator<(const Attribute& other) const {

            // this places EGL_NONE at the end

            EGLint lhs(v);

            EGLint rhs(other.v);

            if (lhs == EGL_NONE) lhs = 0x7FFFFFFF;

            if (rhs == EGL_NONE) rhs = 0x7FFFFFFF;

            return lhs < rhs;

        }

    };

    class Adder {

        friend class EGLAttributeVector;

        EGLAttributeVector& v;

        EGLint attribute;

        Adder(EGLAttributeVector& v, EGLint attribute) : v(v), attribute(attribute) {}



    public:

        void operator=(EGLint value) {

            if (attribute != EGL_NONE) {

                v.mList.add(Attribute(attribute), value);

            }

        }

        operator EGLint() const { return v.mList[attribute]; }

    };



public:

    EGLAttributeVector() { mList.add(Attribute(EGL_NONE), EGL_NONE); }

    void remove(EGLint attribute) {

        if (attribute != EGL_NONE) {

            mList.removeItem(Attribute(attribute));

        }

    }

    Adder operator[](EGLint attribute) { return Adder(*this, attribute); }

    EGLint operator[](EGLint attribute) const { return mList[attribute]; }

    // cast-operator to (EGLint const*)

    operator EGLint const*() const { return &mList.keyAt(0).v; }

};



static status_t selectEGLConfig(EGLDisplay display, EGLint format, EGLint renderableType,

                                EGLConfig* config) {

    // select our EGLConfig. It must support EGL_RECORDABLE_ANDROID if

    // it is to be used with WIFI displays

    status_t err;

    EGLint wantedAttribute;

    EGLint wantedAttributeValue;



    EGLAttributeVector attribs;

    if (renderableType) {

        attribs[EGL_RENDERABLE_TYPE] = renderableType;

        attribs[EGL_RECORDABLE_ANDROID] = EGL_TRUE;

        attribs[EGL_SURFACE_TYPE] = EGL_WINDOW_BIT | EGL_PBUFFER_BIT;

        attribs[EGL_FRAMEBUFFER_TARGET_ANDROID] = EGL_TRUE;

        attribs[EGL_RED_SIZE] = 8;

        attribs[EGL_GREEN_SIZE] = 8;

        attribs[EGL_BLUE_SIZE] = 8;

        attribs[EGL_ALPHA_SIZE] = 8;

        wantedAttribute = EGL_NONE;

        wantedAttributeValue = EGL_NONE;

    } else {

        // if no renderable type specified, fallback to a simplified query

        wantedAttribute = EGL_NATIVE_VISUAL_ID;

        wantedAttributeValue = format;

    }



    err = selectConfigForAttribute(display, attribs, wantedAttribute, wantedAttributeValue, config);

    if (err == NO_ERROR) {

        EGLint caveat;

        if (eglGetConfigAttrib(display, *config, EGL_CONFIG_CAVEAT, &caveat))

            ALOGW_IF(caveat == EGL_SLOW_CONFIG, "EGL_SLOW_CONFIG selected!");

    }



    return err;

}



EGLConfig RenderEngine::chooseEglConfig(EGLDisplay display, int format, bool logConfig) {

    status_t err;

    EGLConfig config;



    // First try to get an ES2 config

    err = selectEGLConfig(display, format, EGL_OPENGL_ES2_BIT, &config);

    if (err != NO_ERROR) {

        // If ES2 fails, try ES1

        err = selectEGLConfig(display, format, EGL_OPENGL_ES_BIT, &config);

        if (err != NO_ERROR) {

            // still didn't work, probably because we're on the emulator...

            // try a simplified query

            ALOGW("no suitable EGLConfig found, trying a simpler query");

            err = selectEGLConfig(display, format, 0, &config);

            if (err != NO_ERROR) {

                // this EGL is too lame for android

                LOG_ALWAYS_FATAL("no suitable EGLConfig found, giving up");

            }

        }

    }



    if (logConfig) {

        // print some debugging info

        EGLint r, g, b, a;

        eglGetConfigAttrib(display, config, EGL_RED_SIZE, &r);

        eglGetConfigAttrib(display, config, EGL_GREEN_SIZE, &g);

        eglGetConfigAttrib(display, config, EGL_BLUE_SIZE, &b);

        eglGetConfigAttrib(display, config, EGL_ALPHA_SIZE, &a);

        ALOGI("EGL information:");

        ALOGI("vendor    : %s", eglQueryString(display, EGL_VENDOR));

        ALOGI("version   : %s", eglQueryString(display, EGL_VERSION));

        ALOGI("extensions: %s", eglQueryString(display, EGL_EXTENSIONS));

        ALOGI("Client API: %s", eglQueryString(display, EGL_CLIENT_APIS) ?: "Not Supported");

        ALOGI("EGLSurface: %d-%d-%d-%d, config=%p", r, g, b, a, config);

    }



    return config;

}



}  // namespace impl

}  // namespace renderengine

}  // namespace android

services/surfaceflinger/RenderEngine/gl/GLES20RenderEngine.cpp

+295 −8

File changed.

Preview size limit exceeded, changes collapsed.

services/surfaceflinger/RenderEngine/gl/GLES20RenderEngine.h

+31 −7
Original line number Diff line number Diff line
@@ -20,10 +20,14 @@ 
#include <stdint.h>

#include <sys/types.h>



#include <EGL/egl.h>

#include <EGL/eglext.h>

#include <GLES2/gl2.h>

#include <renderengine/RenderEngine.h>

#include <renderengine/private/Description.h>



#define EGL_NO_CONFIG ((EGLConfig)0)



namespace android {



class String8;
@@ -40,6 +44,9 @@ class GLSurface; 


class GLES20RenderEngine : public impl::RenderEngine {

public:

    static std::unique_ptr<GLES20RenderEngine> create(int hwcFormat, uint32_t featureFlags);

    static EGLConfig chooseEglConfig(EGLDisplay display, int format, bool logConfig);



    GLES20RenderEngine(uint32_t featureFlags); // See RenderEngine::FeatureFlag

    ~GLES20RenderEngine() override;
@@ -67,19 +74,16 @@ public: 
    void unbindFrameBuffer(Framebuffer* framebuffer) override;

    void checkErrors() const override;



    // internal to RenderEngine

    EGLDisplay getEGLDisplay() const { return mEGLDisplay; }

    EGLConfig getEGLConfig() const { return mEGLConfig; }



protected:

    void dump(String8& result) override;

    void setViewportAndProjection(size_t vpw, size_t vph, Rect sourceCrop,

                                  ui::Transform::orientation_flags rotation) override;

    void setupLayerBlending(bool premultipliedAlpha, bool opaque, bool disableTexture,

                            const half4& color) override;



    // Color management related functions and state

    void setSourceY410BT2020(bool enable) override;

    void setSourceDataSpace(ui::Dataspace source) override;

    void setOutputDataSpace(ui::Dataspace dataspace) override;

    void setDisplayMaxLuminance(const float maxLuminance) override;



    void setupLayerTexturing(const Texture& texture) override;

    void setupLayerBlackedOut() override;

    void setupFillWithColor(float r, float g, float b, float a) override;
@@ -87,17 +91,37 @@ protected: 
    void disableTexturing() override;

    void disableBlending() override;



    // HDR and color management related functions and state

    void setSourceY410BT2020(bool enable) override;

    void setSourceDataSpace(ui::Dataspace source) override;

    void setOutputDataSpace(ui::Dataspace dataspace) override;

    void setDisplayMaxLuminance(const float maxLuminance) override;



    // drawing

    void drawMesh(const Mesh& mesh) override;



    size_t getMaxTextureSize() const override;

    size_t getMaxViewportDims() const override;



private:

    enum GlesVersion {

        GLES_VERSION_1_0 = 0x10000,

        GLES_VERSION_1_1 = 0x10001,

        GLES_VERSION_2_0 = 0x20000,

        GLES_VERSION_3_0 = 0x30000,

    };



    static GlesVersion parseGlesVersion(const char* str);



    // A data space is considered HDR data space if it has BT2020 color space

    // with PQ or HLG transfer function.

    bool isHdrDataSpace(const ui::Dataspace dataSpace) const;

    bool needsXYZTransformMatrix() const;

    void setEGLHandles(EGLDisplay display, EGLConfig config, EGLContext ctxt);



    EGLDisplay mEGLDisplay;

    EGLConfig mEGLConfig;

    EGLContext mEGLContext;

    GLuint mProtectedTexName;

    GLint mMaxViewportDims[2];

    GLint mMaxTextureSize;

services/surfaceflinger/RenderEngine/include/renderengine/RenderEngine.h

+6 −29
Original line number Diff line number Diff line
@@ -59,6 +59,8 @@ public: 
        USE_HIGH_PRIORITY_CONTEXT = 1 << 1, // Use high priority context

    };



    static std::unique_ptr<impl::RenderEngine> create(int hwcFormat, uint32_t featureFlags);



    virtual ~RenderEngine() = 0;



    virtual std::unique_ptr<Framebuffer> createFramebuffer() = 0;
@@ -155,43 +157,18 @@ private: 


namespace impl {



// impl::RenderEngine contains common implementation that is graphics back-end agnostic.

class RenderEngine : public renderengine::RenderEngine {

protected:

    enum GlesVersion {

        GLES_VERSION_1_0 = 0x10000,

        GLES_VERSION_1_1 = 0x10001,

        GLES_VERSION_2_0 = 0x20000,

        GLES_VERSION_3_0 = 0x30000,

    };

    static GlesVersion parseGlesVersion(const char* str);



    EGLDisplay mEGLDisplay;

    EGLConfig mEGLConfig;

    EGLContext mEGLContext;

    void setEGLHandles(EGLDisplay display, EGLConfig config, EGLContext ctxt);



    RenderEngine(uint32_t featureFlags);



    const uint32_t mFeatureFlags;



public:

    virtual ~RenderEngine() = 0;



    static std::unique_ptr<RenderEngine> create(int hwcFormat, uint32_t featureFlags);



    static EGLConfig chooseEglConfig(EGLDisplay display, int format, bool logConfig);



    // dump the extension strings. always call the base class.

    void dump(String8& result) override;



    bool useNativeFenceSync() const override;

    bool useWaitSync() const override;



    void setupColorTransform(const mat4& /* colorTransform */) override {}



    // internal to RenderEngine

    EGLDisplay getEGLDisplay() const;

    EGLConfig getEGLConfig() const;

protected:

    RenderEngine(uint32_t featureFlags);

    const uint32_t mFeatureFlags;

};



}  // namespace impl

services/surfaceflinger/SurfaceFlinger.cpp

+2 −2
Original line number Diff line number Diff line
@@ -667,7 +667,7 @@ void SurfaceFlinger::init() { 


    // TODO(b/77156734): We need to stop casting and use HAL types when possible.

    getBE().mRenderEngine =

        renderengine::impl::RenderEngine::create(static_cast<int32_t>(compositionPixelFormat),

        renderengine::RenderEngine::create(static_cast<int32_t>(compositionPixelFormat),

                                           renderEngineFeature);

    LOG_ALWAYS_FATAL_IF(getBE().mRenderEngine == nullptr, "couldn't create RenderEngine");