Merge "Revert "Deprecate support for legacy effect config file... (cc25eeca) · Commits · e / os / android_frameworks_av

media/libeffects/factory/Android.bp

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -21,6 +21,7 @@ cc_library_shared {
	vendor: true,		vendor: true,
	srcs: [		srcs: [
	"EffectsFactory.c",		"EffectsFactory.c",
			"EffectsConfigLoader.c",
	"EffectsFactoryState.c",		"EffectsFactoryState.c",
	"EffectsXmlConfigLoader.cpp",		"EffectsXmlConfigLoader.cpp",
	],		],

media/libeffects/factory/EffectsConfigLoader.c

0 → 100644

+439 −0

Original line number	Original line	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	Original line	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	Original line	Diff line number	Diff line
	@@ -26,6 +26,7 @@

	#include <media/EffectsFactoryApi.h>		#include <media/EffectsFactoryApi.h>

			#include "EffectsConfigLoader.h"
	#include "EffectsFactoryState.h"		#include "EffectsFactoryState.h"
	#include "EffectsXmlConfigLoader.h"		#include "EffectsXmlConfigLoader.h"

	@@ -463,7 +464,8 @@ int init() {
	} else {		} else {
	gConfigNbElemSkipped = EffectLoadXmlEffectConfig(NULL);		gConfigNbElemSkipped = EffectLoadXmlEffectConfig(NULL);
	if (gConfigNbElemSkipped < 0) {		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) {		} else if (gConfigNbElemSkipped > 0) {
	ALOGE("Effect config is partially invalid, skipped %zd elements", gConfigNbElemSkipped);		ALOGE("Effect config is partially invalid, skipped %zd elements", gConfigNbElemSkipped);
	}		}

media/libeffects/factory/EffectsXmlConfigLoader.cpp

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -26,6 +26,7 @@

	#include <media/EffectsConfig.h>		#include <media/EffectsConfig.h>

			#include "EffectsConfigLoader.h"
	#include "EffectsFactoryState.h"		#include "EffectsFactoryState.h"
	#include "EffectsXmlConfigLoader.h"		#include "EffectsXmlConfigLoader.h"