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

Commit fa528940 authored by Eric Laurent's avatar Eric Laurent Committed by Automerger Merge Worker
Browse files

Merge "Revert "Deprecate support for legacy effect config file... 

Merge "Revert "Deprecate support for legacy effect config file audio_effects.conf"" into udc-dev am: 7ffe564e am: dcc196c2 am: b59b10c7

Original change: https://googleplex-android-review.googlesource.com/c/platform/frameworks/av/+/23247960



Change-Id: Ic103143af30a03a9a33f18ed6ca090629848c289
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents c712e0bc b59b10c7

media/libeffects/factory/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -21,6 +21,7 @@ cc_library_shared { 
    vendor: true,

    srcs: [

         "EffectsFactory.c",

         "EffectsConfigLoader.c",

         "EffectsFactoryState.c",

         "EffectsXmlConfigLoader.cpp",

    ],

media/libeffects/factory/EffectsConfigLoader.c

0 → 100644
+439 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2017 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#define LOG_TAG "EffectsFactoryConfigLoader"

//#define LOG_NDEBUG 0



#include <dlfcn.h>

#include <stdlib.h>

#include <unistd.h>



#include <cutils/config_utils.h>

#include <cutils/misc.h>

#include <log/log.h>



#include <system/audio_effects/audio_effects_conf.h>



#include "EffectsConfigLoader.h"

#include "EffectsFactoryState.h"



/////////////////////////////////////////////////

//      Local functions prototypes

/////////////////////////////////////////////////



static int loadEffectConfigFile(const char *path);

static int loadLibraries(cnode *root);

static int loadLibrary(cnode *root, const char *name);

static int loadEffects(cnode *root);

static int loadEffect(cnode *node);

// To get and add the effect pointed by the passed node to the gSubEffectList

static int addSubEffect(cnode *root);

static lib_entry_t *getLibrary(const char *path);



static lib_entry_t *gCachedLibrary;  // last library accessed by getLibrary()



int EffectLoadEffectConfig()

{

    if (access(AUDIO_EFFECT_VENDOR_CONFIG_FILE, R_OK) == 0) {

        return loadEffectConfigFile(AUDIO_EFFECT_VENDOR_CONFIG_FILE);

    } else if (access(AUDIO_EFFECT_DEFAULT_CONFIG_FILE, R_OK) == 0) {

        return loadEffectConfigFile(AUDIO_EFFECT_DEFAULT_CONFIG_FILE);

    }

    return 0;

}



int loadEffectConfigFile(const char *path)

{

    cnode *root;

    char *data;



    data = load_file(path, NULL);

    if (data == NULL) {

        return -ENODEV;

    }

    root = config_node("", "");

    config_load(root, data);

    loadLibraries(root);

    loadEffects(root);

    config_free(root);

    free(root);

    free(data);



    return 0;

}



int loadLibraries(cnode *root)

{

    cnode *node;



    node = config_find(root, LIBRARIES_TAG);

    if (node == NULL) {

        return -ENOENT;

    }

    node = node->first_child;

    while (node) {

        loadLibrary(node, node->name);

        node = node->next;

    }

    return 0;

}



#ifdef __LP64__

// audio_effects.conf always specifies 32 bit lib path: convert to 64 bit path if needed

static const char *kLibraryPathRoot[] =

        {"/odm/lib64/soundfx", "/vendor/lib64/soundfx", "/system/lib64/soundfx"};

#else

static const char *kLibraryPathRoot[] =

        {"/odm/lib/soundfx", "/vendor/lib/soundfx", "/system/lib/soundfx"};

#endif



static const int kLibraryPathRootSize =

        (sizeof(kLibraryPathRoot) / sizeof(kLibraryPathRoot[0]));



// Checks if the library path passed as lib_path_in can be opened and if not

// tries in standard effect library directories with just the library name and returns correct path

// in lib_path_out

int checkLibraryPath(const char *lib_path_in, char *lib_path_out) {

    char *str;

    const char *lib_name;

    size_t len;



    if (lib_path_in == NULL || lib_path_out == NULL) {

        return -EINVAL;

    }



    strlcpy(lib_path_out, lib_path_in, PATH_MAX);



    // Try exact path first

    str = strstr(lib_path_out, "/lib/soundfx/");

    if (str == NULL) {

        return -EINVAL;

    }



    // Extract library name from input path

    len = str - lib_path_out;

    lib_name = lib_path_in + len + strlen("/lib/soundfx/");



    // Then try with library name and standard path names in order of preference

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

        char path[PATH_MAX];



        snprintf(path,

                 PATH_MAX,

                 "%s/%s",

                 kLibraryPathRoot[i],

                 lib_name);

        if (F_OK == access(path, 0)) {

            strcpy(lib_path_out, path);

            ALOGW_IF(strncmp(lib_path_out, lib_path_in, PATH_MAX) != 0,

                "checkLibraryPath() corrected library path %s to %s", lib_path_in, lib_path_out);

            return 0;

        }

    }

    return -EINVAL;

}







