--- /dev/null
+/**
+ * \file control/namehint.c
+ * \brief Give device name hints
+ * \author Jaroslav Kysela <perex@suse.cz>
+ * \date 2006
+ */
+/*
+ * Give device name hints - main file
+ * Copyright (c) 2006 by Jaroslav Kysela <perex@suse.cz>
+ *
+ *
+ * This library is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+#include "local.h"
+
+#ifndef DOC_HIDDEN
+struct hint_list {
+ char **list;
+ unsigned int count;
+ unsigned int allocated;
+ snd_ctl_elem_iface_t iface;
+ snd_ctl_t *ctl;
+ snd_ctl_card_info_t *info;
+ int card;
+ int device;
+ long device_input;
+ long device_output;
+ int stream;
+};
+#endif
+
+static int hint_list_add(struct hint_list *list,
+ const char *name,
+ const char *description)
+{
+ char *x;
+
+ if (list->count == list->allocated) {
+ char **n = realloc(list->list, (list->allocated + 10) * sizeof(char *));
+ if (n == NULL)
+ return -ENOMEM;
+ list->allocated += 10;
+ list->list = n;
+ }
+ if (name == NULL) {
+ x = NULL;
+ } else {
+ x = malloc(strlen(name) + (description != NULL ? (strlen(description) + 1) : 0) + 1);
+ if (x == NULL)
+ return -ENOMEM;
+ strcpy(x, name);
+ if (description != NULL) {
+ strcat(x, "|");
+ strcat(x, description);
+ }
+ }
+ list->list[list->count++] = x;
+ return 0;
+}
+
+static void zero_handler(const char *file ATTRIBUTE_UNUSED,
+ int line ATTRIBUTE_UNUSED,
+ const char *function ATTRIBUTE_UNUSED,
+ int err ATTRIBUTE_UNUSED,
+ const char *fmt ATTRIBUTE_UNUSED, ...)
+{
+}
+
+static char *get_dev_name1(struct hint_list *list)
+{
+ if (list->device < 0)
+ return NULL;
+ switch (list->iface) {
+ case SND_CTL_ELEM_IFACE_HWDEP:
+ {
+ snd_hwdep_info_t *info;
+ snd_hwdep_info_alloca(&info);
+ snd_hwdep_info_set_device(info, list->device);
+ if (snd_ctl_hwdep_info(list->ctl, info) < 0)
+ return NULL;
+ return strdup(snd_hwdep_info_get_name(info));
+ }
+ case SND_CTL_ELEM_IFACE_PCM:
+ {
+ snd_pcm_info_t *info;
+ snd_pcm_info_alloca(&info);
+ snd_pcm_info_set_device(info, list->device);
+ snd_pcm_info_set_stream(info, list->stream ? SND_PCM_STREAM_CAPTURE : SND_PCM_STREAM_PLAYBACK);
+ if (snd_ctl_pcm_info(list->ctl, info) < 0)
+ return NULL;
+ switch (snd_pcm_info_get_class(info)) {
+ case SND_PCM_CLASS_MODEM:
+ case SND_PCM_CLASS_DIGITIZER:
+ return NULL;
+ default:
+ break;
+ }
+ return strdup(snd_pcm_info_get_name(info));
+ }
+ case SND_CTL_ELEM_IFACE_RAWMIDI:
+ {
+ snd_rawmidi_info_t *info;
+ snd_rawmidi_info_alloca(&info);
+ snd_rawmidi_info_set_device(info, list->device);
+ snd_rawmidi_info_set_stream(info, list->stream ? SND_RAWMIDI_STREAM_INPUT : SND_RAWMIDI_STREAM_OUTPUT);
+ if (snd_ctl_rawmidi_info(list->ctl, info) < 0)
+ return NULL;
+ return strdup(snd_rawmidi_info_get_name(info));
+ }
+ default:
+ return NULL;
+ }
+}
+
+static char *get_dev_name(struct hint_list *list)
+{
+ char *str1, *str2, *res;
+
+ list->device = list->device_input >= 0 ? list->device_input : list->device;
+ list->stream = 1;
+ str1 = get_dev_name1(list);
+ list->device = list->device_output >= 0 ? list->device_input : list->device;
+ list->stream = 0;
+ str2 = get_dev_name1(list);
+ if (str1 != NULL || str2 != NULL) {
+ if (str1 != NULL && str2 != NULL) {
+ if (strcmp(str1, str2) == 0) {
+ free(str1);
+ return str2;
+ }
+ res = realloc(str2, strlen(str2) + strlen(str1) + 4);
+ if (res != NULL) {
+ strcat(res, " / ");
+ strcat(res, str1);
+ free(str1);
+ return res;
+ } else {
+ free(str2);
+ free(str1);
+ }
+ } else {
+ if (str1 != NULL) {
+ res = realloc(str1, strlen(str1) + 16);
+ if (res == NULL) {
+ free(str1);
+ return NULL;
+ }
+ strcat(res, " {");
+ strcat(res, list->iface == SND_CTL_ELEM_IFACE_PCM ? "Capture" : "Input");
+ strcat(res, "}");
+ return res;
+ } else {
+ res = realloc(str2, strlen(str2) + 16);
+ if (res == NULL) {
+ free(str2);
+ return NULL;
+ }
+ strcat(res, " {");
+ strcat(res, list->iface == SND_CTL_ELEM_IFACE_PCM ? "Playback" : "Output");
+ strcat(res, "}");
+ return res;
+ }
+ }
+ }
+ return NULL;
+}
+
+#ifndef DOC_HIDDEN
+#define BUF_SIZE 128
+#endif
+
+static int try_config(struct hint_list *list,
+ const char *base,
+ const char *name)
+{
+ snd_lib_error_handler_t eh;
+ snd_config_t *res, *cfg, *n;
+ snd_config_iterator_t i, next;
+ char *buf, *buf1 = NULL, *buf2;
+ const char *str;
+ int err;
+ long dev = list->device;
+
+ list->device_input = -1;
+ list->device_output = -1;
+ buf = malloc(BUF_SIZE);
+ if (buf == NULL)
+ return -ENOMEM;
+ if (list->card >= 0 && list->device >= 0)
+ sprintf(buf, "%s:CARD=%s,DEV=%i", name, snd_ctl_card_info_get_id(list->info), list->device);
+ else if (list->card >= 0)
+ sprintf(buf, "%s:CARD=%s", name, snd_ctl_card_info_get_id(list->info));
+ else
+ strcpy(buf, name);
+ eh = snd_lib_error;
+ snd_lib_error_set_handler(&zero_handler);
+ err = snd_config_search_definition(snd_config, base, buf, &res);
+ snd_lib_error_set_handler(eh);
+ if (err < 0)
+ return err;
+ err = -EINVAL;
+ if (snd_config_get_type(res) != SND_CONFIG_TYPE_COMPOUND)
+ goto __cleanup;
+ if (snd_config_search(res, "type", NULL) < 0)
+ goto __cleanup;
+ cfg = res;
+ __hint:
+ if (snd_config_search(cfg, "hint", &cfg) >= 0) {
+ if (snd_config_get_type(cfg) == SND_CONFIG_TYPE_COMPOUND) {
+ if (snd_config_search(cfg, "description", &n) >= 0 &&
+ snd_config_get_string(n, &str) >= 0) {
+ buf1 = strdup(str);
+ if (buf1 == NULL) {
+ err = -ENOMEM;
+ goto __cleanup;
+ }
+ }
+ if (snd_config_search(cfg, "device", &n) >= 0) {
+ if (snd_config_get_integer(n, &dev) < 0) {
+ err = -EINVAL;
+ goto __cleanup;
+ }
+ }
+ if (snd_config_search(cfg, "device_input", &n) >= 0) {
+ if (snd_config_get_integer(n, &list->device_input) < 0) {
+ err = -EINVAL;
+ goto __cleanup;
+ }
+ }
+ if (snd_config_search(cfg, "device_output", &n) >= 0) {
+ if (snd_config_get_integer(n, &list->device_output) < 0) {
+ err = -EINVAL;
+ goto __cleanup;
+ }
+ }
+ } else if (snd_config_get_bool(cfg) == 0) {
+ err = -EXDEV;
+ goto __cleanup;
+ }
+ goto __hint_ok;
+ }
+ if (snd_config_search(cfg, "slave", &cfg) >= 0 &&
+ snd_config_search(cfg, base, &cfg) >= 0)
+ goto __hint;
+ __hint_ok:
+#if 0 /* for debug purposes */
+ {
+ snd_output_t *out;
+ fprintf(stderr, "********* PCM '%s':\n", buf);
+ snd_output_stdio_attach(&out, stderr, 0);
+ snd_config_save(res, out);
+ snd_output_close(out);
+ printf("\n");
+ }
+#endif
+ snd_config_delete(res);
+ res = NULL;
+ if (strchr(buf, ':') != NULL)
+ goto __ok;
+ /* find, if all parameters have a default, */
+ /* otherwise filter this definition */
+ eh = snd_lib_error;
+ snd_lib_error_set_handler(&zero_handler);
+ err = snd_config_search_alias_hooks(snd_config, base, buf, &res);
+ snd_lib_error_set_handler(eh);
+ if (err < 0)
+ goto __cleanup;
+ if (snd_config_search(res, "@args", &cfg) >= 0) {
+ snd_config_for_each(i, next, cfg) {
+ if (snd_config_search(snd_config_iterator_entry(i),
+ "default", NULL) < 0) {
+ err = -EINVAL;
+ goto __cleanup;
+ }
+ }
+ }
+ __ok:
+ err = 0;
+ __cleanup:
+ if (res)
+ snd_config_delete(res);
+ if (err >= 0) {
+ list->device = dev;
+ str = get_dev_name(list);
+ if (str != NULL) {
+ buf2 = realloc((char *)str, (buf1 == NULL ? 0 : strlen(buf1)) + 2 + strlen(str) + 1);
+ if (buf2 != NULL) {
+ if (buf1 != NULL) {
+ strcat(buf2, ": ");
+ strcat(buf2, buf1);
+ free(buf1);
+ }
+ buf1 = buf2;
+ } else {
+ free((char *)str);
+ }
+ } else if (list->device >= 0)
+ goto __skip_add;
+ err = hint_list_add(list, buf, buf1);
+ }
+ __skip_add:
+ if (buf1)
+ free(buf1);
+ free(buf);
+ return err;
+}
+
+#ifndef DOC_HIDDEN
+#define IFACE(v, fcn) [SND_CTL_ELEM_IFACE_##v] = (next_devices_t)fcn
+
+typedef int (*next_devices_t)(snd_ctl_t *, int *);
+
+static next_devices_t next_devices[] = {
+ IFACE(CARD, NULL),
+ IFACE(HWDEP, snd_ctl_hwdep_next_device),
+ IFACE(MIXER, NULL),
+ IFACE(PCM, snd_ctl_pcm_next_device),
+ IFACE(RAWMIDI, snd_ctl_rawmidi_next_device),
+ IFACE(TIMER, NULL),
+ IFACE(SEQUENCER, NULL)
+};
+#endif
+
+static int add_card(struct hint_list *list, int card, snd_ctl_elem_iface_t iface)
+{
+ int err, ok;
+ snd_config_t *conf, *n;
+ snd_config_iterator_t i, next;
+ const char *str, *base;
+ char ctl_name[16];
+ snd_ctl_card_info_t *info;
+
+ snd_ctl_card_info_alloca(&info);
+ list->info = info;
+ if (iface > SND_CTL_ELEM_IFACE_LAST)
+ return -EINVAL;
+ if (snd_card_get_name(card, (char **)&str) < 0)
+ return 0;
+ base = snd_ctl_iface_conf_name(iface);
+ err = snd_config_search(snd_config, base, &conf);
+ if (err < 0)
+ return err;
+ sprintf(ctl_name, "hw:%i", card);
+ err = snd_ctl_open(&list->ctl, ctl_name, 0);
+ if (err < 0)
+ return err;
+ err = snd_ctl_card_info(list->ctl, info);
+ if (err < 0)
+ goto __error;
+ snd_config_for_each(i, next, conf) {
+ n = snd_config_iterator_entry(i);
+ if (snd_config_get_id(n, &str) < 0)
+ continue;
+ if (next_devices[iface] != NULL) {
+ list->card = card;
+ list->device = -1;
+ err = next_devices[iface](list->ctl, &list->device);
+ if (list->device < 0)
+ err = -EINVAL;
+ ok = 0;
+ while (err >= 0 && list->device >= 0) {
+ err = try_config(list, base, str);
+ if (err < 0)
+ break;
+ err = next_devices[iface](list->ctl, &list->device);
+ ok++;
+ }
+ if (ok)
+ continue;
+ } else {
+ err = -EINVAL;
+ }
+ if (err == -EXDEV)
+ continue;
+ if (err < 0) {
+ list->device = -1;
+ err = try_config(list, base, str);
+ }
+ if (err < 0) {
+ list->card = -1;
+ err = try_config(list, base, str);
+ }
+ if (err == -ENOMEM)
+ goto __error;
+ }
+ err = 0;
+ __error:
+ if (err < 0)
+ snd_ctl_close(list->ctl);
+ return err;
+}
+
+/**
+ * \brief Return string list with device name hints.
+ * \param card Card number or -1 (means all cards)
+ * \param iface Interface identification
+ * \param hints Result - array of string with device name hints
+ * \result zero if success, otherwise a negative error code
+ *
+ * Note: The device description is separated with '|' char.
+ *
+ * User defined hints are gathered from namehint.IFACE tree like:
+ *
+ * <code>
+ * namehint.pcm {<br>
+ * myfile "file:FILE=/tmp/soundwave.raw|Save sound output to /tmp/soundwave.raw"<br>
+ * myplug "plug:front:Do all conversions for front speakers"<br>
+ * }
+ * </code>
+ */
+int snd_device_name_hint(int card, snd_ctl_elem_iface_t iface, char ***hints)
+{
+ struct hint_list list;
+ char ehints[16];
+ const char *str;
+ snd_config_t *conf;
+ snd_config_iterator_t i, next;
+ int err;
+
+ if (hints == NULL)
+ return -EINVAL;
+ err = snd_config_update();
+ if (err < 0)
+ return err;
+ list.list = NULL;
+ list.count = list.allocated = 0;
+ list.iface = iface;
+ if (card >= 0) {
+ err = add_card(&list, card, iface);
+ } else {
+ err = snd_card_next(&card);
+ if (err < 0)
+ goto __error;
+ while (card >= 0) {
+ err = add_card(&list, card, iface);
+ if (err < 0)
+ goto __error;
+ err = snd_card_next(&card);
+ if (err < 0)
+ goto __error;
+ }
+ }
+ sprintf(ehints, "namehint.%s", snd_ctl_iface_conf_name(iface));
+ err = snd_config_search(snd_config, ehints, &conf);
+ if (err >= 0) {
+ snd_config_for_each(i, next, conf) {
+ if (snd_config_get_string(snd_config_iterator_entry(i),
+ &str) < 0)
+ continue;
+ err = hint_list_add(&list, str, NULL);
+ if (err < 0)
+ goto __error;
+ }
+ }
+ __error:
+ if (err < 0) {
+ snd_device_name_free_hint(list.list);
+ return err;
+ } else {
+ err = hint_list_add(&list, NULL, NULL);
+ if (err < 0)
+ goto __error;
+ *hints = list.list;
+ }
+ return 0;
+}
+
+/**
+ * \brief Free a string list with device name hints.
+ * \param hints A string list to free
+ * \result zero if success, otherwise a negative error code
+ */
+int snd_device_name_free_hint(char **hints)
+{
+ char **h;
+
+ if (hints == NULL)
+ return 0;
+ h = hints;
+ while (*h) {
+ free(*h);
+ h++;
+ }
+ free(hints);
+ return 0;
+}
OSDN Git Service
