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

Commit 2fe9f86d authored by TreeHugger Robot's avatar TreeHugger Robot Committed by Android (Google) Code Review
Browse files

Merge "[RenderEngine] Create GLES 3 RenderEngine."

parents 2afae6d9 7e219eb7

libs/renderengine/Android.bp

+1 −1
Original line number Diff line number Diff line
@@ -46,7 +46,7 @@ filegroup { 
filegroup {

    name: "librenderengine_gl_sources",

    srcs: [

        "gl/GLES20RenderEngine.cpp",

        "gl/GLESRenderEngine.cpp",

        "gl/GLExtensions.cpp",

        "gl/GLFramebuffer.cpp",

        "gl/GLImage.cpp",

libs/renderengine/RenderEngine.cpp

+3 −3
Original line number Diff line number Diff line
@@ -19,7 +19,7 @@ 
#include <cutils/properties.h>

#include <log/log.h>

#include <private/gui/SyncFeatures.h>

#include "gl/GLES20RenderEngine.h"

#include "gl/GLESRenderEngine.h"



namespace android {

namespace renderengine {
@@ -29,10 +29,10 @@ std::unique_ptr<impl::RenderEngine> RenderEngine::create(int hwcFormat, uint32_t 
    property_get(PROPERTY_DEBUG_RENDERENGINE_BACKEND, prop, "gles");

    if (strcmp(prop, "gles") == 0) {

        ALOGD("RenderEngine GLES Backend");

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

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

    }

    ALOGE("UNKNOWN BackendType: %s, create GLES RenderEngine.", prop);

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

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

}



RenderEngine::~RenderEngine() = default;

libs/renderengine/gl/GLES20RenderEngine.cpp→libs/renderengine/gl/GLESRenderEngine.cpp

+80 −67
Original line number Diff line number Diff line
@@ -19,7 +19,7 @@ 
#define LOG_TAG "RenderEngine"

#define ATRACE_TAG ATRACE_TAG_GRAPHICS



#include "GLES20RenderEngine.h"

#include "GLESRenderEngine.h"



#include <math.h>

#include <fstream>
@@ -221,8 +221,7 @@ static status_t selectEGLConfig(EGLDisplay display, EGLint format, EGLint render 
    return err;

}



std::unique_ptr<GLES20RenderEngine> GLES20RenderEngine::create(int hwcFormat,

                                                               uint32_t featureFlags) {

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

    // initialize EGL for the default display

    EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);

    if (!eglInitialize(display, nullptr, nullptr)) {
@@ -263,7 +262,7 @@ std::unique_ptr<GLES20RenderEngine> GLES20RenderEngine::create(int hwcFormat, 
    GlesVersion version = parseGlesVersion(extensions.getVersion());



    // initialize the renderer while GL is current

    std::unique_ptr<GLES20RenderEngine> engine;

    std::unique_ptr<GLESRenderEngine> engine;

    switch (version) {

        case GLES_VERSION_1_0:

        case GLES_VERSION_1_1:
@@ -271,8 +270,7 @@ std::unique_ptr<GLES20RenderEngine> GLES20RenderEngine::create(int hwcFormat, 
            break;

        case GLES_VERSION_2_0:

        case GLES_VERSION_3_0:

            engine = std::make_unique<GLES20RenderEngine>(featureFlags, display, config, ctxt,

                                                          dummy);

            engine = std::make_unique<GLESRenderEngine>(featureFlags, display, config, ctxt, dummy);

            break;

    }
@@ -287,17 +285,17 @@ std::unique_ptr<GLES20RenderEngine> GLES20RenderEngine::create(int hwcFormat, 
    return engine;

}



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

EGLConfig GLESRenderEngine::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);

    // First try to get an ES3 config

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

    if (err != NO_ERROR) {

        // If ES2 fails, try ES1

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

        // If ES3 fails, try to get an ES2 config

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

        if (err != NO_ERROR) {

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

            // If ES2 still doesn'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);
@@ -326,7 +324,7 @@ EGLConfig GLES20RenderEngine::chooseEglConfig(EGLDisplay display, int format, bo 
    return config;

}



GLES20RenderEngine::GLES20RenderEngine(uint32_t featureFlags, EGLDisplay display, EGLConfig config,

GLESRenderEngine::GLESRenderEngine(uint32_t featureFlags, EGLDisplay display, EGLConfig config,

                                   EGLContext ctxt, EGLSurface dummy)

      : renderengine::impl::RenderEngine(featureFlags),

        mEGLDisplay(display),
@@ -382,28 +380,28 @@ GLES20RenderEngine::GLES20RenderEngine(uint32_t featureFlags, EGLDisplay display 
    }

}



GLES20RenderEngine::~GLES20RenderEngine() {

GLESRenderEngine::~GLESRenderEngine() {

    eglMakeCurrent(mEGLDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);

    eglTerminate(mEGLDisplay);

}



std::unique_ptr<Framebuffer> GLES20RenderEngine::createFramebuffer() {

std::unique_ptr<Framebuffer> GLESRenderEngine::createFramebuffer() {

    return std::make_unique<GLFramebuffer>(*this);

}



std::unique_ptr<Image> GLES20RenderEngine::createImage() {

std::unique_ptr<Image> GLESRenderEngine::createImage() {

    return std::make_unique<GLImage>(*this);

}



void GLES20RenderEngine::primeCache() const {

void GLESRenderEngine::primeCache() const {

    ProgramCache::getInstance().primeCache(mFeatureFlags & USE_COLOR_MANAGEMENT);

}



bool GLES20RenderEngine::isCurrent() const {

bool GLESRenderEngine::isCurrent() const {

    return mEGLDisplay == eglGetCurrentDisplay() && mEGLContext == eglGetCurrentContext();

}



base::unique_fd GLES20RenderEngine::flush() {

base::unique_fd GLESRenderEngine::flush() {

    if (!GLExtensions::getInstance().hasNativeFenceSync()) {

        return base::unique_fd();

    }
@@ -427,7 +425,7 @@ base::unique_fd GLES20RenderEngine::flush() { 
    return fenceFd;

}



bool GLES20RenderEngine::finish() {

bool GLESRenderEngine::finish() {

    if (!GLExtensions::getInstance().hasFenceSync()) {

        ALOGW("no synchronization support");

        return false;
@@ -455,7 +453,7 @@ bool GLES20RenderEngine::finish() { 
    return true;

}



bool GLES20RenderEngine::waitFence(base::unique_fd fenceFd) {

bool GLESRenderEngine::waitFence(base::unique_fd fenceFd) {

    if (!GLExtensions::getInstance().hasNativeFenceSync() ||

        !GLExtensions::getInstance().hasWaitSync()) {

        return false;
@@ -485,13 +483,13 @@ bool GLES20RenderEngine::waitFence(base::unique_fd fenceFd) { 
    return true;

}



void GLES20RenderEngine::clearWithColor(float red, float green, float blue, float alpha) {

void GLESRenderEngine::clearWithColor(float red, float green, float blue, float alpha) {

    glClearColor(red, green, blue, alpha);

    glClear(GL_COLOR_BUFFER_BIT);

}



void GLES20RenderEngine::fillRegionWithColor(const Region& region, float red, float green,

                                             float blue, float alpha) {

void GLESRenderEngine::fillRegionWithColor(const Region& region, float red, float green, float blue,

                                           float alpha) {

    size_t c;

    Rect const* r = region.getArray(&c);

    Mesh mesh(Mesh::TRIANGLES, c * 6, 2);
@@ -514,7 +512,7 @@ void GLES20RenderEngine::fillRegionWithColor(const Region& region, float red, fl 
    drawMesh(mesh);

}



void GLES20RenderEngine::setScissor(const Rect& region) {

void GLESRenderEngine::setScissor(const Rect& region) {

    // Invert y-coordinate to map to GL-space.

    int32_t canvasHeight = mFboHeight;

    int32_t glBottom = canvasHeight - region.bottom;
@@ -523,19 +521,19 @@ void GLES20RenderEngine::setScissor(const Rect& region) { 
    glEnable(GL_SCISSOR_TEST);

}



void GLES20RenderEngine::disableScissor() {

void GLESRenderEngine::disableScissor() {

    glDisable(GL_SCISSOR_TEST);

}



void GLES20RenderEngine::genTextures(size_t count, uint32_t* names) {

void GLESRenderEngine::genTextures(size_t count, uint32_t* names) {

    glGenTextures(count, names);

}



void GLES20RenderEngine::deleteTextures(size_t count, uint32_t const* names) {

void GLESRenderEngine::deleteTextures(size_t count, uint32_t const* names) {

    glDeleteTextures(count, names);

}



void GLES20RenderEngine::bindExternalTextureImage(uint32_t texName, const Image& image) {

void GLESRenderEngine::bindExternalTextureImage(uint32_t texName, const Image& image) {

    const GLImage& glImage = static_cast<const GLImage&>(image);

    const GLenum target = GL_TEXTURE_EXTERNAL_OES;
@@ -545,7 +543,7 @@ void GLES20RenderEngine::bindExternalTextureImage(uint32_t texName, const Image& 
    }

}



status_t GLES20RenderEngine::bindFrameBuffer(Framebuffer* framebuffer) {

status_t GLESRenderEngine::bindFrameBuffer(Framebuffer* framebuffer) {

    GLFramebuffer* glFramebuffer = static_cast<GLFramebuffer*>(framebuffer);

    EGLImageKHR eglImage = glFramebuffer->getEGLImage();

    uint32_t textureName = glFramebuffer->getTextureName();
@@ -569,14 +567,14 @@ status_t GLES20RenderEngine::bindFrameBuffer(Framebuffer* framebuffer) { 
    return glStatus == GL_FRAMEBUFFER_COMPLETE_OES ? NO_ERROR : BAD_VALUE;

}



void GLES20RenderEngine::unbindFrameBuffer(Framebuffer* /* framebuffer */) {

void GLESRenderEngine::unbindFrameBuffer(Framebuffer* /* framebuffer */) {

    mFboHeight = 0;



    // back to main framebuffer

    glBindFramebuffer(GL_FRAMEBUFFER, 0);

}



void GLES20RenderEngine::checkErrors() const {

void GLESRenderEngine::checkErrors() const {

    do {

        // there could be more than one error flag

        GLenum error = glGetError();
@@ -585,14 +583,14 @@ void GLES20RenderEngine::checkErrors() const { 
    } while (true);

}



status_t GLES20RenderEngine::drawLayers(const DisplaySettings& /*settings*/,

status_t GLESRenderEngine::drawLayers(const DisplaySettings& /*settings*/,

                                      const std::vector<LayerSettings>& /*layers*/,

                                      ANativeWindowBuffer* const /*buffer*/,

                                      base::unique_fd* /*displayFence*/) const {

    return NO_ERROR;

}



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

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

                                                ui::Transform::orientation_flags rotation) {

    int32_t l = sourceCrop.left;

    int32_t r = sourceCrop.right;
@@ -625,9 +623,8 @@ void GLES20RenderEngine::setViewportAndProjection(size_t vpw, size_t vph, Rect s 
    mVpHeight = vph;

}



void GLES20RenderEngine::setupLayerBlending(bool premultipliedAlpha, bool opaque,

                                            bool disableTexture, const half4& color,

                                            float cornerRadius) {

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

                                          const half4& color, float cornerRadius) {

    mState.isPremultipliedAlpha = premultipliedAlpha;

    mState.isOpaque = opaque;

    mState.color = color;
@@ -645,23 +642,23 @@ void GLES20RenderEngine::setupLayerBlending(bool premultipliedAlpha, bool opaque 
    }

}



void GLES20RenderEngine::setSourceY410BT2020(bool enable) {

void GLESRenderEngine::setSourceY410BT2020(bool enable) {

    mState.isY410BT2020 = enable;

}



void GLES20RenderEngine::setSourceDataSpace(Dataspace source) {

void GLESRenderEngine::setSourceDataSpace(Dataspace source) {

    mDataSpace = source;

}



void GLES20RenderEngine::setOutputDataSpace(Dataspace dataspace) {

void GLESRenderEngine::setOutputDataSpace(Dataspace dataspace) {

    mOutputDataSpace = dataspace;

}



void GLES20RenderEngine::setDisplayMaxLuminance(const float maxLuminance) {

void GLESRenderEngine::setDisplayMaxLuminance(const float maxLuminance) {

    mState.displayMaxLuminance = maxLuminance;

}



void GLES20RenderEngine::setupLayerTexturing(const Texture& texture) {

void GLESRenderEngine::setupLayerTexturing(const Texture& texture) {

    GLuint target = texture.getTextureTarget();

    glBindTexture(target, texture.getTextureName());

    GLenum filter = GL_NEAREST;
@@ -677,7 +674,7 @@ void GLES20RenderEngine::setupLayerTexturing(const Texture& texture) { 
    mState.textureEnabled = true;

}



void GLES20RenderEngine::setupLayerBlackedOut() {

void GLESRenderEngine::setupLayerBlackedOut() {

    glBindTexture(GL_TEXTURE_2D, mProtectedTexName);

    Texture texture(Texture::TEXTURE_2D, mProtectedTexName);

    texture.setDimensions(1, 1); // FIXME: we should get that from somewhere
@@ -685,19 +682,19 @@ void GLES20RenderEngine::setupLayerBlackedOut() { 
    mState.textureEnabled = true;

}



void GLES20RenderEngine::setColorTransform(const mat4& colorTransform) {

void GLESRenderEngine::setColorTransform(const mat4& colorTransform) {

    mState.colorMatrix = colorTransform;

}



void GLES20RenderEngine::disableTexturing() {

void GLESRenderEngine::disableTexturing() {

    mState.textureEnabled = false;

}



void GLES20RenderEngine::disableBlending() {

void GLESRenderEngine::disableBlending() {

    glDisable(GL_BLEND);

}



void GLES20RenderEngine::setupFillWithColor(float r, float g, float b, float a) {

void GLESRenderEngine::setupFillWithColor(float r, float g, float b, float a) {

    mState.isPremultipliedAlpha = true;

    mState.isOpaque = false;

    mState.color = half4(r, g, b, a);
@@ -705,11 +702,11 @@ void GLES20RenderEngine::setupFillWithColor(float r, float g, float b, float a) 
    glDisable(GL_BLEND);

}



void GLES20RenderEngine::setupCornerRadiusCropSize(float width, float height) {

void GLESRenderEngine::setupCornerRadiusCropSize(float width, float height) {

    mState.cropSize = half2(width, height);

}



void GLES20RenderEngine::drawMesh(const Mesh& mesh) {

void GLESRenderEngine::drawMesh(const Mesh& mesh) {

    ATRACE_CALL();

    if (mesh.getTexCoordsSize()) {

        glEnableVertexAttribArray(Program::texCoords);
@@ -849,15 +846,15 @@ void GLES20RenderEngine::drawMesh(const Mesh& mesh) { 
    }

}



size_t GLES20RenderEngine::getMaxTextureSize() const {

size_t GLESRenderEngine::getMaxTextureSize() const {

    return mMaxTextureSize;

}



size_t GLES20RenderEngine::getMaxViewportDims() const {

size_t GLESRenderEngine::getMaxViewportDims() const {

    return mMaxViewportDims[0] < mMaxViewportDims[1] ? mMaxViewportDims[0] : mMaxViewportDims[1];

}



void GLES20RenderEngine::dump(String8& result) {

void GLESRenderEngine::dump(String8& result) {

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



    result.appendFormat("EGL implementation : %s\n", extensions.getEGLVersion());
@@ -875,7 +872,7 @@ void GLES20RenderEngine::dump(String8& result) { 
                        dataspaceDetails(static_cast<android_dataspace>(mOutputDataSpace)).c_str());

}



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

GLESRenderEngine::GlesVersion GLESRenderEngine::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) {
@@ -893,16 +890,18 @@ GLES20RenderEngine::GlesVersion GLES20RenderEngine::parseGlesVersion(const char* 
    return GLES_VERSION_1_0;

}



EGLContext GLES20RenderEngine::createEglContext(EGLDisplay display, EGLConfig config,

EGLContext GLESRenderEngine::createEglContext(EGLDisplay display, EGLConfig config,

                                              EGLContext shareContext, bool useContextPriority) {

    EGLint renderableType = 0;

    if (config == EGL_NO_CONFIG) {

        renderableType = EGL_OPENGL_ES2_BIT;

        renderableType = EGL_OPENGL_ES3_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) {

    if (renderableType & EGL_OPENGL_ES3_BIT) {

        contextClientVersion = 3;

    } else if (renderableType & EGL_OPENGL_ES2_BIT) {

        contextClientVersion = 2;

    } else if (renderableType & EGL_OPENGL_ES_BIT) {

        contextClientVersion = 1;
@@ -920,10 +919,24 @@ EGLContext GLES20RenderEngine::createEglContext(EGLDisplay display, EGLConfig co 
    }

    contextAttributes.push_back(EGL_NONE);



    return eglCreateContext(display, config, shareContext, contextAttributes.data());

    EGLContext context = eglCreateContext(display, config, shareContext, contextAttributes.data());



    if (contextClientVersion == 3 && context == EGL_NO_CONTEXT) {

        // eglGetConfigAttrib indicated we can create GLES 3 context, but we failed, thus

        // EGL_NO_CONTEXT so that we can abort.

        if (config != EGL_NO_CONFIG) {

            return context;

        }

        // If |config| is EGL_NO_CONFIG, we speculatively try to create GLES 3 context, so we should

        // try to fall back to GLES 2.

        contextAttributes[1] = 2;

        context = eglCreateContext(display, config, shareContext, contextAttributes.data());

    }



    return context;

}



EGLSurface GLES20RenderEngine::createDummyEglPbufferSurface(EGLDisplay display, EGLConfig config,

EGLSurface GLESRenderEngine::createDummyEglPbufferSurface(EGLDisplay display, EGLConfig config,

                                                          int hwcFormat) {

    EGLConfig dummyConfig = config;

    if (dummyConfig == EGL_NO_CONFIG) {
@@ -940,7 +953,7 @@ EGLSurface GLES20RenderEngine::createDummyEglPbufferSurface(EGLDisplay display, 
    return eglCreatePbufferSurface(display, dummyConfig, attributes.data());

}



bool GLES20RenderEngine::isHdrDataSpace(const Dataspace dataSpace) const {

bool GLESRenderEngine::isHdrDataSpace(const Dataspace dataSpace) const {

    const Dataspace standard = static_cast<Dataspace>(dataSpace & Dataspace::STANDARD_MASK);

    const Dataspace transfer = static_cast<Dataspace>(dataSpace & Dataspace::TRANSFER_MASK);

    return standard == Dataspace::STANDARD_BT2020 &&
@@ -957,7 +970,7 @@ bool GLES20RenderEngine::isHdrDataSpace(const Dataspace dataSpace) const { 
// input data space or output data space is HDR data space, and the input transfer function

// doesn't match the output transfer function, we would enable an intermediate transfrom to

// XYZ color space.

bool GLES20RenderEngine::needsXYZTransformMatrix() const {

bool GLESRenderEngine::needsXYZTransformMatrix() const {

    const bool isInputHdrDataSpace = isHdrDataSpace(mDataSpace);

    const bool isOutputHdrDataSpace = isHdrDataSpace(mOutputDataSpace);

    const Dataspace inputTransfer = static_cast<Dataspace>(mDataSpace & Dataspace::TRANSFER_MASK);

libs/renderengine/gl/GLES20RenderEngine.h→libs/renderengine/gl/GLESRenderEngine.h

+8 −8
Original line number Diff line number Diff line
@@ -14,8 +14,8 @@ 
 * limitations under the License.

 */



#ifndef SF_GLES20RENDERENGINE_H_

#define SF_GLES20RENDERENGINE_H_

#ifndef SF_GLESRENDERENGINE_H_

#define SF_GLESRENDERENGINE_H_



#include <stdint.h>

#include <sys/types.h>
@@ -41,14 +41,14 @@ namespace gl { 


class GLImage;



class GLES20RenderEngine : public impl::RenderEngine {

class GLESRenderEngine : public impl::RenderEngine {

public:

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

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

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



    GLES20RenderEngine(uint32_t featureFlags, // See RenderEngine::FeatureFlag

    GLESRenderEngine(uint32_t featureFlags, // See RenderEngine::FeatureFlag

                     EGLDisplay display, EGLConfig config, EGLContext ctxt, EGLSurface dummy);

    ~GLES20RenderEngine() override;

    ~GLESRenderEngine() override;



    std::unique_ptr<Framebuffer> createFramebuffer() override;

    std::unique_ptr<Image> createImage() override;
@@ -165,4 +165,4 @@ private: 
} // namespace renderengine

} // namespace android



#endif /* SF_GLES20RENDERENGINE_H_ */
 
#endif /* SF_GLESRENDERENGINE_H_ */

libs/renderengine/gl/GLFramebuffer.cpp

+2 −2
Original line number Diff line number Diff line
@@ -21,13 +21,13 @@ 
#include <GLES2/gl2.h>

#include <GLES2/gl2ext.h>

#include <nativebase/nativebase.h>

#include "GLES20RenderEngine.h"

#include "GLESRenderEngine.h"



namespace android {

namespace renderengine {

namespace gl {



GLFramebuffer::GLFramebuffer(const GLES20RenderEngine& engine)

GLFramebuffer::GLFramebuffer(const GLESRenderEngine& engine)

      : mEGLDisplay(engine.getEGLDisplay()), mEGLImage(EGL_NO_IMAGE_KHR) {

    glGenTextures(1, &mTextureName);

    glGenFramebuffers(1, &mFramebufferName);