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

Commit 5279f866 authored by Ian Elliott's avatar Ian Elliott
Browse files

Can switch to legacy GLES driver when ANGLE is system driver 

Change the sense of the run-time switches so that ANGLE can be an
optional GLES driver or the default system GLES driver.  When ANGLE is
the system GLES driver, also handle the case of there being no legacy
GLES driver.

Test: logcat
Test: atest CtsAngleIntegrationHostTestCases
Test: atest CtsEffectTestCases:android.effect.cts.EffectTest#test5_effectCreate
Bug: 224558229
Change-Id: I5383966daeea74a9d7c878c8f63f70f7fc7ccc50
parent 2a4434af

libs/graphicsenv/GraphicsEnv.cpp

+58 −4
Original line number Diff line number Diff line
@@ -364,26 +364,61 @@ bool GraphicsEnv::shouldUseAngle() { 
    return (mUseAngle == YES) ? true : false;

}



bool GraphicsEnv::angleIsSystemDriver() {

    // Make sure we are init'ed

    if (mAngleAppName.empty()) {

        ALOGV("App name is empty. setAngleInfo() has not been called to enable ANGLE.");

        return false;

    }



    return (mAngleIsSystemDriver == YES) ? true : false;

}



bool GraphicsEnv::shouldForceLegacyDriver() {

    // Make sure we are init'ed

    if (mAngleAppName.empty()) {

        ALOGV("App name is empty. setAngleInfo() has not been called to enable ANGLE.");

        return false;

    }



    return (mAngleIsSystemDriver == YES && mUseAngle == NO) ? true : false;

}



std::string GraphicsEnv::getLegacySuffix() {

    return mLegacyDriverSuffix;

}



void GraphicsEnv::updateUseAngle() {

    mUseAngle = NO;



    const char* ANGLE_PREFER_ANGLE = "angle";

    const char* ANGLE_PREFER_LEGACY = "legacy";

    // The following is a deprecated version of "legacy"

    const char* ANGLE_PREFER_NATIVE = "native";



    mUseAngle = NO;

    if (mAngleDeveloperOptIn == ANGLE_PREFER_ANGLE) {

        ALOGV("User set \"Developer Options\" to force the use of ANGLE");

        ALOGI("Using ANGLE, the %s GLES driver for package '%s'",

              mAngleIsSystemDriver == YES ? "system" : "optional", mAngleAppName.c_str());

        mUseAngle = YES;

    } else if (mAngleDeveloperOptIn == ANGLE_PREFER_NATIVE) {

        ALOGV("User set \"Developer Options\" to force the use of Native");

    } else if (mAngleDeveloperOptIn == ANGLE_PREFER_LEGACY ||

               mAngleDeveloperOptIn == ANGLE_PREFER_NATIVE) {

        ALOGI("Using the (%s) Legacy GLES driver for package '%s'",

              mAngleIsSystemDriver == YES ? "optional" : "system", mAngleAppName.c_str());

    } else {

        ALOGV("User set invalid \"Developer Options\": '%s'", mAngleDeveloperOptIn.c_str());

    }

}



