mirror of
https://github.com/alsa-project/alsa-lib.git
synced 2025-11-05 13:30:00 -05:00
Completed mixer API. Improved iterators. Renamed control values struct. Rewritten simple elements implementation
This commit is contained in:
Abramo Bagnara
parent
38033b49dd
commit
a2d3434961
54 changed files with 2081 additions and 1712 deletions
|
|
@ -1,6 +1,5 @@
|
|||
/*
|
||||
* Control Interface - highlevel API - helem bag operations
|
||||
* Copyright (c) 2000 by Jaroslav Kysela <perex@suse.cz>
|
||||
* Bag of pointers
|
||||
* Copyright (c) 2001 by Abramo Bagnara <abramo@alsa-project.org>
|
||||
*
|
||||
*
|
||||
|
|
@ -20,61 +19,54 @@
|
|||
*
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <unistd.h>
|
||||
#include <string.h>
|
||||
#include <fcntl.h>
|
||||
#include <sys/ioctl.h>
|
||||
#define __USE_GNU
|
||||
#include <search.h>
|
||||
#include "mixer_local.h"
|
||||
|
||||
int snd_hctl_compare_fast(const snd_hctl_elem_t *c1,
|
||||
const snd_hctl_elem_t *c2);
|
||||
|
||||
static void _free(void *ptr ATTRIBUTE_UNUSED) { };
|
||||
|
||||
int snd_hctl_bag_destroy(snd_hctl_bag_t *bag)
|
||||
int bag_new(bag_t **bag)
|
||||
{
|
||||
assert(bag != NULL);
|
||||
tdestroy(bag->root, _free);
|
||||
bag->root = NULL;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int snd_hctl_bag_add(snd_hctl_bag_t *bag, snd_hctl_elem_t *helem)
|
||||
{
|
||||
void *res;
|
||||
assert(bag != NULL && helem != NULL);
|
||||
res = tsearch(helem, &bag->root, (__compar_fn_t)snd_hctl_compare_fast);
|
||||
if (res == NULL)
|
||||
bag_t *b = malloc(sizeof(*b));
|
||||
if (!b)
|
||||
return -ENOMEM;
|
||||
if ((snd_hctl_elem_t *)res == helem)
|
||||
return -EALREADY;
|
||||
INIT_LIST_HEAD(b);
|
||||
*bag = b;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int snd_hctl_bag_del(snd_hctl_bag_t *bag, snd_hctl_elem_t *helem)
|
||||
void bag_free(bag_t *bag)
|
||||
{
|
||||
assert(bag != NULL && helem != NULL);
|
||||
if (tdelete(helem, &bag->root, (__compar_fn_t)snd_hctl_compare_fast) == NULL)
|
||||
return -ENOENT;
|
||||
assert(list_empty(bag));
|
||||
free(bag);
|
||||
}
|
||||
|
||||
int bag_empty(bag_t *bag)
|
||||
{
|
||||
return list_empty(bag);
|
||||
}
|
||||
|
||||
int bag_add(bag_t *bag, void *ptr)
|
||||
{
|
||||
bag1_t *b = malloc(sizeof(*b));
|
||||
if (!b)
|
||||
return -ENOMEM;
|
||||
b->ptr = ptr;
|
||||
list_add_tail(&b->list, bag);
|
||||
return 0;
|
||||
}
|
||||
|
||||
snd_hctl_elem_t *snd_hctl_bag_find(snd_hctl_bag_t *bag, snd_ctl_elem_id_t *id)
|
||||
int bag_del(bag_t *bag, void *ptr)
|
||||
{
|
||||
void *res;
|
||||
assert(bag != NULL && id != NULL);
|
||||
if (bag->root == NULL)
|
||||
return NULL;
|
||||
res = tfind(id, &bag->root, (__compar_fn_t)snd_hctl_compare_fast);
|
||||
return res == NULL ? NULL : *(snd_hctl_elem_t **)res;
|
||||
struct list_head *pos, *next;
|
||||
list_for_each(pos, next, bag) {
|
||||
bag1_t *b = list_entry(pos, bag1_t, list);
|
||||
if (b->ptr == ptr) {
|
||||
list_del(&b->list);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
return -ENOENT;
|
||||
}
|
||||
|
||||
int snd_hctl_bag_empty(snd_hctl_bag_t *bag)
|
||||
void bag_del_all(bag_t *bag)
|
||||
{
|
||||
assert(bag != NULL);
|
||||
return bag->root == NULL;
|
||||
while (!list_empty(bag))
|
||||
list_del(bag->next);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -28,68 +28,319 @@
|
|||
#include <sys/ioctl.h>
|
||||
#include "mixer_local.h"
|
||||
|
||||
int snd_mixer_open(snd_mixer_t **mixerp, char *name)
|
||||
typedef struct _snd_mixer_slave {
|
||||
snd_hctl_t *hctl;
|
||||
struct list_head list;
|
||||
} snd_mixer_slave_t;
|
||||
|
||||
|
||||
typedef struct _snd_mixer_elem_bag {
|
||||
|
||||
} snd_mixer_elem_bag_t;
|
||||
|
||||
int snd_mixer_open(snd_mixer_t **mixerp)
|
||||
{
|
||||
snd_mixer_t *mixer;
|
||||
snd_hctl_t *hctl;
|
||||
int err;
|
||||
assert(mixerp);
|
||||
if ((err = snd_hctl_open(&hctl, name)) < 0)
|
||||
return err;
|
||||
mixer = calloc(1, sizeof(snd_mixer_t));
|
||||
if (mixer == NULL) {
|
||||
snd_hctl_close(hctl);
|
||||
mixer = calloc(1, sizeof(*mixer));
|
||||
if (mixer == NULL)
|
||||
return -ENOMEM;
|
||||
}
|
||||
mixer->hctl = hctl;
|
||||
INIT_LIST_HEAD(&mixer->slaves);
|
||||
INIT_LIST_HEAD(&mixer->classes);
|
||||
INIT_LIST_HEAD(&mixer->elems);
|
||||
*mixerp = mixer;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int snd_mixer_add_elem(snd_mixer_t *mixer, snd_mixer_elem_t *elem)
|
||||
int snd_mixer_elem_attach(snd_mixer_elem_t *melem,
|
||||
snd_hctl_elem_t *helem)
|
||||
{
|
||||
elem->mixer = mixer;
|
||||
bag_t *bag = snd_hctl_elem_get_callback_private(helem);
|
||||
int err;
|
||||
err = bag_add(bag, melem);
|
||||
if (err < 0)
|
||||
return err;
|
||||
return bag_add(&melem->helems, helem);
|
||||
}
|
||||
|
||||
int snd_mixer_elem_detach(snd_mixer_elem_t *melem,
|
||||
snd_hctl_elem_t *helem)
|
||||
{
|
||||
bag_t *bag = snd_hctl_elem_get_callback_private(helem);
|
||||
int err;
|
||||
err = bag_del(bag, melem);
|
||||
assert(err >= 0);
|
||||
err = bag_del(&melem->helems, helem);
|
||||
assert(err >= 0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int snd_mixer_elem_empty(snd_mixer_elem_t *melem)
|
||||
{
|
||||
return bag_empty(&melem->helems);
|
||||
}
|
||||
|
||||
static int hctl_elem_event_handler(snd_hctl_elem_t *helem,
|
||||
snd_ctl_event_type_t event)
|
||||
{
|
||||
bag_t *bag = snd_hctl_elem_get_callback_private(helem);
|
||||
int res = 0;
|
||||
switch (event) {
|
||||
case SND_CTL_EVENT_VALUE:
|
||||
case SND_CTL_EVENT_INFO:
|
||||
{
|
||||
int err = 0;
|
||||
bag_iterator_t i, n;
|
||||
bag_for_each(i, n, bag) {
|
||||
snd_mixer_elem_t *melem = bag_iterator_entry(i);
|
||||
snd_mixer_class_t *class = melem->class;
|
||||
err = class->event(class, event, helem, melem);
|
||||
if (err < 0)
|
||||
break;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case SND_CTL_EVENT_REMOVE:
|
||||
{
|
||||
int err;
|
||||
bag_iterator_t i, n;
|
||||
bag_for_each(i, n, bag) {
|
||||
snd_mixer_elem_t *melem = bag_iterator_entry(i);
|
||||
snd_mixer_class_t *class = melem->class;
|
||||
err = class->event(class, event, helem, melem);
|
||||
if (err < 0)
|
||||
res = err;
|
||||
}
|
||||
assert(bag_empty(bag));
|
||||
bag_free(bag);
|
||||
break;
|
||||
|
||||
}
|
||||
default:
|
||||
assert(0);
|
||||
break;
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
static int hctl_event_handler(snd_hctl_t *hctl, snd_ctl_event_type_t event,
|
||||
snd_hctl_elem_t *elem)
|
||||
{
|
||||
snd_mixer_t *mixer = snd_hctl_get_callback_private(hctl);
|
||||
int res = 0;
|
||||
switch (event) {
|
||||
case SND_CTL_EVENT_ADD:
|
||||
{
|
||||
struct list_head *pos, *next;
|
||||
bag_t *bag;
|
||||
int err = bag_new(&bag);
|
||||
if (err < 0)
|
||||
return err;
|
||||
snd_hctl_elem_set_callback(elem, hctl_elem_event_handler);
|
||||
snd_hctl_elem_set_callback_private(elem, bag);
|
||||
list_for_each(pos, next, &mixer->classes) {
|
||||
snd_mixer_class_t *c;
|
||||
c = list_entry(pos, snd_mixer_class_t, list);
|
||||
err = c->event(c, event, elem, NULL);
|
||||
if (err < 0)
|
||||
res = err;
|
||||
}
|
||||
break;
|
||||
}
|
||||
default:
|
||||
assert(0);
|
||||
break;
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
|
||||
int snd_mixer_attach(snd_mixer_t *mixer, const char *name)
|
||||
{
|
||||
snd_mixer_slave_t *slave;
|
||||
snd_hctl_t *hctl;
|
||||
int err;
|
||||
slave = calloc(1, sizeof(*slave));
|
||||
if (slave == NULL)
|
||||
return -ENOMEM;
|
||||
err = snd_hctl_open(&hctl, name);
|
||||
if (err < 0) {
|
||||
free(slave);
|
||||
return err;
|
||||
}
|
||||
err = snd_hctl_nonblock(hctl, 1);
|
||||
if (err < 0) {
|
||||
snd_hctl_close(hctl);
|
||||
free(slave);
|
||||
return err;
|
||||
}
|
||||
snd_hctl_set_callback(hctl, hctl_event_handler);
|
||||
snd_hctl_set_callback_private(hctl, mixer);
|
||||
slave->hctl = hctl;
|
||||
list_add_tail(&slave->list, &mixer->slaves);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int snd_mixer_detach(snd_mixer_t *mixer, const char *name)
|
||||
{
|
||||
struct list_head *pos, *next;
|
||||
list_for_each(pos, next, &mixer->slaves) {
|
||||
snd_mixer_slave_t *s;
|
||||
s = list_entry(pos, snd_mixer_slave_t, list);
|
||||
if (strcmp(name, snd_hctl_name(s->hctl)) == 0) {
|
||||
snd_hctl_close(s->hctl);
|
||||
list_del(pos);
|
||||
free(s);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
return -ENOENT;
|
||||
}
|
||||
|
||||
int snd_mixer_throw_event(snd_mixer_t *mixer, snd_ctl_event_type_t event,
|
||||
snd_mixer_elem_t *elem)
|
||||
{
|
||||
if (mixer->callback)
|
||||
return mixer->callback(mixer, event, elem);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int snd_mixer_elem_throw_event(snd_mixer_elem_t *elem,
|
||||
snd_ctl_event_type_t event)
|
||||
{
|
||||
if (elem->callback)
|
||||
return elem->callback(elem, event);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int snd_mixer_elem_add(snd_mixer_elem_t *elem, snd_mixer_class_t *class)
|
||||
{
|
||||
snd_mixer_t *mixer = class->mixer;
|
||||
elem->class = class;
|
||||
list_add_tail(&elem->list, &mixer->elems);
|
||||
mixer->count++;
|
||||
if (mixer->callback) {
|
||||
int err = mixer->callback(mixer, SND_CTL_EVENT_ADD, elem);
|
||||
return snd_mixer_throw_event(mixer, SND_CTL_EVENT_ADD, elem);
|
||||
}
|
||||
|
||||
int snd_mixer_elem_remove(snd_mixer_elem_t *elem)
|
||||
{
|
||||
snd_mixer_t *mixer = elem->class->mixer;
|
||||
int err;
|
||||
err = snd_mixer_elem_throw_event(elem, SND_CTL_EVENT_REMOVE);
|
||||
list_del(&elem->list);
|
||||
free(elem);
|
||||
mixer->count--;
|
||||
return err;
|
||||
}
|
||||
|
||||
int snd_mixer_elem_change(snd_mixer_elem_t *elem)
|
||||
{
|
||||
return snd_mixer_elem_throw_event(elem, SND_CTL_EVENT_INFO);
|
||||
}
|
||||
|
||||
|
||||
int snd_mixer_class_register(snd_mixer_class_t *class, snd_mixer_t *mixer)
|
||||
{
|
||||
struct list_head *pos, *next;
|
||||
class->mixer = mixer;
|
||||
list_add_tail(&class->list, &mixer->classes);
|
||||
if (!class->event)
|
||||
return 0;
|
||||
list_for_each(pos, next, &mixer->slaves) {
|
||||
int err;
|
||||
snd_mixer_slave_t *slave;
|
||||
snd_hctl_elem_t *elem;
|
||||
slave = list_entry(pos, snd_mixer_slave_t, list);
|
||||
elem = snd_hctl_first_elem(slave->hctl);
|
||||
while (elem) {
|
||||
err = class->event(class, SND_CTL_EVENT_ADD, elem, NULL);
|
||||
if (err < 0)
|
||||
return err;
|
||||
elem = snd_hctl_elem_next(elem);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int snd_mixer_class_unregister(snd_mixer_class_t *class)
|
||||
{
|
||||
struct list_head *pos, *next;
|
||||
snd_mixer_t *mixer = class->mixer;
|
||||
list_for_each(pos, next, &mixer->elems) {
|
||||
snd_mixer_elem_t *e;
|
||||
e = list_entry(pos, snd_mixer_elem_t, list);
|
||||
if (e->class == class && e->private_free)
|
||||
e->private_free(e);
|
||||
snd_mixer_elem_remove(e);
|
||||
}
|
||||
if (class->private_free)
|
||||
class->private_free(class);
|
||||
list_del(&class->list);
|
||||
free(class);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int snd_mixer_load(snd_mixer_t *mixer)
|
||||
{
|
||||
struct list_head *pos, *next;
|
||||
list_for_each(pos, next, &mixer->slaves) {
|
||||
int err;
|
||||
snd_mixer_slave_t *s;
|
||||
s = list_entry(pos, snd_mixer_slave_t, list);
|
||||
err = snd_hctl_load(s->hctl);
|
||||
if (err < 0)
|
||||
return err;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
void snd_mixer_remove_elem(snd_mixer_elem_t *elem)
|
||||
{
|
||||
snd_mixer_t *mixer = elem->mixer;
|
||||
if (elem->private_free)
|
||||
elem->private_free(elem);
|
||||
if (elem->callback)
|
||||
elem->callback(elem, SND_CTL_EVENT_REMOVE);
|
||||
list_del(&elem->list);
|
||||
free(elem);
|
||||
mixer->count--;
|
||||
}
|
||||
|
||||
void snd_mixer_free(snd_mixer_t *mixer)
|
||||
{
|
||||
while (!list_empty(&mixer->elems))
|
||||
snd_mixer_remove_elem(list_entry(mixer->elems.next, snd_mixer_elem_t, list));
|
||||
struct list_head *pos, *next;
|
||||
list_for_each(pos, next, &mixer->slaves) {
|
||||
snd_mixer_slave_t *s;
|
||||
s = list_entry(pos, snd_mixer_slave_t, list);
|
||||
snd_hctl_free(s->hctl);
|
||||
}
|
||||
}
|
||||
|
||||
int snd_mixer_close(snd_mixer_t *mixer)
|
||||
{
|
||||
int res = 0;
|
||||
assert(mixer);
|
||||
snd_mixer_free(mixer);
|
||||
return snd_hctl_close(mixer->hctl);
|
||||
while (!list_empty(&mixer->classes)) {
|
||||
snd_mixer_class_t *c;
|
||||
c = list_entry(mixer->classes.next, snd_mixer_class_t, list);
|
||||
snd_mixer_class_unregister(c);
|
||||
}
|
||||
assert(list_empty(&mixer->elems));
|
||||
while (!list_empty(&mixer->slaves)) {
|
||||
int err;
|
||||
snd_mixer_slave_t *s;
|
||||
s = list_entry(mixer->slaves.next, snd_mixer_slave_t, list);
|
||||
err = snd_hctl_close(s->hctl);
|
||||
if (err < 0)
|
||||
res = err;
|
||||
list_del(&s->list);
|
||||
free(s);
|
||||
}
|
||||
free(mixer);
|
||||
return res;
|
||||
}
|
||||
|
||||
int snd_mixer_poll_descriptor(snd_mixer_t *mixer)
|
||||
int snd_mixer_poll_descriptor(snd_mixer_t *mixer, const char *name)
|
||||
{
|
||||
if (mixer == NULL || mixer->hctl == NULL)
|
||||
return -EIO;
|
||||
return snd_hctl_poll_descriptor(mixer->hctl);
|
||||
struct list_head *pos, *next;
|
||||
assert(mixer && name);
|
||||
list_for_each(pos, next, &mixer->slaves) {
|
||||
snd_mixer_slave_t *s;
|
||||
const char *n;
|
||||
s = list_entry(pos, snd_mixer_slave_t, list);
|
||||
n = snd_hctl_name(s->hctl);
|
||||
if (n && strcmp(name, n) == 0)
|
||||
return snd_hctl_poll_descriptor(s->hctl);
|
||||
}
|
||||
return -ENOENT;
|
||||
}
|
||||
|
||||
snd_mixer_elem_t *snd_mixer_first_elem(snd_mixer_t *mixer)
|
||||
|
|
@ -111,7 +362,7 @@ snd_mixer_elem_t *snd_mixer_last_elem(snd_mixer_t *mixer)
|
|||
snd_mixer_elem_t *snd_mixer_elem_next(snd_mixer_elem_t *elem)
|
||||
{
|
||||
assert(elem);
|
||||
if (elem->list.next == &elem->mixer->elems)
|
||||
if (elem->list.next == &elem->class->mixer->elems)
|
||||
return NULL;
|
||||
return list_entry(elem->list.next, snd_mixer_elem_t, list);
|
||||
}
|
||||
|
|
@ -119,13 +370,23 @@ snd_mixer_elem_t *snd_mixer_elem_next(snd_mixer_elem_t *elem)
|
|||
snd_mixer_elem_t *snd_mixer_elem_prev(snd_mixer_elem_t *elem)
|
||||
{
|
||||
assert(elem);
|
||||
if (elem->list.prev == &elem->mixer->elems)
|
||||
if (elem->list.prev == &elem->class->mixer->elems)
|
||||
return NULL;
|
||||
return list_entry(elem->list.prev, snd_mixer_elem_t, list);
|
||||
}
|
||||
|
||||
int snd_mixer_events(snd_mixer_t *mixer)
|
||||
int snd_mixer_handle_events(snd_mixer_t *mixer)
|
||||
{
|
||||
return snd_hctl_events(mixer->hctl);
|
||||
struct list_head *pos, *next;
|
||||
assert(mixer);
|
||||
list_for_each(pos, next, &mixer->slaves) {
|
||||
int err;
|
||||
snd_mixer_slave_t *s;
|
||||
s = list_entry(pos, snd_mixer_slave_t, list);
|
||||
err = snd_hctl_handle_events(s->hctl);
|
||||
if (err < 0)
|
||||
return err;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -20,62 +20,94 @@
|
|||
*
|
||||
*/
|
||||
|
||||
//#include "../control/control_local.h"
|
||||
#include "list.h"
|
||||
#include "local.h"
|
||||
|
||||
typedef struct _snd_hctl_bag {
|
||||
void *root;
|
||||
void *private;
|
||||
} snd_hctl_bag_t;
|
||||
typedef struct _bag1 {
|
||||
void *ptr;
|
||||
struct list_head list;
|
||||
} bag1_t;
|
||||
|
||||
int snd_hctl_bag_destroy(snd_hctl_bag_t *bag);
|
||||
int snd_hctl_bag_add(snd_hctl_bag_t *bag, snd_hctl_elem_t *helem);
|
||||
int snd_hctl_bag_del(snd_hctl_bag_t *bag, snd_hctl_elem_t *helem);
|
||||
snd_hctl_elem_t *snd_hctl_bag_find(snd_hctl_bag_t *bag, snd_ctl_elem_id_t *id);
|
||||
int snd_hctl_bag_empty(snd_hctl_bag_t *bag);
|
||||
typedef struct list_head bag_t;
|
||||
|
||||
int bag_new(bag_t **bag);
|
||||
void bag_free(bag_t *bag);
|
||||
int bag_add(bag_t *bag, void *ptr);
|
||||
int bag_del(bag_t *bag, void *ptr);
|
||||
int bag_empty(bag_t *bag);
|
||||
|
||||
typedef struct list_head *bag_iterator_t;
|
||||
|
||||
#define bag_iterator_entry(i) (list_entry((i), bag1_t, list)->ptr)
|
||||
#define bag_for_each(pos, next, bag) list_for_each(pos, next, bag)
|
||||
|
||||
struct _snd_mixer_class {
|
||||
struct list_head list;
|
||||
snd_mixer_t *mixer;
|
||||
int (*event)(snd_mixer_class_t *class, snd_ctl_event_type_t event,
|
||||
snd_hctl_elem_t *helem, snd_mixer_elem_t *melem);
|
||||
void *private_data;
|
||||
void (*private_free)(snd_mixer_class_t *class);
|
||||
};
|
||||
|
||||
struct _snd_mixer_elem {
|
||||
snd_mixer_elem_type_t type;
|
||||
struct list_head list; /* links for list of all elems */
|
||||
void *private;
|
||||
snd_mixer_class_t *class;
|
||||
void *private_data;
|
||||
void (*private_free)(snd_mixer_elem_t *elem);
|
||||
snd_mixer_elem_callback_t callback;
|
||||
void *callback_private;
|
||||
snd_mixer_t *mixer;
|
||||
bag_t helems;
|
||||
};
|
||||
|
||||
struct _snd_mixer {
|
||||
snd_hctl_t *hctl;
|
||||
struct list_head elems; /* list of all elemss */
|
||||
struct list_head slaves; /* list of all slaves */
|
||||
struct list_head classes; /* list of all elem classes */
|
||||
struct list_head elems; /* list of all elems */
|
||||
|
||||
unsigned int count;
|
||||
snd_mixer_callback_t callback;
|
||||
void *callback_private;
|
||||
};
|
||||
|
||||
#define SND_MIXER_SCTCAP_VOLUME (1<<0)
|
||||
#define SND_MIXER_SCTCAP_JOIN_VOLUME (1<<1)
|
||||
#define SND_MIXER_SCTCAP_MUTE (1<<2)
|
||||
#define SND_MIXER_SCTCAP_JOIN_MUTE (1<<3)
|
||||
#define SND_MIXER_SCTCAP_CAPTURE (1<<4)
|
||||
#define SND_MIXER_SCTCAP_JOIN_CAPTURE (1<<5)
|
||||
#define SND_MIXER_SCTCAP_EXCL_CAPTURE (1<<6)
|
||||
|
||||
struct _snd_mixer_selem_id {
|
||||
unsigned char name[60];
|
||||
unsigned int index;
|
||||
};
|
||||
|
||||
struct _snd_mixer_selem {
|
||||
unsigned int caps; /* RO: capabilities */
|
||||
unsigned int channels; /* RO: bitmap of active channels */
|
||||
#define CAP_VOLUME (1<<0)
|
||||
#define CAP_JOIN_VOLUME (1<<1)
|
||||
#define CAP_MUTE (1<<2)
|
||||
#define CAP_JOIN_MUTE (1<<3)
|
||||
#define CAP_CAPTURE (1<<4)
|
||||
#define CAP_JOIN_CAPTURE (1<<5)
|
||||
#define CAP_EXCL_CAPTURE (1<<6)
|
||||
|
||||
struct _snd_mixer_selem_info {
|
||||
unsigned int caps; /* capabilities */
|
||||
unsigned int channels; /* bitmap of active channels */
|
||||
int capture_group; /* capture group (for exclusive capture) */
|
||||
long min; /* minimum value */
|
||||
long max; /* maximum value */
|
||||
};
|
||||
|
||||
struct _snd_mixer_selem_value {
|
||||
unsigned int mute; /* RW: bitmap of muted channels */
|
||||
unsigned int capture; /* RW: bitmap of capture channels */
|
||||
int capture_group; /* RO: capture group (for exclusive capture) */
|
||||
long min; /* RO: minimum value */
|
||||
long max; /* RO: maximum value */
|
||||
long volume[32];
|
||||
};
|
||||
|
||||
int snd_mixer_class_register(snd_mixer_class_t *class, snd_mixer_t *mixer);
|
||||
int snd_mixer_add_elem(snd_mixer_t *mixer, snd_mixer_elem_t *elem);
|
||||
void snd_mixer_free(snd_mixer_t *mixer);
|
||||
int snd_mixer_remove_elem(snd_mixer_t *mixer, snd_mixer_elem_t *elem);
|
||||
int snd_mixer_elem_throw_event(snd_mixer_elem_t *elem,
|
||||
snd_ctl_event_type_t event);
|
||||
int snd_mixer_elem_add(snd_mixer_elem_t *elem, snd_mixer_class_t *class);
|
||||
int snd_mixer_elem_remove(snd_mixer_elem_t *elem);
|
||||
int snd_mixer_elem_change(snd_mixer_elem_t *elem);
|
||||
int snd_mixer_elem_attach(snd_mixer_elem_t *melem,
|
||||
snd_hctl_elem_t *helem);
|
||||
int snd_mixer_elem_detach(snd_mixer_elem_t *melem,
|
||||
snd_hctl_elem_t *helem);
|
||||
int snd_mixer_elem_empty(snd_mixer_elem_t *melem);
|
||||
|
|
|
|||
|
|
@ -118,88 +118,113 @@ snd_mixer_elem_type_t snd_mixer_elem_get_type(const snd_mixer_elem_t *obj)
|
|||
return obj->type;
|
||||
}
|
||||
|
||||
size_t snd_mixer_selem_sizeof()
|
||||
size_t snd_mixer_selem_info_sizeof()
|
||||
{
|
||||
return sizeof(snd_mixer_selem_t);
|
||||
return sizeof(snd_mixer_selem_info_t);
|
||||
}
|
||||
|
||||
int snd_mixer_selem_malloc(snd_mixer_selem_t **ptr)
|
||||
int snd_mixer_selem_info_malloc(snd_mixer_selem_info_t **ptr)
|
||||
{
|
||||
assert(ptr);
|
||||
*ptr = calloc(1, sizeof(snd_mixer_selem_t));
|
||||
*ptr = calloc(1, sizeof(snd_mixer_selem_info_t));
|
||||
if (!*ptr)
|
||||
return -ENOMEM;
|
||||
return 0;
|
||||
}
|
||||
|
||||
void snd_mixer_selem_free(snd_mixer_selem_t *obj)
|
||||
void snd_mixer_selem_info_free(snd_mixer_selem_info_t *obj)
|
||||
{
|
||||
free(obj);
|
||||
}
|
||||
|
||||
void snd_mixer_selem_copy(snd_mixer_selem_t *dst, const snd_mixer_selem_t *src)
|
||||
void snd_mixer_selem_info_copy(snd_mixer_selem_info_t *dst, const snd_mixer_selem_info_t *src)
|
||||
{
|
||||
assert(dst && src);
|
||||
*dst = *src;
|
||||
}
|
||||
|
||||
long snd_mixer_selem_get_min(const snd_mixer_selem_t *obj)
|
||||
long snd_mixer_selem_info_get_min(const snd_mixer_selem_info_t *obj)
|
||||
{
|
||||
assert(obj);
|
||||
return obj->min;
|
||||
}
|
||||
|
||||
long snd_mixer_selem_get_max(const snd_mixer_selem_t *obj)
|
||||
long snd_mixer_selem_info_get_max(const snd_mixer_selem_info_t *obj)
|
||||
{
|
||||
assert(obj);
|
||||
return obj->max;
|
||||
}
|
||||
|
||||
int snd_mixer_selem_get_capture_group(const snd_mixer_selem_t *obj)
|
||||
int snd_mixer_selem_info_get_capture_group(const snd_mixer_selem_info_t *obj)
|
||||
{
|
||||
assert(obj);
|
||||
return obj->capture_group;
|
||||
}
|
||||
|
||||
int snd_mixer_selem_has_volume(const snd_mixer_selem_t *obj)
|
||||
int snd_mixer_selem_info_has_volume(const snd_mixer_selem_info_t *obj)
|
||||
{
|
||||
assert(obj);
|
||||
return !!(obj->caps & SND_MIXER_SCTCAP_VOLUME);
|
||||
return !!(obj->caps & CAP_VOLUME);
|
||||
}
|
||||
|
||||
int snd_mixer_selem_has_joined_volume(const snd_mixer_selem_t *obj)
|
||||
int snd_mixer_selem_info_has_joined_volume(const snd_mixer_selem_info_t *obj)
|
||||
{
|
||||
assert(obj);
|
||||
return !!(obj->caps & SND_MIXER_SCTCAP_JOIN_VOLUME);
|
||||
return !!(obj->caps & CAP_JOIN_VOLUME);
|
||||
}
|
||||
|
||||
int snd_mixer_selem_has_mute(const snd_mixer_selem_t *obj)
|
||||
int snd_mixer_selem_info_has_mute(const snd_mixer_selem_info_t *obj)
|
||||
{
|
||||
assert(obj);
|
||||
return !!(obj->caps & SND_MIXER_SCTCAP_MUTE);
|
||||
return !!(obj->caps & CAP_MUTE);
|
||||
}
|
||||
|
||||
int snd_mixer_selem_has_joined_mute(const snd_mixer_selem_t *obj)
|
||||
int snd_mixer_selem_info_has_joined_mute(const snd_mixer_selem_info_t *obj)
|
||||
{
|
||||
assert(obj);
|
||||
return !!(obj->caps & SND_MIXER_SCTCAP_JOIN_MUTE);
|
||||
return !!(obj->caps & CAP_JOIN_MUTE);
|
||||
}
|
||||
|
||||
int snd_mixer_selem_has_capture(const snd_mixer_selem_t *obj)
|
||||
int snd_mixer_selem_info_has_capture(const snd_mixer_selem_info_t *obj)
|
||||
{
|
||||
assert(obj);
|
||||
return !!(obj->caps & SND_MIXER_SCTCAP_CAPTURE);
|
||||
return !!(obj->caps & CAP_CAPTURE);
|
||||
}
|
||||
|
||||
int snd_mixer_selem_has_joined_capture(const snd_mixer_selem_t *obj)
|
||||
int snd_mixer_selem_info_has_joined_capture(const snd_mixer_selem_info_t *obj)
|
||||
{
|
||||
assert(obj);
|
||||
return !!(obj->caps & SND_MIXER_SCTCAP_JOIN_CAPTURE);
|
||||
return !!(obj->caps & CAP_JOIN_CAPTURE);
|
||||
}
|
||||
|
||||
int snd_mixer_selem_has_exclusive_capture(const snd_mixer_selem_t *obj)
|
||||
int snd_mixer_selem_info_has_exclusive_capture(const snd_mixer_selem_info_t *obj)
|
||||
{
|
||||
assert(obj);
|
||||
return !!(obj->caps & SND_MIXER_SCTCAP_EXCL_CAPTURE);
|
||||
return !!(obj->caps & CAP_EXCL_CAPTURE);
|
||||
}
|
||||
|
||||
size_t snd_mixer_selem_value_sizeof()
|
||||
{
|
||||
return sizeof(snd_mixer_selem_value_t);
|
||||
}
|
||||
|
||||
int snd_mixer_selem_value_malloc(snd_mixer_selem_value_t **ptr)
|
||||
{
|
||||
assert(ptr);
|
||||
*ptr = calloc(1, sizeof(snd_mixer_selem_value_t));
|
||||
if (!*ptr)
|
||||
return -ENOMEM;
|
||||
return 0;
|
||||
}
|
||||
|
||||
void snd_mixer_selem_value_free(snd_mixer_selem_value_t *obj)
|
||||
{
|
||||
free(obj);
|
||||
}
|
||||
|
||||
void snd_mixer_selem_value_copy(snd_mixer_selem_value_t *dst, const snd_mixer_selem_value_t *src)
|
||||
{
|
||||
assert(dst && src);
|
||||
*dst = *src;
|
||||
}
|
||||
|
||||
|
|
|
|||
1461
src/mixer/simple.c
1461
src/mixer/simple.c
File diff suppressed because it is too large
Load diff
Loading…
Add table
Add a link
Reference in a new issue