int loadLibrary(cnode *root, const char *name)

{

    cnode *node;

    void *hdl = NULL;

    audio_effect_library_t *desc;

    list_elem_t *e;

    lib_entry_t *l;

    char path[PATH_MAX];



    node = config_find(root, PATH_TAG);

    if (node == NULL) {

        return -EINVAL;

    }



    if (checkLibraryPath((const char *)node->value, path) != 0) {

        ALOGW("loadLibrary() could not find library %s", path);

        goto error;

    }



    hdl = dlopen(path, RTLD_NOW);

    if (hdl == NULL) {

        ALOGW("loadLibrary() failed to open %s", path);

        goto error;

    }



    desc = (audio_effect_library_t *)dlsym(hdl, AUDIO_EFFECT_LIBRARY_INFO_SYM_AS_STR);

    if (desc == NULL) {

        ALOGW("loadLibrary() could not find symbol %s", AUDIO_EFFECT_LIBRARY_INFO_SYM_AS_STR);

        goto error;

    }



    if (AUDIO_EFFECT_LIBRARY_TAG != desc->tag) {

        ALOGW("getLibrary() bad tag %08x in lib info struct", desc->tag);

        goto error;

    }



    if (EFFECT_API_VERSION_MAJOR(desc->version) !=

            EFFECT_API_VERSION_MAJOR(EFFECT_LIBRARY_API_VERSION)) {

        ALOGW("loadLibrary() bad lib version %08x", desc->version);

        goto error;

    }



    // add entry for library in gLibraryList

    l = malloc(sizeof(lib_entry_t));

    l->name = strndup(name, PATH_MAX);

    l->path = strndup(path, PATH_MAX);

    l->handle = hdl;

    l->desc = desc;

    l->effects = NULL;

    pthread_mutex_init(&l->lock, NULL);



    e = malloc(sizeof(list_elem_t));

    e->object = l;

    pthread_mutex_lock(&gLibLock);

    e->next = gLibraryList;

    gLibraryList = e;

    pthread_mutex_unlock(&gLibLock);

    ALOGV("getLibrary() linked library %p for path %s", l, path);



    return 0;



error:

    if (hdl != NULL) {

        dlclose(hdl);

    }

    //add entry for library errors in gLibraryFailedList

    lib_failed_entry_t *fl = malloc(sizeof(lib_failed_entry_t));

    fl->name = strndup(name, PATH_MAX);

    fl->path = strndup(path, PATH_MAX);



    list_elem_t *fe = malloc(sizeof(list_elem_t));

    fe->object = fl;

    fe->next = gLibraryFailedList;

    gLibraryFailedList = fe;

    ALOGV("getLibrary() linked error in library %p for path %s", fl, path);



    return -EINVAL;

}



// This will find the library and UUID tags of the sub effect pointed by the

// node, gets the effect descriptor and lib_entry_t and adds the subeffect -

// sub_entry_t to the gSubEffectList

int addSubEffect(cnode *root)