void GraphicsEnv::setAngleInfo(const std::string path, const std::string appName,

                               const std::string developerOptIn,

                               const bool angleIsSystemDriver, const std::string developerOptIn,

                               const std::vector<std::string> eglFeatures) {

    // Set whether ANGLE is the system driver:

    mAngleIsSystemDriver = angleIsSystemDriver ? YES : NO;



    // Note: Given the current logic and lack of the old rules file processing,

    // there seems to be little chance that mUseAngle != UNKNOWN.  Leave this

    // for now, even though it seems outdated.

    if (mUseAngle != UNKNOWN) {

        // We've already figured out an answer for this app, so just return.

        ALOGV("Already evaluated the rules file for '%s': use ANGLE = %s", appName.c_str(),
@@ -404,6 +439,25 @@ void GraphicsEnv::setAngleInfo(const std::string path, const std::string appName 
    updateUseAngle();

}



void GraphicsEnv::setLegacyDriverInfo(const std::string appName, const bool angleIsSystemDriver,

                                      const std::string legacyDriverName) {

    ALOGV("setting legacy app name to '%s'", appName.c_str());

    mAngleAppName = appName;



    // Force the use of the legacy driver instead of ANGLE

    const char* ANGLE_PREFER_LEGACY = "legacy";

    mAngleDeveloperOptIn = ANGLE_PREFER_LEGACY;

    ALOGV("setting ANGLE application opt-in to 'legacy'");



    // Set whether ANGLE is the system driver:

    mAngleIsSystemDriver = angleIsSystemDriver ? YES : NO;



    mLegacyDriverSuffix = legacyDriverName;



    // Update the current status of whether we should use ANGLE or not

    updateUseAngle();

}



void GraphicsEnv::setLayerPaths(NativeLoaderNamespace* appNamespace, const std::string layerPaths) {

    if (mLayerPaths.empty()) {

        mLayerPaths = layerPaths;

libs/graphicsenv/include/graphicsenv/GraphicsEnv.h

+16 −1
Original line number Diff line number Diff line
@@ -91,17 +91,28 @@ public: 
    bool shouldUseAngle(std::string appName);

    // Check if this app process should use ANGLE.

    bool shouldUseAngle();

    // If ANGLE is the system GLES driver

    bool angleIsSystemDriver();

    // If should use legacy driver instead of a system ANGLE driver

    bool shouldForceLegacyDriver();

    // Set a search path for loading ANGLE libraries. The path is a list of

    // directories separated by ':'. A directory can be contained in a zip file

    // (libraries must be stored uncompressed and page aligned); such elements

    // in the search path must have a '!' after the zip filename, e.g.

    //     /system/app/ANGLEPrebuilt/ANGLEPrebuilt.apk!/lib/arm64-v8a

    void setAngleInfo(const std::string path, const std::string appName, std::string devOptIn,

    void setAngleInfo(const std::string path, const std::string appName,

                      const bool angleIsSystemDriver, std::string devOptIn,

                      const std::vector<std::string> eglFeatures);

    // Set the state so that the legacy driver will be used, and in case ANGLE

    // is the system driver, provide the name of the legacy driver.

    void setLegacyDriverInfo(const std::string appName, const bool angleIsSystemDriver,

                             const std::string legacyDriverName);

    // Get the ANGLE driver namespace.

    android_namespace_t* getAngleNamespace();

    // Get the app name for ANGLE debug message.

    std::string& getAngleAppName();

    // Get the legacy driver's suffix name.

    std::string getLegacySuffix();



    const std::vector<std::string>& getAngleEglFeatures();
@@ -156,6 +167,10 @@ private: 
    std::string mAngleDeveloperOptIn;

    // ANGLE EGL features;

    std::vector<std::string> mAngleEglFeatures;

    // ANGLE is System Driver flag.

    UseAngle mAngleIsSystemDriver = UNKNOWN;

    // Legacy driver name to use when ANGLE is the system driver.

    std::string mLegacyDriverSuffix;

    // Use ANGLE flag.

    UseAngle mUseAngle = UNKNOWN;

    // Vulkan debug layers libs.

opengl/libs/EGL/Loader.cpp

+32 −18
Original line number Diff line number Diff line
@@ -207,7 +207,8 @@ void* Loader::open(egl_connection_t* cnx) 
    ATRACE_CALL();

    const nsecs_t openTime = systemTime();



    if (should_unload_system_driver(cnx)) {

    if (!android::GraphicsEnv::getInstance().angleIsSystemDriver() &&

        should_unload_system_driver(cnx)) {

        unload_system_driver(cnx);

    }
@@ -216,8 +217,13 @@ void* Loader::open(egl_connection_t* cnx) 
        return cnx->dso;

    }



    // Firstly, try to load ANGLE driver.

    driver_t* hnd = attempt_to_load_angle(cnx);

    // Firstly, try to load ANGLE driver, unless we know that we shouldn't.

    bool shouldForceLegacyDriver = android::GraphicsEnv::getInstance().shouldForceLegacyDriver();

    driver_t* hnd = nullptr;

    if (!shouldForceLegacyDriver) {

        hnd = attempt_to_load_angle(cnx);

    }



    if (!hnd) {

        // Secondly, try to load from driver apk.

        hnd = attempt_to_load_updated_driver(cnx);
@@ -230,8 +236,15 @@ void* Loader::open(egl_connection_t* cnx) 
            LOG_ALWAYS_FATAL("couldn't find an OpenGL ES implementation from %s",

                             android::GraphicsEnv::getInstance().getDriverPath().c_str());

        }

        // Finally, try to load system driver, start by searching for the library name appended by

        // the system properties of the GLES userspace driver in both locations.

        // Finally, try to load system driver.  If ANGLE is the system driver

        // (i.e. we are forcing the legacy system driver instead of ANGLE), use

        // the driver suffix that was passed down from above.

        if (shouldForceLegacyDriver) {

            std::string suffix = android::GraphicsEnv::getInstance().getLegacySuffix();

            hnd = attempt_to_load_system_driver(cnx, suffix.c_str(), true);

        } else {

            // Start by searching for the library name appended by the system

            // properties of the GLES userspace driver in both locations.

            // i.e.:

            //      libGLES_${prop}.so, or:

            //      libEGL_${prop}.so, libGLESv1_CM_${prop}.so, libGLESv2_${prop}.so
@@ -248,6 +261,7 @@ void* Loader::open(egl_connection_t* cnx) 
                }

            }

        }

    }



    if (!hnd) {

        // Can't find graphics driver by appending system properties, now search for the exact name