mirror of
https://github.com/alsa-project/alsa-lib.git
synced 2025-12-16 08:56:42 -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
|
|
@ -97,8 +97,8 @@ typedef struct {
|
|||
snd_ctl_card_info_t hw_info;
|
||||
snd_ctl_elem_list_t element_list;
|
||||
snd_ctl_elem_info_t element_info;
|
||||
snd_ctl_elem_t element_read;
|
||||
snd_ctl_elem_t element_write;
|
||||
snd_ctl_elem_value_t element_read;
|
||||
snd_ctl_elem_value_t element_write;
|
||||
snd_hwdep_info_t hwdep_info;
|
||||
snd_pcm_info_t pcm_info;
|
||||
int pcm_prefer_subdevice;
|
||||
|
|
|
|||
|
|
@ -25,7 +25,7 @@ extern "C" {
|
|||
#endif
|
||||
|
||||
snd_config_type_t snd_config_get_type(snd_config_t *config);
|
||||
char *snd_config_get_id(snd_config_t *config);
|
||||
const char *snd_config_get_id(snd_config_t *config);
|
||||
|
||||
int snd_config_top(snd_config_t **config);
|
||||
|
||||
|
|
@ -59,11 +59,11 @@ snd_config_iterator_t snd_config_iterator_next(snd_config_iterator_t iterator);
|
|||
snd_config_iterator_t snd_config_iterator_end(snd_config_t *node);
|
||||
snd_config_t *snd_config_iterator_entry(snd_config_iterator_t iterator);
|
||||
|
||||
#define snd_config_foreach(iterator, node) \
|
||||
for (iterator = snd_config_iterator_first(node); iterator != snd_config_iterator_end(node); iterator = snd_config_iterator_next(iterator))
|
||||
#define snd_config_for_each(pos, next, node) \
|
||||
for (pos = snd_config_iterator_first(node), next = snd_config_iterator_next(pos); pos != snd_config_iterator_end(node); pos = next, next = snd_config_iterator_next(pos))
|
||||
|
||||
snd_config_type_t snd_config_get_type(snd_config_t *config);
|
||||
char *snd_config_get_id(snd_config_t *config);
|
||||
const char *snd_config_get_id(snd_config_t *config);
|
||||
|
||||
extern snd_config_t *snd_config;
|
||||
int snd_config_update();
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@ typedef struct _snd_ctl_card_info snd_ctl_card_info_t;
|
|||
typedef struct _snd_ctl_elem_id snd_ctl_elem_id_t;
|
||||
typedef struct _snd_ctl_elem_list snd_ctl_elem_list_t;
|
||||
typedef struct _snd_ctl_elem_info snd_ctl_elem_info_t;
|
||||
typedef struct _snd_ctl_elem snd_ctl_elem_t;
|
||||
typedef struct _snd_ctl_elem_value snd_ctl_elem_value_t;
|
||||
typedef struct _snd_ctl_event snd_ctl_event_t;
|
||||
|
||||
#ifdef SND_ENUM_TYPECHECK
|
||||
|
|
@ -114,7 +114,7 @@ typedef enum sndrv_ctl_event_type snd_ctl_event_type_t;
|
|||
|
||||
#define SND_CTL_EVENT_REBUILD ((snd_ctl_event_type_t) SNDRV_CTL_EVENT_REBUILD)
|
||||
#define SND_CTL_EVENT_VALUE ((snd_ctl_event_type_t) SNDRV_CTL_EVENT_VALUE)
|
||||
#define SND_CTL_EVENT_CHANGE ((snd_ctl_event_type_t) SNDRV_CTL_EVENT_CHANGE)
|
||||
#define SND_CTL_EVENT_INFO ((snd_ctl_event_type_t) SNDRV_CTL_EVENT_INFO)
|
||||
#define SND_CTL_EVENT_ADD ((snd_ctl_event_type_t) SNDRV_CTL_EVENT_ADD)
|
||||
#define SND_CTL_EVENT_REMOVE ((snd_ctl_event_type_t) SNDRV_CTL_EVENT_REMOVE)
|
||||
#define SND_CTL_EVENT_LAST ((snd_ctl_event_type_t) SNDRV_CTL_EVENT_LAST)
|
||||
|
|
@ -155,7 +155,7 @@ int snd_defaults_rawmidi_card(void);
|
|||
int snd_defaults_rawmidi_device(void);
|
||||
|
||||
snd_ctl_type_t snd_ctl_type(snd_ctl_t *ctl);
|
||||
int snd_ctl_open(snd_ctl_t **ctl, char *name);
|
||||
int snd_ctl_open(snd_ctl_t **ctl, const char *name);
|
||||
int snd_ctl_close(snd_ctl_t *ctl);
|
||||
int snd_ctl_nonblock(snd_ctl_t *ctl, int nonblock);
|
||||
int snd_ctl_async(snd_ctl_t *ctl, int sig, pid_t pid);
|
||||
|
|
@ -163,8 +163,8 @@ int snd_ctl_poll_descriptor(snd_ctl_t *ctl);
|
|||
int snd_ctl_card_info(snd_ctl_t *ctl, snd_ctl_card_info_t *info);
|
||||
int snd_ctl_elem_list(snd_ctl_t *ctl, snd_ctl_elem_list_t * list);
|
||||
int snd_ctl_elem_info(snd_ctl_t *ctl, snd_ctl_elem_info_t *info);
|
||||
int snd_ctl_elem_read(snd_ctl_t *ctl, snd_ctl_elem_t *value);
|
||||
int snd_ctl_elem_write(snd_ctl_t *ctl, snd_ctl_elem_t *value);
|
||||
int snd_ctl_elem_read(snd_ctl_t *ctl, snd_ctl_elem_value_t *value);
|
||||
int snd_ctl_elem_write(snd_ctl_t *ctl, snd_ctl_elem_value_t *value);
|
||||
int snd_ctl_hwdep_next_device(snd_ctl_t *ctl, int * device);
|
||||
int snd_ctl_hwdep_info(snd_ctl_t *ctl, snd_hwdep_info_t * info);
|
||||
int snd_ctl_pcm_next_device(snd_ctl_t *ctl, int *device);
|
||||
|
|
@ -176,9 +176,10 @@ int snd_ctl_rawmidi_prefer_subdevice(snd_ctl_t *ctl, int subdev);
|
|||
|
||||
int snd_ctl_read(snd_ctl_t *ctl, snd_ctl_event_t *event);
|
||||
int snd_ctl_wait(snd_ctl_t *ctl, int timeout);
|
||||
const char *snd_ctl_name(snd_ctl_t *ctl);
|
||||
snd_ctl_type_t snd_ctl_type(snd_ctl_t *ctl);
|
||||
|
||||
void snd_ctl_elem_set_bytes(snd_ctl_elem_t *obj, void *data, size_t size);
|
||||
|
||||
void snd_ctl_elem_set_bytes(snd_ctl_elem_value_t *obj, void *data, size_t size);
|
||||
const char *snd_ctl_elem_type_name(snd_ctl_elem_type_t type);
|
||||
const char *snd_ctl_elem_iface_name(snd_ctl_elem_iface_t iface);
|
||||
const char *snd_ctl_event_type_name(snd_ctl_event_type_t type);
|
||||
|
|
@ -210,25 +211,31 @@ typedef int (*snd_hctl_callback_t)(snd_hctl_t *hctl,
|
|||
typedef int (*snd_hctl_elem_callback_t)(snd_hctl_elem_t *elem,
|
||||
snd_ctl_event_type_t event);
|
||||
|
||||
int snd_hctl_open(snd_hctl_t **hctl, char *name);
|
||||
int snd_hctl_open(snd_hctl_t **hctl, const char *name);
|
||||
int snd_hctl_close(snd_hctl_t *hctl);
|
||||
int snd_hctl_nonblock(snd_hctl_t *hctl, int nonblock);
|
||||
int snd_hctl_async(snd_hctl_t *hctl, int sig, pid_t pid);
|
||||
int snd_hctl_poll_descriptor(snd_hctl_t *hctl);
|
||||
unsigned int snd_hctl_get_count(snd_hctl_t *ctl);
|
||||
void snd_hctl_set_compare(snd_hctl_t *hctl, snd_hctl_compare_t hsort);
|
||||
snd_hctl_elem_t *snd_hctl_first_elem(snd_hctl_t *hctl);
|
||||
snd_hctl_elem_t *snd_hctl_last_elem(snd_hctl_t *hctl);
|
||||
snd_hctl_elem_t *snd_hctl_find_elem(snd_hctl_t *ctl, const snd_ctl_elem_id_t *id);
|
||||
void snd_hctl_set_callback(snd_hctl_t *ctl, snd_hctl_callback_t callback);
|
||||
void snd_hctl_set_callback_private(snd_hctl_t *ctl, void *data);
|
||||
void *snd_hctl_get_callback_private(snd_hctl_t *ctl);
|
||||
int snd_hctl_load(snd_hctl_t *ctl);
|
||||
int snd_hctl_free(snd_hctl_t *ctl);
|
||||
int snd_hctl_handle_event(snd_hctl_t *ctl, snd_ctl_event_t *event);
|
||||
int snd_hctl_handle_events(snd_hctl_t *ctl);
|
||||
const char *snd_hctl_name(snd_hctl_t *hctl);
|
||||
snd_ctl_type_t snd_hctl_type(snd_hctl_t *hctl);
|
||||
|
||||
snd_hctl_elem_t *snd_hctl_elem_next(snd_hctl_elem_t *elem);
|
||||
snd_hctl_elem_t *snd_hctl_elem_prev(snd_hctl_elem_t *elem);
|
||||
int snd_hctl_elem_info(snd_hctl_elem_t *elem, snd_ctl_elem_info_t * info);
|
||||
int snd_hctl_elem_read(snd_hctl_elem_t *elem, snd_ctl_elem_t * value);
|
||||
int snd_hctl_elem_write(snd_hctl_elem_t *elem, snd_ctl_elem_t * value);
|
||||
unsigned int snd_hctl_get_count(snd_hctl_t *ctl);
|
||||
snd_hctl_elem_t *snd_hctl_find_elem(snd_hctl_t *ctl, const snd_ctl_elem_id_t *id);
|
||||
void snd_hctl_set_callback(snd_hctl_t *ctl, snd_hctl_callback_t callback);
|
||||
void snd_hctl_set_callback_private(snd_hctl_t *ctl, void *private);
|
||||
void *snd_hctl_get_callback_private(snd_hctl_t *ctl);
|
||||
int snd_hctl_event(snd_hctl_t *ctl, snd_ctl_event_t *event);
|
||||
int snd_hctl_events(snd_hctl_t *ctl);
|
||||
int snd_hctl_elem_read(snd_hctl_elem_t *elem, snd_ctl_elem_value_t * value);
|
||||
int snd_hctl_elem_write(snd_hctl_elem_t *elem, snd_ctl_elem_value_t * value);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
|
|
|||
|
|
@ -164,67 +164,61 @@ void snd_ctl_elem_info_set_name(snd_ctl_elem_info_t *obj, const char *val);
|
|||
|
||||
void snd_ctl_elem_info_set_index(snd_ctl_elem_info_t *obj, unsigned int val);
|
||||
|
||||
size_t snd_ctl_elem_sizeof();
|
||||
#define snd_ctl_elem_alloca(ptr) ({ assert(ptr); *ptr = (snd_ctl_elem_t *) alloca(snd_ctl_elem_sizeof()); memset(*ptr, 0, snd_ctl_elem_sizeof()); 0; })
|
||||
int snd_ctl_elem_malloc(snd_ctl_elem_t **ptr);
|
||||
void snd_ctl_elem_free(snd_ctl_elem_t *obj);
|
||||
void snd_ctl_elem_copy(snd_ctl_elem_t *dst, const snd_ctl_elem_t *src);
|
||||
size_t snd_ctl_elem_value_sizeof();
|
||||
#define snd_ctl_elem_value_alloca(ptr) ({ assert(ptr); *ptr = (snd_ctl_elem_value_t *) alloca(snd_ctl_elem_value_sizeof()); memset(*ptr, 0, snd_ctl_elem_value_sizeof()); 0; })
|
||||
int snd_ctl_elem_value_malloc(snd_ctl_elem_value_t **ptr);
|
||||
void snd_ctl_elem_value_free(snd_ctl_elem_value_t *obj);
|
||||
void snd_ctl_elem_value_copy(snd_ctl_elem_value_t *dst, const snd_ctl_elem_value_t *src);
|
||||
|
||||
void snd_ctl_elem_get_id(const snd_ctl_elem_t *obj, snd_ctl_elem_id_t *ptr);
|
||||
void snd_ctl_elem_value_get_id(const snd_ctl_elem_value_t *obj, snd_ctl_elem_id_t *ptr);
|
||||
|
||||
unsigned int snd_ctl_elem_get_numid(const snd_ctl_elem_t *obj);
|
||||
unsigned int snd_ctl_elem_value_get_numid(const snd_ctl_elem_value_t *obj);
|
||||
|
||||
snd_ctl_elem_iface_t snd_ctl_elem_get_interface(const snd_ctl_elem_t *obj);
|
||||
snd_ctl_elem_iface_t snd_ctl_elem_value_get_interface(const snd_ctl_elem_value_t *obj);
|
||||
|
||||
unsigned int snd_ctl_elem_get_device(const snd_ctl_elem_t *obj);
|
||||
unsigned int snd_ctl_elem_value_get_device(const snd_ctl_elem_value_t *obj);
|
||||
|
||||
unsigned int snd_ctl_elem_get_subdevice(const snd_ctl_elem_t *obj);
|
||||
unsigned int snd_ctl_elem_value_get_subdevice(const snd_ctl_elem_value_t *obj);
|
||||
|
||||
const char *snd_ctl_elem_get_name(const snd_ctl_elem_t *obj);
|
||||
const char *snd_ctl_elem_value_get_name(const snd_ctl_elem_value_t *obj);
|
||||
|
||||
unsigned int snd_ctl_elem_get_index(const snd_ctl_elem_t *obj);
|
||||
unsigned int snd_ctl_elem_value_get_index(const snd_ctl_elem_value_t *obj);
|
||||
|
||||
void snd_ctl_elem_set_id(snd_ctl_elem_t *obj, const snd_ctl_elem_id_t *ptr);
|
||||
void snd_ctl_elem_value_set_id(snd_ctl_elem_value_t *obj, const snd_ctl_elem_id_t *ptr);
|
||||
|
||||
void snd_ctl_elem_set_numid(snd_ctl_elem_t *obj, unsigned int val);
|
||||
void snd_ctl_elem_value_set_numid(snd_ctl_elem_value_t *obj, unsigned int val);
|
||||
|
||||
void snd_ctl_elem_set_interface(snd_ctl_elem_t *obj, snd_ctl_elem_iface_t val);
|
||||
void snd_ctl_elem_value_set_interface(snd_ctl_elem_value_t *obj, snd_ctl_elem_iface_t val);
|
||||
|
||||
void snd_ctl_elem_set_device(snd_ctl_elem_t *obj, unsigned int val);
|
||||
void snd_ctl_elem_value_set_device(snd_ctl_elem_value_t *obj, unsigned int val);
|
||||
|
||||
void snd_ctl_elem_set_subdevice(snd_ctl_elem_t *obj, unsigned int val);
|
||||
void snd_ctl_elem_value_set_subdevice(snd_ctl_elem_value_t *obj, unsigned int val);
|
||||
|
||||
void snd_ctl_elem_set_name(snd_ctl_elem_t *obj, const char *val);
|
||||
void snd_ctl_elem_value_set_name(snd_ctl_elem_value_t *obj, const char *val);
|
||||
|
||||
void snd_ctl_elem_set_index(snd_ctl_elem_t *obj, unsigned int val);
|
||||
void snd_ctl_elem_value_set_index(snd_ctl_elem_value_t *obj, unsigned int val);
|
||||
|
||||
long snd_ctl_elem_get_boolean(const snd_ctl_elem_t *obj, unsigned int idx);
|
||||
long snd_ctl_elem_value_get_boolean(const snd_ctl_elem_value_t *obj, unsigned int idx);
|
||||
|
||||
long snd_ctl_elem_get_integer(const snd_ctl_elem_t *obj, unsigned int idx);
|
||||
long snd_ctl_elem_value_get_integer(const snd_ctl_elem_value_t *obj, unsigned int idx);
|
||||
|
||||
unsigned int snd_ctl_elem_get_enumerated(const snd_ctl_elem_t *obj, unsigned int idx);
|
||||
unsigned int snd_ctl_elem_value_get_enumerated(const snd_ctl_elem_value_t *obj, unsigned int idx);
|
||||
|
||||
unsigned char snd_ctl_elem_get_byte(const snd_ctl_elem_t *obj, unsigned int idx);
|
||||
unsigned char snd_ctl_elem_value_get_byte(const snd_ctl_elem_value_t *obj, unsigned int idx);
|
||||
|
||||
void snd_ctl_elem_set_boolean(snd_ctl_elem_t *obj, unsigned int idx, long val);
|
||||
void snd_ctl_elem_value_set_boolean(snd_ctl_elem_value_t *obj, unsigned int idx, long val);
|
||||
|
||||
void snd_ctl_elem_set_integer(snd_ctl_elem_t *obj, unsigned int idx, long val);
|
||||
void snd_ctl_elem_value_set_integer(snd_ctl_elem_value_t *obj, unsigned int idx, long val);
|
||||
|
||||
void snd_ctl_elem_set_enumerated(snd_ctl_elem_t *obj, unsigned int idx, unsigned int val);
|
||||
void snd_ctl_elem_value_set_enumerated(snd_ctl_elem_value_t *obj, unsigned int idx, unsigned int val);
|
||||
|
||||
void snd_ctl_elem_set_byte(snd_ctl_elem_t *obj, unsigned int idx, unsigned char val);
|
||||
void snd_ctl_elem_value_set_byte(snd_ctl_elem_value_t *obj, unsigned int idx, unsigned char val);
|
||||
|
||||
const void * snd_ctl_elem_get_bytes(const snd_ctl_elem_t *obj);
|
||||
const void * snd_ctl_elem_value_get_bytes(const snd_ctl_elem_value_t *obj);
|
||||
|
||||
void snd_ctl_elem_get_iec958(const snd_ctl_elem_t *obj, snd_aes_iec958_t *ptr);
|
||||
void snd_ctl_elem_value_get_iec958(const snd_ctl_elem_value_t *obj, snd_aes_iec958_t *ptr);
|
||||
|
||||
void snd_ctl_elem_set_iec958(snd_ctl_elem_t *obj, const snd_aes_iec958_t *ptr);
|
||||
|
||||
size_t snd_hctl_elem_sizeof();
|
||||
#define snd_hctl_elem_alloca(ptr) ({ assert(ptr); *ptr = (snd_hctl_elem_t *) alloca(snd_hctl_elem_sizeof()); memset(*ptr, 0, snd_hctl_elem_sizeof()); 0; })
|
||||
int snd_hctl_elem_malloc(snd_hctl_elem_t **ptr);
|
||||
void snd_hctl_elem_free(snd_hctl_elem_t *obj);
|
||||
void snd_hctl_elem_copy(snd_hctl_elem_t *dst, const snd_hctl_elem_t *src);
|
||||
void snd_ctl_elem_value_set_iec958(snd_ctl_elem_value_t *obj, const snd_aes_iec958_t *ptr);
|
||||
|
||||
void snd_hctl_elem_get_id(const snd_hctl_elem_t *obj, snd_ctl_elem_id_t *ptr);
|
||||
|
||||
|
|
|
|||
|
|
@ -139,10 +139,11 @@ static __inline__ void list_splice(struct list_head *list, struct list_head *hea
|
|||
/**
|
||||
* list_for_each - iterate over a list
|
||||
* @pos: the &struct list_head to use as a loop counter.
|
||||
* @next: the &struct list_head to use to save next.
|
||||
* @head: the head for your list.
|
||||
*/
|
||||
#define list_for_each(pos, head) \
|
||||
for (pos = (head)->next; pos != (head); pos = pos->next)
|
||||
#define list_for_each(pos, npos, head) \
|
||||
for (pos = (head)->next, npos = pos->next ; pos != (head); pos = npos, npos = pos->next)
|
||||
|
||||
/**
|
||||
* list_entry - get the struct for this entry
|
||||
|
|
|
|||
|
|
@ -32,7 +32,7 @@
|
|||
#define _snd_ctl_elem_id sndrv_ctl_elem_id
|
||||
#define _snd_ctl_elem_list sndrv_ctl_elem_list
|
||||
#define _snd_ctl_elem_info sndrv_ctl_elem_info
|
||||
#define _snd_ctl_elem sndrv_ctl_elem
|
||||
#define _snd_ctl_elem_value sndrv_ctl_elem_value
|
||||
#define _snd_ctl_event sndrv_ctl_event
|
||||
|
||||
#define _snd_rawmidi_info sndrv_rawmidi_info
|
||||
|
|
|
|||
|
|
@ -6,6 +6,7 @@
|
|||
****************************************************************************/
|
||||
|
||||
typedef struct _snd_mixer snd_mixer_t;
|
||||
typedef struct _snd_mixer_class snd_mixer_class_t;
|
||||
typedef struct _snd_mixer_info snd_mixer_info_t;
|
||||
typedef struct _snd_mixer_elem snd_mixer_elem_t;
|
||||
typedef int (*snd_mixer_callback_t)(snd_mixer_t *ctl,
|
||||
|
|
@ -13,6 +14,8 @@ typedef int (*snd_mixer_callback_t)(snd_mixer_t *ctl,
|
|||
snd_mixer_elem_t *elem);
|
||||
typedef int (*snd_mixer_elem_callback_t)(snd_mixer_elem_t *elem,
|
||||
snd_ctl_event_type_t event);
|
||||
typedef int (*snd_mixer_compare_t)(const snd_mixer_elem_t *e1,
|
||||
const snd_mixer_elem_t *e2);
|
||||
|
||||
enum _snd_mixer_elem_type {
|
||||
SND_MIXER_ELEM_SIMPLE,
|
||||
|
|
@ -33,15 +36,22 @@ typedef enum _snd_mixer_elem_type snd_mixer_elem_type_t;
|
|||
extern "C" {
|
||||
#endif
|
||||
|
||||
int snd_mixer_open(snd_mixer_t **mixer, char *name);
|
||||
int snd_mixer_open(snd_mixer_t **mixer);
|
||||
int snd_mixer_close(snd_mixer_t *mixer);
|
||||
int snd_mixer_poll_descriptor(snd_mixer_t *mixer);
|
||||
int snd_mixer_info(snd_mixer_t *mixer, snd_mixer_info_t *info);
|
||||
snd_mixer_elem_t *snd_mixer_first_elem(snd_mixer_t *mixer);
|
||||
snd_mixer_elem_t *snd_mixer_last_elem(snd_mixer_t *mixer);
|
||||
int snd_mixer_handle_events(snd_mixer_t *mixer);
|
||||
int snd_mixer_attach(snd_mixer_t *mixer, const char *name);
|
||||
int snd_mixer_detach(snd_mixer_t *mixer, const char *name);
|
||||
int snd_mixer_poll_descriptor(snd_mixer_t *mixer, const char *name);
|
||||
int snd_mixer_load(snd_mixer_t *mixer);
|
||||
void snd_mixer_set_compare(snd_hctl_t *hctl, snd_mixer_compare_t hsort);
|
||||
|
||||
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 *helem);
|
||||
int snd_mixer_events(snd_mixer_t *mixer);
|
||||
|
||||
int snd_mixer_class_unregister(snd_mixer_class_t *clss);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
|
@ -51,65 +61,69 @@ int snd_mixer_events(snd_mixer_t *mixer);
|
|||
* Simple (legacy) mixer API
|
||||
*/
|
||||
|
||||
enum _snd_mixer_channel_id {
|
||||
SND_MIXER_CHN_UNKNOWN = -1,
|
||||
SND_MIXER_CHN_FRONT_LEFT = 0,
|
||||
SND_MIXER_CHN_FRONT_RIGHT,
|
||||
SND_MIXER_CHN_FRONT_CENTER,
|
||||
SND_MIXER_CHN_REAR_LEFT,
|
||||
SND_MIXER_CHN_REAR_RIGHT,
|
||||
SND_MIXER_CHN_WOOFER,
|
||||
SND_MIXER_CHN_LAST = 31,
|
||||
SND_MIXER_CHN_MONO = SND_MIXER_CHN_FRONT_LEFT
|
||||
enum _snd_mixer_selem_channel_id {
|
||||
SND_MIXER_SCHN_UNKNOWN = -1,
|
||||
SND_MIXER_SCHN_FRONT_LEFT = 0,
|
||||
SND_MIXER_SCHN_FRONT_RIGHT,
|
||||
SND_MIXER_SCHN_FRONT_CENTER,
|
||||
SND_MIXER_SCHN_REAR_LEFT,
|
||||
SND_MIXER_SCHN_REAR_RIGHT,
|
||||
SND_MIXER_SCHN_WOOFER,
|
||||
SND_MIXER_SCHN_LAST = 31,
|
||||
SND_MIXER_SCHN_MONO = SND_MIXER_SCHN_FRONT_LEFT
|
||||
};
|
||||
|
||||
/* Simple mixer */
|
||||
|
||||
typedef struct _snd_mixer_selem snd_mixer_selem_t;
|
||||
typedef struct _snd_mixer_selem_info snd_mixer_selem_info_t;
|
||||
typedef struct _snd_mixer_selem_value snd_mixer_selem_value_t;
|
||||
typedef struct _snd_mixer_selem_id snd_mixer_selem_id_t;
|
||||
|
||||
#ifdef SND_ENUM_TYPECHECK
|
||||
typedef struct __snd_mixer_channel_id *snd_mixer_channel_id_t;
|
||||
typedef struct __snd_mixer_selem_channel_id *snd_mixer_selem_channel_id_t;
|
||||
#else
|
||||
typedef enum _snd_mixer_channel_id snd_mixer_channel_id_t;
|
||||
typedef enum _snd_mixer_selem_channel_id snd_mixer_selem_channel_id_t;
|
||||
#endif
|
||||
|
||||
#define SND_MIXER_CHN_UNKNOWN ((snd_mixer_channel_id_t) SND_MIXER_CHN_UNKNOWN)
|
||||
#define SND_MIXER_CHN_FRONT_LEFT ((snd_mixer_channel_id_t) SND_MIXER_CHN_FRONT_LEFT)
|
||||
#define SND_MIXER_CHN_FRONT_RIGHT ((snd_mixer_channel_id_t) SND_MIXER_CHN_FRONT_RIGHT)
|
||||
#define SND_MIXER_CHN_FRONT_CENTER ((snd_mixer_channel_id_t) SND_MIXER_CHN_FRONT_CENTER)
|
||||
#define SND_MIXER_CHN_REAR_LEFT ((snd_mixer_channel_id_t) SND_MIXER_CHN_REAR_LEFT)
|
||||
#define SND_MIXER_CHN_REAR_RIGHT ((snd_mixer_channel_id_t) SND_MIXER_CHN_REAR_RIGHT)
|
||||
#define SND_MIXER_CHN_WOOFER ((snd_mixer_channel_id_t) SND_MIXER_CHN_WOOFER)
|
||||
#define SND_MIXER_CHN_LAST ((snd_mixer_channel_id_t) SND_MIXER_CHN_LAST)
|
||||
#define SND_MIXER_CHN_MONO ((snd_mixer_channel_id_t) SND_MIXER_CHN_MONO)
|
||||
#define SND_MIXER_SCHN_UNKNOWN ((snd_mixer_selem_channel_id_t) SND_MIXER_SCHN_UNKNOWN)
|
||||
#define SND_MIXER_SCHN_FRONT_LEFT ((snd_mixer_selem_channel_id_t) SND_MIXER_SCHN_FRONT_LEFT)
|
||||
#define SND_MIXER_SCHN_FRONT_RIGHT ((snd_mixer_selem_channel_id_t) SND_MIXER_SCHN_FRONT_RIGHT)
|
||||
#define SND_MIXER_SCHN_FRONT_CENTER ((snd_mixer_selem_channel_id_t) SND_MIXER_SCHN_FRONT_CENTER)
|
||||
#define SND_MIXER_SCHN_REAR_LEFT ((snd_mixer_selem_channel_id_t) SND_MIXER_SCHN_REAR_LEFT)
|
||||
#define SND_MIXER_SCHN_REAR_RIGHT ((snd_mixer_selem_channel_id_t) SND_MIXER_SCHN_REAR_RIGHT)
|
||||
#define SND_MIXER_SCHN_WOOFER ((snd_mixer_selem_channel_id_t) SND_MIXER_SCHN_WOOFER)
|
||||
#define SND_MIXER_SCHN_LAST ((snd_mixer_selem_channel_id_t) SND_MIXER_SCHN_LAST)
|
||||
#define SND_MIXER_SCHN_MONO ((snd_mixer_selem_channel_id_t) SND_MIXER_SCHN_MONO)
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
const char *snd_mixer_channel_name(snd_mixer_channel_id_t channel);
|
||||
int snd_mixer_simple_build(snd_mixer_t *mixer);
|
||||
snd_mixer_elem_t *snd_mixer_find_selem(snd_mixer_t *mixer,
|
||||
const snd_mixer_selem_id_t *id);
|
||||
const char *snd_mixer_selem_channel_name(snd_mixer_selem_channel_id_t channel);
|
||||
|
||||
int snd_mixer_selem_register(snd_mixer_t *mixer, snd_mixer_class_t **classp);
|
||||
void snd_mixer_selem_get_id(snd_mixer_elem_t *element,
|
||||
snd_mixer_selem_id_t *id);
|
||||
snd_mixer_elem_t *snd_mixer_find_selem(snd_mixer_t *mixer,
|
||||
const snd_mixer_selem_id_t *id);
|
||||
int snd_mixer_selem_info(snd_mixer_elem_t *element,
|
||||
snd_mixer_selem_info_t *info);
|
||||
int snd_mixer_selem_read(snd_mixer_elem_t *element,
|
||||
snd_mixer_selem_t *simple);
|
||||
snd_mixer_selem_value_t *value);
|
||||
int snd_mixer_selem_write(snd_mixer_elem_t *element,
|
||||
const snd_mixer_selem_t *simple);
|
||||
const snd_mixer_selem_value_t *value);
|
||||
|
||||
int snd_mixer_selem_is_mono(const snd_mixer_selem_t *obj);
|
||||
int snd_mixer_selem_has_channel(const snd_mixer_selem_t *obj, snd_mixer_channel_id_t channel);
|
||||
long snd_mixer_selem_get_volume(const snd_mixer_selem_t *obj, snd_mixer_channel_id_t channel);
|
||||
void snd_mixer_selem_set_volume(snd_mixer_selem_t *obj, snd_mixer_channel_id_t channel, long value);
|
||||
int snd_mixer_selem_get_mute(const snd_mixer_selem_t *obj, snd_mixer_channel_id_t channel);
|
||||
int snd_mixer_selem_get_capture(const snd_mixer_selem_t *obj, snd_mixer_channel_id_t channel);
|
||||
void snd_mixer_selem_set_mute(snd_mixer_selem_t *obj, snd_mixer_channel_id_t channel, int mute);
|
||||
void snd_mixer_selem_set_capture(snd_mixer_selem_t *obj, snd_mixer_channel_id_t channel, int capture);
|
||||
void snd_mixer_selem_set_mute_all(snd_mixer_selem_t *obj, int mute);
|
||||
void snd_mixer_selem_set_capture_all(snd_mixer_selem_t *obj, int capture);
|
||||
void snd_mixer_selem_set_volume_all(snd_mixer_selem_t *obj, long value);
|
||||
int snd_mixer_selem_info_is_mono(const snd_mixer_selem_info_t *info);
|
||||
int snd_mixer_selem_info_has_channel(const snd_mixer_selem_info_t *obj, snd_mixer_selem_channel_id_t channel);
|
||||
long snd_mixer_selem_value_get_volume(const snd_mixer_selem_value_t *obj, snd_mixer_selem_channel_id_t channel);
|
||||
void snd_mixer_selem_value_set_volume(snd_mixer_selem_value_t *obj, snd_mixer_selem_channel_id_t channel, long value);
|
||||
int snd_mixer_selem_value_get_mute(const snd_mixer_selem_value_t *obj, snd_mixer_selem_channel_id_t channel);
|
||||
int snd_mixer_selem_value_get_capture(const snd_mixer_selem_value_t *obj, snd_mixer_selem_channel_id_t channel);
|
||||
void snd_mixer_selem_value_set_mute(snd_mixer_selem_value_t *obj, snd_mixer_selem_channel_id_t channel, int mute);
|
||||
void snd_mixer_selem_value_set_capture(snd_mixer_selem_value_t *obj, snd_mixer_selem_channel_id_t channel, int capture);
|
||||
void snd_mixer_selem_value_set_mute_all(snd_mixer_selem_value_t *obj, int mute);
|
||||
void snd_mixer_selem_value_set_capture_all(snd_mixer_selem_value_t *obj, int capture);
|
||||
void snd_mixer_selem_value_set_volume_all(snd_mixer_selem_value_t *obj, long value);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
|
|
|||
|
|
@ -32,31 +32,37 @@ void snd_mixer_elem_set_callback_private(snd_mixer_elem_t *obj, void * val);
|
|||
|
||||
snd_mixer_elem_type_t snd_mixer_elem_get_type(const snd_mixer_elem_t *obj);
|
||||
|
||||
size_t snd_mixer_selem_sizeof();
|
||||
#define snd_mixer_selem_alloca(ptr) ({ assert(ptr); *ptr = (snd_mixer_selem_t *) alloca(snd_mixer_selem_sizeof()); memset(*ptr, 0, snd_mixer_selem_sizeof()); 0; })
|
||||
int snd_mixer_selem_malloc(snd_mixer_selem_t **ptr);
|
||||
void snd_mixer_selem_free(snd_mixer_selem_t *obj);
|
||||
void snd_mixer_selem_copy(snd_mixer_selem_t *dst, const snd_mixer_selem_t *src);
|
||||
size_t snd_mixer_selem_info_sizeof();
|
||||
#define snd_mixer_selem_info_alloca(ptr) ({ assert(ptr); *ptr = (snd_mixer_selem_info_t *) alloca(snd_mixer_selem_info_sizeof()); memset(*ptr, 0, snd_mixer_selem_info_sizeof()); 0; })
|
||||
int snd_mixer_selem_info_malloc(snd_mixer_selem_info_t **ptr);
|
||||
void snd_mixer_selem_info_free(snd_mixer_selem_info_t *obj);
|
||||
void snd_mixer_selem_info_copy(snd_mixer_selem_info_t *dst, const snd_mixer_selem_info_t *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);
|
||||
|
||||
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);
|
||||
|
||||
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);
|
||||
|
||||
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);
|
||||
|
||||
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);
|
||||
|
||||
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);
|
||||
|
||||
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);
|
||||
|
||||
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);
|
||||
|
||||
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);
|
||||
|
||||
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);
|
||||
|
||||
size_t snd_mixer_selem_value_sizeof();
|
||||
#define snd_mixer_selem_value_alloca(ptr) ({ assert(ptr); *ptr = (snd_mixer_selem_value_t *) alloca(snd_mixer_selem_value_sizeof()); memset(*ptr, 0, snd_mixer_selem_value_sizeof()); 0; })
|
||||
int snd_mixer_selem_value_malloc(snd_mixer_selem_value_t **ptr);
|
||||
void snd_mixer_selem_value_free(snd_mixer_selem_value_t *obj);
|
||||
void snd_mixer_selem_value_copy(snd_mixer_selem_value_t *dst, const snd_mixer_selem_value_t *src);
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
|
|
|
|||
|
|
@ -247,6 +247,8 @@ int snd_pcm_unlink(snd_pcm_t *pcm);
|
|||
|
||||
int snd_pcm_wait(snd_pcm_t *pcm, int timeout);
|
||||
snd_pcm_sframes_t snd_pcm_avail_update(snd_pcm_t *pcm);
|
||||
const char *snd_pcm_name(snd_pcm_t *pcm);
|
||||
snd_pcm_type_t snd_pcm_type(snd_pcm_t *pcm);
|
||||
|
||||
/* HW params */
|
||||
int snd_pcm_hw_params_any(snd_pcm_t *pcm, snd_pcm_hw_params_t *params);
|
||||
|
|
|
|||
|
|
@ -45,7 +45,7 @@ extern "C" {
|
|||
#endif
|
||||
|
||||
int snd_rawmidi_open(snd_rawmidi_t **in_rmidi, snd_rawmidi_t **out_rmidi,
|
||||
char *name, int mode);
|
||||
const char *name, int mode);
|
||||
int snd_rawmidi_close(snd_rawmidi_t *rmidi);
|
||||
int snd_rawmidi_poll_descriptor(snd_rawmidi_t *rmidi);
|
||||
int snd_rawmidi_nonblock(snd_rawmidi_t *rmidi, int nonblock);
|
||||
|
|
@ -56,6 +56,8 @@ int snd_rawmidi_drain(snd_rawmidi_t *rmidi);
|
|||
int snd_rawmidi_drop(snd_rawmidi_t *rmidi);
|
||||
ssize_t snd_rawmidi_write(snd_rawmidi_t *rmidi, const void *buffer, size_t size);
|
||||
ssize_t snd_rawmidi_read(snd_rawmidi_t *rmidi, void *buffer, size_t size);
|
||||
const char *snd_rawmidi_name(snd_rawmidi_t *rmidi);
|
||||
snd_rawmidi_type_t snd_rawmidi_type(snd_rawmidi_t *rmidi);
|
||||
|
||||
int snd_rawmidi_params_current(snd_rawmidi_t *rmidi, snd_rawmidi_params_t *params);
|
||||
|
||||
|
|
|
|||
|
|
@ -322,7 +322,7 @@ typedef struct _snd_seq snd_seq_t;
|
|||
extern "C" {
|
||||
#endif
|
||||
|
||||
int snd_seq_open(snd_seq_t **handle, char *name, int streams, int mode);
|
||||
int snd_seq_open(snd_seq_t **handle, const char *name, int streams, int mode);
|
||||
int snd_seq_close(snd_seq_t *handle);
|
||||
int snd_seq_poll_descriptor(snd_seq_t *handle);
|
||||
int snd_seq_nonblock(snd_seq_t *handle, int nonblock);
|
||||
|
|
@ -354,15 +354,15 @@ int snd_seq_set_queue_timer(snd_seq_t *handle, int q, snd_seq_queue_timer_t *tim
|
|||
int snd_seq_get_queue_client(snd_seq_t *handle, int q, snd_seq_queue_client_t *queue);
|
||||
int snd_seq_set_queue_client(snd_seq_t *handle, int q, snd_seq_queue_client_t *queue);
|
||||
int snd_seq_create_queue(snd_seq_t *seq, snd_seq_queue_info_t *info);
|
||||
int snd_seq_alloc_named_queue(snd_seq_t *seq, char *name);
|
||||
int snd_seq_alloc_named_queue(snd_seq_t *seq, const char *name);
|
||||
int snd_seq_alloc_queue(snd_seq_t *handle);
|
||||
#ifdef SND_SEQ_SYNC_SUPPORT
|
||||
int snd_seq_alloc_sync_queue(snd_seq_t *seq, char *name);
|
||||
int snd_seq_alloc_sync_queue(snd_seq_t *seq, const char *name);
|
||||
#endif
|
||||
int snd_seq_free_queue(snd_seq_t *handle, int q);
|
||||
int snd_seq_get_queue_info(snd_seq_t *seq, int q, snd_seq_queue_info_t *info);
|
||||
int snd_seq_set_queue_info(snd_seq_t *seq, int q, snd_seq_queue_info_t *info);
|
||||
int snd_seq_get_named_queue(snd_seq_t *seq, char *name);
|
||||
int snd_seq_get_named_queue(snd_seq_t *seq, const char *name);
|
||||
int snd_seq_get_client_pool(snd_seq_t *handle, snd_seq_client_pool_t * info);
|
||||
int snd_seq_set_client_pool(snd_seq_t *handle, snd_seq_client_pool_t * info);
|
||||
int snd_seq_query_next_client(snd_seq_t *handle, snd_seq_client_info_t * info);
|
||||
|
|
@ -376,6 +376,8 @@ int snd_seq_add_sync_std_master(snd_seq_t *seq, int queue, snd_seq_addr_t *dest,
|
|||
|
||||
int snd_seq_set_sync_slave(snd_seq_t *seq, int queue, snd_seq_addr_t *src, snd_seq_queue_sync_t *info);
|
||||
int snd_seq_reset_sync_slave(snd_seq_t *seq, int queue, snd_seq_addr_t *src);
|
||||
const char *snd_seq_name(snd_seq_t *seq);
|
||||
snd_seq_type_t snd_seq_type(snd_seq_t *seq);
|
||||
|
||||
#endif
|
||||
|
||||
|
|
|
|||
|
|
@ -72,7 +72,7 @@ int snd_seq_change_queue_tempo(snd_seq_t *seq, int q, int tempo, snd_seq_event_t
|
|||
int snd_seq_setpos_queue(snd_seq_t *seq, int q, snd_seq_timestamp_t *rtime, snd_seq_event_t *ev);
|
||||
|
||||
/* create a port - simple version - return the port number */
|
||||
int snd_seq_create_simple_port(snd_seq_t *seq, char *name,
|
||||
int snd_seq_create_simple_port(snd_seq_t *seq, const char *name,
|
||||
unsigned int caps, unsigned int type);
|
||||
/* delete the port */
|
||||
int snd_seq_delete_simple_port(snd_seq_t *seq, int port);
|
||||
|
|
@ -88,8 +88,8 @@ int snd_seq_disconnect_to(snd_seq_t *seq, int my_port, int dest_client, int dest
|
|||
/*
|
||||
* set client information
|
||||
*/
|
||||
int snd_seq_set_client_name(snd_seq_t *seq, char *name);
|
||||
int snd_seq_set_client_group(snd_seq_t *seq, char *name);
|
||||
int snd_seq_set_client_name(snd_seq_t *seq, const char *name);
|
||||
int snd_seq_set_client_group(snd_seq_t *seq, const char *name);
|
||||
int snd_seq_set_client_filter(snd_seq_t *seq, unsigned int filter);
|
||||
int snd_seq_set_client_event_filter(snd_seq_t *seq, int event_type);
|
||||
int snd_seq_set_client_pool_output(snd_seq_t *seq, int size);
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue