@@ -103,6 +103,7 @@ typedef struct {
snd_pcm_format_t sformat;
int schannels;
snd_pcm_route_params_t params;
+ snd_pcm_chmap_t *chmap;
} snd_pcm_route_t;
#endif /* DOC_HIDDEN */
@@ -518,6 +519,7 @@ static int snd_pcm_route_close(snd_pcm_t *pcm)
}
free(params->dsts);
}
+ free(route->chmap);
return snd_pcm_generic_close(pcm);
}
@@ -789,21 +791,187 @@ static void snd_pcm_route_dump(snd_pcm_t *pcm, snd_output_t *out)
snd_pcm_dump(route->plug.gen.slave, out);
}
-static int strtochannel(const char *id, long *channel)
+/*
+ * Converts a string to an array of channel indices:
+ * - Given a number, the result is an array with one element,
+ * containing that number
+ * - Given a channel name (e g "FL") and a chmap,
+ * it will look this up in the chmap and return all matches
+ * - Given a channel name and no chmap, the result is an array with one element,
+ containing alsa standard channel map. Note that this might be a negative
+ number in case of "UNKNOWN", "NA" or "MONO".
+ * Return value is number of matches written.
+ */
+static int strtochannel(const char *id, snd_pcm_chmap_t *chmap,
+ long *channel, int channel_size)
{
- int err;
int ch;
- err = safe_strtol(id, channel);
- if (err >= 0)
- return err;
+ if (safe_strtol(id, channel) >= 0)
+ return 1;
ch = (int) snd_pcm_chmap_from_string(id);
if (ch == -1)
return -EINVAL;
- /* For now, assume standard channel mapping */
- *channel = ch - SND_CHMAP_FL;
+ if (chmap) {
+ int i, r = 0;
+ /* Start with highest channel to simplify implementation of
+ determine ttable size */
+ for (i = chmap->channels - 1; i >= 0; i--) {
+ if ((int) chmap->pos[i] != ch)
+ continue;
+ if (r >= channel_size)
+ continue;
+ channel[r++] = i;
+ }
+ return r;
+ }
+ else {
+ /* Assume ALSA standard channel mapping */
+ *channel = ch - SND_CHMAP_FL;
+ return 1;
+ }
+}
+
+#define MAX_CHMAP_CHANNELS 256
+
+static int determine_chmap(snd_config_t *tt, snd_pcm_chmap_t **tt_chmap)
+{
+ snd_config_iterator_t i, inext;
+ snd_pcm_chmap_t *chmap;
+
+ assert(tt && tt_chmap);
+ chmap = malloc(sizeof(snd_pcm_chmap_t) +
+ MAX_CHMAP_CHANNELS * sizeof(unsigned int));
+
+ chmap->channels = 0;
+ snd_config_for_each(i, inext, tt) {
+ const char *id;
+ snd_config_iterator_t j, jnext;
+ snd_config_t *in = snd_config_iterator_entry(i);
+
+ if (!snd_config_get_id(in, &id) < 0)
+ continue;
+ if (snd_config_get_type(in) != SND_CONFIG_TYPE_COMPOUND)
+ goto err;
+ snd_config_for_each(j, jnext, in) {
+ int ch, k, found;
+ long schannel;
+ snd_config_t *jnode = snd_config_iterator_entry(j);
+ if (snd_config_get_id(jnode, &id) < 0)
+ continue;
+ if (safe_strtol(id, &schannel) >= 0)
+ continue;
+ ch = (int) snd_pcm_chmap_from_string(id);
+ if (ch == -1)
+ goto err;
+
+ found = 0;
+ for (k = 0; k < (int) chmap->channels; k++)
+ if (ch == (int) chmap->pos[k]) {
+ found = 1;
+ break;
+ }
+ if (found)
+ continue;
+
+ if (chmap->channels >= MAX_CHMAP_CHANNELS) {
+ SNDERR("Too many channels in ttable chmap");
+ goto err;
+ }
+ chmap->pos[chmap->channels++] = ch;
+ }
+ }
+
+
+ *tt_chmap = chmap;
return 0;
+
+err:
+ *tt_chmap = NULL;
+ free(chmap);
+ return -EINVAL;
+}
+
+static int find_matching_chmap(snd_pcm_t *spcm, snd_pcm_chmap_t *tt_chmap,
+ snd_pcm_chmap_t **found_chmap, int *schannels)
+{
+ snd_pcm_chmap_query_t** chmaps = snd_pcm_query_chmaps(spcm);
+ int i;
+
+ *found_chmap = NULL;
+
+ if (chmaps == NULL)
+ return 0; /* chmap API not supported for this slave */
+
+ for (i = 0; chmaps[i]; i++) {
+ unsigned int j, k;
+ int match = 1;
+ snd_pcm_chmap_t *c = &chmaps[i]->map;
+ if (*schannels >= 0 && (int) c->channels != *schannels)
+ continue;
+
+ for (j = 0; j < tt_chmap->channels; j++) {
+ int found = 0;
+ unsigned int ch = tt_chmap->pos[j];
+ for (k = 0; k < c->channels; k++)
+ if (c->pos[k] == ch) {
+ found = 1;
+ break;
+ }
+ if (!found) {
+ match = 0;
+ break;
+ }
+ }
+
+ if (match) {
+ int size = sizeof(snd_pcm_chmap_t) + c->channels * sizeof(unsigned int);
+ *found_chmap = malloc(size);
+ if (!*found_chmap) {
+ snd_pcm_free_chmaps(chmaps);
+ return -ENOMEM;
+ }
+ memcpy(*found_chmap, c, size);
+ *schannels = c->channels;
+ break;
+ }
+ }
+
+ snd_pcm_free_chmaps(chmaps);
+
+ if (*found_chmap == NULL) {
+ SNDERR("Found no matching channel map");
+ return -EINVAL;
+ }
+ return 0;
+}
+
+static int route_chmap_init(snd_pcm_t *pcm)
+{
+ int set_map = 0;
+ snd_pcm_chmap_t *current;
+ snd_pcm_route_t *route = pcm->private_data;
+ if (!route->chmap)
+ return 0;
+ if (snd_pcm_state(pcm) != SND_PCM_STATE_PREPARED)
+ return 0;
+
+ /* Check if we really need to set the chmap or not.
+ This is important in case set_chmap is not implemented. */
+ current = snd_pcm_get_chmap(route->plug.gen.slave);
+ if (!current)
+ return -ENOSYS;
+ if (current->channels != route->chmap->channels)
+ set_map = 1;
+ else
+ set_map = memcmp(current->pos, route->chmap->pos,
+ current->channels);
+ free(current);
+ if (!set_map)
+ return 0;
+
+ return snd_pcm_set_chmap(route->plug.gen.slave, route->chmap);
}
@@ -939,6 +1107,7 @@ int snd_pcm_route_open(snd_pcm_t **pcmp, const char *name,
route->plug.undo_write = snd_pcm_plugin_undo_write_generic;
route->plug.gen.slave = slave;
route->plug.gen.close_slave = close_slave;
+ route->plug.init = route_chmap_init;
err = snd_pcm_new(&pcm, SND_PCM_TYPE_ROUTE, name, slave->stream, slave->mode);
if (err < 0) {
@@ -963,16 +1132,10 @@ int snd_pcm_route_open(snd_pcm_t **pcmp, const char *name,
return 0;
}
-/**
- * \brief Determine route matrix sizes
- * \param tt Configuration root describing route matrix
- * \param tt_csize Returned client size in elements
- * \param tt_ssize Returned slave size in elements
- * \retval zero on success otherwise a negative error code
- */
-int snd_pcm_route_determine_ttable(snd_config_t *tt,
- unsigned int *tt_csize,
- unsigned int *tt_ssize)
+static int _snd_pcm_route_determine_ttable(snd_config_t *tt,
+ unsigned int *tt_csize,
+ unsigned int *tt_ssize,
+ snd_pcm_chmap_t *chmap)
{
snd_config_iterator_t i, inext;
long csize = 0, ssize = 0;
@@ -1001,7 +1164,7 @@ int snd_pcm_route_determine_ttable(snd_config_t *tt,
const char *id;
if (snd_config_get_id(jnode, &id) < 0)
continue;
- err = strtochannel(id, &schannel);
+ err = strtochannel(id, chmap, &schannel, 1);
if (err < 0) {
SNDERR("Invalid slave channel: %s", id);
return -EINVAL;
@@ -1020,6 +1183,20 @@ int snd_pcm_route_determine_ttable(snd_config_t *tt,
}
/**
+ * \brief Determine route matrix sizes
+ * \param tt Configuration root describing route matrix
+ * \param tt_csize Returned client size in elements
+ * \param tt_ssize Returned slave size in elements
+ * \retval zero on success otherwise a negative error code
+ */
+int snd_pcm_route_determine_ttable(snd_config_t *tt,
+ unsigned int *tt_csize,
+ unsigned int *tt_ssize)
+{
+ return _snd_pcm_route_determine_ttable(tt, tt_csize, tt_ssize, NULL);
+}
+
+/**
* \brief Load route matrix
* \param tt Configuration root describing route matrix
* \param ttable Returned route matrix
@@ -1030,10 +1207,10 @@ int snd_pcm_route_determine_ttable(snd_config_t *tt,
* \param schannels Slave channels
* \retval zero on success otherwise a negative error code
*/
-int snd_pcm_route_load_ttable(snd_config_t *tt, snd_pcm_route_ttable_entry_t *ttable,
- unsigned int tt_csize, unsigned int tt_ssize,
- unsigned int *tt_cused, unsigned int *tt_sused,
- int schannels)
+static int _snd_pcm_route_load_ttable(snd_config_t *tt, snd_pcm_route_ttable_entry_t *ttable,
+ unsigned int tt_csize, unsigned int tt_ssize,
+ unsigned int *tt_cused, unsigned int *tt_sused,
+ int schannels, snd_pcm_chmap_t *chmap)
{
int cused = -1;
int sused = -1;
@@ -1060,17 +1237,18 @@ int snd_pcm_route_load_ttable(snd_config_t *tt, snd_pcm_route_ttable_entry_t *tt
snd_config_for_each(j, jnext, in) {
snd_config_t *jnode = snd_config_iterator_entry(j);
double value;
- long schannel;
+ int ss;
+ long *scha = alloca(tt_ssize * sizeof(long));
const char *id;
if (snd_config_get_id(jnode, &id) < 0)
continue;
- err = strtochannel(id, &schannel);
- if (err < 0 ||
- schannel < 0 || (unsigned int) schannel > tt_ssize ||
- (schannels > 0 && schannel >= schannels)) {
+
+ ss = strtochannel(id, chmap, scha, tt_ssize);
+ if (ss < 0) {
SNDERR("Invalid slave channel: %s", id);
return -EINVAL;
}
+
err = snd_config_get_real(jnode, &value);
if (err < 0) {
long v;
@@ -1081,9 +1259,18 @@ int snd_pcm_route_load_ttable(snd_config_t *tt, snd_pcm_route_ttable_entry_t *tt
}
value = v;
}
- ttable[cchannel * tt_ssize + schannel] = value;
- if (schannel > sused)
- sused = schannel;
+
+ for (k = 0; (int) k < ss; k++) {
+ long schannel = scha[k];
+ if (schannel < 0 || (unsigned int) schannel > tt_ssize ||
+ (schannels > 0 && schannel >= schannels)) {
+ SNDERR("Invalid slave channel: %s", id);
+ return -EINVAL;
+ }
+ ttable[cchannel * tt_ssize + schannel] = value;
+ if (schannel > sused)
+ sused = schannel;
+ }
}
if (cchannel > cused)
cused = cchannel;
@@ -1093,6 +1280,26 @@ int snd_pcm_route_load_ttable(snd_config_t *tt, snd_pcm_route_ttable_entry_t *tt
return 0;
}
+/**
+ * \brief Load route matrix
+ * \param tt Configuration root describing route matrix
+ * \param ttable Returned route matrix
+ * \param tt_csize Client size in elements
+ * \param tt_ssize Slave size in elements
+ * \param tt_cused Used client elements
+ * \param tt_sused Used slave elements
+ * \param schannels Slave channels
+ * \retval zero on success otherwise a negative error code
+ */
+int snd_pcm_route_load_ttable(snd_config_t *tt, snd_pcm_route_ttable_entry_t *ttable,
+ unsigned int tt_csize, unsigned int tt_ssize,
+ unsigned int *tt_cused, unsigned int *tt_sused,
+ int schannels)
+{
+ return _snd_pcm_route_load_ttable(tt, ttable, tt_csize, tt_ssize,
+ tt_cused, tt_sused, schannels, NULL);
+}
+
/*! \page pcm_plugins
\section pcm_plugins_route Plugin: Route & Volume
@@ -1100,6 +1307,9 @@ int snd_pcm_route_load_ttable(snd_config_t *tt, snd_pcm_route_ttable_entry_t *tt
This plugin converts channels and applies volume during the conversion.
The format and rate must match for both of them.
+SCHANNEL can be a channel name instead of a number (e g FL, LFE).
+If so, a matching channel map will be selected for the slave.
+
\code
pcm.name {
type route # Route & Volume conversion PCM
@@ -1150,6 +1360,7 @@ int _snd_pcm_route_open(snd_pcm_t **pcmp, const char *name,
int err;
snd_pcm_t *spcm;
snd_config_t *slave = NULL, *sconf;
+ snd_pcm_chmap_t *tt_chmap, *chmap;
snd_pcm_format_t sformat = SND_PCM_FORMAT_UNKNOWN;
int schannels = -1;
snd_config_t *tt = NULL;
@@ -1198,37 +1409,59 @@ int _snd_pcm_route_open(snd_pcm_t **pcmp, const char *name,
return -EINVAL;
}
- err = snd_pcm_route_determine_ttable(tt, &csize, &ssize);
+ err = determine_chmap(tt, &tt_chmap);
if (err < 0) {
- snd_config_delete(sconf);
+ free(ttable);
return err;
}
- ttable = malloc(csize * ssize * sizeof(snd_pcm_route_ttable_entry_t));
- if (ttable == NULL) {
- snd_config_delete(sconf);
- return -ENOMEM;
- }
- err = snd_pcm_route_load_ttable(tt, ttable, csize, ssize,
- &cused, &sused, schannels);
+
+ err = snd_pcm_open_slave(&spcm, root, sconf, stream, mode, conf);
+ snd_config_delete(sconf);
if (err < 0) {
+ free(tt_chmap);
free(ttable);
- snd_config_delete(sconf);
return err;
}
- err = snd_pcm_open_slave(&spcm, root, sconf, stream, mode, conf);
- snd_config_delete(sconf);
+ if (tt_chmap) {
+ err = find_matching_chmap(spcm, tt_chmap, &chmap, &schannels);
+ free(tt_chmap);
+ if (err < 0)
+ return err;
+ }
+
+ err = _snd_pcm_route_determine_ttable(tt, &csize, &ssize, chmap);
+ if (err < 0) {
+ free(chmap);
+ snd_pcm_close(spcm);
+ return err;
+ }
+ ttable = malloc(csize * ssize * sizeof(snd_pcm_route_ttable_entry_t));
+ if (ttable == NULL) {
+ free(chmap);
+ snd_pcm_close(spcm);
+ return -ENOMEM;
+ }
+ err = _snd_pcm_route_load_ttable(tt, ttable, csize, ssize,
+ &cused, &sused, schannels, chmap);
if (err < 0) {
+ free(chmap);
free(ttable);
+ snd_pcm_close(spcm);
return err;
}
+
err = snd_pcm_route_open(pcmp, name, sformat, schannels,
ttable, ssize,
cused, sused,
spcm, 1);
free(ttable);
- if (err < 0)
+ if (err < 0) {
+ free(chmap);
snd_pcm_close(spcm);
+ }
+ ((snd_pcm_route_t*) (*pcmp)->private_data)->chmap = chmap;
+
return err;
}
#ifndef DOC_HIDDEN
It means we need to initialize this order: 1) Read the ttable to figure out which channels are present 2) Open slave pcm and find a matching chmap 3) Determine size of ttable (this can now depend on the chmap) 4) Read ttable coefficients 5) At prepare time, select the matching chmap Signed-off-by: David Henningsson <david.henningsson@canonical.com> --- src/pcm/pcm_route.c | 319 ++++++++++++++++++++++++++++++++++++++++++++------- 1 file changed, 276 insertions(+), 43 deletions(-)