mirror of
https://github.com/alsa-project/alsa-lib.git
synced 2025-12-16 08:56:42 -05:00
Better names for control API
This commit is contained in:
Abramo Bagnara
parent
66f13f6115
commit
45c416ed82
22 changed files with 666 additions and 668 deletions
|
|
@ -89,11 +89,11 @@ typedef struct {
|
|||
int cmd;
|
||||
union {
|
||||
int device;
|
||||
snd_ctl_info_t hw_info;
|
||||
snd_control_list_t clist;
|
||||
snd_control_info_t cinfo;
|
||||
snd_control_t cread;
|
||||
snd_control_t cwrite;
|
||||
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_hwdep_info_t hwdep_info;
|
||||
snd_pcm_info_t pcm_info;
|
||||
int pcm_prefer_subdevice;
|
||||
|
|
|
|||
|
|
@ -6,22 +6,22 @@
|
|||
****************************************************************************/
|
||||
|
||||
typedef struct sndrv_aes_iec958 snd_aes_iec958_t;
|
||||
typedef struct _snd_ctl_info snd_ctl_info_t;
|
||||
typedef struct _snd_control_id snd_control_id_t;
|
||||
typedef struct _snd_control_list snd_control_list_t;
|
||||
typedef struct _snd_control_info snd_control_info_t;
|
||||
typedef struct _snd_control snd_control_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_event snd_ctl_event_t;
|
||||
|
||||
#ifdef SND_ENUM_TYPECHECK
|
||||
typedef struct __snd_card_type *snd_card_type_t;
|
||||
typedef struct __snd_control_type *snd_control_type_t;
|
||||
typedef struct __snd_control_iface *snd_control_iface_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_event_type *snd_ctl_event_type_t;
|
||||
#else
|
||||
typedef enum sndrv_card_type snd_card_type_t;
|
||||
typedef enum sndrv_control_type snd_control_type_t;
|
||||
typedef enum sndrv_control_iface snd_control_iface_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_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_CONTROL_TYPE_NONE ((snd_control_type_t) SNDRV_CONTROL_TYPE_NONE)
|
||||
#define SND_CONTROL_TYPE_BOOLEAN ((snd_control_type_t) SNDRV_CONTROL_TYPE_BOOLEAN)
|
||||
#define SND_CONTROL_TYPE_INTEGER ((snd_control_type_t) SNDRV_CONTROL_TYPE_INTEGER)
|
||||
#define SND_CONTROL_TYPE_ENUMERATED ((snd_control_type_t) SNDRV_CONTROL_TYPE_ENUMERATED)
|
||||
#define SND_CONTROL_TYPE_BYTES ((snd_control_type_t) SNDRV_CONTROL_TYPE_BYTES)
|
||||
#define SND_CONTROL_TYPE_IEC958 ((snd_control_type_t) SNDRV_CONTROL_TYPE_IEC958)
|
||||
#define SND_CONTROL_TYPE_LAST ((snd_control_type_t) SNDRV_CONTROL_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_CONTROL_IFACE_CARD ((snd_control_iface_t) SNDRV_CONTROL_IFACE_CARD)
|
||||
#define SND_CONTROL_IFACE_HWDEP ((snd_control_iface_t) SNDRV_CONTROL_IFACE_HWDEP)
|
||||
#define SND_CONTROL_IFACE_MIXER ((snd_control_iface_t) SNDRV_CONTROL_IFACE_MIXER)
|
||||
#define SND_CONTROL_IFACE_PCM ((snd_control_iface_t) SNDRV_CONTROL_IFACE_PCM)
|
||||
#define SND_CONTROL_IFACE_RAWMIDI ((snd_control_iface_t) SNDRV_CONTROL_IFACE_RAWMIDI)
|
||||
#define SND_CONTROL_IFACE_TIMER ((snd_control_iface_t) SNDRV_CONTROL_IFACE_TIMER)
|
||||
#define SND_CONTROL_IFACE_SEQUENCER ((snd_control_iface_t) SNDRV_CONTROL_IFACE_SEQUENCER)
|
||||
#define SND_CONTROL_IFACE_LAST ((snd_control_iface_t) SNDRV_CONTROL_IFACE_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_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)
|
||||
|
|
@ -160,11 +160,11 @@ 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_info(snd_ctl_t *handle, snd_ctl_info_t *info);
|
||||
int snd_ctl_clist(snd_ctl_t *handle, snd_control_list_t * list);
|
||||
int snd_ctl_cinfo(snd_ctl_t *handle, snd_control_info_t * sw);
|
||||
int snd_ctl_cread(snd_ctl_t *handle, snd_control_t * control);
|
||||
int snd_ctl_cwrite(snd_ctl_t *handle, snd_control_t * control);
|
||||
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);
|
||||
|
|
@ -176,14 +176,14 @@ int snd_ctl_rawmidi_prefer_subdevice(snd_ctl_t *handle, int subdev);
|
|||
|
||||
int snd_ctl_read(snd_ctl_t *handle, snd_ctl_callbacks_t * callbacks);
|
||||
|
||||
void snd_control_set_bytes(snd_control_t *obj, void *data, size_t size);
|
||||
void snd_ctl_element_set_bytes(snd_ctl_element_t *obj, void *data, size_t size);
|
||||
|
||||
const char *snd_control_type_name(snd_control_type_t type);
|
||||
const char *snd_control_iface_name(snd_control_iface_t iface);
|
||||
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_event_type_name(snd_ctl_event_type_t type);
|
||||
|
||||
int snd_control_list_alloc_space(snd_control_list_t *obj, unsigned int entries);
|
||||
void snd_control_list_free_space(snd_control_list_t *obj);
|
||||
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);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
|
@ -193,41 +193,41 @@ void snd_control_list_free_space(snd_control_list_t *obj);
|
|||
* Highlevel API for controls
|
||||
*/
|
||||
|
||||
typedef struct _snd_hcontrol_list snd_hcontrol_list_t;
|
||||
typedef struct _snd_hcontrol snd_hcontrol_t;
|
||||
typedef struct _snd_hctl_element_list snd_hctl_element_list_t;
|
||||
typedef struct _snd_hctl_element snd_hctl_element_t;
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef int (*snd_ctl_hsort_t)(const snd_hcontrol_t *c1, const snd_hcontrol_t *c2);
|
||||
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_hcontrol_t *hcontrol);
|
||||
typedef void (*snd_hcontrol_callback_t)(snd_ctl_t *handle, snd_hcontrol_t *hcontrol);
|
||||
typedef void (*snd_hcontrol_private_free_t)(snd_hcontrol_t *hcontrol);
|
||||
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);
|
||||
|
||||
int snd_ctl_hbuild(snd_ctl_t *handle, snd_ctl_hsort_t csort);
|
||||
int snd_ctl_hfree(snd_ctl_t *handle);
|
||||
snd_hcontrol_t *snd_ctl_hfirst(snd_ctl_t *handle);
|
||||
snd_hcontrol_t *snd_ctl_hlast(snd_ctl_t *handle);
|
||||
snd_hcontrol_t *snd_ctl_hnext(snd_ctl_t *handle, snd_hcontrol_t *hcontrol);
|
||||
snd_hcontrol_t *snd_ctl_hprev(snd_ctl_t *handle, snd_hcontrol_t *hcontrol);
|
||||
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_hcontrol_t *snd_ctl_hfind(snd_ctl_t *handle, snd_control_id_t *id);
|
||||
int snd_ctl_hlist(snd_ctl_t *handle, snd_hcontrol_list_t *hlist);
|
||||
int snd_ctl_hsort(const snd_hcontrol_t *c1, const snd_hcontrol_t *c2);
|
||||
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 (*hcontrol_free)(snd_hcontrol_t *hcontrol));
|
||||
int snd_ctl_hbag_add(void **bag, snd_hcontrol_t *hcontrol);
|
||||
int snd_ctl_hbag_del(void **bag, snd_hcontrol_t *hcontrol);
|
||||
snd_hcontrol_t *snd_ctl_hbag_find(void **bag, snd_control_id_t *id);
|
||||
int snd_hcontrol_list_alloc_space(snd_hcontrol_list_t *obj, unsigned int entries);
|
||||
void snd_hcontrol_list_free_space(snd_hcontrol_list_t *obj);
|
||||
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);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
|
|
|||
|
|
@ -2,57 +2,57 @@
|
|||
extern "C" {
|
||||
#endif
|
||||
|
||||
size_t snd_control_id_sizeof();
|
||||
#define snd_control_id_alloca(ptr) ({ assert(ptr); *ptr = (snd_control_id_t *) alloca(snd_control_id_sizeof()); memset(*ptr, 0, snd_control_id_sizeof()); 0; })
|
||||
int snd_control_id_malloc(snd_control_id_t **ptr);
|
||||
void snd_control_id_free(snd_control_id_t *obj);
|
||||
void snd_control_id_copy(snd_control_id_t *dst, const snd_control_id_t *src);
|
||||
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);
|
||||
|
||||
unsigned int snd_control_id_get_numid(const snd_control_id_t *obj);
|
||||
unsigned int snd_ctl_element_id_get_numid(const snd_ctl_element_id_t *obj);
|
||||
|
||||
snd_control_iface_t snd_control_id_get_interface(const snd_control_id_t *obj);
|
||||
snd_ctl_element_iface_t snd_ctl_element_id_get_interface(const snd_ctl_element_id_t *obj);
|
||||
|
||||
unsigned int snd_control_id_get_device(const snd_control_id_t *obj);
|
||||
unsigned int snd_ctl_element_id_get_device(const snd_ctl_element_id_t *obj);
|
||||
|
||||
unsigned int snd_control_id_get_subdevice(const snd_control_id_t *obj);
|
||||
unsigned int snd_ctl_element_id_get_subdevice(const snd_ctl_element_id_t *obj);
|
||||
|
||||
const char *snd_control_id_get_name(const snd_control_id_t *obj);
|
||||
const char *snd_ctl_element_id_get_name(const snd_ctl_element_id_t *obj);
|
||||
|
||||
unsigned int snd_control_id_get_index(const snd_control_id_t *obj);
|
||||
unsigned int snd_ctl_element_id_get_index(const snd_ctl_element_id_t *obj);
|
||||
|
||||
void snd_control_id_set_numid(snd_control_id_t *obj, unsigned int val);
|
||||
void snd_ctl_element_id_set_numid(snd_ctl_element_id_t *obj, unsigned int val);
|
||||
|
||||
void snd_control_id_set_interface(snd_control_id_t *obj, snd_control_iface_t val);
|
||||
void snd_ctl_element_id_set_interface(snd_ctl_element_id_t *obj, snd_ctl_element_iface_t val);
|
||||
|
||||
void snd_control_id_set_device(snd_control_id_t *obj, unsigned int val);
|
||||
void snd_ctl_element_id_set_device(snd_ctl_element_id_t *obj, unsigned int val);
|
||||
|
||||
void snd_control_id_set_subdevice(snd_control_id_t *obj, unsigned int val);
|
||||
void snd_ctl_element_id_set_subdevice(snd_ctl_element_id_t *obj, unsigned int val);
|
||||
|
||||
void snd_control_id_set_name(snd_control_id_t *obj, const char *val);
|
||||
void snd_ctl_element_id_set_name(snd_ctl_element_id_t *obj, const char *val);
|
||||
|
||||
void snd_control_id_set_index(snd_control_id_t *obj, unsigned int val);
|
||||
void snd_ctl_element_id_set_index(snd_ctl_element_id_t *obj, unsigned int val);
|
||||
|
||||
size_t snd_ctl_info_sizeof();
|
||||
#define snd_ctl_info_alloca(ptr) ({ assert(ptr); *ptr = (snd_ctl_info_t *) alloca(snd_ctl_info_sizeof()); memset(*ptr, 0, snd_ctl_info_sizeof()); 0; })
|
||||
int snd_ctl_info_malloc(snd_ctl_info_t **ptr);
|
||||
void snd_ctl_info_free(snd_ctl_info_t *obj);
|
||||
void snd_ctl_info_copy(snd_ctl_info_t *dst, const snd_ctl_info_t *src);
|
||||
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; })
|
||||
int snd_ctl_card_info_malloc(snd_ctl_card_info_t **ptr);
|
||||
void snd_ctl_card_info_free(snd_ctl_card_info_t *obj);
|
||||
void snd_ctl_card_info_copy(snd_ctl_card_info_t *dst, const snd_ctl_card_info_t *src);
|
||||
|
||||
int snd_ctl_info_get_card(const snd_ctl_info_t *obj);
|
||||
int snd_ctl_card_info_get_card(const snd_ctl_card_info_t *obj);
|
||||
|
||||
snd_card_type_t snd_ctl_info_get_type(const snd_ctl_info_t *obj);
|
||||
snd_card_type_t snd_ctl_card_info_get_type(const snd_ctl_card_info_t *obj);
|
||||
|
||||
const char *snd_ctl_info_get_id(const snd_ctl_info_t *obj);
|
||||
const char *snd_ctl_card_info_get_id(const snd_ctl_card_info_t *obj);
|
||||
|
||||
const char *snd_ctl_info_get_abbreviation(const snd_ctl_info_t *obj);
|
||||
const char *snd_ctl_card_info_get_abbreviation(const snd_ctl_card_info_t *obj);
|
||||
|
||||
const char *snd_ctl_info_get_name(const snd_ctl_info_t *obj);
|
||||
const char *snd_ctl_card_info_get_name(const snd_ctl_card_info_t *obj);
|
||||
|
||||
const char *snd_ctl_info_get_longname(const snd_ctl_info_t *obj);
|
||||
const char *snd_ctl_card_info_get_longname(const snd_ctl_card_info_t *obj);
|
||||
|
||||
const char *snd_ctl_info_get_mixerid(const snd_ctl_info_t *obj);
|
||||
const char *snd_ctl_card_info_get_mixerid(const snd_ctl_card_info_t *obj);
|
||||
|
||||
const char *snd_ctl_info_get_mixername(const snd_ctl_info_t *obj);
|
||||
const char *snd_ctl_card_info_get_mixername(const snd_ctl_card_info_t *obj);
|
||||
|
||||
size_t snd_ctl_event_sizeof();
|
||||
#define snd_ctl_event_alloca(ptr) ({ assert(ptr); *ptr = (snd_ctl_event_t *) alloca(snd_ctl_event_sizeof()); memset(*ptr, 0, snd_ctl_event_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_control_id_t *ptr);
|
||||
void snd_ctl_event_get_id(const snd_ctl_event_t *obj, snd_ctl_element_id_t *ptr);
|
||||
|
||||
snd_control_iface_t snd_ctl_event_get_interface(const snd_ctl_event_t *obj);
|
||||
snd_ctl_element_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,207 @@ 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_control_list_sizeof();
|
||||
#define snd_control_list_alloca(ptr) ({ assert(ptr); *ptr = (snd_control_list_t *) alloca(snd_control_list_sizeof()); memset(*ptr, 0, snd_control_list_sizeof()); 0; })
|
||||
int snd_control_list_malloc(snd_control_list_t **ptr);
|
||||
void snd_control_list_free(snd_control_list_t *obj);
|
||||
void snd_control_list_copy(snd_control_list_t *dst, const snd_control_list_t *src);
|
||||
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);
|
||||
|
||||
void snd_control_list_set_offset(snd_control_list_t *obj, unsigned int val);
|
||||
void snd_ctl_element_list_set_offset(snd_ctl_element_list_t *obj, unsigned int val);
|
||||
|
||||
unsigned int snd_control_list_get_used(const snd_control_list_t *obj);
|
||||
unsigned int snd_ctl_element_list_get_used(const snd_ctl_element_list_t *obj);
|
||||
|
||||
unsigned int snd_control_list_get_count(const snd_control_list_t *obj);
|
||||
unsigned int snd_ctl_element_list_get_count(const snd_ctl_element_list_t *obj);
|
||||
|
||||
void snd_control_list_get_id(const snd_control_list_t *obj, unsigned int idx, snd_control_id_t *ptr);
|
||||
void snd_ctl_element_list_get_id(const snd_ctl_element_list_t *obj, unsigned int idx, snd_ctl_element_id_t *ptr);
|
||||
|
||||
unsigned int snd_control_list_get_numid(const snd_control_list_t *obj, unsigned int idx);
|
||||
unsigned int snd_ctl_element_list_get_numid(const snd_ctl_element_list_t *obj, unsigned int idx);
|
||||
|
||||
snd_control_iface_t snd_control_list_get_interface(const snd_control_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);
|
||||
|
||||
unsigned int snd_control_list_get_device(const snd_control_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_control_list_get_subdevice(const snd_control_list_t *obj, unsigned int idx);
|
||||
unsigned int snd_ctl_element_list_get_subdevice(const snd_ctl_element_list_t *obj, unsigned int idx);
|
||||
|
||||
const char *snd_control_list_get_name(const snd_control_list_t *obj, unsigned int idx);
|
||||
const char *snd_ctl_element_list_get_name(const snd_ctl_element_list_t *obj, unsigned int idx);
|
||||
|
||||
unsigned int snd_control_list_get_index(const snd_control_list_t *obj, unsigned int idx);
|
||||
unsigned int snd_ctl_element_list_get_index(const snd_ctl_element_list_t *obj, unsigned int idx);
|
||||
|
||||
size_t snd_control_info_sizeof();
|
||||
#define snd_control_info_alloca(ptr) ({ assert(ptr); *ptr = (snd_control_info_t *) alloca(snd_control_info_sizeof()); memset(*ptr, 0, snd_control_info_sizeof()); 0; })
|
||||
int snd_control_info_malloc(snd_control_info_t **ptr);
|
||||
void snd_control_info_free(snd_control_info_t *obj);
|
||||
void snd_control_info_copy(snd_control_info_t *dst, const snd_control_info_t *src);
|
||||
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);
|
||||
|
||||
snd_control_type_t snd_control_info_get_type(const snd_control_info_t *obj);
|
||||
snd_ctl_element_type_t snd_ctl_element_info_get_type(const snd_ctl_element_info_t *obj);
|
||||
|
||||
int snd_control_info_is_readable(const snd_control_info_t *obj);
|
||||
int snd_ctl_element_info_is_readable(const snd_ctl_element_info_t *obj);
|
||||
|
||||
int snd_control_info_is_writable(const snd_control_info_t *obj);
|
||||
int snd_ctl_element_info_is_writable(const snd_ctl_element_info_t *obj);
|
||||
|
||||
int snd_control_info_is_volatile(const snd_control_info_t *obj);
|
||||
int snd_ctl_element_info_is_volatile(const snd_ctl_element_info_t *obj);
|
||||
|
||||
int snd_control_info_is_inactive(const snd_control_info_t *obj);
|
||||
int snd_ctl_element_info_is_inactive(const snd_ctl_element_info_t *obj);
|
||||
|
||||
int snd_control_info_is_locked(const snd_control_info_t *obj);
|
||||
int snd_ctl_element_info_is_locked(const snd_ctl_element_info_t *obj);
|
||||
|
||||
int snd_control_info_is_indirect(const snd_control_info_t *obj);
|
||||
int snd_ctl_element_info_is_indirect(const snd_ctl_element_info_t *obj);
|
||||
|
||||
unsigned int snd_control_info_get_count(const snd_control_info_t *obj);
|
||||
unsigned int snd_ctl_element_info_get_count(const snd_ctl_element_info_t *obj);
|
||||
|
||||
long snd_control_info_get_min(const snd_control_info_t *obj);
|
||||
long snd_ctl_element_info_get_min(const snd_ctl_element_info_t *obj);
|
||||
|
||||
long snd_control_info_get_max(const snd_control_info_t *obj);
|
||||
long snd_ctl_element_info_get_max(const snd_ctl_element_info_t *obj);
|
||||
|
||||
long snd_control_info_get_step(const snd_control_info_t *obj);
|
||||
long snd_ctl_element_info_get_step(const snd_ctl_element_info_t *obj);
|
||||
|
||||
unsigned int snd_control_info_get_items(const snd_control_info_t *obj);
|
||||
unsigned int snd_ctl_element_info_get_items(const snd_ctl_element_info_t *obj);
|
||||
|
||||
void snd_control_info_set_item(snd_control_info_t *obj, unsigned int val);
|
||||
void snd_ctl_element_info_set_item(snd_ctl_element_info_t *obj, unsigned int val);
|
||||
|
||||
const char *snd_control_info_get_item_name(const snd_control_info_t *obj);
|
||||
const char *snd_ctl_element_info_get_item_name(const snd_ctl_element_info_t *obj);
|
||||
|
||||
void snd_control_info_get_id(const snd_control_info_t *obj, snd_control_id_t *ptr);
|
||||
void snd_ctl_element_info_get_id(const snd_ctl_element_info_t *obj, snd_ctl_element_id_t *ptr);
|
||||
|
||||
unsigned int snd_control_info_get_numid(const snd_control_info_t *obj);
|
||||
unsigned int snd_ctl_element_info_get_numid(const snd_ctl_element_info_t *obj);
|
||||
|
||||
snd_control_iface_t snd_control_info_get_interface(const snd_control_info_t *obj);
|
||||
snd_ctl_element_iface_t snd_ctl_element_info_get_interface(const snd_ctl_element_info_t *obj);
|
||||
|
||||
unsigned int snd_control_info_get_device(const snd_control_info_t *obj);
|
||||
unsigned int snd_ctl_element_info_get_device(const snd_ctl_element_info_t *obj);
|
||||
|
||||
unsigned int snd_control_info_get_subdevice(const snd_control_info_t *obj);
|
||||
unsigned int snd_ctl_element_info_get_subdevice(const snd_ctl_element_info_t *obj);
|
||||
|
||||
const char *snd_control_info_get_name(const snd_control_info_t *obj);
|
||||
const char *snd_ctl_element_info_get_name(const snd_ctl_element_info_t *obj);
|
||||
|
||||
unsigned int snd_control_info_get_index(const snd_control_info_t *obj);
|
||||
unsigned int snd_ctl_element_info_get_index(const snd_ctl_element_info_t *obj);
|
||||
|
||||
void snd_control_info_set_id(snd_control_info_t *obj, const snd_control_id_t *ptr);
|
||||
void snd_ctl_element_info_set_id(snd_ctl_element_info_t *obj, const snd_ctl_element_id_t *ptr);
|
||||
|
||||
void snd_control_info_set_numid(snd_control_info_t *obj, unsigned int val);
|
||||
void snd_ctl_element_info_set_numid(snd_ctl_element_info_t *obj, unsigned int val);
|
||||
|
||||
void snd_control_info_set_interface(snd_control_info_t *obj, snd_control_iface_t val);
|
||||
void snd_ctl_element_info_set_interface(snd_ctl_element_info_t *obj, snd_ctl_element_iface_t val);
|
||||
|
||||
void snd_control_info_set_device(snd_control_info_t *obj, unsigned int val);
|
||||
void snd_ctl_element_info_set_device(snd_ctl_element_info_t *obj, unsigned int val);
|
||||
|
||||
void snd_control_info_set_subdevice(snd_control_info_t *obj, unsigned int val);
|
||||
void snd_ctl_element_info_set_subdevice(snd_ctl_element_info_t *obj, unsigned int val);
|
||||
|
||||
void snd_control_info_set_name(snd_control_info_t *obj, const char *val);
|
||||
void snd_ctl_element_info_set_name(snd_ctl_element_info_t *obj, const char *val);
|
||||
|
||||
void snd_control_info_set_index(snd_control_info_t *obj, unsigned int val);
|
||||
void snd_ctl_element_info_set_index(snd_ctl_element_info_t *obj, unsigned int val);
|
||||
|
||||
size_t snd_control_sizeof();
|
||||
#define snd_control_alloca(ptr) ({ assert(ptr); *ptr = (snd_control_t *) alloca(snd_control_sizeof()); memset(*ptr, 0, snd_control_sizeof()); 0; })
|
||||
int snd_control_malloc(snd_control_t **ptr);
|
||||
void snd_control_free(snd_control_t *obj);
|
||||
void snd_control_copy(snd_control_t *dst, const snd_control_t *src);
|
||||
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);
|
||||
|
||||
void snd_control_get_id(const snd_control_t *obj, snd_control_id_t *ptr);
|
||||
void snd_ctl_element_get_id(const snd_ctl_element_t *obj, snd_ctl_element_id_t *ptr);
|
||||
|
||||
unsigned int snd_control_get_numid(const snd_control_t *obj);
|
||||
unsigned int snd_ctl_element_get_numid(const snd_ctl_element_t *obj);
|
||||
|
||||
snd_control_iface_t snd_control_get_interface(const snd_control_t *obj);
|
||||
snd_ctl_element_iface_t snd_ctl_element_get_interface(const snd_ctl_element_t *obj);
|
||||
|
||||
unsigned int snd_control_get_device(const snd_control_t *obj);
|
||||
unsigned int snd_ctl_element_get_device(const snd_ctl_element_t *obj);
|
||||
|
||||
unsigned int snd_control_get_subdevice(const snd_control_t *obj);
|
||||
unsigned int snd_ctl_element_get_subdevice(const snd_ctl_element_t *obj);
|
||||
|
||||
const char *snd_control_get_name(const snd_control_t *obj);
|
||||
const char *snd_ctl_element_get_name(const snd_ctl_element_t *obj);
|
||||
|
||||
unsigned int snd_control_get_index(const snd_control_t *obj);
|
||||
unsigned int snd_ctl_element_get_index(const snd_ctl_element_t *obj);
|
||||
|
||||
void snd_control_set_id(snd_control_t *obj, const snd_control_id_t *ptr);
|
||||
void snd_ctl_element_set_id(snd_ctl_element_t *obj, const snd_ctl_element_id_t *ptr);
|
||||
|
||||
void snd_control_set_numid(snd_control_t *obj, unsigned int val);
|
||||
void snd_ctl_element_set_numid(snd_ctl_element_t *obj, unsigned int val);
|
||||
|
||||
void snd_control_set_interface(snd_control_t *obj, snd_control_iface_t val);
|
||||
void snd_ctl_element_set_interface(snd_ctl_element_t *obj, snd_ctl_element_iface_t val);
|
||||
|
||||
void snd_control_set_device(snd_control_t *obj, unsigned int val);
|
||||
void snd_ctl_element_set_device(snd_ctl_element_t *obj, unsigned int val);
|
||||
|
||||
void snd_control_set_subdevice(snd_control_t *obj, unsigned int val);
|
||||
void snd_ctl_element_set_subdevice(snd_ctl_element_t *obj, unsigned int val);
|
||||
|
||||
void snd_control_set_name(snd_control_t *obj, const char *val);
|
||||
void snd_ctl_element_set_name(snd_ctl_element_t *obj, const char *val);
|
||||
|
||||
void snd_control_set_index(snd_control_t *obj, unsigned int val);
|
||||
void snd_ctl_element_set_index(snd_ctl_element_t *obj, unsigned int val);
|
||||
|
||||
long snd_control_get_boolean(const snd_control_t *obj, unsigned int idx);
|
||||
long snd_ctl_element_get_boolean(const snd_ctl_element_t *obj, unsigned int idx);
|
||||
|
||||
long snd_control_get_integer(const snd_control_t *obj, unsigned int idx);
|
||||
long snd_ctl_element_get_integer(const snd_ctl_element_t *obj, unsigned int idx);
|
||||
|
||||
unsigned int snd_control_get_enumerated(const snd_control_t *obj, unsigned int idx);
|
||||
unsigned int snd_ctl_element_get_enumerated(const snd_ctl_element_t *obj, unsigned int idx);
|
||||
|
||||
unsigned char snd_control_get_byte(const snd_control_t *obj, unsigned int idx);
|
||||
unsigned char snd_ctl_element_get_byte(const snd_ctl_element_t *obj, unsigned int idx);
|
||||
|
||||
void snd_control_set_boolean(snd_control_t *obj, unsigned int idx, long val);
|
||||
void snd_ctl_element_set_boolean(snd_ctl_element_t *obj, unsigned int idx, long val);
|
||||
|
||||
void snd_control_set_integer(snd_control_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_control_set_enumerated(snd_control_t *obj, unsigned int idx, unsigned int val);
|
||||
void snd_ctl_element_set_enumerated(snd_ctl_element_t *obj, unsigned int idx, unsigned int val);
|
||||
|
||||
void snd_control_set_byte(snd_control_t *obj, unsigned int idx, unsigned char val);
|
||||
void snd_ctl_element_set_byte(snd_ctl_element_t *obj, unsigned int idx, unsigned char val);
|
||||
|
||||
const void * snd_control_get_bytes(const snd_control_t *obj);
|
||||
const void * snd_ctl_element_get_bytes(const snd_ctl_element_t *obj);
|
||||
|
||||
void snd_control_get_iec958(const snd_control_t *obj, snd_aes_iec958_t *ptr);
|
||||
void snd_ctl_element_get_iec958(const snd_ctl_element_t *obj, snd_aes_iec958_t *ptr);
|
||||
|
||||
void snd_control_set_iec958(snd_control_t *obj, const snd_aes_iec958_t *ptr);
|
||||
void snd_ctl_element_set_iec958(snd_ctl_element_t *obj, const snd_aes_iec958_t *ptr);
|
||||
|
||||
size_t snd_hcontrol_list_sizeof();
|
||||
#define snd_hcontrol_list_alloca(ptr) ({ assert(ptr); *ptr = (snd_hcontrol_list_t *) alloca(snd_hcontrol_list_sizeof()); memset(*ptr, 0, snd_hcontrol_list_sizeof()); 0; })
|
||||
int snd_hcontrol_list_malloc(snd_hcontrol_list_t **ptr);
|
||||
void snd_hcontrol_list_free(snd_hcontrol_list_t *obj);
|
||||
void snd_hcontrol_list_copy(snd_hcontrol_list_t *dst, const snd_hcontrol_list_t *src);
|
||||
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);
|
||||
|
||||
void snd_hcontrol_list_set_offset(snd_hcontrol_list_t *obj, unsigned int val);
|
||||
void snd_hctl_element_list_set_offset(snd_hctl_element_list_t *obj, unsigned int val);
|
||||
|
||||
unsigned int snd_hcontrol_list_get_used(const snd_hcontrol_list_t *obj);
|
||||
unsigned int snd_hctl_element_list_get_used(const snd_hctl_element_list_t *obj);
|
||||
|
||||
unsigned int snd_hcontrol_list_get_count(const snd_hcontrol_list_t *obj);
|
||||
unsigned int snd_hctl_element_list_get_count(const snd_hctl_element_list_t *obj);
|
||||
|
||||
void snd_hcontrol_list_get_id(const snd_hcontrol_list_t *obj, unsigned int idx, snd_control_id_t *ptr);
|
||||
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_hcontrol_list_get_numid(const snd_hcontrol_list_t *obj, unsigned int idx);
|
||||
unsigned int snd_hctl_element_list_get_numid(const snd_hctl_element_list_t *obj, unsigned int idx);
|
||||
|
||||
snd_control_iface_t snd_hcontrol_list_get_interface(const snd_hcontrol_list_t *obj, unsigned int idx);
|
||||
snd_ctl_element_iface_t snd_hctl_element_list_get_interface(const snd_hctl_element_list_t *obj, unsigned int idx);
|
||||
|
||||
unsigned int snd_hcontrol_list_get_device(const snd_hcontrol_list_t *obj, unsigned int idx);
|
||||
unsigned int snd_hctl_element_list_get_device(const snd_hctl_element_list_t *obj, unsigned int idx);
|
||||
|
||||
unsigned int snd_hcontrol_list_get_subdevice(const snd_hcontrol_list_t *obj, unsigned int idx);
|
||||
unsigned int snd_hctl_element_list_get_subdevice(const snd_hctl_element_list_t *obj, unsigned int idx);
|
||||
|
||||
const char *snd_hcontrol_list_get_name(const snd_hcontrol_list_t *obj, unsigned int idx);
|
||||
const char *snd_hctl_element_list_get_name(const snd_hctl_element_list_t *obj, unsigned int idx);
|
||||
|
||||
unsigned int snd_hcontrol_list_get_index(const snd_hcontrol_list_t *obj, unsigned int idx);
|
||||
unsigned int snd_hctl_element_list_get_index(const snd_hctl_element_list_t *obj, unsigned int idx);
|
||||
|
||||
size_t snd_hcontrol_sizeof();
|
||||
#define snd_hcontrol_alloca(ptr) ({ assert(ptr); *ptr = (snd_hcontrol_t *) alloca(snd_hcontrol_sizeof()); memset(*ptr, 0, snd_hcontrol_sizeof()); 0; })
|
||||
int snd_hcontrol_malloc(snd_hcontrol_t **ptr);
|
||||
void snd_hcontrol_free(snd_hcontrol_t *obj);
|
||||
void snd_hcontrol_copy(snd_hcontrol_t *dst, const snd_hcontrol_t *src);
|
||||
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_hcontrol_get_id(const snd_hcontrol_t *obj, snd_control_id_t *ptr);
|
||||
void snd_hctl_element_get_id(const snd_hctl_element_t *obj, snd_ctl_element_id_t *ptr);
|
||||
|
||||
unsigned int snd_hcontrol_get_numid(const snd_hcontrol_t *obj);
|
||||
unsigned int snd_hctl_element_get_numid(const snd_hctl_element_t *obj);
|
||||
|
||||
snd_control_iface_t snd_hcontrol_get_interface(const snd_hcontrol_t *obj);
|
||||
snd_ctl_element_iface_t snd_hctl_element_get_interface(const snd_hctl_element_t *obj);
|
||||
|
||||
unsigned int snd_hcontrol_get_device(const snd_hcontrol_t *obj);
|
||||
unsigned int snd_hctl_element_get_device(const snd_hctl_element_t *obj);
|
||||
|
||||
unsigned int snd_hcontrol_get_subdevice(const snd_hcontrol_t *obj);
|
||||
unsigned int snd_hctl_element_get_subdevice(const snd_hctl_element_t *obj);
|
||||
|
||||
const char *snd_hcontrol_get_name(const snd_hcontrol_t *obj);
|
||||
const char *snd_hctl_element_get_name(const snd_hctl_element_t *obj);
|
||||
|
||||
unsigned int snd_hcontrol_get_index(const snd_hcontrol_t *obj);
|
||||
unsigned int snd_hctl_element_get_index(const snd_hctl_element_t *obj);
|
||||
|
||||
void snd_hcontrol_set_callback_change(snd_hcontrol_t *obj, snd_hcontrol_callback_t val);
|
||||
void snd_hctl_element_set_callback_change(snd_hctl_element_t *obj, snd_hctl_element_callback_t val);
|
||||
|
||||
void snd_hcontrol_set_callback_value(snd_hcontrol_t *obj, snd_hcontrol_callback_t val);
|
||||
void snd_hctl_element_set_callback_value(snd_hctl_element_t *obj, snd_hctl_element_callback_t val);
|
||||
|
||||
void snd_hcontrol_set_callback_remove(snd_hcontrol_t *obj, snd_hcontrol_callback_t val);
|
||||
void snd_hctl_element_set_callback_remove(snd_hctl_element_t *obj, snd_hctl_element_callback_t val);
|
||||
|
||||
void * snd_hcontrol_get_private_data(const snd_hcontrol_t *obj);
|
||||
void * snd_hctl_element_get_private_data(const snd_hctl_element_t *obj);
|
||||
|
||||
void snd_hcontrol_set_private_data(snd_hcontrol_t *obj, void * val);
|
||||
void snd_hctl_element_set_private_data(snd_hctl_element_t *obj, void * val);
|
||||
|
||||
void snd_hcontrol_set_private_free(snd_hcontrol_t *obj, snd_hcontrol_private_free_t val);
|
||||
void snd_hctl_element_set_private_free(snd_hctl_element_t *obj, snd_hctl_element_private_free_t val);
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
|
|
|
|||
|
|
@ -28,11 +28,11 @@
|
|||
#define _snd_pcm_sw_params sndrv_pcm_sw_params
|
||||
#define _snd_pcm_status sndrv_pcm_status
|
||||
|
||||
#define _snd_ctl_info sndrv_ctl_info
|
||||
#define _snd_control_id sndrv_control_id
|
||||
#define _snd_control_list sndrv_control_list
|
||||
#define _snd_control_info sndrv_control_info
|
||||
#define _snd_control sndrv_control
|
||||
#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_event sndrv_ctl_event
|
||||
|
||||
#define _snd_rawmidi_info sndrv_rawmidi_info
|
||||
|
|
|
|||
|
|
@ -74,16 +74,16 @@ typedef struct _snd_mixer_sid {
|
|||
unsigned int index;
|
||||
} snd_mixer_sid_t;
|
||||
|
||||
typedef struct _snd_mixer_simple_control_list {
|
||||
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_control_list_t;
|
||||
} snd_mixer_simple_element_list_t;
|
||||
|
||||
typedef struct _snd_mixer_simple_control {
|
||||
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 */
|
||||
|
|
@ -104,7 +104,7 @@ typedef struct _snd_mixer_simple_control {
|
|||
} names;
|
||||
long values[32];
|
||||
} volume; /* RW */
|
||||
} snd_mixer_simple_control_t;
|
||||
} snd_mixer_simple_element_t;
|
||||
|
||||
typedef struct _snd_mixer_simple_callbacks {
|
||||
void *private_data; /* may be used by an application */
|
||||
|
|
@ -121,9 +121,9 @@ extern "C" {
|
|||
#endif
|
||||
|
||||
const char *snd_mixer_simple_channel_name(snd_mixer_channel_id_t channel);
|
||||
int snd_mixer_simple_control_list(snd_mixer_t *handle, snd_mixer_simple_control_list_t *list);
|
||||
int snd_mixer_simple_control_read(snd_mixer_t *handle, snd_mixer_simple_control_t *simple);
|
||||
int snd_mixer_simple_control_write(snd_mixer_t *handle, snd_mixer_simple_control_t *simple);
|
||||
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);
|
||||
|
||||
#ifdef __cplusplus
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue