Added event layer for simple mixer controls (not fully finished).
int snd_ctl_hcallback_add(snd_ctl_t *handle, snd_ctl_hcallback_add_t *callback, void *private_data);
int snd_ctl_hevent(snd_ctl_t *handle);
+int snd_ctl_hbag_create(void **bag);
+int snd_ctl_hbag_destroy(void **bag, void (*hcontrol_free)(snd_hcontrol_t *hcontrol));
+int snd_ctl_hbag_add(void **bag, snd_hcontrol_t *hcontrol);
+int snd_ctl_hbag_del(void **bag, snd_hcontrol_t *hcontrol);
+snd_hcontrol_t *snd_ctl_hbag_find(void **bag, snd_control_id_t *id);
+
#ifdef __cplusplus
}
#endif
EXTRA_LTLIBRARIES = libcontrol.la
-libcontrol_la_SOURCES = cards.c control.c controls.c defaults.c
+libcontrol_la_SOURCES = cards.c control.c controls.c bag.c defaults.c
all: libcontrol.la
--- /dev/null
+/*
+ * Control Interface - highlevel API - hcontrol bag operations
+ * Copyright (c) 2000 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 Library General Public License as
+ * published by the Free Software Foundation; either version 2 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 Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <assert.h>
+#define __USE_GNU
+#include <search.h>
+#include "asoundlib.h"
+#include "control_local.h"
+
+int snd_ctl_hbag_create(void **bag)
+{
+ assert(bag != NULL);
+ *bag = NULL;
+ return 0;
+}
+
+static void snd_ctl_hbag_free_private(snd_hcontrol_t *hcontrol ATTRIBUTE_UNUSED)
+{
+ /* nothing */
+}
+
+int snd_ctl_hbag_destroy(void **bag, void (*hcontrol_free)(snd_hcontrol_t *hcontrol))
+{
+ assert(bag != NULL);
+ if (hcontrol_free == NULL)
+ hcontrol_free = snd_ctl_hbag_free_private;
+ tdestroy(*bag, (__free_fn_t)hcontrol_free);
+ *bag = NULL;
+ return 0;
+}
+
+int snd_ctl_hbag_add(void **bag, snd_hcontrol_t *hcontrol)
+{
+ void *res;
+
+ assert(bag != NULL && hcontrol != NULL);
+ res = tsearch(hcontrol, bag, (__compar_fn_t)snd_ctl_hsort);
+ if (res == NULL)
+ return -ENOMEM;
+ if ((snd_hcontrol_t *)res == hcontrol)
+ return -EALREADY;
+ return 0;
+}
+
+int snd_ctl_hbag_del(void **bag, snd_hcontrol_t *hcontrol)
+{
+ assert(bag != NULL && hcontrol != NULL);
+ if (tdelete(hcontrol, bag, (__compar_fn_t)snd_ctl_hsort) == NULL)
+ return -ENOENT;
+ return 0;
+}
+
+snd_hcontrol_t *snd_ctl_hbag_find(void **bag, snd_control_id_t *id)
+{
+ void *res;
+
+ assert(bag != NULL && id != NULL);
+ if (*bag == NULL)
+ return NULL;
+ res = tfind(id, bag, (__compar_fn_t)snd_ctl_hsort);
+ return res == NULL ? NULL : *(snd_hcontrol_t **)res;
+}
return 0;
}
-int snd_ctl_hsort(const snd_hcontrol_t *c1, const snd_hcontrol_t *c2)
+#define NOT_FOUND 1000000000
+
+static int snd_ctl_hsort_mixer_priority_lookup(char **name, char * const *names, int coef)
{
int res;
+ for (res = 0; *names; names++, res += coef) {
+ if (!strncmp(*name, *names, strlen(*names))) {
+ *name += strlen(*names);
+ if (**name == ' ')
+ *name++;
+ return res;
+ }
+ }
+ return NOT_FOUND;
+}
+
+static int snd_ctl_hsort_mixer_priority(const char *name)
+{
+ static char *names[] = {
+ "Master",
+ "Master Digital",
+ "Master Mono",
+ "Hardware Master",
+ "Headphone",
+ "Tone Control",
+ "3D Control",
+ "PCM",
+ "PCM Front",
+ "PCM Rear",
+ "PCM Pan",
+ "Wave",
+ "Music",
+ "Line",
+ "CD",
+ "Mic",
+ "Phone",
+ "Video",
+ "PC Speaker",
+ "Aux",
+ "ADC",
+ "Capture Source",
+ "Capture",
+ "Playback",
+ "Loopback",
+ "Analog Loopback",
+ "Digital Loopback",
+ "S/PDIF Input",
+ "S/PDIF Output",
+ NULL
+ };
+ static char *names1[] = {
+ "Switch",
+ "Volume",
+ "Playback",
+ "Capture",
+ "Bypass",
+ NULL
+ };
+ static char *names2[] = {
+ "Switch",
+ "Volume",
+ "Bypass",
+ NULL
+ };
+ char **ptr, *s;
+ int res, res1;
+
+ if ((res = snd_ctl_hsort_mixer_priority_lookup((char **)&name, names, 1000000)) == NOT_FOUND)
+ return NOT_FOUND;
+ if ((res1 = snd_ctl_hsort_mixer_priority_lookup((char **)&name, names1, 1000)) == NOT_FOUND)
+ return res;
+ res += res1;
+ if ((res1 = snd_ctl_hsort_mixer_priority_lookup((char **)&name, names2, 1)) == NOT_FOUND)
+ return res;
+ return res + res1;
+}
+
+int snd_ctl_hsort(const snd_hcontrol_t *c1, const snd_hcontrol_t *c2)
+{
+ int res, p1, p2;
+
if (c1->id.iface < c2->id.iface)
return -1;
if (c1->id.iface > c2->id.iface)
return 1;
- if ((res = strcmp(c1->id.name, c2->id.name)) != 0)
+ if ((res = strcmp(c1->id.name, c2->id.name)) != 0) {
+ if (c1->id.iface != SND_CONTROL_IFACE_MIXER)
+ return res;
+ p1 = snd_ctl_hsort_mixer_priority(c1->id.name);
+ p2 = snd_ctl_hsort_mixer_priority(c2->id.name);
+ if (p1 < p2)
+ return -1;
+ if (p1 > p2)
+ return 1;
return res;
+ }
if (c1->id.index < c2->id.index)
return -1;
if (c1->id.index > c2->id.index)
#include "asoundlib.h"
#include "mixer_local.h"
+static void snd_mixer_simple_read_rebuild(snd_ctl_t *ctl_handle, void *private_data);
+static void snd_mixer_simple_read_add(snd_ctl_t *ctl_handle, void *private_data, snd_hcontrol_t *hcontrol);
+
int snd_mixer_open(snd_mixer_t **r_handle, int card)
{
snd_mixer_t *handle;
*r_handle = NULL;
if ((err = snd_ctl_open(&ctl_handle, card)) < 0)
return err;
+ if ((err = snd_ctl_hcallback_rebuild(ctl_handle, snd_mixer_simple_read_rebuild, handle)) < 0) {
+ snd_ctl_close(ctl_handle);
+ return err;
+ }
+ if ((err = snd_ctl_hcallback_add(ctl_handle, snd_mixer_simple_read_add, handle)) < 0) {
+ snd_ctl_close(ctl_handle);
+ return err;
+ }
handle = (snd_mixer_t *) calloc(1, sizeof(snd_mixer_t));
if (handle == NULL) {
snd_ctl_close(ctl_handle);
return -ENOMEM;
}
handle->ctl_handle = ctl_handle;
+ INIT_LIST_HEAD(&handle->simples);
*r_handle = handle;
return 0;
}
int snd_mixer_simple_control_list(snd_mixer_t *handle, snd_mixer_simple_control_list_t *list)
{
+ struct list_head *lh;
mixer_simple_t *s;
snd_mixer_sid_t *p;
- int err;
- unsigned int tmp;
+ int err, idx;
if (handle == NULL || list == NULL)
return -EINVAL;
if ((err = snd_mixer_simple_build(handle)) < 0)
return err;
list->controls_count = 0;
- tmp = list->controls_offset;
- for (s = handle->simple_first; s != NULL && tmp > 0; s = s->next);
- tmp = list->controls_request;
p = list->pids;
- if (tmp > 0 && p == NULL)
+ if (list->controls_request > 0 && p == NULL)
return -EINVAL;
- for (; s != NULL && tmp > 0; s = s->next, tmp--, p++, list->controls_count++)
- memcpy(p, &s->sid, sizeof(*p));
+ idx = 0;
+ list_for_each(lh, &handle->simples) {
+ if (idx >= list->controls_offset + list->controls_request)
+ break;
+ if (idx >= list->controls_offset) {
+ s = list_entry(lh, mixer_simple_t, list);
+ memcpy(p, &s->sid, sizeof(*p)); p++;
+ list->controls_count++;
+ }
+ idx++;
+ }
list->controls = handle->simple_count;
return 0;
}
static mixer_simple_t *look_for_simple(snd_mixer_t *handle, snd_mixer_sid_t *sid)
{
+ struct list_head *list;
mixer_simple_t *s;
- for (s = handle->simple_first; s != NULL; s = s->next)
+ list_for_each(list, &handle->simples) {
+ s = list_entry(list, mixer_simple_t, list);
if (!strcmp(s->sid.name, sid->name) && s->sid.index == sid->index)
return s;
+ }
return NULL;
}
handle->simple_changes++;
}
-static void event_for_all_simple_controls(snd_mixer_t *handle, snd_ctl_event_type_t etype, snd_control_id_t *id)
+static void snd_mixer_simple_read_add(snd_ctl_t *ctl_handle, void *private_data, snd_hcontrol_t *hcontrol)
{
+ snd_mixer_t *handle = (snd_mixer_t *)private_data;
mixer_simple_t *s;
+ struct list_head *list;
- for (s = handle->simple_first; s != NULL; s = s->next) {
- if (s->event)
- s->event(handle, etype, id);
+ list_for_each(list, &handle->simples) {
+ s = list_entry(list, mixer_simple_t, list);
+ if (s->event_add)
+ s->event_add(handle, hcontrol);
}
}
-static void snd_mixer_simple_read_value(snd_ctl_t *ctl_handle, void *private_data, snd_control_id_t *id)
-{
- snd_mixer_t *handle = (snd_mixer_t *)private_data;
- if (handle->ctl_handle != ctl_handle)
- return;
- event_for_all_simple_controls(handle, SND_CTL_EVENT_VALUE, id);
-}
-
-static void snd_mixer_simple_read_change(snd_ctl_t *ctl_handle, void *private_data, snd_control_id_t *id)
-{
- snd_mixer_t *handle = (snd_mixer_t *)private_data;
- if (handle->ctl_handle != ctl_handle)
- return;
- event_for_all_simple_controls(handle, SND_CTL_EVENT_CHANGE, id);
-}
-
-static void snd_mixer_simple_read_add(snd_ctl_t *ctl_handle, void *private_data, snd_control_id_t *id)
-{
- snd_mixer_t *handle = (snd_mixer_t *)private_data;
- if (handle->ctl_handle != ctl_handle)
- return;
- event_for_all_simple_controls(handle, SND_CTL_EVENT_ADD, id);
-}
-
-static void snd_mixer_simple_read_remove(snd_ctl_t *ctl_handle, void *private_data, snd_control_id_t *id)
-{
- snd_mixer_t *handle = (snd_mixer_t *)private_data;
- if (handle->ctl_handle != ctl_handle)
- return;
- event_for_all_simple_controls(handle, SND_CTL_EVENT_REMOVE, id);
-}
-
int snd_mixer_simple_read(snd_mixer_t *handle, snd_mixer_simple_callbacks_t *callbacks)
{
+ mixer_simple_t *s;
+ struct list_head *list;
int err;
- if (handle == NULL)
+ if (handle == NULL || callbacks == NULL)
return -EINVAL;
if (!handle->simple_valid)
snd_mixer_simple_build(handle);
return err;
}
handle->callbacks = NULL;
+ list_for_each(list, &handle->simples) {
+ s = list_entry(list, mixer_simple_t, list);
+ if (s->change > 0) {
+ s->change = 0;
+ if (callbacks->value)
+ callbacks->value(handle, callbacks->private_data, &s->sid);
+ }
+ }
return handle->simple_changes;
}
#include <assert.h>
#include "asoundlib.h"
+#include "list.h"
typedef struct mixer_simple mixer_simple_t;
+typedef struct mixer_simple_hcontrol_private mixer_simple_hcontrol_private_t;
typedef int (mixer_simple_get_t) (snd_mixer_t *handle, mixer_simple_t *simple, snd_mixer_simple_control_t *control);
typedef int (mixer_simple_put_t) (snd_mixer_t *handle, mixer_simple_t *simple, snd_mixer_simple_control_t *control);
-typedef int (mixer_simple_event_t) (snd_mixer_t *handle, snd_ctl_event_type_t etype, snd_control_id_t *id);
+typedef int (mixer_simple_event_add_t) (snd_mixer_t *handle, snd_hcontrol_t *hcontrol);
#define MIXER_PRESENT_GLOBAL_SWITCH (1<<0)
#define MIXER_PRESENT_GLOBAL_VOLUME (1<<1)
snd_mixer_sid_t sid;
mixer_simple_get_t *get;
mixer_simple_put_t *put;
- mixer_simple_event_t *event;
- mixer_simple_t *prev;
- mixer_simple_t *next;
+ mixer_simple_event_add_t *event_add;
+ struct list_head list;
+ void *hcontrols; /* bag of associated hcontrols */
unsigned long private_value;
};
+
+struct mixer_simple_hcontrol_private {
+ void *simples; /* list of associated hcontrols */
+};
struct snd_mixer {
snd_ctl_t *ctl_handle;
int simple_valid;
- int simple_count;
int simple_changes; /* total number of changes */
- mixer_simple_t *simple_first;
- mixer_simple_t *simple_last;
+ int simple_count;
+ struct list_head simples; /* list of all simple controls */
snd_mixer_simple_callbacks_t *callbacks;
};
#include "asoundlib.h"
#include "mixer_local.h"
-static int test_mixer_id(snd_mixer_t *handle, const char *name, int index)
+static snd_hcontrol_t *test_mixer_id(snd_mixer_t *handle, const char *name, int index)
{
snd_control_id_t id;
snd_hcontrol_t *hcontrol;
id.index = index;
hcontrol = snd_ctl_hfind(handle->ctl_handle, &id);
// fprintf(stderr, "Looking for control: '%s', %i (0x%lx)\n", name, index, (long)hcontrol);
- return hcontrol != NULL;
+ return hcontrol;
}
static int get_mixer_info(snd_mixer_t *handle, const char *name, int index, snd_control_info_t *info)
return s;
}
+static void hcontrol_event_change(snd_ctl_t *ctl_handle, snd_hcontrol_t *hcontrol)
+{
+ /* ignore at this moment */
+}
+
+static void hcontrol_event_value(snd_ctl_t *ctl_handle, snd_hcontrol_t *hcontrol)
+{
+ snd_mixer_t *handle = (snd_mixer_t *)hcontrol->private_data;
+ mixer_simple_t *s;
+ struct list_head *list;
+ list_for_each(list, &handle->simples) {
+ s = list_entry(list, mixer_simple_t, list);
+ if (snd_ctl_hbag_find(&s->hcontrols, &hcontrol->id))
+ s->change++;
+ }
+}
+
+static void hcontrol_event_remove(snd_ctl_t *ctl_handle, snd_hcontrol_t *hcontrol)
+{
+ /* ignore at this moment */
+}
+
+static void hcontrol_add(snd_mixer_t *handle, void **bag, snd_hcontrol_t *hcontrol)
+{
+ snd_ctl_hbag_add(bag, hcontrol);
+ hcontrol->event_change = hcontrol_event_change;
+ hcontrol->event_value = hcontrol_event_value;
+ hcontrol->event_remove = hcontrol_event_remove;
+ hcontrol->private_data = handle;
+}
+
static int simple_add(snd_mixer_t *handle, mixer_simple_t *scontrol)
{
if (handle == NULL || scontrol == NULL)
return -EINVAL;
- if (handle->simple_last != NULL) {
- handle->simple_last->next = scontrol;
- scontrol->prev = handle->simple_last;
- scontrol->next = NULL;
- handle->simple_last = scontrol;
- } else {
- handle->simple_first = handle->simple_last = scontrol;
- scontrol->prev = scontrol->next = NULL;
- }
+ list_add_tail(&scontrol->list, &handle->simples);
handle->simple_count++;
return 0;
}
{
if (handle == NULL || scontrol == NULL)
return -EINVAL;
- if (handle->simple_first == scontrol)
- handle->simple_first = scontrol->next;
- if (handle->simple_last == scontrol)
- handle->simple_last = scontrol->prev;
- if (scontrol->prev)
- scontrol->prev->next = scontrol->next;
- if (scontrol->next)
- scontrol->next->prev = scontrol->prev;
+ list_del(&scontrol->list);
handle->simple_count--;
+ snd_ctl_hbag_destroy(&scontrol->hcontrols, NULL);
+ free(scontrol);
return 0;
}
snd_control_info_t gvolume_info, pvolume_info, cvolume_info;
snd_control_info_t csource_info;
long min, max;
+ void *bag;
mixer_simple_t *simple;
+ snd_hcontrol_t *hcontrol;
memset(&gswitch_info, 0, sizeof(gswitch_info));
memset(&pswitch_info, 0, sizeof(pswitch_info));
voices = 0;
present = caps = capture_item = 0;
min = max = 0;
+ bag = NULL;
sprintf(str, "%s Switch", sname);
- if (test_mixer_id(handle, str, index)) {
+ if (hcontrol = test_mixer_id(handle, str, index)) {
if ((err = get_mixer_info(handle, str, index, &gswitch_info)) < 0)
return err;
if (gswitch_info.type == SND_CONTROL_TYPE_BOOLEAN) {
voices = gswitch_info.values_count;
caps |= SND_MIXER_SCTCAP_MUTE;
present |= MIXER_PRESENT_GLOBAL_SWITCH;
+ hcontrol_add(handle, &bag, hcontrol);
}
}
sprintf(str, "%s Volume", sname);
- if (test_mixer_id(handle, str, index)) {
+ if (hcontrol = test_mixer_id(handle, str, index)) {
if ((err = get_mixer_info(handle, str, index, &gvolume_info)) < 0)
return err;
if (gvolume_info.type == SND_CONTROL_TYPE_INTEGER) {
max = gvolume_info.value.integer.max;
caps |= SND_MIXER_SCTCAP_VOLUME;
present |= MIXER_PRESENT_GLOBAL_VOLUME;
+ hcontrol_add(handle, &bag, hcontrol);
}
}
sprintf(str, "%s Playback Switch", sname);
- if (test_mixer_id(handle, str, index)) {
+ if (hcontrol = test_mixer_id(handle, str, index)) {
if ((err = get_mixer_info(handle, str, index, &pswitch_info)) < 0)
return err;
if (pswitch_info.type == SND_CONTROL_TYPE_BOOLEAN) {
voices = pswitch_info.values_count;
caps |= SND_MIXER_SCTCAP_MUTE;
present |= MIXER_PRESENT_PLAYBACK_SWITCH;
+ hcontrol_add(handle, &bag, hcontrol);
}
}
sprintf(str, "%s Capture Switch", sname);
- if (test_mixer_id(handle, str, index)) {
+ if (hcontrol = test_mixer_id(handle, str, index)) {
if ((err = get_mixer_info(handle, str, index, &cswitch_info)) < 0)
return err;
if (cswitch_info.type == SND_CONTROL_TYPE_BOOLEAN) {
voices = cswitch_info.values_count;
caps |= SND_MIXER_SCTCAP_CAPTURE;
present |= MIXER_PRESENT_CAPTURE_SWITCH;
+ hcontrol_add(handle, &bag, hcontrol);
}
}
sprintf(str, "%s Playback Volume", sname);
- if (test_mixer_id(handle, str, index)) {
+ if (hcontrol = test_mixer_id(handle, str, index)) {
if ((err = get_mixer_info(handle, str, index, &pvolume_info)) < 0)
return err;
if (pvolume_info.type == SND_CONTROL_TYPE_INTEGER) {
max = pvolume_info.value.integer.max;
caps |= SND_MIXER_SCTCAP_VOLUME;
present |= MIXER_PRESENT_PLAYBACK_VOLUME;
+ hcontrol_add(handle, &bag, hcontrol);
}
}
sprintf(str, "%s Capture Volume", sname);
- if (test_mixer_id(handle, str, index)) {
+ if (hcontrol = test_mixer_id(handle, str, index)) {
if ((err = get_mixer_info(handle, str, index, &cvolume_info)) < 0)
return err;
if (cvolume_info.type == SND_CONTROL_TYPE_INTEGER) {
max = pvolume_info.value.integer.max;
caps |= SND_MIXER_SCTCAP_VOLUME;
present |= MIXER_PRESENT_CAPTURE_VOLUME;
+ hcontrol_add(handle, &bag, hcontrol);
}
}
- if (index == 0 && test_mixer_id(handle, "Capture Source", 0)) {
+ if (index == 0 && (hcontrol = test_mixer_id(handle, "Capture Source", 0)) != NULL) {
if ((err = get_mixer_info(handle, "Capture Source", 0, &csource_info)) < 0)
return err;
strcpy(str, sname);
voices = csource_info.values_count;
caps |= SND_MIXER_SCTCAP_CAPTURE;
present |= MIXER_PRESENT_CAPTURE_SOURCE;
+ hcontrol_add(handle, &bag, hcontrol);
} else for (capture_item = 1; capture_item < csource_info.value.enumerated.items; capture_item++) {
csource_info.value.enumerated.item = capture_item;
if ((err = snd_ctl_cinfo(handle->ctl_handle, &csource_info)) < 0)
voices = csource_info.values_count;
caps |= SND_MIXER_SCTCAP_CAPTURE;
present |= MIXER_PRESENT_CAPTURE_SOURCE;
+ hcontrol_add(handle, &bag, hcontrol);
break;
}
}
if (present == 0)
break;
simple = build_input_scontrol(handle, sname, index);
- if (simple == NULL)
+ if (simple == NULL) {
+ snd_ctl_hbag_destroy(&bag, NULL);
return -ENOMEM;
+ }
simple->present = present;
simple->gswitch_values = gswitch_info.values_count;
simple->pswitch_values = pswitch_info.values_count;
simple->voices = voices;
simple->min = min;
simple->max = max;
+ simple->hcontrols = bag;
// fprintf(stderr, "sname = '%s', index = %i, present = 0x%x, voices = %i\n", sname, index, present, voices);
};
return 0;
int snd_mixer_simple_destroy(snd_mixer_t *handle)
{
- while (handle->simple_first)
- simple_remove(handle, handle->simple_first);
+ while (!list_empty(&handle->simples))
+ simple_remove(handle, list_entry(handle->simples.next, mixer_simple_t, list));
handle->simple_valid = 0;
snd_ctl_hfree(handle->ctl_handle);
return 0;
git://git.alsa-project.org / alsa-lib.git / commitdiff