cras/src/server/cras_dsp_ini.c - platform/external/adhd - Git at Google

 /* Copyright (c) 2012 The Chromium OS Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */

 #include <errno.h>
 #include <stdlib.h>
 #include <syslog.h>
 #include "cras_dsp_ini.h"
 #include "iniparser_wrapper.h"

 #define MAX_NR_PORT 128 /* the max number of ports for a plugin */
 #define MAX_PORT_NAME_LENGTH 20 /* names like "output_32" */
 #define MAX_MOCK_INI_CH 20 /* Max number of channels to create mock ini */

 /* Format of the ini file (See dsp.ini.sample for an example).

 - Each section in the ini file specifies a plugin. The section name is
   just an identifier. The "library" and "label" attributes in a
   section must be defined. The "library" attribute is the name of the
   shared library from which this plugin will be loaded, or a special
   value "builtin" for built-in plugins. The "label" attribute specify
   which plugin inside the shared library should be loaded.

 - Built-in plugins have an attribute "label" which has value "source"
   or "sink". It defines where the audio data flows into and flows out
   of the pipeline.  Built-in plugins also have a attribute "purpose"
   which has the value "playback" or "capture". It defines which
   pipeline these plugins belong to.

 - Each plugin can have an optional "disable expression", which defines
   under which conditions the plugin is disabled.

 - Each plugin have some ports which specify the parameters for the
   plugin or to specify connections to other plugins. The ports in each
   plugin are numbered from 0. Each port is either an input port or an
   output port, and each port is either an audio port or a control
   port. The connections between two ports are expressed by giving the
   same value to both ports. For audio ports, the value should be
   "{identifier}". For control ports, the value shoule be
   "<identifier>". For example, the following fragment

   [plugin1]
   ...
   output_4={audio_left}
   output_5={audio_right}

   [plugin2]
   ...
   input_0={audio_left}

   [plugin3]
   ...
   input_2={audio_right}

   specifies these connections:
   port 4 of plugin1 --> port 0 of plugin2
   port 5 of plugin1 --> port 2 of plugin3

 */

 static const char *getstring(struct ini *ini, const char *sec_name,
 			     const char *key)
 {
 	char full_key[MAX_INI_KEY_LENGTH + 1];
 	snprintf(full_key, sizeof(full_key), "%s:%s", sec_name, key);
 	return iniparser_getstring(ini->dict, full_key, NULL);
 }

 static int lookup_flow(struct ini *ini, const char *name)
 {
 	int i;
 	const struct flow *flow;

 	ARRAY_ELEMENT_FOREACH (&ini->flows, i, flow) {
 		if (strcmp(flow->name, name) == 0)
 			return i;
 	}

 	return -1;
 }

 static int lookup_or_add_flow(struct ini *ini, const char *name)
 {
 	struct flow *flow;
 	int i = lookup_flow(ini, name);
 	if (i != -1)
 		return i;
 	i = ARRAY_COUNT(&ini->flows);
 	flow = ARRAY_APPEND_ZERO(&ini->flows);
 	flow->name = name;
 	return i;
 }

 static int parse_ports(struct ini *ini, const char *sec_name,
 		       struct plugin *plugin)
 {
 	char key[MAX_PORT_NAME_LENGTH];
 	const char *str;
 	int i;
 	struct port *p;
 	int direction;

 	for (i = 0; i < MAX_NR_PORT; i++) {
 		direction = PORT_INPUT;
 		snprintf(key, sizeof(key), "input_%d", i);
 		str = getstring(ini, sec_name, key);
 		if (str == NULL) {
 			direction = PORT_OUTPUT;
 			snprintf(key, sizeof(key), "output_%d", i);
 			str = getstring(ini, sec_name, key);
 			if (str == NULL)
 				break; /* no more ports */
 		}

 		if (*str == '\0') {
 			syslog(LOG_ERR, "empty value for %s:%s", sec_name, key);
 			return -1;
 		}

 		if (str[0] == '<' || str[0] == '{') {
 			p = ARRAY_APPEND_ZERO(&plugin->ports);
 			p->type = (str[0] == '<') ? PORT_CONTROL : PORT_AUDIO;
 			p->flow_id = lookup_or_add_flow(ini, str);
 			p->init_value = 0;
 		} else {
 			char *endptr;
 			float init_value = strtof(str, &endptr);
 			if (endptr == str) {
 				syslog(LOG_ERR, "cannot parse number from '%s'",
 				       str);
 			}
 			p = ARRAY_APPEND_ZERO(&plugin->ports);
 			p->type = PORT_CONTROL;
 			p->flow_id = INVALID_FLOW_ID;
 			p->init_value = init_value;
 		}
 		p->direction = direction;
 	}

 	return 0;
 }

 static int parse_plugin_section(struct ini *ini, const char *sec_name,
 				struct plugin *p)
 {
 	p->title = sec_name;
 	p->library = getstring(ini, sec_name, "library");
 	p->label = getstring(ini, sec_name, "label");
 	p->purpose = getstring(ini, sec_name, "purpose");
 	p->disable_expr =
 		cras_expr_expression_parse(getstring(ini, sec_name, "disable"));

 	if (p->library == NULL || p->label == NULL) {
 		syslog(LOG_ERR, "A plugin must have library and label: %s",
 		       sec_name);
 		return -1;
 	}

 	if (parse_ports(ini, sec_name, p) < 0) {
 		syslog(LOG_ERR, "Failed to parse ports: %s", sec_name);
 		return -1;
 	}

 	return 0;
 }

 static void fill_flow_info(struct ini *ini)
 {
 	int i, j;
 	struct plugin *plugin;
 	struct port *port;
 	struct flow *flow;
 	struct plugin **pplugin;
 	int *pport;

 	ARRAY_ELEMENT_FOREACH (&ini->plugins, i, plugin) {
 		ARRAY_ELEMENT_FOREACH (&plugin->ports, j, port) {
 			int flow_id = port->flow_id;
 			if (flow_id == INVALID_FLOW_ID)
 				continue;
 			flow = ARRAY_ELEMENT(&ini->flows, flow_id);
 			flow->type = port->type;
 			if (port->direction == PORT_INPUT) {
 				pplugin = &flow->to;
 				pport = &flow->to_port;
 			} else {
 				pplugin = &flow->from;
 				pport = &flow->from_port;
 			}
 			*pplugin = plugin;
 			*pport = j;
 		}
 	}
 }

 /* Adds a port to a plugin with specified flow id and direction. */
 static void add_audio_port(struct ini *ini, struct plugin *plugin, int flow_id,
 			   enum port_direction port_direction)
 {
 	struct port *p;
 	p = ARRAY_APPEND_ZERO(&plugin->ports);
 	p->type = PORT_AUDIO;
 	p->flow_id = flow_id;
 	p->init_value = 0;
 	p->direction = port_direction;
 }

 /* Fills fields for a swap_lr plugin.*/
 static void fill_swap_lr_plugin(struct ini *ini, struct plugin *plugin,
 				int input_flowid_0, int input_flowid_1,
 				int output_flowid_0, int output_flowid_1)
 {
 	plugin->title = "swap_lr";
 	plugin->library = "builtin";
 	plugin->label = "swap_lr";
 	plugin->purpose = "playback";
 	plugin->disable_expr = cras_expr_expression_parse("swap_lr_disabled");

 	add_audio_port(ini, plugin, input_flowid_0, PORT_INPUT);
 	add_audio_port(ini, plugin, input_flowid_1, PORT_INPUT);
 	add_audio_port(ini, plugin, output_flowid_0, PORT_OUTPUT);
 	add_audio_port(ini, plugin, output_flowid_1, PORT_OUTPUT);
 }

 /* Adds a new flow with name. If there is already a flow with the name, returns
  * INVALID_FLOW_ID.
  */
 static int add_new_flow(struct ini *ini, const char *name)
 {
 	struct flow *flow;
 	int i = lookup_flow(ini, name);
 	if (i != -1)
 		return INVALID_FLOW_ID;
 	i = ARRAY_COUNT(&ini->flows);
 	flow = ARRAY_APPEND_ZERO(&ini->flows);
 	flow->name = name;
 	return i;
 }

 /* Finds the first playback sink plugin in ini. */
 struct plugin *find_first_playback_sink_plugin(struct ini *ini)
 {
 	int i;
 	struct plugin *plugin;

 	ARRAY_ELEMENT_FOREACH (&ini->plugins, i, plugin) {
 		if (strcmp(plugin->library, "builtin") != 0)
 			continue;
 		if (strcmp(plugin->label, "sink") != 0)
 			continue;
 		if (!plugin->purpose ||
 		    strcmp(plugin->purpose, "playback") != 0)
 			continue;
 		return plugin;
 	}

 	return NULL;
 }

 /* Inserts a swap_lr plugin before sink. Handles the port change such that
  * the port originally connects to sink will connect to swap_lr.
  */
 static int insert_swap_lr_plugin(struct ini *ini)
 {
 	struct plugin *swap_lr, *sink;
 	int sink_input_flowid_0, sink_input_flowid_1;
 	int swap_lr_output_flowid_0, swap_lr_output_flowid_1;

 	/* Only add swap_lr plugin for two-channel playback dsp.
 	 * TODO(cychiang): Handle multiple sinks if needed.
 	 */
 	sink = find_first_playback_sink_plugin(ini);
 	if ((sink == NULL) || ARRAY_COUNT(&sink->ports) != 2)
 		return 0;

 	/* Gets the original flow ids of the sink input ports. */
 	sink_input_flowid_0 = ARRAY_ELEMENT(&sink->ports, 0)->flow_id;
 	sink_input_flowid_1 = ARRAY_ELEMENT(&sink->ports, 1)->flow_id;

 	/* Create new flow ids for swap_lr output ports. */
 	swap_lr_output_flowid_0 = add_new_flow(ini, "{swap_lr_out:0}");
 	swap_lr_output_flowid_1 = add_new_flow(ini, "{swap_lr_out:1}");

 	if (swap_lr_output_flowid_0 == INVALID_FLOW_ID ||
 	    swap_lr_output_flowid_1 == INVALID_FLOW_ID) {
 		syslog(LOG_ERR, "Can not create flow id for swap_lr_out");
 		return -EINVAL;
 	}

 	/* Creates a swap_lr plugin and sets the input and output ports. */
 	swap_lr = ARRAY_APPEND_ZERO(&ini->plugins);
 	fill_swap_lr_plugin(ini, swap_lr, sink_input_flowid_0,
 			    sink_input_flowid_1, swap_lr_output_flowid_0,
 			    swap_lr_output_flowid_1);

 	/* Look up first sink again because ini->plugins could be realloc'ed */
 	sink = find_first_playback_sink_plugin(ini);

 	/* The flow ids of sink input ports should be changed to flow ids of
 	 * {swap_lr_out:0}, {swap_lr_out:1}. */
 	ARRAY_ELEMENT(&sink->ports, 0)->flow_id = swap_lr_output_flowid_0;
 	ARRAY_ELEMENT(&sink->ports, 1)->flow_id = swap_lr_output_flowid_1;

 	return 0;
 }

 struct ini *create_mock_ini(const char *purpose, unsigned int num_channels)
 {
 	static char mock_flow_names[MAX_MOCK_INI_CH][9] = {
 		"{tmp:0}",  "{tmp:1}",	"{tmp:2}",  "{tmp:3}",	"{tmp:4}",
 		"{tmp:5}",  "{tmp:6}",	"{tmp:7}",  "{tmp:8}",	"{tmp:9}",
 		"{tmp:10}", "{tmp:11}", "{tmp:12}", "{tmp:13}", "{tmp:14}",
 		"{tmp:15}", "{tmp:16}", "{tmp:17}", "{tmp:18}", "{tmp:19}",
 	};
 	struct ini *ini;
 	struct plugin *source, *sink;
 	int tmp_flow_ids[MAX_MOCK_INI_CH];
 	int i;

 	if (num_channels > MAX_MOCK_INI_CH) {
 		syslog(LOG_ERR, "Unable to create %u channels of mock ini",
 		       num_channels);
 		return NULL;
 	}

 	ini = calloc(1, sizeof(struct ini));
 	if (!ini) {
 		syslog(LOG_ERR, "no memory for ini struct");
 		return NULL;
 	}

 	for (i = 0; i < num_channels; i++)
 		tmp_flow_ids[i] = add_new_flow(ini, mock_flow_names[i]);

 	source = ARRAY_APPEND_ZERO(&ini->plugins);
 	source->title = "source";
 	source->library = "builtin";
 	source->label = "source";
 	source->purpose = purpose;

 	for (i = 0; i < num_channels; i++)
 		add_audio_port(ini, source, tmp_flow_ids[i], PORT_OUTPUT);

 	sink = ARRAY_APPEND_ZERO(&ini->plugins);
 	sink->title = "sink";
 	sink->library = "builtin";
 	sink->label = "sink";
 	sink->purpose = purpose;

 	for (i = 0; i < num_channels; i++)
 		add_audio_port(ini, sink, tmp_flow_ids[i], PORT_INPUT);

 	fill_flow_info(ini);

 	return ini;
 }

 struct ini *cras_dsp_ini_create(const char *ini_filename)
 {
 	struct ini *ini;
 	dictionary *dict;
 	int nsec, i;
 	const char *sec_name;
 	struct plugin *plugin;
 	int rc;

 	ini = calloc(1, sizeof(struct ini));
 	if (!ini) {
 		syslog(LOG_ERR, "no memory for ini struct");
 		return NULL;
 	}

 	dict = iniparser_load_wrapper((char *)ini_filename);
 	if (!dict) {
 		syslog(LOG_DEBUG, "no ini file %s", ini_filename);
 		goto bail;
 	}
 	ini->dict = dict;

 	/* Parse the plugin sections */
 	nsec = iniparser_getnsec(dict);
 	for (i = 0; i < nsec; i++) {
 		sec_name = iniparser_getsecname(dict, i);
 		plugin = ARRAY_APPEND_ZERO(&ini->plugins);
 		if (parse_plugin_section(ini, sec_name, plugin) < 0)
 			goto bail;
 	}

 	/* Insert a swap_lr plugin before sink. */
 	rc = insert_swap_lr_plugin(ini);
 	if (rc < 0) {
 		syslog(LOG_ERR, "failed to insert swap_lr plugin");
 		goto bail;
 	}

 	/* Fill flow info now because now the plugin array won't change */
 	fill_flow_info(ini);

 	return ini;
 bail:
 	cras_dsp_ini_free(ini);
 	return NULL;
 }

 void cras_dsp_ini_free(struct ini *ini)
 {
 	struct plugin *p;
 	int i;

 	/* free plugins */
 	ARRAY_ELEMENT_FOREACH (&ini->plugins, i, p) {
 		cras_expr_expression_free(p->disable_expr);
 		ARRAY_FREE(&p->ports);
 	}
 	ARRAY_FREE(&ini->plugins);
 	ARRAY_FREE(&ini->flows);

 	if (ini->dict) {
 		iniparser_freedict(ini->dict);
 		ini->dict = NULL;
 	}

 	free(ini);
 }

 static const char *port_direction_str(enum port_direction port_direction)
 {
 	switch (port_direction) {
 	case PORT_INPUT:
 		return "input";
 	case PORT_OUTPUT:
 		return "output";
 	default:
 		return "unknown";
 	}
 }

 static const char *port_type_str(enum port_type port_type)
 {
 	switch (port_type) {
 	case PORT_CONTROL:
 		return "control";
 	case PORT_AUDIO:
 		return "audio";
 	default:
 		return "unknown";
 	}
 }

 static const char *plugin_title(struct plugin *plugin)
 {
 	if (plugin == NULL)
 		return "(null)";
 	return plugin->title;
 }

 void cras_dsp_ini_dump(struct dumper *d, struct ini *ini)
 {
 	int i, j;
 	struct plugin *plugin;
 	struct port *port;
 	const struct flow *flow;

 	dumpf(d, "---- ini dump begin ---\n");
 	dumpf(d, "ini->dict = %p\n", ini->dict);

 	dumpf(d, "number of plugins = %d\n", ARRAY_COUNT(&ini->plugins));
 	ARRAY_ELEMENT_FOREACH (&ini->plugins, i, plugin) {
 		dumpf(d, "[plugin %d: %s]\n", i, plugin->title);
 		dumpf(d, "library=%s\n", plugin->library);
 		dumpf(d, "label=%s\n", plugin->label);
 		dumpf(d, "purpose=%s\n", plugin->purpose);
 		dumpf(d, "disable=%p\n", plugin->disable_expr);
 		ARRAY_ELEMENT_FOREACH (&plugin->ports, j, port) {
 			dumpf(d,
 			      "  [%s port %d] type=%s, flow_id=%d, value=%g\n",
 			      port_direction_str(port->direction), j,
 			      port_type_str(port->type), port->flow_id,
 			      port->init_value);
 		}
 	}

 	dumpf(d, "number of flows = %d\n", ARRAY_COUNT(&ini->flows));
 	ARRAY_ELEMENT_FOREACH (&ini->flows, i, flow) {
 		dumpf(d, "  [flow %d] %s, %s, %s:%d -> %s:%d\n", i, flow->name,
 		      port_type_str(flow->type), plugin_title(flow->from),
 		      flow->from_port, plugin_title(flow->to), flow->to_port);
 	}

 	dumpf(d, "---- ini dump end ----\n");
 }
	/* Copyright (c) 2012 The Chromium OS Authors. All rights reserved.
	* Use of this source code is governed by a BSD-style license that can be
	* found in the LICENSE file.
	*/

	#include <errno.h>
	#include <stdlib.h>
	#include <syslog.h>
	#include "cras_dsp_ini.h"
	#include "iniparser_wrapper.h"

	#define MAX_NR_PORT 128 /* the max number of ports for a plugin */
	#define MAX_PORT_NAME_LENGTH 20 /* names like "output_32" */
	#define MAX_MOCK_INI_CH 20 /* Max number of channels to create mock ini */

	/* Format of the ini file (See dsp.ini.sample for an example).

	- Each section in the ini file specifies a plugin. The section name is
	just an identifier. The "library" and "label" attributes in a
	section must be defined. The "library" attribute is the name of the
	shared library from which this plugin will be loaded, or a special
	value "builtin" for built-in plugins. The "label" attribute specify
	which plugin inside the shared library should be loaded.

	- Built-in plugins have an attribute "label" which has value "source"
	or "sink". It defines where the audio data flows into and flows out
	of the pipeline. Built-in plugins also have a attribute "purpose"
	which has the value "playback" or "capture". It defines which
	pipeline these plugins belong to.

	- Each plugin can have an optional "disable expression", which defines
	under which conditions the plugin is disabled.

	- Each plugin have some ports which specify the parameters for the
	plugin or to specify connections to other plugins. The ports in each
	plugin are numbered from 0. Each port is either an input port or an
	output port, and each port is either an audio port or a control
	port. The connections between two ports are expressed by giving the
	same value to both ports. For audio ports, the value should be
	"{identifier}". For control ports, the value shoule be
	"<identifier>". For example, the following fragment

	[plugin1]
	...
	output_4={audio_left}
	output_5={audio_right}

	[plugin2]
	...
	input_0={audio_left}

	[plugin3]
	...
	input_2={audio_right}

	specifies these connections:
	port 4 of plugin1 --> port 0 of plugin2
	port 5 of plugin1 --> port 2 of plugin3

	*/

	static const char getstring(struct ini ini, const char *sec_name,
	const char *key)
	{
	char full_key[MAX_INI_KEY_LENGTH + 1];
	snprintf(full_key, sizeof(full_key), "%s:%s", sec_name, key);
	return iniparser_getstring(ini->dict, full_key, NULL);
	}

	static int lookup_flow(struct ini ini, const char name)
	{
	int i;
	const struct flow *flow;

	ARRAY_ELEMENT_FOREACH (&ini->flows, i, flow) {
	if (strcmp(flow->name, name) == 0)
	return i;
	}

	return -1;
	}

	static int lookup_or_add_flow(struct ini ini, const char name)
	{
	struct flow *flow;
	int i = lookup_flow(ini, name);
	if (i != -1)
	return i;
	i = ARRAY_COUNT(&ini->flows);
	flow = ARRAY_APPEND_ZERO(&ini->flows);
	flow->name = name;
	return i;
	}

	static int parse_ports(struct ini ini, const char sec_name,
	struct plugin *plugin)
	{
	char key[MAX_PORT_NAME_LENGTH];
	const char *str;
	int i;
	struct port *p;
	int direction;

	for (i = 0; i < MAX_NR_PORT; i++) {
	direction = PORT_INPUT;
	snprintf(key, sizeof(key), "input_%d", i);
	str = getstring(ini, sec_name, key);
	if (str == NULL) {
	direction = PORT_OUTPUT;
	snprintf(key, sizeof(key), "output_%d", i);
	str = getstring(ini, sec_name, key);
	if (str == NULL)
	break; /* no more ports */
	}

	if (*str == '\0') {
	syslog(LOG_ERR, "empty value for %s:%s", sec_name, key);
	return -1;
	}

	if (str[0] == '<' \|\| str[0] == '{') {
	p = ARRAY_APPEND_ZERO(&plugin->ports);
	p->type = (str[0] == '<') ? PORT_CONTROL : PORT_AUDIO;
	p->flow_id = lookup_or_add_flow(ini, str);
	p->init_value = 0;
	} else {
	char *endptr;
	float init_value = strtof(str, &endptr);
	if (endptr == str) {
	syslog(LOG_ERR, "cannot parse number from '%s'",
	str);
	}
	p = ARRAY_APPEND_ZERO(&plugin->ports);
	p->type = PORT_CONTROL;
	p->flow_id = INVALID_FLOW_ID;
	p->init_value = init_value;
	}
	p->direction = direction;
	}

	return 0;
	}

	static int parse_plugin_section(struct ini ini, const char sec_name,
	struct plugin *p)
	{
	p->title = sec_name;
	p->library = getstring(ini, sec_name, "library");
	p->label = getstring(ini, sec_name, "label");
	p->purpose = getstring(ini, sec_name, "purpose");
	p->disable_expr =
	cras_expr_expression_parse(getstring(ini, sec_name, "disable"));

	if (p->library == NULL \|\| p->label == NULL) {
	syslog(LOG_ERR, "A plugin must have library and label: %s",
	sec_name);
	return -1;
	}

	if (parse_ports(ini, sec_name, p) < 0) {
	syslog(LOG_ERR, "Failed to parse ports: %s", sec_name);
	return -1;
	}

	return 0;
	}

	static void fill_flow_info(struct ini *ini)
	{
	int i, j;
	struct plugin *plugin;
	struct port *port;
	struct flow *flow;
	struct plugin **pplugin;
	int *pport;

	ARRAY_ELEMENT_FOREACH (&ini->plugins, i, plugin) {
	ARRAY_ELEMENT_FOREACH (&plugin->ports, j, port) {
	int flow_id = port->flow_id;
	if (flow_id == INVALID_FLOW_ID)
	continue;
	flow = ARRAY_ELEMENT(&ini->flows, flow_id);
	flow->type = port->type;
	if (port->direction == PORT_INPUT) {
	pplugin = &flow->to;
	pport = &flow->to_port;
	} else {
	pplugin = &flow->from;
	pport = &flow->from_port;
	}
	*pplugin = plugin;
	*pport = j;
	}
	}
	}

	/* Adds a port to a plugin with specified flow id and direction. */
	static void add_audio_port(struct ini ini, struct plugin plugin, int flow_id,
	enum port_direction port_direction)
	{
	struct port *p;
	p = ARRAY_APPEND_ZERO(&plugin->ports);
	p->type = PORT_AUDIO;
	p->flow_id = flow_id;
	p->init_value = 0;
	p->direction = port_direction;
	}

	/* Fills fields for a swap_lr plugin.*/
	static void fill_swap_lr_plugin(struct ini ini, struct plugin plugin,
	int input_flowid_0, int input_flowid_1,
	int output_flowid_0, int output_flowid_1)
	{
	plugin->title = "swap_lr";
	plugin->library = "builtin";
	plugin->label = "swap_lr";
	plugin->purpose = "playback";
	plugin->disable_expr = cras_expr_expression_parse("swap_lr_disabled");

	add_audio_port(ini, plugin, input_flowid_0, PORT_INPUT);
	add_audio_port(ini, plugin, input_flowid_1, PORT_INPUT);
	add_audio_port(ini, plugin, output_flowid_0, PORT_OUTPUT);
	add_audio_port(ini, plugin, output_flowid_1, PORT_OUTPUT);
	}

	/* Adds a new flow with name. If there is already a flow with the name, returns
	* INVALID_FLOW_ID.
	*/
	static int add_new_flow(struct ini ini, const char name)
	{
	struct flow *flow;
	int i = lookup_flow(ini, name);
	if (i != -1)
	return INVALID_FLOW_ID;
	i = ARRAY_COUNT(&ini->flows);
	flow = ARRAY_APPEND_ZERO(&ini->flows);
	flow->name = name;
	return i;
	}

	/* Finds the first playback sink plugin in ini. */
	struct plugin find_first_playback_sink_plugin(struct ini ini)
	{
	int i;
	struct plugin *plugin;

	ARRAY_ELEMENT_FOREACH (&ini->plugins, i, plugin) {
	if (strcmp(plugin->library, "builtin") != 0)
	continue;
	if (strcmp(plugin->label, "sink") != 0)
	continue;
	if (!plugin->purpose \|\|
	strcmp(plugin->purpose, "playback") != 0)
	continue;
	return plugin;
	}

	return NULL;
	}

	/* Inserts a swap_lr plugin before sink. Handles the port change such that
	* the port originally connects to sink will connect to swap_lr.
	*/
	static int insert_swap_lr_plugin(struct ini *ini)
	{
	struct plugin swap_lr, sink;
	int sink_input_flowid_0, sink_input_flowid_1;
	int swap_lr_output_flowid_0, swap_lr_output_flowid_1;

	/* Only add swap_lr plugin for two-channel playback dsp.
	* TODO(cychiang): Handle multiple sinks if needed.
	*/
	sink = find_first_playback_sink_plugin(ini);
	if ((sink == NULL) \|\| ARRAY_COUNT(&sink->ports) != 2)
	return 0;

	/* Gets the original flow ids of the sink input ports. */
	sink_input_flowid_0 = ARRAY_ELEMENT(&sink->ports, 0)->flow_id;
	sink_input_flowid_1 = ARRAY_ELEMENT(&sink->ports, 1)->flow_id;

	/* Create new flow ids for swap_lr output ports. */
	swap_lr_output_flowid_0 = add_new_flow(ini, "{swap_lr_out:0}");
	swap_lr_output_flowid_1 = add_new_flow(ini, "{swap_lr_out:1}");

	if (swap_lr_output_flowid_0 == INVALID_FLOW_ID \|\|
	swap_lr_output_flowid_1 == INVALID_FLOW_ID) {
	syslog(LOG_ERR, "Can not create flow id for swap_lr_out");
	return -EINVAL;
	}

	/* Creates a swap_lr plugin and sets the input and output ports. */
	swap_lr = ARRAY_APPEND_ZERO(&ini->plugins);
	fill_swap_lr_plugin(ini, swap_lr, sink_input_flowid_0,
	sink_input_flowid_1, swap_lr_output_flowid_0,
	swap_lr_output_flowid_1);

	/* Look up first sink again because ini->plugins could be realloc'ed */
	sink = find_first_playback_sink_plugin(ini);

	/* The flow ids of sink input ports should be changed to flow ids of
	* {swap_lr_out:0}, {swap_lr_out:1}. */
	ARRAY_ELEMENT(&sink->ports, 0)->flow_id = swap_lr_output_flowid_0;
	ARRAY_ELEMENT(&sink->ports, 1)->flow_id = swap_lr_output_flowid_1;

	return 0;
	}

	struct ini create_mock_ini(const char purpose, unsigned int num_channels)
	{
	static char mock_flow_names[MAX_MOCK_INI_CH][9] = {
	"{tmp:0}", "{tmp:1}", "{tmp:2}", "{tmp:3}", "{tmp:4}",
	"{tmp:5}", "{tmp:6}", "{tmp:7}", "{tmp:8}", "{tmp:9}",
	"{tmp:10}", "{tmp:11}", "{tmp:12}", "{tmp:13}", "{tmp:14}",
	"{tmp:15}", "{tmp:16}", "{tmp:17}", "{tmp:18}", "{tmp:19}",
	};
	struct ini *ini;
	struct plugin source, sink;
	int tmp_flow_ids[MAX_MOCK_INI_CH];
	int i;

	if (num_channels > MAX_MOCK_INI_CH) {
	syslog(LOG_ERR, "Unable to create %u channels of mock ini",
	num_channels);
	return NULL;
	}

	ini = calloc(1, sizeof(struct ini));
	if (!ini) {
	syslog(LOG_ERR, "no memory for ini struct");
	return NULL;
	}

	for (i = 0; i < num_channels; i++)
	tmp_flow_ids[i] = add_new_flow(ini, mock_flow_names[i]);

	source = ARRAY_APPEND_ZERO(&ini->plugins);
	source->title = "source";
	source->library = "builtin";
	source->label = "source";
	source->purpose = purpose;

	for (i = 0; i < num_channels; i++)
	add_audio_port(ini, source, tmp_flow_ids[i], PORT_OUTPUT);

	sink = ARRAY_APPEND_ZERO(&ini->plugins);
	sink->title = "sink";
	sink->library = "builtin";
	sink->label = "sink";
	sink->purpose = purpose;

	for (i = 0; i < num_channels; i++)
	add_audio_port(ini, sink, tmp_flow_ids[i], PORT_INPUT);

	fill_flow_info(ini);

	return ini;
	}

	struct ini cras_dsp_ini_create(const char ini_filename)
	{
	struct ini *ini;
	dictionary *dict;
	int nsec, i;
	const char *sec_name;
	struct plugin *plugin;
	int rc;

	ini = calloc(1, sizeof(struct ini));
	if (!ini) {
	syslog(LOG_ERR, "no memory for ini struct");
	return NULL;
	}

	dict = iniparser_load_wrapper((char *)ini_filename);
	if (!dict) {
	syslog(LOG_DEBUG, "no ini file %s", ini_filename);
	goto bail;
	}
	ini->dict = dict;

	/* Parse the plugin sections */
	nsec = iniparser_getnsec(dict);
	for (i = 0; i < nsec; i++) {
	sec_name = iniparser_getsecname(dict, i);
	plugin = ARRAY_APPEND_ZERO(&ini->plugins);
	if (parse_plugin_section(ini, sec_name, plugin) < 0)
	goto bail;
	}

	/* Insert a swap_lr plugin before sink. */
	rc = insert_swap_lr_plugin(ini);
	if (rc < 0) {
	syslog(LOG_ERR, "failed to insert swap_lr plugin");
	goto bail;
	}

	/* Fill flow info now because now the plugin array won't change */
	fill_flow_info(ini);

	return ini;
	bail:
	cras_dsp_ini_free(ini);
	return NULL;
	}

	void cras_dsp_ini_free(struct ini *ini)
	{
	struct plugin *p;
	int i;

	/* free plugins */
	ARRAY_ELEMENT_FOREACH (&ini->plugins, i, p) {
	cras_expr_expression_free(p->disable_expr);
	ARRAY_FREE(&p->ports);
	}
	ARRAY_FREE(&ini->plugins);
	ARRAY_FREE(&ini->flows);

	if (ini->dict) {
	iniparser_freedict(ini->dict);
	ini->dict = NULL;
	}

	free(ini);
	}

	static const char *port_direction_str(enum port_direction port_direction)
	{
	switch (port_direction) {
	case PORT_INPUT:
	return "input";
	case PORT_OUTPUT:
	return "output";
	default:
	return "unknown";
	}
	}

	static const char *port_type_str(enum port_type port_type)
	{
	switch (port_type) {
	case PORT_CONTROL:
	return "control";
	case PORT_AUDIO:
	return "audio";
	default:
	return "unknown";
	}
	}

	static const char plugin_title(struct plugin plugin)
	{
	if (plugin == NULL)
	return "(null)";
	return plugin->title;
	}

	void cras_dsp_ini_dump(struct dumper d, struct ini ini)
	{
	int i, j;
	struct plugin *plugin;
	struct port *port;
	const struct flow *flow;

	dumpf(d, "---- ini dump begin ---\n");
	dumpf(d, "ini->dict = %p\n", ini->dict);

	dumpf(d, "number of plugins = %d\n", ARRAY_COUNT(&ini->plugins));
	ARRAY_ELEMENT_FOREACH (&ini->plugins, i, plugin) {
	dumpf(d, "[plugin %d: %s]\n", i, plugin->title);
	dumpf(d, "library=%s\n", plugin->library);
	dumpf(d, "label=%s\n", plugin->label);
	dumpf(d, "purpose=%s\n", plugin->purpose);
	dumpf(d, "disable=%p\n", plugin->disable_expr);
	ARRAY_ELEMENT_FOREACH (&plugin->ports, j, port) {
	dumpf(d,
	" [%s port %d] type=%s, flow_id=%d, value=%g\n",
	port_direction_str(port->direction), j,
	port_type_str(port->type), port->flow_id,
	port->init_value);
	}
	}

	dumpf(d, "number of flows = %d\n", ARRAY_COUNT(&ini->flows));
	ARRAY_ELEMENT_FOREACH (&ini->flows, i, flow) {
	dumpf(d, " [flow %d] %s, %s, %s:%d -> %s:%d\n", i, flow->name,
	port_type_str(flow->type), plugin_title(flow->from),
	flow->from_port, plugin_title(flow->to), flow->to_port);
	}

	dumpf(d, "---- ini dump end ----\n");
	}