{

    ALOGV("addSubEffect");

    cnode *node;

    effect_uuid_t uuid;

    effect_descriptor_t *d;

    lib_entry_t *l;

    list_elem_t *e;

    node = config_find(root, LIBRARY_TAG);

    if (node == NULL) {

        return -EINVAL;

    }

    l = getLibrary(node->value);

    if (l == NULL) {

        ALOGW("addSubEffect() could not get library %s", node->value);

        return -EINVAL;

    }

    node = config_find(root, UUID_TAG);

    if (node == NULL) {

        return -EINVAL;

    }

    if (stringToUuid(node->value, &uuid) != 0) {

        ALOGW("addSubEffect() invalid uuid %s", node->value);

        return -EINVAL;

    }

    d = malloc(sizeof(effect_descriptor_t));

    if (l->desc->get_descriptor(&uuid, d) != 0) {

        char s[40];

        uuidToString(&uuid, s, 40);

        ALOGW("Error querying effect %s on lib %s", s, l->name);

        free(d);

        return -EINVAL;

    }

#if (LOG_NDEBUG==0)

    char s[512];

    dumpEffectDescriptor(d, s, sizeof(s), 0 /* indent */);

    ALOGV("addSubEffect() read descriptor %p:%s",d, s);

#endif

    if (EFFECT_API_VERSION_MAJOR(d->apiVersion) !=

            EFFECT_API_VERSION_MAJOR(EFFECT_CONTROL_API_VERSION)) {

        ALOGW("Bad API version %08x on lib %s", d->apiVersion, l->name);

        free(d);

        return -EINVAL;

    }

    sub_effect_entry_t *sub_effect = malloc(sizeof(sub_effect_entry_t));

    sub_effect->object = d;

    // lib_entry_t is stored since the sub effects are not linked to the library

    sub_effect->lib = l;

    e = malloc(sizeof(list_elem_t));

    e->object = sub_effect;

    e->next = gSubEffectList->sub_elem;

    gSubEffectList->sub_elem = e;

    ALOGV("addSubEffect end");

    return 0;

}



int loadEffects(cnode *root)

{

    cnode *node;



    node = config_find(root, EFFECTS_TAG);

    if (node == NULL) {

        return -ENOENT;

    }

    node = node->first_child;

    while (node) {

        loadEffect(node);

        node = node->next;

    }

    return 0;

}



int loadEffect(cnode *root)

{

    cnode *node;

    effect_uuid_t uuid;

    lib_entry_t *l;

    effect_descriptor_t *d;

    list_elem_t *e;



    node = config_find(root, LIBRARY_TAG);

    if (node == NULL) {

        return -EINVAL;

    }



    l = getLibrary(node->value);

    if (l == NULL) {

        ALOGW("loadEffect() could not get library %s", node->value);

        return -EINVAL;

    }



    node = config_find(root, UUID_TAG);

    if (node == NULL) {

        return -EINVAL;

    }

    if (stringToUuid(node->value, &uuid) != 0) {

        ALOGW("loadEffect() invalid uuid %s", node->value);

        return -EINVAL;

    }

    lib_entry_t *tmp;

    bool skip = false;

    if (findEffect(NULL, &uuid, &tmp, NULL) == 0) {

        ALOGW("skipping duplicate uuid %s %s", node->value,

                node->next ? "and its sub-effects" : "");

        skip = true;

    }



    d = malloc(sizeof(effect_descriptor_t));

    if (l->desc->get_descriptor(&uuid, d) != 0) {

        char s[40];

        uuidToString(&uuid, s, 40);

        ALOGW("Error querying effect %s on lib %s", s, l->name);

        free(d);

        return -EINVAL;

    }

#if (LOG_NDEBUG==0)

    char s[512];

    dumpEffectDescriptor(d, s, sizeof(s), 0 /* indent */);

    ALOGV("loadEffect() read descriptor %p:%s",d, s);

#endif

    if (EFFECT_API_VERSION_MAJOR(d->apiVersion) !=

            EFFECT_API_VERSION_MAJOR(EFFECT_CONTROL_API_VERSION)) {

        ALOGW("Bad API version %08x on lib %s", d->apiVersion, l->name);

        free(d);

        return -EINVAL;

    }

    e = malloc(sizeof(list_elem_t));

    e->object = d;

    if (skip) {

        e->next = gSkippedEffects;

        gSkippedEffects = e;

        return -EINVAL;

    } else {

        e->next = l->effects;

        l->effects = e;

    }



    // After the UUID node in the config_tree, if node->next is valid,

    // that would be sub effect node.

    // Find the sub effects and add them to the gSubEffectList

    node = node->next;

    int count = 2;

    bool hwSubefx = false, swSubefx = false;

    list_sub_elem_t *sube = NULL;

    if (node != NULL) {

        ALOGV("Adding the effect to gEffectSubList as there are sub effects");

        sube = malloc(sizeof(list_sub_elem_t));

        sube->object = d;

        sube->sub_elem = NULL;

        sube->next = gSubEffectList;

        gSubEffectList = sube;

    }

    while (node != NULL && count) {

       if (addSubEffect(node)) {

           ALOGW("loadEffect() could not add subEffect %s", node->value);

           // Change the gSubEffectList to point to older list;

           gSubEffectList = sube->next;

           free(sube->sub_elem);// Free an already added sub effect

           sube->sub_elem = NULL;

           free(sube);

           return -ENOENT;

       }

       sub_effect_entry_t *subEntry = (sub_effect_entry_t*)gSubEffectList->sub_elem->object;

       effect_descriptor_t *subEffectDesc = (effect_descriptor_t*)(subEntry->object);

       // Since we return a stub descriptor for the proxy during

       // get_descriptor call,we replace it with the correspoding

       // sw effect descriptor, but with Proxy UUID

       // check for Sw desc

        if (!((subEffectDesc->flags & EFFECT_FLAG_HW_ACC_MASK) ==

                                           EFFECT_FLAG_HW_ACC_TUNNEL)) {

             swSubefx = true;

             *d = *subEffectDesc;

             d->uuid = uuid;

             ALOGV("loadEffect() Changed the Proxy desc");

       } else

           hwSubefx = true;

       count--;

       node = node->next;

    }

    // 1 HW and 1 SW sub effect found. Set the offload flag in the Proxy desc

    if (hwSubefx && swSubefx) {

        d->flags |= EFFECT_FLAG_OFFLOAD_SUPPORTED;

    }

    return 0;

}



