mirror of
https://github.com/alsa-project/alsa-lib.git
synced 2025-12-16 08:56:42 -05:00
Completed control and mixer API
This commit is contained in:
Abramo Bagnara
parent
c709b0a627
commit
fea0c73cdb
23 changed files with 1988 additions and 1251 deletions
|
|
@ -3,9 +3,10 @@ sysinclude_HEADERS = asoundlib.h
|
|||
|
||||
# This is the order they will be concatenated into asoundlib.h!
|
||||
#
|
||||
header_files=header.h version.h global.h input.h output.h error.h mixer.h \
|
||||
header_files=header.h version.h global.h input.h output.h error.h \
|
||||
pcm.h pcm_m4.h rawmidi.h rawmidi_m4.h timer.h \
|
||||
hwdep.h hwdep_m4.h control.h control_m4.h \
|
||||
mixer.h mixer_m4.h \
|
||||
seq.h seqmid.h seq_midi_event.h \
|
||||
conv.h instr.h conf.h footer.h
|
||||
|
||||
|
|
|
|||
|
|
@ -83,17 +83,22 @@ typedef struct {
|
|||
#define SND_CTL_IOCTL_READ _IOR('U', 0xf1, snd_ctl_event_t)
|
||||
#define SND_CTL_IOCTL_CLOSE _IO ('U', 0xf2)
|
||||
#define SND_CTL_IOCTL_POLL_DESCRIPTOR _IO ('U', 0xf3)
|
||||
#define SND_CTL_IOCTL_ASYNC _IO ('U', 0xf4)
|
||||
|
||||
typedef struct {
|
||||
int result;
|
||||
int cmd;
|
||||
union {
|
||||
struct {
|
||||
int sig;
|
||||
pid_t pid;
|
||||
} async;
|
||||
int device;
|
||||
snd_ctl_card_info_t hw_info;
|
||||
snd_ctl_element_list_t clist;
|
||||
snd_ctl_element_info_t cinfo;
|
||||
snd_ctl_element_t cread;
|
||||
snd_ctl_element_t cwrite;
|
||||
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_hwdep_info_t hwdep_info;
|
||||
snd_pcm_info_t pcm_info;
|
||||
int pcm_prefer_subdevice;
|
||||
|
|
|
|||
|
|
@ -7,21 +7,21 @@
|
|||
|
||||
typedef struct sndrv_aes_iec958 snd_aes_iec958_t;
|
||||
typedef struct _snd_ctl_card_info snd_ctl_card_info_t;
|
||||
typedef struct _snd_ctl_element_id snd_ctl_element_id_t;
|
||||
typedef struct _snd_ctl_element_list snd_ctl_element_list_t;
|
||||
typedef struct _snd_ctl_element_info snd_ctl_element_info_t;
|
||||
typedef struct _snd_ctl_element snd_ctl_element_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_event snd_ctl_event_t;
|
||||
|
||||
#ifdef SND_ENUM_TYPECHECK
|
||||
typedef struct __snd_card_type *snd_card_type_t;
|
||||
typedef struct __snd_ctl_element_type *snd_ctl_element_type_t;
|
||||
typedef struct __snd_ctl_element_iface *snd_ctl_element_iface_t;
|
||||
typedef struct __snd_ctl_elem_type *snd_ctl_elem_type_t;
|
||||
typedef struct __snd_ctl_elem_iface *snd_ctl_elem_iface_t;
|
||||
typedef struct __snd_ctl_event_type *snd_ctl_event_type_t;
|
||||
#else
|
||||
typedef enum sndrv_card_type snd_card_type_t;
|
||||
typedef enum sndrv_ctl_element_type snd_ctl_element_type_t;
|
||||
typedef enum sndrv_ctl_element_iface snd_ctl_element_iface_t;
|
||||
typedef enum sndrv_ctl_elem_type snd_ctl_elem_type_t;
|
||||
typedef enum sndrv_ctl_elem_iface snd_ctl_elem_iface_t;
|
||||
typedef enum sndrv_ctl_event_type snd_ctl_event_type_t;
|
||||
#endif
|
||||
|
||||
|
|
@ -95,22 +95,22 @@ typedef enum sndrv_ctl_event_type snd_ctl_event_type_t;
|
|||
#define SND_CARD_TYPE_VIA8233 ((snd_card_type_t) SNDRV_CARD_TYPE_VIA8233)
|
||||
#define SND_CARD_TYPE_LAST ((snd_card_type_t) SNDRV_CARD_TYPE_LAST)
|
||||
|
||||
#define SND_CTL_ELEMENT_TYPE_NONE ((snd_ctl_element_type_t) SNDRV_CTL_ELEMENT_TYPE_NONE)
|
||||
#define SND_CTL_ELEMENT_TYPE_BOOLEAN ((snd_ctl_element_type_t) SNDRV_CTL_ELEMENT_TYPE_BOOLEAN)
|
||||
#define SND_CTL_ELEMENT_TYPE_INTEGER ((snd_ctl_element_type_t) SNDRV_CTL_ELEMENT_TYPE_INTEGER)
|
||||
#define SND_CTL_ELEMENT_TYPE_ENUMERATED ((snd_ctl_element_type_t) SNDRV_CTL_ELEMENT_TYPE_ENUMERATED)
|
||||
#define SND_CTL_ELEMENT_TYPE_BYTES ((snd_ctl_element_type_t) SNDRV_CTL_ELEMENT_TYPE_BYTES)
|
||||
#define SND_CTL_ELEMENT_TYPE_IEC958 ((snd_ctl_element_type_t) SNDRV_CTL_ELEMENT_TYPE_IEC958)
|
||||
#define SND_CTL_ELEMENT_TYPE_LAST ((snd_ctl_element_type_t) SNDRV_CTL_ELEMENT_TYPE_LAST)
|
||||
#define SND_CTL_ELEM_TYPE_NONE ((snd_ctl_elem_type_t) SNDRV_CTL_ELEM_TYPE_NONE)
|
||||
#define SND_CTL_ELEM_TYPE_BOOLEAN ((snd_ctl_elem_type_t) SNDRV_CTL_ELEM_TYPE_BOOLEAN)
|
||||
#define SND_CTL_ELEM_TYPE_INTEGER ((snd_ctl_elem_type_t) SNDRV_CTL_ELEM_TYPE_INTEGER)
|
||||
#define SND_CTL_ELEM_TYPE_ENUMERATED ((snd_ctl_elem_type_t) SNDRV_CTL_ELEM_TYPE_ENUMERATED)
|
||||
#define SND_CTL_ELEM_TYPE_BYTES ((snd_ctl_elem_type_t) SNDRV_CTL_ELEM_TYPE_BYTES)
|
||||
#define SND_CTL_ELEM_TYPE_IEC958 ((snd_ctl_elem_type_t) SNDRV_CTL_ELEM_TYPE_IEC958)
|
||||
#define SND_CTL_ELEM_TYPE_LAST ((snd_ctl_elem_type_t) SNDRV_CTL_ELEM_TYPE_LAST)
|
||||
|
||||
#define SND_CTL_ELEMENT_IFACE_CARD ((snd_ctl_element_iface_t) SNDRV_CTL_ELEMENT_IFACE_CARD)
|
||||
#define SND_CTL_ELEMENT_IFACE_HWDEP ((snd_ctl_element_iface_t) SNDRV_CTL_ELEMENT_IFACE_HWDEP)
|
||||
#define SND_CTL_ELEMENT_IFACE_MIXER ((snd_ctl_element_iface_t) SNDRV_CTL_ELEMENT_IFACE_MIXER)
|
||||
#define SND_CTL_ELEMENT_IFACE_PCM ((snd_ctl_element_iface_t) SNDRV_CTL_ELEMENT_IFACE_PCM)
|
||||
#define SND_CTL_ELEMENT_IFACE_RAWMIDI ((snd_ctl_element_iface_t) SNDRV_CTL_ELEMENT_IFACE_RAWMIDI)
|
||||
#define SND_CTL_ELEMENT_IFACE_TIMER ((snd_ctl_element_iface_t) SNDRV_CTL_ELEMENT_IFACE_TIMER)
|
||||
#define SND_CTL_ELEMENT_IFACE_SEQUENCER ((snd_ctl_element_iface_t) SNDRV_CTL_ELEMENT_IFACE_SEQUENCER)
|
||||
#define SND_CTL_ELEMENT_IFACE_LAST ((snd_ctl_element_iface_t) SNDRV_CTL_ELEMENT_IFACE_LAST)
|
||||
#define SND_CTL_ELEM_IFACE_CARD ((snd_ctl_elem_iface_t) SNDRV_CTL_ELEM_IFACE_CARD)
|
||||
#define SND_CTL_ELEM_IFACE_HWDEP ((snd_ctl_elem_iface_t) SNDRV_CTL_ELEM_IFACE_HWDEP)
|
||||
#define SND_CTL_ELEM_IFACE_MIXER ((snd_ctl_elem_iface_t) SNDRV_CTL_ELEM_IFACE_MIXER)
|
||||
#define SND_CTL_ELEM_IFACE_PCM ((snd_ctl_elem_iface_t) SNDRV_CTL_ELEM_IFACE_PCM)
|
||||
#define SND_CTL_ELEM_IFACE_RAWMIDI ((snd_ctl_elem_iface_t) SNDRV_CTL_ELEM_IFACE_RAWMIDI)
|
||||
#define SND_CTL_ELEM_IFACE_TIMER ((snd_ctl_elem_iface_t) SNDRV_CTL_ELEM_IFACE_TIMER)
|
||||
#define SND_CTL_ELEM_IFACE_SEQUENCER ((snd_ctl_elem_iface_t) SNDRV_CTL_ELEM_IFACE_SEQUENCER)
|
||||
#define SND_CTL_ELEM_IFACE_LAST ((snd_ctl_elem_iface_t) SNDRV_CTL_ELEM_IFACE_LAST)
|
||||
|
||||
#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)
|
||||
|
|
@ -136,7 +136,6 @@ typedef enum _snd_ctl_type snd_ctl_type_t;
|
|||
#define SND_CTL_TYPE_INET ((snd_ctl_type_t) SND_CTL_TYPE_INET)
|
||||
|
||||
typedef struct _snd_ctl snd_ctl_t;
|
||||
typedef struct _snd_ctl_callbacks snd_ctl_callbacks_t;
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
|
|
@ -155,35 +154,37 @@ int snd_defaults_pcm_device(void);
|
|||
int snd_defaults_rawmidi_card(void);
|
||||
int snd_defaults_rawmidi_device(void);
|
||||
|
||||
snd_ctl_type_t snd_ctl_type(snd_ctl_t *handle);
|
||||
int snd_ctl_open(snd_ctl_t **handle, char *name);
|
||||
int snd_ctl_close(snd_ctl_t *handle);
|
||||
int snd_ctl_card(snd_ctl_t *handle);
|
||||
int snd_ctl_poll_descriptor(snd_ctl_t *handle);
|
||||
int snd_ctl_card_info(snd_ctl_t *handle, snd_ctl_card_info_t *info);
|
||||
int snd_ctl_clist(snd_ctl_t *handle, snd_ctl_element_list_t * list);
|
||||
int snd_ctl_element_info(snd_ctl_t *handle, snd_ctl_element_info_t * sw);
|
||||
int snd_ctl_element_read(snd_ctl_t *handle, snd_ctl_element_t * control);
|
||||
int snd_ctl_element_write(snd_ctl_t *handle, snd_ctl_element_t * control);
|
||||
int snd_ctl_hwdep_next_device(snd_ctl_t *handle, int * device);
|
||||
int snd_ctl_hwdep_info(snd_ctl_t *handle, snd_hwdep_info_t * info);
|
||||
int snd_ctl_pcm_next_device(snd_ctl_t *handle, int *device);
|
||||
int snd_ctl_pcm_info(snd_ctl_t *handle, snd_pcm_info_t * info);
|
||||
int snd_ctl_pcm_prefer_subdevice(snd_ctl_t *handle, int subdev);
|
||||
int snd_ctl_rawmidi_next_device(snd_ctl_t *handle, int * device);
|
||||
int snd_ctl_rawmidi_info(snd_ctl_t *handle, snd_rawmidi_info_t * info);
|
||||
int snd_ctl_rawmidi_prefer_subdevice(snd_ctl_t *handle, int subdev);
|
||||
snd_ctl_type_t snd_ctl_type(snd_ctl_t *ctl);
|
||||
int snd_ctl_open(snd_ctl_t **ctl, 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);
|
||||
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_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);
|
||||
int snd_ctl_pcm_info(snd_ctl_t *ctl, snd_pcm_info_t * info);
|
||||
int snd_ctl_pcm_prefer_subdevice(snd_ctl_t *ctl, int subdev);
|
||||
int snd_ctl_rawmidi_next_device(snd_ctl_t *ctl, int * device);
|
||||
int snd_ctl_rawmidi_info(snd_ctl_t *ctl, snd_rawmidi_info_t * info);
|
||||
int snd_ctl_rawmidi_prefer_subdevice(snd_ctl_t *ctl, int subdev);
|
||||
|
||||
int snd_ctl_read(snd_ctl_t *handle, snd_ctl_callbacks_t * callbacks);
|
||||
int snd_ctl_read(snd_ctl_t *ctl, snd_ctl_event_t *event);
|
||||
int snd_ctl_wait(snd_ctl_t *ctl, int timeout);
|
||||
|
||||
void snd_ctl_element_set_bytes(snd_ctl_element_t *obj, void *data, size_t size);
|
||||
void snd_ctl_elem_set_bytes(snd_ctl_elem_t *obj, void *data, size_t size);
|
||||
|
||||
const char *snd_ctl_element_type_name(snd_ctl_element_type_t type);
|
||||
const char *snd_ctl_element_iface_name(snd_ctl_element_iface_t iface);
|
||||
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);
|
||||
|
||||
int snd_ctl_element_list_alloc_space(snd_ctl_element_list_t *obj, unsigned int entries);
|
||||
void snd_ctl_element_list_free_space(snd_ctl_element_list_t *obj);
|
||||
int snd_ctl_elem_list_alloc_space(snd_ctl_elem_list_t *obj, unsigned int entries);
|
||||
void snd_ctl_elem_list_free_space(snd_ctl_elem_list_t *obj);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
|
@ -193,41 +194,35 @@ void snd_ctl_element_list_free_space(snd_ctl_element_list_t *obj);
|
|||
* Highlevel API for controls
|
||||
*/
|
||||
|
||||
typedef struct _snd_hctl_element_list snd_hctl_element_list_t;
|
||||
typedef struct _snd_hctl_element snd_hctl_element_t;
|
||||
typedef struct _snd_hctl_elem snd_hctl_elem_t;
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef int (*snd_ctl_hsort_t)(const snd_hctl_element_t *c1, const snd_hctl_element_t *c2);
|
||||
typedef void (*snd_ctl_hcallback_rebuild_t)(snd_ctl_t *handle, void *private_data);
|
||||
typedef void (*snd_ctl_hcallback_add_t)(snd_ctl_t *handle, void *private_data, snd_hctl_element_t *helem);
|
||||
typedef void (*snd_hctl_element_callback_t)(snd_ctl_t *handle, snd_hctl_element_t *helem);
|
||||
typedef void (*snd_hctl_element_private_free_t)(snd_hctl_element_t *helem);
|
||||
typedef int (*snd_hctl_compare_t)(const snd_hctl_elem_t *e1,
|
||||
const snd_hctl_elem_t *e2);
|
||||
typedef int (*snd_hctl_callback_t)(snd_ctl_t *ctl,
|
||||
snd_ctl_event_type_t event,
|
||||
snd_hctl_elem_t *elem);
|
||||
typedef int (*snd_hctl_elem_callback_t)(snd_hctl_elem_t *elem,
|
||||
snd_ctl_event_type_t event);
|
||||
|
||||
int snd_ctl_hbuild(snd_ctl_t *handle, snd_ctl_hsort_t csort);
|
||||
int snd_ctl_hfree(snd_ctl_t *handle);
|
||||
snd_hctl_element_t *snd_ctl_hfirst(snd_ctl_t *handle);
|
||||
snd_hctl_element_t *snd_ctl_hlast(snd_ctl_t *handle);
|
||||
snd_hctl_element_t *snd_ctl_hnext(snd_ctl_t *handle, snd_hctl_element_t *helem);
|
||||
snd_hctl_element_t *snd_ctl_hprev(snd_ctl_t *handle, snd_hctl_element_t *helem);
|
||||
int snd_ctl_hcount(snd_ctl_t *handle);
|
||||
snd_hctl_element_t *snd_ctl_hfind(snd_ctl_t *handle, snd_ctl_element_id_t *id);
|
||||
int snd_ctl_hlist(snd_ctl_t *handle, snd_hctl_element_list_t *hlist);
|
||||
int snd_ctl_hsort(const snd_hctl_element_t *c1, const snd_hctl_element_t *c2);
|
||||
int snd_ctl_hresort(snd_ctl_t *handle, snd_ctl_hsort_t csort);
|
||||
int snd_ctl_hcallback_rebuild(snd_ctl_t *handle, snd_ctl_hcallback_rebuild_t callback, void *private_data);
|
||||
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 (*hctl_element_free)(snd_hctl_element_t *helem));
|
||||
int snd_ctl_hbag_add(void **bag, snd_hctl_element_t *helem);
|
||||
int snd_ctl_hbag_del(void **bag, snd_hctl_element_t *helem);
|
||||
snd_hctl_element_t *snd_ctl_hbag_find(void **bag, snd_ctl_element_id_t *id);
|
||||
int snd_hctl_element_list_alloc_space(snd_hctl_element_list_t *obj, unsigned int entries);
|
||||
void snd_hctl_element_list_free_space(snd_hctl_element_list_t *obj);
|
||||
int snd_hctl_build(snd_ctl_t *ctl);
|
||||
snd_hctl_elem_t *snd_hctl_first_elem(snd_ctl_t *ctl);
|
||||
snd_hctl_elem_t *snd_hctl_last_elem(snd_ctl_t *ctl);
|
||||
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_ctl_t *ctl);
|
||||
snd_hctl_elem_t *snd_hctl_find_elem(snd_ctl_t *ctl, const snd_ctl_elem_id_t *id);
|
||||
void snd_hctl_set_callback(snd_ctl_t *ctl, snd_hctl_callback_t callback);
|
||||
void snd_hctl_set_callback_private(snd_ctl_t *ctl, void *private);
|
||||
void *snd_hctl_get_callback_private(snd_ctl_t *ctl);
|
||||
int snd_hctl_event(snd_ctl_t *ctl, snd_ctl_event_t *event);
|
||||
int snd_hctl_events(snd_ctl_t *ctl);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
|
|
|||
|
|
@ -2,35 +2,35 @@
|
|||
extern "C" {
|
||||
#endif
|
||||
|
||||
size_t snd_ctl_element_id_sizeof();
|
||||
#define snd_ctl_element_id_alloca(ptr) ({ assert(ptr); *ptr = (snd_ctl_element_id_t *) alloca(snd_ctl_element_id_sizeof()); memset(*ptr, 0, snd_ctl_element_id_sizeof()); 0; })
|
||||
int snd_ctl_element_id_malloc(snd_ctl_element_id_t **ptr);
|
||||
void snd_ctl_element_id_free(snd_ctl_element_id_t *obj);
|
||||
void snd_ctl_element_id_copy(snd_ctl_element_id_t *dst, const snd_ctl_element_id_t *src);
|
||||
size_t snd_ctl_elem_id_sizeof();
|
||||
#define snd_ctl_elem_id_alloca(ptr) ({ assert(ptr); *ptr = (snd_ctl_elem_id_t *) alloca(snd_ctl_elem_id_sizeof()); memset(*ptr, 0, snd_ctl_elem_id_sizeof()); 0; })
|
||||
int snd_ctl_elem_id_malloc(snd_ctl_elem_id_t **ptr);
|
||||
void snd_ctl_elem_id_free(snd_ctl_elem_id_t *obj);
|
||||
void snd_ctl_elem_id_copy(snd_ctl_elem_id_t *dst, const snd_ctl_elem_id_t *src);
|
||||
|
||||
unsigned int snd_ctl_element_id_get_numid(const snd_ctl_element_id_t *obj);
|
||||
unsigned int snd_ctl_elem_id_get_numid(const snd_ctl_elem_id_t *obj);
|
||||
|
||||
snd_ctl_element_iface_t snd_ctl_element_id_get_interface(const snd_ctl_element_id_t *obj);
|
||||
snd_ctl_elem_iface_t snd_ctl_elem_id_get_interface(const snd_ctl_elem_id_t *obj);
|
||||
|
||||
unsigned int snd_ctl_element_id_get_device(const snd_ctl_element_id_t *obj);
|
||||
unsigned int snd_ctl_elem_id_get_device(const snd_ctl_elem_id_t *obj);
|
||||
|
||||
unsigned int snd_ctl_element_id_get_subdevice(const snd_ctl_element_id_t *obj);
|
||||
unsigned int snd_ctl_elem_id_get_subdevice(const snd_ctl_elem_id_t *obj);
|
||||
|
||||
const char *snd_ctl_element_id_get_name(const snd_ctl_element_id_t *obj);
|
||||
const char *snd_ctl_elem_id_get_name(const snd_ctl_elem_id_t *obj);
|
||||
|
||||
unsigned int snd_ctl_element_id_get_index(const snd_ctl_element_id_t *obj);
|
||||
unsigned int snd_ctl_elem_id_get_index(const snd_ctl_elem_id_t *obj);
|
||||
|
||||
void snd_ctl_element_id_set_numid(snd_ctl_element_id_t *obj, unsigned int val);
|
||||
void snd_ctl_elem_id_set_numid(snd_ctl_elem_id_t *obj, unsigned int val);
|
||||
|
||||
void snd_ctl_element_id_set_interface(snd_ctl_element_id_t *obj, snd_ctl_element_iface_t val);
|
||||
void snd_ctl_elem_id_set_interface(snd_ctl_elem_id_t *obj, snd_ctl_elem_iface_t val);
|
||||
|
||||
void snd_ctl_element_id_set_device(snd_ctl_element_id_t *obj, unsigned int val);
|
||||
void snd_ctl_elem_id_set_device(snd_ctl_elem_id_t *obj, unsigned int val);
|
||||
|
||||
void snd_ctl_element_id_set_subdevice(snd_ctl_element_id_t *obj, unsigned int val);
|
||||
void snd_ctl_elem_id_set_subdevice(snd_ctl_elem_id_t *obj, unsigned int val);
|
||||
|
||||
void snd_ctl_element_id_set_name(snd_ctl_element_id_t *obj, const char *val);
|
||||
void snd_ctl_elem_id_set_name(snd_ctl_elem_id_t *obj, const char *val);
|
||||
|
||||
void snd_ctl_element_id_set_index(snd_ctl_element_id_t *obj, unsigned int val);
|
||||
void snd_ctl_elem_id_set_index(snd_ctl_elem_id_t *obj, unsigned int val);
|
||||
|
||||
size_t snd_ctl_card_info_sizeof();
|
||||
#define snd_ctl_card_info_alloca(ptr) ({ assert(ptr); *ptr = (snd_ctl_card_info_t *) alloca(snd_ctl_card_info_sizeof()); memset(*ptr, 0, snd_ctl_card_info_sizeof()); 0; })
|
||||
|
|
@ -64,9 +64,9 @@ snd_ctl_event_type_t snd_ctl_event_get_type(const snd_ctl_event_t *obj);
|
|||
|
||||
unsigned int snd_ctl_event_get_numid(const snd_ctl_event_t *obj);
|
||||
|
||||
void snd_ctl_event_get_id(const snd_ctl_event_t *obj, snd_ctl_element_id_t *ptr);
|
||||
void snd_ctl_event_get_id(const snd_ctl_event_t *obj, snd_ctl_elem_id_t *ptr);
|
||||
|
||||
snd_ctl_element_iface_t snd_ctl_event_get_interface(const snd_ctl_event_t *obj);
|
||||
snd_ctl_elem_iface_t snd_ctl_event_get_interface(const snd_ctl_event_t *obj);
|
||||
|
||||
unsigned int snd_ctl_event_get_device(const snd_ctl_event_t *obj);
|
||||
|
||||
|
|
@ -76,207 +76,175 @@ const char *snd_ctl_event_get_name(const snd_ctl_event_t *obj);
|
|||
|
||||
unsigned int snd_ctl_event_get_index(const snd_ctl_event_t *obj);
|
||||
|
||||
size_t snd_ctl_element_list_sizeof();
|
||||
#define snd_ctl_element_list_alloca(ptr) ({ assert(ptr); *ptr = (snd_ctl_element_list_t *) alloca(snd_ctl_element_list_sizeof()); memset(*ptr, 0, snd_ctl_element_list_sizeof()); 0; })
|
||||
int snd_ctl_element_list_malloc(snd_ctl_element_list_t **ptr);
|
||||
void snd_ctl_element_list_free(snd_ctl_element_list_t *obj);
|
||||
void snd_ctl_element_list_copy(snd_ctl_element_list_t *dst, const snd_ctl_element_list_t *src);
|
||||
size_t snd_ctl_elem_list_sizeof();
|
||||
#define snd_ctl_elem_list_alloca(ptr) ({ assert(ptr); *ptr = (snd_ctl_elem_list_t *) alloca(snd_ctl_elem_list_sizeof()); memset(*ptr, 0, snd_ctl_elem_list_sizeof()); 0; })
|
||||
int snd_ctl_elem_list_malloc(snd_ctl_elem_list_t **ptr);
|
||||
void snd_ctl_elem_list_free(snd_ctl_elem_list_t *obj);
|
||||
void snd_ctl_elem_list_copy(snd_ctl_elem_list_t *dst, const snd_ctl_elem_list_t *src);
|
||||
|
||||
void snd_ctl_element_list_set_offset(snd_ctl_element_list_t *obj, unsigned int val);
|
||||
void snd_ctl_elem_list_set_offset(snd_ctl_elem_list_t *obj, unsigned int val);
|
||||
|
||||
unsigned int snd_ctl_element_list_get_used(const snd_ctl_element_list_t *obj);
|
||||
unsigned int snd_ctl_elem_list_get_used(const snd_ctl_elem_list_t *obj);
|
||||
|
||||
unsigned int snd_ctl_element_list_get_count(const snd_ctl_element_list_t *obj);
|
||||
unsigned int snd_ctl_elem_list_get_count(const snd_ctl_elem_list_t *obj);
|
||||
|
||||
void snd_ctl_element_list_get_id(const snd_ctl_element_list_t *obj, unsigned int idx, snd_ctl_element_id_t *ptr);
|
||||
void snd_ctl_elem_list_get_id(const snd_ctl_elem_list_t *obj, unsigned int idx, snd_ctl_elem_id_t *ptr);
|
||||
|
||||
unsigned int snd_ctl_element_list_get_numid(const snd_ctl_element_list_t *obj, unsigned int idx);
|
||||
unsigned int snd_ctl_elem_list_get_numid(const snd_ctl_elem_list_t *obj, unsigned int idx);
|
||||
|
||||
snd_ctl_element_iface_t snd_ctl_element_list_get_interface(const snd_ctl_element_list_t *obj, unsigned int idx);
|
||||
snd_ctl_elem_iface_t snd_ctl_elem_list_get_interface(const snd_ctl_elem_list_t *obj, unsigned int idx);
|
||||
|
||||
unsigned int snd_ctl_element_list_get_device(const snd_ctl_element_list_t *obj, unsigned int idx);
|
||||
unsigned int snd_ctl_elem_list_get_device(const snd_ctl_elem_list_t *obj, unsigned int idx);
|
||||
|
||||
unsigned int snd_ctl_element_list_get_subdevice(const snd_ctl_element_list_t *obj, unsigned int idx);
|
||||
unsigned int snd_ctl_elem_list_get_subdevice(const snd_ctl_elem_list_t *obj, unsigned int idx);
|
||||
|
||||
const char *snd_ctl_element_list_get_name(const snd_ctl_element_list_t *obj, unsigned int idx);
|
||||
const char *snd_ctl_elem_list_get_name(const snd_ctl_elem_list_t *obj, unsigned int idx);
|
||||
|
||||
unsigned int snd_ctl_element_list_get_index(const snd_ctl_element_list_t *obj, unsigned int idx);
|
||||
unsigned int snd_ctl_elem_list_get_index(const snd_ctl_elem_list_t *obj, unsigned int idx);
|
||||
|
||||
size_t snd_ctl_element_info_sizeof();
|
||||
#define snd_ctl_element_info_alloca(ptr) ({ assert(ptr); *ptr = (snd_ctl_element_info_t *) alloca(snd_ctl_element_info_sizeof()); memset(*ptr, 0, snd_ctl_element_info_sizeof()); 0; })
|
||||
int snd_ctl_element_info_malloc(snd_ctl_element_info_t **ptr);
|
||||
void snd_ctl_element_info_free(snd_ctl_element_info_t *obj);
|
||||
void snd_ctl_element_info_copy(snd_ctl_element_info_t *dst, const snd_ctl_element_info_t *src);
|
||||
size_t snd_ctl_elem_info_sizeof();
|
||||
#define snd_ctl_elem_info_alloca(ptr) ({ assert(ptr); *ptr = (snd_ctl_elem_info_t *) alloca(snd_ctl_elem_info_sizeof()); memset(*ptr, 0, snd_ctl_elem_info_sizeof()); 0; })
|
||||
int snd_ctl_elem_info_malloc(snd_ctl_elem_info_t **ptr);
|
||||
void snd_ctl_elem_info_free(snd_ctl_elem_info_t *obj);
|
||||
void snd_ctl_elem_info_copy(snd_ctl_elem_info_t *dst, const snd_ctl_elem_info_t *src);
|
||||
|
||||
snd_ctl_element_type_t snd_ctl_element_info_get_type(const snd_ctl_element_info_t *obj);
|
||||
snd_ctl_elem_type_t snd_ctl_elem_info_get_type(const snd_ctl_elem_info_t *obj);
|
||||
|
||||
int snd_ctl_element_info_is_readable(const snd_ctl_element_info_t *obj);
|
||||
int snd_ctl_elem_info_is_readable(const snd_ctl_elem_info_t *obj);
|
||||
|
||||
int snd_ctl_element_info_is_writable(const snd_ctl_element_info_t *obj);
|
||||
int snd_ctl_elem_info_is_writable(const snd_ctl_elem_info_t *obj);
|
||||
|
||||
int snd_ctl_element_info_is_volatile(const snd_ctl_element_info_t *obj);
|
||||
int snd_ctl_elem_info_is_volatile(const snd_ctl_elem_info_t *obj);
|
||||
|
||||
int snd_ctl_element_info_is_inactive(const snd_ctl_element_info_t *obj);
|
||||
int snd_ctl_elem_info_is_inactive(const snd_ctl_elem_info_t *obj);
|
||||
|
||||
int snd_ctl_element_info_is_locked(const snd_ctl_element_info_t *obj);
|
||||
int snd_ctl_elem_info_is_locked(const snd_ctl_elem_info_t *obj);
|
||||
|
||||
int snd_ctl_element_info_is_indirect(const snd_ctl_element_info_t *obj);
|
||||
int snd_ctl_elem_info_is_indirect(const snd_ctl_elem_info_t *obj);
|
||||
|
||||
unsigned int snd_ctl_element_info_get_count(const snd_ctl_element_info_t *obj);
|
||||
unsigned int snd_ctl_elem_info_get_count(const snd_ctl_elem_info_t *obj);
|
||||
|
||||
long snd_ctl_element_info_get_min(const snd_ctl_element_info_t *obj);
|
||||
long snd_ctl_elem_info_get_min(const snd_ctl_elem_info_t *obj);
|
||||
|
||||
long snd_ctl_element_info_get_max(const snd_ctl_element_info_t *obj);
|
||||
long snd_ctl_elem_info_get_max(const snd_ctl_elem_info_t *obj);
|
||||
|
||||
long snd_ctl_element_info_get_step(const snd_ctl_element_info_t *obj);
|
||||
long snd_ctl_elem_info_get_step(const snd_ctl_elem_info_t *obj);
|
||||
|
||||
unsigned int snd_ctl_element_info_get_items(const snd_ctl_element_info_t *obj);
|
||||
unsigned int snd_ctl_elem_info_get_items(const snd_ctl_elem_info_t *obj);
|
||||
|
||||
void snd_ctl_element_info_set_item(snd_ctl_element_info_t *obj, unsigned int val);
|
||||
void snd_ctl_elem_info_set_item(snd_ctl_elem_info_t *obj, unsigned int val);
|
||||
|
||||
const char *snd_ctl_element_info_get_item_name(const snd_ctl_element_info_t *obj);
|
||||
const char *snd_ctl_elem_info_get_item_name(const snd_ctl_elem_info_t *obj);
|
||||
|
||||
void snd_ctl_element_info_get_id(const snd_ctl_element_info_t *obj, snd_ctl_element_id_t *ptr);
|
||||
void snd_ctl_elem_info_get_id(const snd_ctl_elem_info_t *obj, snd_ctl_elem_id_t *ptr);
|
||||
|
||||
unsigned int snd_ctl_element_info_get_numid(const snd_ctl_element_info_t *obj);
|
||||
unsigned int snd_ctl_elem_info_get_numid(const snd_ctl_elem_info_t *obj);
|
||||
|
||||
snd_ctl_element_iface_t snd_ctl_element_info_get_interface(const snd_ctl_element_info_t *obj);
|
||||
snd_ctl_elem_iface_t snd_ctl_elem_info_get_interface(const snd_ctl_elem_info_t *obj);
|
||||
|
||||
unsigned int snd_ctl_element_info_get_device(const snd_ctl_element_info_t *obj);
|
||||
unsigned int snd_ctl_elem_info_get_device(const snd_ctl_elem_info_t *obj);
|
||||
|
||||
unsigned int snd_ctl_element_info_get_subdevice(const snd_ctl_element_info_t *obj);
|
||||
unsigned int snd_ctl_elem_info_get_subdevice(const snd_ctl_elem_info_t *obj);
|
||||
|
||||
const char *snd_ctl_element_info_get_name(const snd_ctl_element_info_t *obj);
|
||||
const char *snd_ctl_elem_info_get_name(const snd_ctl_elem_info_t *obj);
|
||||
|
||||
unsigned int snd_ctl_element_info_get_index(const snd_ctl_element_info_t *obj);
|
||||
unsigned int snd_ctl_elem_info_get_index(const snd_ctl_elem_info_t *obj);
|
||||
|
||||
void snd_ctl_element_info_set_id(snd_ctl_element_info_t *obj, const snd_ctl_element_id_t *ptr);
|
||||
void snd_ctl_elem_info_set_id(snd_ctl_elem_info_t *obj, const snd_ctl_elem_id_t *ptr);
|
||||
|
||||
void snd_ctl_element_info_set_numid(snd_ctl_element_info_t *obj, unsigned int val);
|
||||
void snd_ctl_elem_info_set_numid(snd_ctl_elem_info_t *obj, unsigned int val);
|
||||
|
||||
void snd_ctl_element_info_set_interface(snd_ctl_element_info_t *obj, snd_ctl_element_iface_t val);
|
||||
void snd_ctl_elem_info_set_interface(snd_ctl_elem_info_t *obj, snd_ctl_elem_iface_t val);
|
||||
|
||||
void snd_ctl_element_info_set_device(snd_ctl_element_info_t *obj, unsigned int val);
|
||||
void snd_ctl_elem_info_set_device(snd_ctl_elem_info_t *obj, unsigned int val);
|
||||
|
||||
void snd_ctl_element_info_set_subdevice(snd_ctl_element_info_t *obj, unsigned int val);
|
||||
void snd_ctl_elem_info_set_subdevice(snd_ctl_elem_info_t *obj, unsigned int val);
|
||||
|
||||
void snd_ctl_element_info_set_name(snd_ctl_element_info_t *obj, const char *val);
|
||||
void snd_ctl_elem_info_set_name(snd_ctl_elem_info_t *obj, const char *val);
|
||||
|
||||
void snd_ctl_element_info_set_index(snd_ctl_element_info_t *obj, unsigned int val);
|
||||
void snd_ctl_elem_info_set_index(snd_ctl_elem_info_t *obj, unsigned int val);
|
||||
|
||||
size_t snd_ctl_element_sizeof();
|
||||
#define snd_ctl_element_alloca(ptr) ({ assert(ptr); *ptr = (snd_ctl_element_t *) alloca(snd_ctl_element_sizeof()); memset(*ptr, 0, snd_ctl_element_sizeof()); 0; })
|
||||
int snd_ctl_element_malloc(snd_ctl_element_t **ptr);
|
||||
void snd_ctl_element_free(snd_ctl_element_t *obj);
|
||||
void snd_ctl_element_copy(snd_ctl_element_t *dst, const snd_ctl_element_t *src);
|
||||
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);
|
||||
|
||||
void snd_ctl_element_get_id(const snd_ctl_element_t *obj, snd_ctl_element_id_t *ptr);
|
||||
void snd_ctl_elem_get_id(const snd_ctl_elem_t *obj, snd_ctl_elem_id_t *ptr);
|
||||
|
||||
unsigned int snd_ctl_element_get_numid(const snd_ctl_element_t *obj);
|
||||
unsigned int snd_ctl_elem_get_numid(const snd_ctl_elem_t *obj);
|
||||
|
||||
snd_ctl_element_iface_t snd_ctl_element_get_interface(const snd_ctl_element_t *obj);
|
||||
snd_ctl_elem_iface_t snd_ctl_elem_get_interface(const snd_ctl_elem_t *obj);
|
||||
|
||||
unsigned int snd_ctl_element_get_device(const snd_ctl_element_t *obj);
|
||||
unsigned int snd_ctl_elem_get_device(const snd_ctl_elem_t *obj);
|
||||
|
||||
unsigned int snd_ctl_element_get_subdevice(const snd_ctl_element_t *obj);
|
||||
unsigned int snd_ctl_elem_get_subdevice(const snd_ctl_elem_t *obj);
|
||||
|
||||
const char *snd_ctl_element_get_name(const snd_ctl_element_t *obj);
|
||||
const char *snd_ctl_elem_get_name(const snd_ctl_elem_t *obj);
|
||||
|
||||
unsigned int snd_ctl_element_get_index(const snd_ctl_element_t *obj);
|
||||
unsigned int snd_ctl_elem_get_index(const snd_ctl_elem_t *obj);
|
||||
|
||||
void snd_ctl_element_set_id(snd_ctl_element_t *obj, const snd_ctl_element_id_t *ptr);
|
||||
void snd_ctl_elem_set_id(snd_ctl_elem_t *obj, const snd_ctl_elem_id_t *ptr);
|
||||
|
||||
void snd_ctl_element_set_numid(snd_ctl_element_t *obj, unsigned int val);
|
||||
void snd_ctl_elem_set_numid(snd_ctl_elem_t *obj, unsigned int val);
|
||||
|
||||
void snd_ctl_element_set_interface(snd_ctl_element_t *obj, snd_ctl_element_iface_t val);
|
||||
void snd_ctl_elem_set_interface(snd_ctl_elem_t *obj, snd_ctl_elem_iface_t val);
|
||||
|
||||
void snd_ctl_element_set_device(snd_ctl_element_t *obj, unsigned int val);
|
||||
void snd_ctl_elem_set_device(snd_ctl_elem_t *obj, unsigned int val);
|
||||
|
||||
void snd_ctl_element_set_subdevice(snd_ctl_element_t *obj, unsigned int val);
|
||||
void snd_ctl_elem_set_subdevice(snd_ctl_elem_t *obj, unsigned int val);
|
||||
|
||||
void snd_ctl_element_set_name(snd_ctl_element_t *obj, const char *val);
|
||||
void snd_ctl_elem_set_name(snd_ctl_elem_t *obj, const char *val);
|
||||
|
||||
void snd_ctl_element_set_index(snd_ctl_element_t *obj, unsigned int val);
|
||||
void snd_ctl_elem_set_index(snd_ctl_elem_t *obj, unsigned int val);
|
||||
|
||||
long snd_ctl_element_get_boolean(const snd_ctl_element_t *obj, unsigned int idx);
|
||||
long snd_ctl_elem_get_boolean(const snd_ctl_elem_t *obj, unsigned int idx);
|
||||
|
||||
long snd_ctl_element_get_integer(const snd_ctl_element_t *obj, unsigned int idx);
|
||||
long snd_ctl_elem_get_integer(const snd_ctl_elem_t *obj, unsigned int idx);
|
||||
|
||||
unsigned int snd_ctl_element_get_enumerated(const snd_ctl_element_t *obj, unsigned int idx);
|
||||
unsigned int snd_ctl_elem_get_enumerated(const snd_ctl_elem_t *obj, unsigned int idx);
|
||||
|
||||
unsigned char snd_ctl_element_get_byte(const snd_ctl_element_t *obj, unsigned int idx);
|
||||
unsigned char snd_ctl_elem_get_byte(const snd_ctl_elem_t *obj, unsigned int idx);
|
||||
|
||||
void snd_ctl_element_set_boolean(snd_ctl_element_t *obj, unsigned int idx, long val);
|
||||
void snd_ctl_elem_set_boolean(snd_ctl_elem_t *obj, unsigned int idx, long val);
|
||||
|
||||
void snd_ctl_element_set_integer(snd_ctl_element_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_element_set_enumerated(snd_ctl_element_t *obj, unsigned int idx, unsigned int val);
|
||||
void snd_ctl_elem_set_enumerated(snd_ctl_elem_t *obj, unsigned int idx, unsigned int val);
|
||||
|
||||
void snd_ctl_element_set_byte(snd_ctl_element_t *obj, unsigned int idx, unsigned char val);
|
||||
void snd_ctl_elem_set_byte(snd_ctl_elem_t *obj, unsigned int idx, unsigned char val);
|
||||
|
||||
const void * snd_ctl_element_get_bytes(const snd_ctl_element_t *obj);
|
||||
const void * snd_ctl_elem_get_bytes(const snd_ctl_elem_t *obj);
|
||||
|
||||
void snd_ctl_element_get_iec958(const snd_ctl_element_t *obj, snd_aes_iec958_t *ptr);
|
||||
void snd_ctl_elem_get_iec958(const snd_ctl_elem_t *obj, snd_aes_iec958_t *ptr);
|
||||
|
||||
void snd_ctl_element_set_iec958(snd_ctl_element_t *obj, const 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_element_list_sizeof();
|
||||
#define snd_hctl_element_list_alloca(ptr) ({ assert(ptr); *ptr = (snd_hctl_element_list_t *) alloca(snd_hctl_element_list_sizeof()); memset(*ptr, 0, snd_hctl_element_list_sizeof()); 0; })
|
||||
int snd_hctl_element_list_malloc(snd_hctl_element_list_t **ptr);
|
||||
void snd_hctl_element_list_free(snd_hctl_element_list_t *obj);
|
||||
void snd_hctl_element_list_copy(snd_hctl_element_list_t *dst, const snd_hctl_element_list_t *src);
|
||||
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_hctl_element_list_set_offset(snd_hctl_element_list_t *obj, unsigned int val);
|
||||
void snd_hctl_elem_get_id(const snd_hctl_elem_t *obj, snd_ctl_elem_id_t *ptr);
|
||||
|
||||
unsigned int snd_hctl_element_list_get_used(const snd_hctl_element_list_t *obj);
|
||||
unsigned int snd_hctl_elem_get_numid(const snd_hctl_elem_t *obj);
|
||||
|
||||
unsigned int snd_hctl_element_list_get_count(const snd_hctl_element_list_t *obj);
|
||||
snd_ctl_elem_iface_t snd_hctl_elem_get_interface(const snd_hctl_elem_t *obj);
|
||||
|
||||
void snd_hctl_element_list_get_id(const snd_hctl_element_list_t *obj, unsigned int idx, snd_ctl_element_id_t *ptr);
|
||||
unsigned int snd_hctl_elem_get_device(const snd_hctl_elem_t *obj);
|
||||
|
||||
unsigned int snd_hctl_element_list_get_numid(const snd_hctl_element_list_t *obj, unsigned int idx);
|
||||
unsigned int snd_hctl_elem_get_subdevice(const snd_hctl_elem_t *obj);
|
||||
|
||||
snd_ctl_element_iface_t snd_hctl_element_list_get_interface(const snd_hctl_element_list_t *obj, unsigned int idx);
|
||||
const char *snd_hctl_elem_get_name(const snd_hctl_elem_t *obj);
|
||||
|
||||
unsigned int snd_hctl_element_list_get_device(const snd_hctl_element_list_t *obj, unsigned int idx);
|
||||
unsigned int snd_hctl_elem_get_index(const snd_hctl_elem_t *obj);
|
||||
|
||||
unsigned int snd_hctl_element_list_get_subdevice(const snd_hctl_element_list_t *obj, unsigned int idx);
|
||||
void snd_hctl_elem_set_callback(snd_hctl_elem_t *obj, snd_hctl_elem_callback_t val);
|
||||
|
||||
const char *snd_hctl_element_list_get_name(const snd_hctl_element_list_t *obj, unsigned int idx);
|
||||
void * snd_hctl_elem_get_callback_private(const snd_hctl_elem_t *obj);
|
||||
|
||||
unsigned int snd_hctl_element_list_get_index(const snd_hctl_element_list_t *obj, unsigned int idx);
|
||||
|
||||
size_t snd_hctl_element_sizeof();
|
||||
#define snd_hctl_element_alloca(ptr) ({ assert(ptr); *ptr = (snd_hctl_element_t *) alloca(snd_hctl_element_sizeof()); memset(*ptr, 0, snd_hctl_element_sizeof()); 0; })
|
||||
int snd_hctl_element_malloc(snd_hctl_element_t **ptr);
|
||||
void snd_hctl_element_free(snd_hctl_element_t *obj);
|
||||
void snd_hctl_element_copy(snd_hctl_element_t *dst, const snd_hctl_element_t *src);
|
||||
|
||||
void snd_hctl_element_get_id(const snd_hctl_element_t *obj, snd_ctl_element_id_t *ptr);
|
||||
|
||||
unsigned int snd_hctl_element_get_numid(const snd_hctl_element_t *obj);
|
||||
|
||||
snd_ctl_element_iface_t snd_hctl_element_get_interface(const snd_hctl_element_t *obj);
|
||||
|
||||
unsigned int snd_hctl_element_get_device(const snd_hctl_element_t *obj);
|
||||
|
||||
unsigned int snd_hctl_element_get_subdevice(const snd_hctl_element_t *obj);
|
||||
|
||||
const char *snd_hctl_element_get_name(const snd_hctl_element_t *obj);
|
||||
|
||||
unsigned int snd_hctl_element_get_index(const snd_hctl_element_t *obj);
|
||||
|
||||
void snd_hctl_element_set_callback_change(snd_hctl_element_t *obj, snd_hctl_element_callback_t val);
|
||||
|
||||
void snd_hctl_element_set_callback_value(snd_hctl_element_t *obj, snd_hctl_element_callback_t val);
|
||||
|
||||
void snd_hctl_element_set_callback_remove(snd_hctl_element_t *obj, snd_hctl_element_callback_t val);
|
||||
|
||||
void * snd_hctl_element_get_private_data(const snd_hctl_element_t *obj);
|
||||
|
||||
void snd_hctl_element_set_private_data(snd_hctl_element_t *obj, void * val);
|
||||
|
||||
void snd_hctl_element_set_private_free(snd_hctl_element_t *obj, snd_hctl_element_private_free_t val);
|
||||
void snd_hctl_elem_set_callback_private(snd_hctl_elem_t *obj, void * val);
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
|
|
|
|||
|
|
@ -29,10 +29,10 @@
|
|||
#define _snd_pcm_status sndrv_pcm_status
|
||||
|
||||
#define _snd_ctl_card_info sndrv_ctl_card_info
|
||||
#define _snd_ctl_element_id sndrv_ctl_element_id
|
||||
#define _snd_ctl_element_list sndrv_ctl_element_list
|
||||
#define _snd_ctl_element_info sndrv_ctl_element_info
|
||||
#define _snd_ctl_element sndrv_ctl_element
|
||||
#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_event sndrv_ctl_event
|
||||
|
||||
#define _snd_rawmidi_info sndrv_rawmidi_info
|
||||
|
|
|
|||
131
include/mixer.h
131
include/mixer.h
|
|
@ -6,15 +6,42 @@
|
|||
****************************************************************************/
|
||||
|
||||
typedef struct _snd_mixer snd_mixer_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,
|
||||
snd_ctl_event_type_t event,
|
||||
snd_mixer_elem_t *elem);
|
||||
typedef int (*snd_mixer_elem_callback_t)(snd_mixer_elem_t *elem,
|
||||
snd_ctl_event_type_t event);
|
||||
|
||||
enum _snd_mixer_elem_type {
|
||||
SND_MIXER_ELEM_SIMPLE,
|
||||
SND_MIXER_ELEM_LAST = SND_MIXER_ELEM_SIMPLE,
|
||||
};
|
||||
|
||||
#ifdef SND_ENUM_TYPECHECK
|
||||
typedef struct __snd_mixer_elem_type *snd_mixer_elem_type_t;
|
||||
#else
|
||||
typedef enum _snd_mixer_elem_type snd_mixer_elem_type_t;
|
||||
#endif
|
||||
|
||||
#define SND_MIXER_ELEM_SIMPLE ((snd_mixer_elem_type_t) SND_MIXER_ELEM_SIMPLE)
|
||||
#define SND_MIXER_ELEM_LAST ((snd_mixer_elem_type_t) SND_MIXER_ELEM_LAST)
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
int snd_mixer_open(snd_mixer_t **handle, char *name);
|
||||
int snd_mixer_close(snd_mixer_t *handle);
|
||||
int snd_mixer_card(snd_mixer_t *handle);
|
||||
int snd_mixer_poll_descriptor(snd_mixer_t *handle);
|
||||
int snd_mixer_open(snd_mixer_t **mixer, char *name);
|
||||
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);
|
||||
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);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
|
@ -36,6 +63,11 @@ enum _snd_mixer_channel_id {
|
|||
SND_MIXER_CHN_MONO = SND_MIXER_CHN_FRONT_LEFT
|
||||
};
|
||||
|
||||
/* Simple mixer */
|
||||
|
||||
typedef struct _snd_mixer_selem snd_mixer_selem_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;
|
||||
#else
|
||||
|
|
@ -52,79 +84,32 @@ typedef enum _snd_mixer_channel_id snd_mixer_channel_id_t;
|
|||
#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_CHN_MASK_MONO (1<<snd_enum_to_int(SND_MIXER_CHN_MONO))
|
||||
#define SND_MIXER_CHN_MASK_FRONT_LEFT (1<<snd_enum_to_int(SND_MIXER_CHN_FRONT_LEFT))
|
||||
#define SND_MIXER_CHN_MASK_FRONT_RIGHT (1<<snd_enum_to_int(SND_MIXER_CHN_FRONT_RIGHT))
|
||||
#define SND_MIXER_CHN_MASK_FRONT_CENTER (1<<snd_enum_to_int(SND_MIXER_CHN_FRONT_CENTER))
|
||||
#define SND_MIXER_CHN_MASK_REAR_LEFT (1<<snd_enum_to_int(SND_MIXER_CHN_REAR_LEFT))
|
||||
#define SND_MIXER_CHN_MASK_REAR_RIGHT (1<<snd_enum_to_int(SND_MIXER_CHN_REAR_RIGHT))
|
||||
#define SND_MIXER_CHN_MASK_WOOFER (1<<snd_enum_to_int(SND_MIXER_CHN_WOOFER))
|
||||
#define SND_MIXER_CHN_MASK_STEREO (SND_MIXER_CHN_MASK_FRONT_LEFT|SND_MIXER_CHN_MASK_FRONT_RIGHT)
|
||||
|
||||
#define SND_MIXER_SCTCAP_VOLUME (1<<0)
|
||||
#define SND_MIXER_SCTCAP_JOINTLY_VOLUME (1<<1)
|
||||
#define SND_MIXER_SCTCAP_MUTE (1<<2)
|
||||
#define SND_MIXER_SCTCAP_JOINTLY_MUTE (1<<3)
|
||||
#define SND_MIXER_SCTCAP_CAPTURE (1<<4)
|
||||
#define SND_MIXER_SCTCAP_JOINTLY_CAPTURE (1<<5)
|
||||
#define SND_MIXER_SCTCAP_EXCL_CAPTURE (1<<6)
|
||||
|
||||
typedef struct _snd_mixer_sid {
|
||||
unsigned char name[60];
|
||||
unsigned int index;
|
||||
} snd_mixer_sid_t;
|
||||
|
||||
typedef struct _snd_mixer_simple_element_list {
|
||||
unsigned int controls_offset; /* W: first control ID to get */
|
||||
unsigned int controls_request; /* W: count of control IDs to get */
|
||||
unsigned int controls_count; /* R: count of available (set) IDs */
|
||||
unsigned int controls; /* R: count of all available controls */
|
||||
snd_mixer_sid_t *pids; /* W: IDs */
|
||||
char reserved[50];
|
||||
} snd_mixer_simple_element_list_t;
|
||||
|
||||
typedef struct _snd_mixer_simple_element {
|
||||
snd_mixer_sid_t sid; /* WR: simple control identification */
|
||||
unsigned int caps; /* RO: capabilities */
|
||||
unsigned int channels; /* RO: bitmap of active channels */
|
||||
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 */
|
||||
char reserved[32];
|
||||
union {
|
||||
struct {
|
||||
long front_left; /* front left value */
|
||||
long front_right; /* front right value */
|
||||
long front_center; /* front center */
|
||||
long rear_left; /* left rear */
|
||||
long rear_right; /* right rear */
|
||||
long woofer; /* woofer */
|
||||
} names;
|
||||
long values[32];
|
||||
} volume; /* RW */
|
||||
} snd_mixer_simple_element_t;
|
||||
|
||||
typedef struct _snd_mixer_simple_callbacks {
|
||||
void *private_data; /* may be used by an application */
|
||||
void (*rebuild) (snd_mixer_t *handle, void *private_data);
|
||||
void (*value) (snd_mixer_t *handle, void *private_data, snd_mixer_sid_t *id);
|
||||
void (*change) (snd_mixer_t *handle, void *private_data, snd_mixer_sid_t *id);
|
||||
void (*add) (snd_mixer_t *handle, void *private_data, snd_mixer_sid_t *id);
|
||||
void (*remove) (snd_mixer_t *handle, void *private_data, snd_mixer_sid_t *id);
|
||||
void *reserved[58]; /* reserved for future use - must be NULL!!! */
|
||||
} snd_mixer_simple_callbacks_t;
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
const char *snd_mixer_simple_channel_name(snd_mixer_channel_id_t channel);
|
||||
int snd_mixer_simple_element_list(snd_mixer_t *handle, snd_mixer_simple_element_list_t *list);
|
||||
int snd_mixer_simple_element_read(snd_mixer_t *handle, snd_mixer_simple_element_t *simple);
|
||||
int snd_mixer_simple_element_write(snd_mixer_t *handle, snd_mixer_simple_element_t *simple);
|
||||
int snd_mixer_simple_read(snd_mixer_t *handle, snd_mixer_simple_callbacks_t *callbacks);
|
||||
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);
|
||||
void snd_mixer_selem_get_id(snd_mixer_elem_t *element,
|
||||
snd_mixer_selem_id_t *id);
|
||||
int snd_mixer_selem_read(snd_mixer_elem_t *element,
|
||||
snd_mixer_selem_t *simple);
|
||||
int snd_mixer_selem_write(snd_mixer_elem_t *element,
|
||||
const snd_mixer_selem_t *simple);
|
||||
|
||||
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);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
|
|
|||
64
include/mixer_m4.h
Normal file
64
include/mixer_m4.h
Normal file
|
|
@ -0,0 +1,64 @@
|
|||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
size_t snd_mixer_selem_id_sizeof();
|
||||
#define snd_mixer_selem_id_alloca(ptr) ({ assert(ptr); *ptr = (snd_mixer_selem_id_t *) alloca(snd_mixer_selem_id_sizeof()); memset(*ptr, 0, snd_mixer_selem_id_sizeof()); 0; })
|
||||
int snd_mixer_selem_id_malloc(snd_mixer_selem_id_t **ptr);
|
||||
void snd_mixer_selem_id_free(snd_mixer_selem_id_t *obj);
|
||||
void snd_mixer_selem_id_copy(snd_mixer_selem_id_t *dst, const snd_mixer_selem_id_t *src);
|
||||
|
||||
const char *snd_mixer_selem_id_get_name(const snd_mixer_selem_id_t *obj);
|
||||
|
||||
unsigned int snd_mixer_selem_id_get_index(const snd_mixer_selem_id_t *obj);
|
||||
|
||||
void snd_mixer_selem_id_set_name(snd_mixer_selem_id_t *obj, const char *val);
|
||||
|
||||
void snd_mixer_selem_id_set_index(snd_mixer_selem_id_t *obj, unsigned int val);
|
||||
|
||||
void snd_mixer_set_callback(snd_mixer_t *obj, snd_mixer_callback_t val);
|
||||
|
||||
void * snd_mixer_get_callback_private(const snd_mixer_t *obj);
|
||||
|
||||
void snd_mixer_set_callback_private(snd_mixer_t *obj, void * val);
|
||||
|
||||
unsigned int snd_mixer_get_count(const snd_mixer_t *obj);
|
||||
|
||||
void snd_mixer_elem_set_callback(snd_mixer_elem_t *obj, snd_mixer_elem_callback_t val);
|
||||
|
||||
void * snd_mixer_elem_get_callback_private(const snd_mixer_elem_t *obj);
|
||||
|
||||
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);
|
||||
|
||||
long snd_mixer_selem_get_min(const snd_mixer_selem_t *obj);
|
||||
|
||||
long snd_mixer_selem_get_max(const snd_mixer_selem_t *obj);
|
||||
|
||||
int snd_mixer_selem_get_capture_group(const snd_mixer_selem_t *obj);
|
||||
|
||||
int snd_mixer_selem_has_volume(const snd_mixer_selem_t *obj);
|
||||
|
||||
int snd_mixer_selem_has_joined_volume(const snd_mixer_selem_t *obj);
|
||||
|
||||
int snd_mixer_selem_has_mute(const snd_mixer_selem_t *obj);
|
||||
|
||||
int snd_mixer_selem_has_joined_mute(const snd_mixer_selem_t *obj);
|
||||
|
||||
int snd_mixer_selem_has_capture(const snd_mixer_selem_t *obj);
|
||||
|
||||
int snd_mixer_selem_has_joined_capture(const snd_mixer_selem_t *obj);
|
||||
|
||||
int snd_mixer_selem_has_exclusive_capture(const snd_mixer_selem_t *obj);
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
Loading…
Add table
Add a link
Reference in a new issue