lib_entry_t *getLibrary(const char *name)

{

    list_elem_t *e;



    if (gCachedLibrary &&

            !strncmp(gCachedLibrary->name, name, PATH_MAX)) {

        return gCachedLibrary;

    }



    e = gLibraryList;

    while (e) {

        lib_entry_t *l = (lib_entry_t *)e->object;

        if (!strcmp(l->name, name)) {

            gCachedLibrary = l;

            return l;

        }

        e = e->next;

    }



    return NULL;

}

media/libeffects/factory/EffectsConfigLoader.h

0 → 100644
+38 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2017 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#ifndef ANDROID_EFFECTSCONFIGLOADER_H

#define ANDROID_EFFECTSCONFIGLOADER_H



#include <cutils/compiler.h>

#include "EffectsFactoryState.h"



#ifdef  __cplusplus

extern "C" {

#endif





/** Parses the platform effect configuration

 * and stores its content in the global EffectFactoryState. */

ANDROID_API

int EffectLoadEffectConfig();





#ifdef  __cplusplus

} // extern "C"

#endif



#endif  // ANDROID_EFFECTSCONFIGLOADER_H

media/libeffects/factory/EffectsFactory.c

+3 −1
Original line number Diff line number Diff line
@@ -26,6 +26,7 @@ 


#include <media/EffectsFactoryApi.h>



#include "EffectsConfigLoader.h"

#include "EffectsFactoryState.h"

#include "EffectsXmlConfigLoader.h"
@@ -463,7 +464,8 @@ int init() { 
    } else {

        gConfigNbElemSkipped = EffectLoadXmlEffectConfig(NULL);

        if (gConfigNbElemSkipped < 0) {

            ALOGE("Failed to load XML effect configuration with status %zd", gConfigNbElemSkipped);

            ALOGW("Failed to load XML effect configuration, fallback to .conf");

            EffectLoadEffectConfig();

        } else if (gConfigNbElemSkipped > 0) {

            ALOGE("Effect config is partially invalid, skipped %zd elements", gConfigNbElemSkipped);

        }

media/libeffects/factory/EffectsXmlConfigLoader.cpp

+1 −0
Original line number Diff line number Diff line
@@ -26,6 +26,7 @@ 


#include <media/EffectsConfig.h>



#include "EffectsConfigLoader.h"

#include "EffectsFactoryState.h"

#include "EffectsXmlConfigLoader.h"