mirror of
https://github.com/alsa-project/alsa-lib.git
synced 2025-12-16 08:56:42 -05:00
Control API encapsulation. Better names for kernel API. Simpler PCM hw_params API. Added missing const.
This commit is contained in:
Abramo Bagnara
parent
ccb399f0cd
commit
8f0cb26fdf
71 changed files with 2001 additions and 694 deletions
|
|
@ -5,7 +5,7 @@ sysinclude_HEADERS = asoundlib.h
|
|||
#
|
||||
header_files=header.h version.h global.h input.h output.h error.h mixer.h \
|
||||
pcm.h pcm_m4.h rawmidi.h rawmidi_m4.h timer.h \
|
||||
hwdep.h hwdep_m4.h control.h \
|
||||
hwdep.h hwdep_m4.h control.h control_m4.h \
|
||||
seq.h seqmid.h seq_midi_event.h \
|
||||
conv.h instr.h conf.h footer.h
|
||||
|
||||
|
|
|
|||
|
|
@ -89,7 +89,7 @@ typedef struct {
|
|||
int cmd;
|
||||
union {
|
||||
int device;
|
||||
snd_ctl_hw_info_t hw_info;
|
||||
snd_ctl_info_t hw_info;
|
||||
snd_control_list_t clist;
|
||||
snd_control_info_t cinfo;
|
||||
snd_control_t cread;
|
||||
|
|
|
|||
|
|
@ -1,4 +1,18 @@
|
|||
|
||||
#define LIST_HEAD_IS_DEFINED
|
||||
struct list_head {
|
||||
struct list_head *next, *prev;
|
||||
};
|
||||
|
||||
/**
|
||||
* list_entry - get the struct for this entry
|
||||
* @ptr: the &struct list_head pointer.
|
||||
* @type: the type of the struct this is embedded in.
|
||||
* @member: the name of the list_struct within the struct.
|
||||
*/
|
||||
#define list_entry(ptr, type, member) \
|
||||
((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member)))
|
||||
|
||||
enum _snd_config_type {
|
||||
SND_CONFIG_TYPE_INTEGER,
|
||||
SND_CONFIG_TYPE_REAL,
|
||||
|
|
@ -50,30 +64,27 @@ int snd_config_top(snd_config_t **config);
|
|||
int snd_config_load(snd_config_t *config, snd_input_t *in);
|
||||
int snd_config_save(snd_config_t *config, snd_output_t *out);
|
||||
|
||||
int snd_config_search(snd_config_t *config, char *key, snd_config_t **result);
|
||||
int snd_config_search(snd_config_t *config, const char *key,
|
||||
snd_config_t **result);
|
||||
int snd_config_searchv(snd_config_t *config,
|
||||
snd_config_t **result, ...);
|
||||
|
||||
int snd_config_add(snd_config_t *config, snd_config_t *leaf);
|
||||
int snd_config_delete(snd_config_t *config);
|
||||
|
||||
int snd_config_make(snd_config_t **config, char *key,
|
||||
int snd_config_make(snd_config_t **config, const char *key,
|
||||
snd_config_type_t type);
|
||||
int snd_config_integer_make(snd_config_t **config, char *key);
|
||||
int snd_config_real_make(snd_config_t **config, char *key);
|
||||
int snd_config_string_make(snd_config_t **config, char *key);
|
||||
int snd_config_compound_make(snd_config_t **config, char *key, int join);
|
||||
int snd_config_integer_make(snd_config_t **config, const char *key);
|
||||
int snd_config_real_make(snd_config_t **config, const char *key);
|
||||
int snd_config_string_make(snd_config_t **config, const char *key);
|
||||
int snd_config_compound_make(snd_config_t **config, const char *key, int join);
|
||||
|
||||
int snd_config_integer_set(snd_config_t *config, long value);
|
||||
int snd_config_real_set(snd_config_t *config, double value);
|
||||
int snd_config_string_set(snd_config_t *config, char *value);
|
||||
int snd_config_string_set(snd_config_t *config, const char *value);
|
||||
int snd_config_integer_get(snd_config_t *config, long *value);
|
||||
int snd_config_real_get(snd_config_t *config, double *value);
|
||||
int snd_config_string_get(snd_config_t *config, char **value);
|
||||
|
||||
/* One argument: long, double or char* */
|
||||
int snd_config_set(snd_config_t *config, ...);
|
||||
int snd_config_get(snd_config_t *config, void *);
|
||||
int snd_config_string_get(snd_config_t *config, const char **value);
|
||||
|
||||
typedef struct list_head *snd_config_iterator_t;
|
||||
|
||||
|
|
|
|||
|
|
@ -6,21 +6,20 @@
|
|||
****************************************************************************/
|
||||
|
||||
typedef struct sndrv_aes_iec958 snd_aes_iec958_t;
|
||||
typedef union sndrv_digital_audio snd_digital_audio_t;
|
||||
typedef struct sndrv_ctl_hw_info snd_ctl_hw_info_t;
|
||||
typedef struct sndrv_control_id snd_control_id_t;
|
||||
typedef struct sndrv_control_list snd_control_list_t;
|
||||
typedef struct sndrv_control_info snd_control_info_t;
|
||||
typedef struct sndrv_control snd_control_t;
|
||||
typedef struct sndrv_ctl_event snd_ctl_event_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_event snd_ctl_event_t;
|
||||
|
||||
#ifdef SND_ENUM_TYPECHECK
|
||||
typedef struct __snd_card_type *snd_card_type;
|
||||
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_event_type *snd_ctl_event_type_t;
|
||||
#else
|
||||
typedef enum sndrv_card_type snd_card_type;
|
||||
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_event_type snd_ctl_event_type_t;
|
||||
|
|
@ -102,6 +101,7 @@ typedef enum sndrv_ctl_event_type snd_ctl_event_type_t;
|
|||
#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_CONTROL_IFACE_CARD ((snd_control_iface_t) SNDRV_CONTROL_IFACE_CARD)
|
||||
#define SND_CONTROL_IFACE_HWDEP ((snd_control_iface_t) SNDRV_CONTROL_IFACE_HWDEP)
|
||||
|
|
@ -110,20 +110,14 @@ typedef enum sndrv_ctl_event_type snd_ctl_event_type_t;
|
|||
#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_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_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_CONTROL_ACCESS_READ SNDRV_CONTROL_ACCESS_READ
|
||||
#define SND_CONTROL_ACCESS_WRITE SNDRV_CONTROL_ACCESS_WRITE
|
||||
#define SND_CONTROL_ACCESS_READWRITE SNDRV_CONTROL_ACCESS_READWRITE
|
||||
#define SND_CONTROL_ACCESS_VOLATILE SNDRV_CONTROL_ACCESS_VOLATILE
|
||||
#define SND_CONTROL_ACCESS_INACTIVE SNDRV_CONTROL_ACCESS_INACTIVE
|
||||
#define SND_CONTROL_ACCESS_LOCK SNDRV_CONTROL_ACCESS_LOCK
|
||||
#define SND_CONTROL_ACCESS_INDIRECT SNDRV_CONTROL_ACCESS_INDIRECT
|
||||
#define SND_CTL_EVENT_LAST ((snd_ctl_event_type_t) SNDRV_CTL_EVENT_LAST)
|
||||
|
||||
enum _snd_ctl_type {
|
||||
SND_CTL_TYPE_HW,
|
||||
|
|
@ -142,16 +136,7 @@ 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 {
|
||||
void *private_data; /* may be used by an application */
|
||||
void (*rebuild) (snd_ctl_t *handle, void *private_data);
|
||||
void (*value) (snd_ctl_t *handle, void *private_data, snd_control_id_t * id);
|
||||
void (*change) (snd_ctl_t *handle, void *private_data, snd_control_id_t * id);
|
||||
void (*add) (snd_ctl_t *handle, void *private_data, snd_control_id_t * id);
|
||||
void (*remove) (snd_ctl_t *handle, void *private_data, snd_control_id_t * id);
|
||||
void *reserved[58]; /* reserved for the future use - must be NULL!!! */
|
||||
} snd_ctl_callbacks_t;
|
||||
typedef struct _snd_ctl_callbacks snd_ctl_callbacks_t;
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
|
|
@ -175,7 +160,7 @@ 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_hw_info(snd_ctl_t *handle, snd_ctl_hw_info_t *info);
|
||||
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);
|
||||
|
|
@ -191,6 +176,15 @@ 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);
|
||||
|
||||
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_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);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
|
@ -199,57 +193,20 @@ int snd_ctl_read(snd_ctl_t *handle, snd_ctl_callbacks_t * callbacks);
|
|||
* Highlevel API for controls
|
||||
*/
|
||||
|
||||
#define LIST_HEAD_IS_DEFINED
|
||||
struct list_head {
|
||||
struct list_head *next, *prev;
|
||||
};
|
||||
|
||||
/**
|
||||
* list_entry - get the struct for this entry
|
||||
* @ptr: the &struct list_head pointer.
|
||||
* @type: the type of the struct this is embedded in.
|
||||
* @member: the name of the list_struct within the struct.
|
||||
*/
|
||||
#define list_entry(ptr, type, member) \
|
||||
((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member)))
|
||||
|
||||
|
||||
typedef struct _snd_hcontrol_list snd_hcontrol_list_t;
|
||||
typedef struct _snd_hcontrol snd_hcontrol_t;
|
||||
|
||||
struct _snd_hcontrol_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) controls */
|
||||
unsigned int controls; /* R: count of all available controls */
|
||||
snd_control_id_t *pids; /* W: IDs */
|
||||
};
|
||||
|
||||
struct _snd_hcontrol {
|
||||
snd_control_id_t id; /* must be always on top */
|
||||
struct list_head list; /* links for list of all hcontrols */
|
||||
int change: 1, /* structure change */
|
||||
value: 1; /* value change */
|
||||
/* event callbacks */
|
||||
void (*event_change)(snd_ctl_t *handle, snd_hcontrol_t *hcontrol);
|
||||
void (*event_value)(snd_ctl_t *handle, snd_hcontrol_t *hcontrol);
|
||||
void (*event_remove)(snd_ctl_t *handle, snd_hcontrol_t *hcontrol);
|
||||
/* private data */
|
||||
void *private_data;
|
||||
void (*private_free)(void *private_data);
|
||||
/* links */
|
||||
snd_ctl_t *handle; /* associated handle */
|
||||
};
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef int (snd_ctl_hsort_t)(const snd_hcontrol_t *c1, const snd_hcontrol_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 int (*snd_ctl_hsort_t)(const snd_hcontrol_t *c1, const snd_hcontrol_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);
|
||||
|
||||
int snd_ctl_hbuild(snd_ctl_t *handle, snd_ctl_hsort_t *csort);
|
||||
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);
|
||||
|
|
@ -259,9 +216,9 @@ 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);
|
||||
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_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);
|
||||
|
|
@ -269,6 +226,8 @@ int snd_ctl_hbag_destroy(void **bag, void (*hcontrol_free)(snd_hcontrol_t *hcont
|
|||
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);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
|
|
|||
284
include/control_m4.h
Normal file
284
include/control_m4.h
Normal file
|
|
@ -0,0 +1,284 @@
|
|||
#ifdef __cplusplus
|
||||
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);
|
||||
|
||||
unsigned int snd_control_id_get_numid(const snd_control_id_t *obj);
|
||||
|
||||
snd_control_iface_t snd_control_id_get_interface(const snd_control_id_t *obj);
|
||||
|
||||
unsigned int snd_control_id_get_device(const snd_control_id_t *obj);
|
||||
|
||||
unsigned int snd_control_id_get_subdevice(const snd_control_id_t *obj);
|
||||
|
||||
const char *snd_control_id_get_name(const snd_control_id_t *obj);
|
||||
|
||||
unsigned int snd_control_id_get_index(const snd_control_id_t *obj);
|
||||
|
||||
void snd_control_id_set_numid(snd_control_id_t *obj, unsigned int val);
|
||||
|
||||
void snd_control_id_set_interface(snd_control_id_t *obj, snd_control_iface_t val);
|
||||
|
||||
void snd_control_id_set_device(snd_control_id_t *obj, unsigned int val);
|
||||
|
||||
void snd_control_id_set_subdevice(snd_control_id_t *obj, unsigned int val);
|
||||
|
||||
void snd_control_id_set_name(snd_control_id_t *obj, const char *val);
|
||||
|
||||
void snd_control_id_set_index(snd_control_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);
|
||||
|
||||
int snd_ctl_info_get_card(const snd_ctl_info_t *obj);
|
||||
|
||||
snd_card_type_t snd_ctl_info_get_type(const snd_ctl_info_t *obj);
|
||||
|
||||
const char *snd_ctl_info_get_id(const snd_ctl_info_t *obj);
|
||||
|
||||
const char *snd_ctl_info_get_abbreviation(const snd_ctl_info_t *obj);
|
||||
|
||||
const char *snd_ctl_info_get_name(const snd_ctl_info_t *obj);
|
||||
|
||||
const char *snd_ctl_info_get_longname(const snd_ctl_info_t *obj);
|
||||
|
||||
const char *snd_ctl_info_get_mixerid(const snd_ctl_info_t *obj);
|
||||
|
||||
const char *snd_ctl_info_get_mixername(const snd_ctl_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; })
|
||||
int snd_ctl_event_malloc(snd_ctl_event_t **ptr);
|
||||
void snd_ctl_event_free(snd_ctl_event_t *obj);
|
||||
void snd_ctl_event_copy(snd_ctl_event_t *dst, const snd_ctl_event_t *src);
|
||||
|
||||
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);
|
||||
|
||||
snd_control_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);
|
||||
|
||||
unsigned int snd_ctl_event_get_subdevice(const snd_ctl_event_t *obj);
|
||||
|
||||
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);
|
||||
|
||||
void snd_control_list_set_offset(snd_control_list_t *obj, unsigned int val);
|
||||
|
||||
unsigned int snd_control_list_get_used(const snd_control_list_t *obj);
|
||||
|
||||
unsigned int snd_control_list_get_count(const snd_control_list_t *obj);
|
||||
|
||||
void snd_control_list_get_id(const snd_control_list_t *obj, unsigned int idx, snd_control_id_t *ptr);
|
||||
|
||||
unsigned int snd_control_list_get_numid(const snd_control_list_t *obj, unsigned int idx);
|
||||
|
||||
snd_control_iface_t snd_control_list_get_interface(const snd_control_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_control_list_get_subdevice(const snd_control_list_t *obj, unsigned int idx);
|
||||
|
||||
const char *snd_control_list_get_name(const snd_control_list_t *obj, unsigned int idx);
|
||||
|
||||
unsigned int snd_control_list_get_index(const snd_control_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);
|
||||
|
||||
snd_control_type_t snd_control_info_get_type(const snd_control_info_t *obj);
|
||||
|
||||
int snd_control_info_is_readable(const snd_control_info_t *obj);
|
||||
|
||||
int snd_control_info_is_writable(const snd_control_info_t *obj);
|
||||
|
||||
int snd_control_info_is_volatile(const snd_control_info_t *obj);
|
||||
|
||||
int snd_control_info_is_inactive(const snd_control_info_t *obj);
|
||||
|
||||
int snd_control_info_is_locked(const snd_control_info_t *obj);
|
||||
|
||||
int snd_control_info_is_indirect(const snd_control_info_t *obj);
|
||||
|
||||
unsigned int snd_control_info_get_count(const snd_control_info_t *obj);
|
||||
|
||||
long snd_control_info_get_min(const snd_control_info_t *obj);
|
||||
|
||||
long snd_control_info_get_max(const snd_control_info_t *obj);
|
||||
|
||||
long snd_control_info_get_step(const snd_control_info_t *obj);
|
||||
|
||||
unsigned int snd_control_info_get_items(const snd_control_info_t *obj);
|
||||
|
||||
void snd_control_info_set_item(snd_control_info_t *obj, unsigned int val);
|
||||
|
||||
const char *snd_control_info_get_item_name(const snd_control_info_t *obj);
|
||||
|
||||
void snd_control_info_get_id(const snd_control_info_t *obj, snd_control_id_t *ptr);
|
||||
|
||||
unsigned int snd_control_info_get_numid(const snd_control_info_t *obj);
|
||||
|
||||
snd_control_iface_t snd_control_info_get_interface(const snd_control_info_t *obj);
|
||||
|
||||
unsigned int snd_control_info_get_device(const snd_control_info_t *obj);
|
||||
|
||||
unsigned int snd_control_info_get_subdevice(const snd_control_info_t *obj);
|
||||
|
||||
const char *snd_control_info_get_name(const snd_control_info_t *obj);
|
||||
|
||||
unsigned int snd_control_info_get_index(const snd_control_info_t *obj);
|
||||
|
||||
void snd_control_info_set_id(snd_control_info_t *obj, const snd_control_id_t *ptr);
|
||||
|
||||
void snd_control_info_set_numid(snd_control_info_t *obj, unsigned int val);
|
||||
|
||||
void snd_control_info_set_interface(snd_control_info_t *obj, snd_control_iface_t val);
|
||||
|
||||
void snd_control_info_set_device(snd_control_info_t *obj, unsigned int val);
|
||||
|
||||
void snd_control_info_set_subdevice(snd_control_info_t *obj, unsigned int val);
|
||||
|
||||
void snd_control_info_set_name(snd_control_info_t *obj, const char *val);
|
||||
|
||||
void snd_control_info_set_index(snd_control_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);
|
||||
|
||||
void snd_control_get_id(const snd_control_t *obj, snd_control_id_t *ptr);
|
||||
|
||||
unsigned int snd_control_get_numid(const snd_control_t *obj);
|
||||
|
||||
snd_control_iface_t snd_control_get_interface(const snd_control_t *obj);
|
||||
|
||||
unsigned int snd_control_get_device(const snd_control_t *obj);
|
||||
|
||||
unsigned int snd_control_get_subdevice(const snd_control_t *obj);
|
||||
|
||||
const char *snd_control_get_name(const snd_control_t *obj);
|
||||
|
||||
unsigned int snd_control_get_index(const snd_control_t *obj);
|
||||
|
||||
void snd_control_set_id(snd_control_t *obj, const snd_control_id_t *ptr);
|
||||
|
||||
void snd_control_set_numid(snd_control_t *obj, unsigned int val);
|
||||
|
||||
void snd_control_set_interface(snd_control_t *obj, snd_control_iface_t val);
|
||||
|
||||
void snd_control_set_device(snd_control_t *obj, unsigned int val);
|
||||
|
||||
void snd_control_set_subdevice(snd_control_t *obj, unsigned int val);
|
||||
|
||||
void snd_control_set_name(snd_control_t *obj, const char *val);
|
||||
|
||||
void snd_control_set_index(snd_control_t *obj, unsigned int val);
|
||||
|
||||
long snd_control_get_boolean(const snd_control_t *obj, unsigned int idx);
|
||||
|
||||
long snd_control_get_integer(const snd_control_t *obj, unsigned int idx);
|
||||
|
||||
unsigned int snd_control_get_enumerated(const snd_control_t *obj, unsigned int idx);
|
||||
|
||||
unsigned char snd_control_get_byte(const snd_control_t *obj, unsigned int idx);
|
||||
|
||||
void snd_control_set_boolean(snd_control_t *obj, unsigned int idx, long val);
|
||||
|
||||
void snd_control_set_integer(snd_control_t *obj, unsigned int idx, long val);
|
||||
|
||||
void snd_control_set_enumerated(snd_control_t *obj, unsigned int idx, unsigned int val);
|
||||
|
||||
void snd_control_set_byte(snd_control_t *obj, unsigned int idx, unsigned char val);
|
||||
|
||||
const void * snd_control_get_bytes(const snd_control_t *obj);
|
||||
|
||||
void snd_control_get_iec958(const snd_control_t *obj, snd_aes_iec958_t *ptr);
|
||||
|
||||
void snd_control_set_iec958(snd_control_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);
|
||||
|
||||
void snd_hcontrol_list_set_offset(snd_hcontrol_list_t *obj, unsigned int val);
|
||||
|
||||
unsigned int snd_hcontrol_list_get_used(const snd_hcontrol_list_t *obj);
|
||||
|
||||
unsigned int snd_hcontrol_list_get_count(const snd_hcontrol_list_t *obj);
|
||||
|
||||
void snd_hcontrol_list_get_id(const snd_hcontrol_list_t *obj, unsigned int idx, snd_control_id_t *ptr);
|
||||
|
||||
unsigned int snd_hcontrol_list_get_numid(const snd_hcontrol_list_t *obj, unsigned int idx);
|
||||
|
||||
snd_control_iface_t snd_hcontrol_list_get_interface(const snd_hcontrol_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_hcontrol_list_get_subdevice(const snd_hcontrol_list_t *obj, unsigned int idx);
|
||||
|
||||
const char *snd_hcontrol_list_get_name(const snd_hcontrol_list_t *obj, unsigned int idx);
|
||||
|
||||
unsigned int snd_hcontrol_list_get_index(const snd_hcontrol_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);
|
||||
|
||||
void snd_hcontrol_get_id(const snd_hcontrol_t *obj, snd_control_id_t *ptr);
|
||||
|
||||
unsigned int snd_hcontrol_get_numid(const snd_hcontrol_t *obj);
|
||||
|
||||
snd_control_iface_t snd_hcontrol_get_interface(const snd_hcontrol_t *obj);
|
||||
|
||||
unsigned int snd_hcontrol_get_device(const snd_hcontrol_t *obj);
|
||||
|
||||
unsigned int snd_hcontrol_get_subdevice(const snd_hcontrol_t *obj);
|
||||
|
||||
const char *snd_hcontrol_get_name(const snd_hcontrol_t *obj);
|
||||
|
||||
unsigned int snd_hcontrol_get_index(const snd_hcontrol_t *obj);
|
||||
|
||||
void snd_hcontrol_set_callback_change(snd_hcontrol_t *obj, snd_hcontrol_callback_t val);
|
||||
|
||||
void snd_hcontrol_set_callback_value(snd_hcontrol_t *obj, snd_hcontrol_callback_t val);
|
||||
|
||||
void snd_hcontrol_set_callback_remove(snd_hcontrol_t *obj, snd_hcontrol_callback_t val);
|
||||
|
||||
void * snd_hcontrol_get_private_data(const snd_hcontrol_t *obj);
|
||||
|
||||
void snd_hcontrol_set_private_data(snd_hcontrol_t *obj, void * val);
|
||||
|
||||
void snd_hcontrol_set_private_free(snd_hcontrol_t *obj, snd_hcontrol_private_free_t val);
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
|
@ -10,7 +10,7 @@
|
|||
#define SND_BIG_ENDIAN SNDRV_BIG_ENDIAN
|
||||
#endif
|
||||
|
||||
//#define SND_ENUM_TYPECHECK
|
||||
#define SND_ENUM_TYPECHECK
|
||||
|
||||
#ifdef SND_ENUM_TYPECHECK
|
||||
#define snd_enum_to_int(v) ((unsigned int)(unsigned long)(v))
|
||||
|
|
@ -22,19 +22,3 @@
|
|||
#define snd_enum_incr(v) (++(v))
|
||||
#endif
|
||||
|
||||
enum _snd_set_mode {
|
||||
SND_CHANGE,
|
||||
SND_TRY,
|
||||
SND_TEST,
|
||||
};
|
||||
|
||||
#ifdef SND_ENUM_TYPECHECK
|
||||
typedef struct __snd_set_mode *snd_set_mode_t;
|
||||
#else
|
||||
typedef enum _snd_set_mode snd_set_mode_t;
|
||||
#endif
|
||||
|
||||
#define SND_CHANGE ((snd_set_mode_t) SND_CHANGE)
|
||||
#define SND_TRY ((snd_set_mode_t) SND_TRY)
|
||||
#define SND_TEST ((snd_set_mode_t) SND_TEST)
|
||||
|
||||
|
|
|
|||
|
|
@ -31,6 +31,7 @@
|
|||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <fcntl.h>
|
||||
#include <assert.h>
|
||||
#include <sys/uio.h>
|
||||
|
||||
#ifndef ATTRIBUTE_UNUSED
|
||||
|
|
|
|||
|
|
@ -3,7 +3,7 @@ extern "C" {
|
|||
#endif
|
||||
|
||||
size_t snd_hwdep_info_sizeof();
|
||||
#define snd_hwdep_info_alloca(ptr) ({assert(ptr); *ptr = (snd_hwdep_info_t *) alloca(snd_hwdep_info_sizeof()); 0;})
|
||||
#define snd_hwdep_info_alloca(ptr) ({ assert(ptr); *ptr = (snd_hwdep_info_t *) alloca(snd_hwdep_info_sizeof()); memset(*ptr, 0, snd_hwdep_info_sizeof()); 0; })
|
||||
int snd_hwdep_info_malloc(snd_hwdep_info_t **ptr);
|
||||
void snd_hwdep_info_free(snd_hwdep_info_t *obj);
|
||||
void snd_hwdep_info_copy(snd_hwdep_info_t *dst, const snd_hwdep_info_t *src);
|
||||
|
|
@ -12,9 +12,9 @@ unsigned int snd_hwdep_info_get_device(const snd_hwdep_info_t *obj);
|
|||
|
||||
int snd_hwdep_info_get_card(const snd_hwdep_info_t *obj);
|
||||
|
||||
const char * snd_hwdep_info_get_id(const snd_hwdep_info_t *obj);
|
||||
const char *snd_hwdep_info_get_id(const snd_hwdep_info_t *obj);
|
||||
|
||||
const char * snd_hwdep_info_get_name(const snd_hwdep_info_t *obj);
|
||||
const char *snd_hwdep_info_get_name(const snd_hwdep_info_t *obj);
|
||||
|
||||
snd_hwdep_type_t snd_hwdep_info_get_type(const snd_hwdep_info_t *obj);
|
||||
|
||||
|
|
|
|||
|
|
@ -19,12 +19,22 @@
|
|||
*
|
||||
*/
|
||||
|
||||
#ifndef __LOCAL_H
|
||||
#define __LOCAL_H
|
||||
|
||||
#define _snd_interval sndrv_interval
|
||||
#define _snd_pcm_info sndrv_pcm_info
|
||||
#define _snd_pcm_hw_params sndrv_pcm_hw_params
|
||||
#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_event sndrv_ctl_event
|
||||
|
||||
#define _snd_rawmidi_info sndrv_rawmidi_info
|
||||
#define _snd_rawmidi_params sndrv_rawmidi_params
|
||||
#define _snd_rawmidi_status sndrv_rawmidi_status
|
||||
|
|
@ -32,6 +42,7 @@
|
|||
#define _snd_hwdep_info sndrv_hwdep_info
|
||||
|
||||
#include "asoundlib.h"
|
||||
#include <errno.h>
|
||||
|
||||
#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
|
||||
#define ERR(...) snd_lib_error(__FILE__, __LINE__, __FUNCTION__, 0, __VA_ARGS__)
|
||||
|
|
@ -41,3 +52,20 @@
|
|||
#define SYSERR(args...) snd_lib_error(__FILE__, __LINE__, __FUNCTION__, errno, ##args)
|
||||
#endif
|
||||
|
||||
enum _snd_set_mode {
|
||||
SND_CHANGE,
|
||||
SND_TRY,
|
||||
SND_TEST,
|
||||
};
|
||||
|
||||
#ifdef SND_ENUM_TYPECHECK
|
||||
typedef struct __snd_set_mode *snd_set_mode_t;
|
||||
#else
|
||||
typedef enum _snd_set_mode snd_set_mode_t;
|
||||
#endif
|
||||
|
||||
#define SND_CHANGE ((snd_set_mode_t) SND_CHANGE)
|
||||
#define SND_TRY ((snd_set_mode_t) SND_TRY)
|
||||
#define SND_TEST ((snd_set_mode_t) SND_TEST)
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -41,17 +41,23 @@ typedef enum sndrv_pcm_tstamp snd_pcm_tstamp_t;
|
|||
#define SND_PCM_CLASS_MULTI ((snd_pcm_class_t) SNDRV_PCM_CLASS_MULTI)
|
||||
#define SND_PCM_CLASS_MODEM ((snd_pcm_class_t) SNDRV_PCM_CLASS_MODEM)
|
||||
#define SND_PCM_CLASS_DIGITIZER ((snd_pcm_class_t) SNDRV_PCM_CLASS_DIGITIZER)
|
||||
#define SND_PCM_CLASS_LAST ((snd_pcm_class_t) SNDRV_PCM_CLASS_LAST)
|
||||
|
||||
#define SND_PCM_SUBCLASS_GENERIC_MIX ((snd_pcm_subclass_t) SNDRV_PCM_SUBCLASS_GENERIC_MIX)
|
||||
#define SND_PCM_SUBCLASS_MULTI_MIX ((snd_pcm_subclass_t) SNDRV_PCM_SUBCLASS_MULTI_MIX)
|
||||
#define SND_PCM_SUBCLASS_LAST ((snd_pcm_subclass_t) SNDRV_PCM_SUBCLASS_LAST)
|
||||
|
||||
#define SND_PCM_STREAM_PLAYBACK ((snd_pcm_stream_t) SNDRV_PCM_STREAM_PLAYBACK)
|
||||
#define SND_PCM_STREAM_CAPTURE ((snd_pcm_stream_t) SNDRV_PCM_STREAM_CAPTURE)
|
||||
#define SND_PCM_STREAM_LAST ((snd_pcm_stream_t) SNDRV_PCM_STREAM_LAST)
|
||||
|
||||
#define SND_PCM_ACCESS_MMAP_INTERLEAVED ((snd_pcm_access_t) SNDRV_PCM_ACCESS_MMAP_INTERLEAVED)
|
||||
#define SND_PCM_ACCESS_MMAP_NONINTERLEAVED ((snd_pcm_access_t) SNDRV_PCM_ACCESS_MMAP_NONINTERLEAVED)
|
||||
#define SND_PCM_ACCESS_MMAP_COMPLEX ((snd_pcm_access_t) SNDRV_PCM_ACCESS_MMAP_COMPLEX)
|
||||
#define SND_PCM_ACCESS_RW_INTERLEAVED ((snd_pcm_access_t) SNDRV_PCM_ACCESS_RW_INTERLEAVED)
|
||||
#define SND_PCM_ACCESS_RW_NONINTERLEAVED ((snd_pcm_access_t) SNDRV_PCM_ACCESS_RW_NONINTERLEAVED)
|
||||
#define SND_PCM_ACCESS_LAST ((snd_pcm_access_t) SNDRV_PCM_ACCESS_LAST)
|
||||
|
||||
#define SND_PCM_FORMAT_UNKNOWN ((snd_pcm_format_t) -1)
|
||||
#define SND_PCM_FORMAT_S8 ((snd_pcm_format_t) SNDRV_PCM_FORMAT_S8)
|
||||
#define SND_PCM_FORMAT_U8 ((snd_pcm_format_t) SNDRV_PCM_FORMAT_U8)
|
||||
|
|
@ -98,8 +104,10 @@ typedef enum sndrv_pcm_tstamp snd_pcm_tstamp_t;
|
|||
#define SND_PCM_FORMAT_FLOAT ((snd_pcm_format_t) SNDRV_PCM_FORMAT_FLOAT)
|
||||
#define SND_PCM_FORMAT_FLOAT64 ((snd_pcm_format_t) SNDRV_PCM_FORMAT_FLOAT64)
|
||||
#define SND_PCM_FORMAT_IEC958_SUBFRAME ((snd_pcm_format_t) SNDRV_PCM_FORMAT_IEC958_SUBFRAME)
|
||||
|
||||
#define SND_PCM_SUBFORMAT_STD ((snd_pcm_subformat_t) SNDRV_PCM_SUBFORMAT_STD)
|
||||
#define SND_PCM_SUBFORMAT_LAST ((snd_pcm_subformat_t) SNDRV_PCM_SUBFORMAT_LAST)
|
||||
|
||||
#define SND_PCM_STATE_OPEN ((snd_pcm_state_t) SNDRV_PCM_STATE_OPEN)
|
||||
#define SND_PCM_STATE_SETUP ((snd_pcm_state_t) SNDRV_PCM_STATE_SETUP)
|
||||
#define SND_PCM_STATE_PREPARED ((snd_pcm_state_t) SNDRV_PCM_STATE_PREPARED)
|
||||
|
|
@ -108,12 +116,15 @@ typedef enum sndrv_pcm_tstamp snd_pcm_tstamp_t;
|
|||
#define SND_PCM_STATE_DRAINING ((snd_pcm_state_t) SNDRV_PCM_STATE_DRAINING)
|
||||
#define SND_PCM_STATE_PAUSED ((snd_pcm_state_t) SNDRV_PCM_STATE_PAUSED)
|
||||
#define SND_PCM_STATE_LAST ((snd_pcm_state_t) SNDRV_PCM_STATE_LAST)
|
||||
|
||||
#define SND_PCM_START_DATA ((snd_pcm_start_t) SNDRV_PCM_START_DATA)
|
||||
#define SND_PCM_START_EXPLICIT ((snd_pcm_start_t) SNDRV_PCM_START_EXPLICIT)
|
||||
#define SND_PCM_START_LAST ((snd_pcm_start_t) SNDRV_PCM_START_LAST)
|
||||
|
||||
#define SND_PCM_XRUN_NONE ((snd_pcm_xrun_t) SNDRV_PCM_XRUN_NONE)
|
||||
#define SND_PCM_XRUN_STOP ((snd_pcm_xrun_t) SNDRV_PCM_XRUN_STOP)
|
||||
#define SND_PCM_XRUN_LAST ((snd_pcm_xrun_t) SNDRV_PCM_XRUN_LAST)
|
||||
|
||||
#define SND_PCM_TSTAMP_NONE ((snd_pcm_tstamp_t) SNDRV_PCM_TSTAMP_NONE)
|
||||
#define SND_PCM_TSTAMP_MMAP ((snd_pcm_tstamp_t) SNDRV_PCM_TSTAMP_MMAP)
|
||||
#define SND_PCM_TSTAMP_LAST ((snd_pcm_tstamp_t) SNDRV_PCM_TSTAMP_LAST)
|
||||
|
|
@ -200,7 +211,7 @@ typedef struct _snd_pcm_channel_area {
|
|||
extern "C" {
|
||||
#endif
|
||||
|
||||
int snd_pcm_open(snd_pcm_t **pcm, char *name,
|
||||
int snd_pcm_open(snd_pcm_t **pcm, const char *name,
|
||||
snd_pcm_stream_t stream, int mode);
|
||||
|
||||
snd_pcm_type_t snd_pcm_type(snd_pcm_t *pcm);
|
||||
|
|
@ -251,7 +262,6 @@ int snd_pcm_hw_params_get_rate_numden(const snd_pcm_hw_params_t *params,
|
|||
unsigned int *rate_num,
|
||||
unsigned int *rate_den);
|
||||
int snd_pcm_hw_params_get_sbits(const snd_pcm_hw_params_t *params);
|
||||
int snd_pcm_hw_params_get_flags(const snd_pcm_hw_params_t *params);
|
||||
int snd_pcm_hw_params_get_fifo_size(const snd_pcm_hw_params_t *params);
|
||||
int snd_pcm_hw_params_dump(snd_pcm_hw_params_t *params, snd_output_t *out);
|
||||
|
||||
|
|
|
|||
172
include/pcm_m4.h
172
include/pcm_m4.h
|
|
@ -3,8 +3,9 @@ extern "C" {
|
|||
#endif
|
||||
|
||||
|
||||
|
||||
size_t snd_pcm_access_mask_sizeof();
|
||||
#define snd_pcm_access_mask_alloca(ptr) ({assert(ptr); *ptr = (snd_pcm_access_mask_t *) alloca(snd_pcm_access_mask_sizeof()); 0;})
|
||||
#define snd_pcm_access_mask_alloca(ptr) ({ assert(ptr); *ptr = (snd_pcm_access_mask_t *) alloca(snd_pcm_access_mask_sizeof()); memset(*ptr, 0, snd_pcm_access_mask_sizeof()); 0; })
|
||||
int snd_pcm_access_mask_malloc(snd_pcm_access_mask_t **ptr);
|
||||
void snd_pcm_access_mask_free(snd_pcm_access_mask_t *obj);
|
||||
void snd_pcm_access_mask_copy(snd_pcm_access_mask_t *dst, const snd_pcm_access_mask_t *src);
|
||||
|
|
@ -16,7 +17,7 @@ void snd_pcm_access_mask_set(snd_pcm_access_mask_t *mask, snd_pcm_access_t val);
|
|||
void snd_pcm_access_mask_reset(snd_pcm_access_mask_t *mask, snd_pcm_access_t val);
|
||||
|
||||
size_t snd_pcm_format_mask_sizeof();
|
||||
#define snd_pcm_format_mask_alloca(ptr) ({assert(ptr); *ptr = (snd_pcm_format_mask_t *) alloca(snd_pcm_format_mask_sizeof()); 0;})
|
||||
#define snd_pcm_format_mask_alloca(ptr) ({ assert(ptr); *ptr = (snd_pcm_format_mask_t *) alloca(snd_pcm_format_mask_sizeof()); memset(*ptr, 0, snd_pcm_format_mask_sizeof()); 0; })
|
||||
int snd_pcm_format_mask_malloc(snd_pcm_format_mask_t **ptr);
|
||||
void snd_pcm_format_mask_free(snd_pcm_format_mask_t *obj);
|
||||
void snd_pcm_format_mask_copy(snd_pcm_format_mask_t *dst, const snd_pcm_format_mask_t *src);
|
||||
|
|
@ -28,7 +29,7 @@ void snd_pcm_format_mask_set(snd_pcm_format_mask_t *mask, snd_pcm_format_t val);
|
|||
void snd_pcm_format_mask_reset(snd_pcm_format_mask_t *mask, snd_pcm_format_t val);
|
||||
|
||||
size_t snd_pcm_subformat_mask_sizeof();
|
||||
#define snd_pcm_subformat_mask_alloca(ptr) ({assert(ptr); *ptr = (snd_pcm_subformat_mask_t *) alloca(snd_pcm_subformat_mask_sizeof()); 0;})
|
||||
#define snd_pcm_subformat_mask_alloca(ptr) ({ assert(ptr); *ptr = (snd_pcm_subformat_mask_t *) alloca(snd_pcm_subformat_mask_sizeof()); memset(*ptr, 0, snd_pcm_subformat_mask_sizeof()); 0; })
|
||||
int snd_pcm_subformat_mask_malloc(snd_pcm_subformat_mask_t **ptr);
|
||||
void snd_pcm_subformat_mask_free(snd_pcm_subformat_mask_t *obj);
|
||||
void snd_pcm_subformat_mask_copy(snd_pcm_subformat_mask_t *dst, const snd_pcm_subformat_mask_t *src);
|
||||
|
|
@ -40,36 +41,40 @@ void snd_pcm_subformat_mask_set(snd_pcm_subformat_mask_t *mask, snd_pcm_subforma
|
|||
void snd_pcm_subformat_mask_reset(snd_pcm_subformat_mask_t *mask, snd_pcm_subformat_t val);
|
||||
|
||||
size_t snd_pcm_hw_params_sizeof();
|
||||
#define snd_pcm_hw_params_alloca(ptr) ({assert(ptr); *ptr = (snd_pcm_hw_params_t *) alloca(snd_pcm_hw_params_sizeof()); 0;})
|
||||
#define snd_pcm_hw_params_alloca(ptr) ({ assert(ptr); *ptr = (snd_pcm_hw_params_t *) alloca(snd_pcm_hw_params_sizeof()); memset(*ptr, 0, snd_pcm_hw_params_sizeof()); 0; })
|
||||
int snd_pcm_hw_params_malloc(snd_pcm_hw_params_t **ptr);
|
||||
void snd_pcm_hw_params_free(snd_pcm_hw_params_t *obj);
|
||||
void snd_pcm_hw_params_copy(snd_pcm_hw_params_t *dst, const snd_pcm_hw_params_t *src);
|
||||
|
||||
snd_pcm_access_t snd_pcm_hw_params_get_access(const snd_pcm_hw_params_t *params);
|
||||
int snd_pcm_hw_params_set_access(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_set_mode_t mode, snd_pcm_access_t val);
|
||||
int snd_pcm_hw_params_test_access(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_access_t val);
|
||||
int snd_pcm_hw_params_set_access(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_access_t val);
|
||||
snd_pcm_access_t snd_pcm_hw_params_set_access_first(snd_pcm_t *pcm, snd_pcm_hw_params_t *params);
|
||||
snd_pcm_access_t snd_pcm_hw_params_set_access_last(snd_pcm_t *pcm, snd_pcm_hw_params_t *params);
|
||||
int snd_pcm_hw_params_set_access_mask(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_set_mode_t mode, snd_pcm_access_mask_t *mask);
|
||||
int snd_pcm_hw_params_set_access_mask(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_access_mask_t *mask);
|
||||
|
||||
snd_pcm_format_t snd_pcm_hw_params_get_format(const snd_pcm_hw_params_t *params);
|
||||
int snd_pcm_hw_params_set_format(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_set_mode_t mode, snd_pcm_format_t val);
|
||||
int snd_pcm_hw_params_test_format(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_format_t val);
|
||||
int snd_pcm_hw_params_set_format(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_format_t val);
|
||||
snd_pcm_format_t snd_pcm_hw_params_set_format_first(snd_pcm_t *pcm, snd_pcm_hw_params_t *params);
|
||||
snd_pcm_format_t snd_pcm_hw_params_set_format_last(snd_pcm_t *pcm, snd_pcm_hw_params_t *params);
|
||||
int snd_pcm_hw_params_set_format_mask(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_set_mode_t mode, snd_pcm_format_mask_t *mask);
|
||||
int snd_pcm_hw_params_set_format_mask(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_format_mask_t *mask);
|
||||
|
||||
int snd_pcm_hw_params_test_subformat(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_subformat_t val);
|
||||
snd_pcm_subformat_t snd_pcm_hw_params_get_subformat(const snd_pcm_hw_params_t *params);
|
||||
int snd_pcm_hw_params_set_subformat(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_set_mode_t mode, snd_pcm_subformat_t val);
|
||||
int snd_pcm_hw_params_set_subformat(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_subformat_t val);
|
||||
snd_pcm_subformat_t snd_pcm_hw_params_set_subformat_first(snd_pcm_t *pcm, snd_pcm_hw_params_t *params);
|
||||
snd_pcm_subformat_t snd_pcm_hw_params_set_subformat_last(snd_pcm_t *pcm, snd_pcm_hw_params_t *params);
|
||||
int snd_pcm_hw_params_set_subformat_mask(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_set_mode_t mode, snd_pcm_subformat_mask_t *mask);
|
||||
int snd_pcm_hw_params_set_subformat_mask(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_subformat_mask_t *mask);
|
||||
|
||||
unsigned int snd_pcm_hw_params_get_channels(const snd_pcm_hw_params_t *params);
|
||||
unsigned int snd_pcm_hw_params_get_channels_min(const snd_pcm_hw_params_t *params);
|
||||
unsigned int snd_pcm_hw_params_get_channels_max(const snd_pcm_hw_params_t *params);
|
||||
int snd_pcm_hw_params_set_channels(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_set_mode_t mode, unsigned int val);
|
||||
int snd_pcm_hw_params_set_channels_min(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_set_mode_t mode, unsigned int *val);
|
||||
int snd_pcm_hw_params_set_channels_max(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_set_mode_t mode, unsigned int *val);
|
||||
int snd_pcm_hw_params_set_channels_minmax(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_set_mode_t mode, unsigned int *min, unsigned int *max);
|
||||
int snd_pcm_hw_params_test_channels(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int val);
|
||||
int snd_pcm_hw_params_set_channels(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int val);
|
||||
int snd_pcm_hw_params_set_channels_min(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int *val);
|
||||
int snd_pcm_hw_params_set_channels_max(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int *val);
|
||||
int snd_pcm_hw_params_set_channels_minmax(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int *min, unsigned int *max);
|
||||
unsigned int snd_pcm_hw_params_set_channels_near(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int val);
|
||||
unsigned int snd_pcm_hw_params_set_channels_first(snd_pcm_t *pcm, snd_pcm_hw_params_t *params);
|
||||
unsigned int snd_pcm_hw_params_set_channels_last(snd_pcm_t *pcm, snd_pcm_hw_params_t *params);
|
||||
|
|
@ -77,10 +82,11 @@ unsigned int snd_pcm_hw_params_set_channels_last(snd_pcm_t *pcm, snd_pcm_hw_para
|
|||
unsigned int snd_pcm_hw_params_get_rate(const snd_pcm_hw_params_t *params, int *dir);
|
||||
unsigned int snd_pcm_hw_params_get_rate_min(const snd_pcm_hw_params_t *params, int *dir);
|
||||
unsigned int snd_pcm_hw_params_get_rate_max(const snd_pcm_hw_params_t *params, int *dir);
|
||||
int snd_pcm_hw_params_set_rate(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_set_mode_t mode, unsigned int val, int dir);
|
||||
int snd_pcm_hw_params_set_rate_min(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_set_mode_t mode, unsigned int *val, int *dir);
|
||||
int snd_pcm_hw_params_set_rate_max(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_set_mode_t mode, unsigned int *val, int *dir);
|
||||
int snd_pcm_hw_params_set_rate_minmax(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_set_mode_t mode, unsigned int *min, int *mindir, unsigned int *max, int *maxdir);
|
||||
int snd_pcm_hw_params_test_rate(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int val, int dir);
|
||||
int snd_pcm_hw_params_set_rate(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int val, int dir);
|
||||
int snd_pcm_hw_params_set_rate_min(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int *val, int *dir);
|
||||
int snd_pcm_hw_params_set_rate_max(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int *val, int *dir);
|
||||
int snd_pcm_hw_params_set_rate_minmax(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int *min, int *mindir, unsigned int *max, int *maxdir);
|
||||
unsigned int snd_pcm_hw_params_set_rate_near(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int val, int *dir);
|
||||
unsigned int snd_pcm_hw_params_set_rate_first(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, int *dir);
|
||||
unsigned int snd_pcm_hw_params_set_rate_last(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, int *dir);
|
||||
|
|
@ -88,10 +94,11 @@ unsigned int snd_pcm_hw_params_set_rate_last(snd_pcm_t *pcm, snd_pcm_hw_params_t
|
|||
unsigned int snd_pcm_hw_params_get_period_time(const snd_pcm_hw_params_t *params, int *dir);
|
||||
unsigned int snd_pcm_hw_params_get_period_time_min(const snd_pcm_hw_params_t *params, int *dir);
|
||||
unsigned int snd_pcm_hw_params_get_period_time_max(const snd_pcm_hw_params_t *params, int *dir);
|
||||
int snd_pcm_hw_params_set_period_time(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_set_mode_t mode, unsigned int val, int dir);
|
||||
int snd_pcm_hw_params_set_period_time_min(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_set_mode_t mode, unsigned int *val, int *dir);
|
||||
int snd_pcm_hw_params_set_period_time_max(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_set_mode_t mode, unsigned int *val, int *dir);
|
||||
int snd_pcm_hw_params_set_period_time_minmax(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_set_mode_t mode, unsigned int *min, int *mindir, unsigned int *max, int *maxdir);
|
||||
int snd_pcm_hw_params_test_period_time(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int val, int dir);
|
||||
int snd_pcm_hw_params_set_period_time(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int val, int dir);
|
||||
int snd_pcm_hw_params_set_period_time_min(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int *val, int *dir);
|
||||
int snd_pcm_hw_params_set_period_time_max(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int *val, int *dir);
|
||||
int snd_pcm_hw_params_set_period_time_minmax(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int *min, int *mindir, unsigned int *max, int *maxdir);
|
||||
unsigned int snd_pcm_hw_params_set_period_time_near(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int val, int *dir);
|
||||
unsigned int snd_pcm_hw_params_set_period_time_first(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, int *dir);
|
||||
unsigned int snd_pcm_hw_params_set_period_time_last(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, int *dir);
|
||||
|
|
@ -99,34 +106,37 @@ unsigned int snd_pcm_hw_params_set_period_time_last(snd_pcm_t *pcm, snd_pcm_hw_p
|
|||
snd_pcm_uframes_t snd_pcm_hw_params_get_period_size(const snd_pcm_hw_params_t *params, int *dir);
|
||||
snd_pcm_uframes_t snd_pcm_hw_params_get_period_size_min(const snd_pcm_hw_params_t *params, int *dir);
|
||||
snd_pcm_uframes_t snd_pcm_hw_params_get_period_size_max(const snd_pcm_hw_params_t *params, int *dir);
|
||||
int snd_pcm_hw_params_set_period_size(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_set_mode_t mode, snd_pcm_uframes_t val, int dir);
|
||||
int snd_pcm_hw_params_set_period_size_min(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_set_mode_t mode, snd_pcm_uframes_t *val, int *dir);
|
||||
int snd_pcm_hw_params_set_period_size_max(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_set_mode_t mode, snd_pcm_uframes_t *val, int *dir);
|
||||
int snd_pcm_hw_params_set_period_size_minmax(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_set_mode_t mode, snd_pcm_uframes_t *min, int *mindir, snd_pcm_uframes_t *max, int *maxdir);
|
||||
int snd_pcm_hw_params_test_period_size(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_uframes_t val, int dir);
|
||||
int snd_pcm_hw_params_set_period_size(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_uframes_t val, int dir);
|
||||
int snd_pcm_hw_params_set_period_size_min(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_uframes_t *val, int *dir);
|
||||
int snd_pcm_hw_params_set_period_size_max(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_uframes_t *val, int *dir);
|
||||
int snd_pcm_hw_params_set_period_size_minmax(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_uframes_t *min, int *mindir, snd_pcm_uframes_t *max, int *maxdir);
|
||||
snd_pcm_uframes_t snd_pcm_hw_params_set_period_size_near(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_uframes_t val, int *dir);
|
||||
snd_pcm_uframes_t snd_pcm_hw_params_set_period_size_first(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, int *dir);
|
||||
snd_pcm_uframes_t snd_pcm_hw_params_set_period_size_last(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, int *dir);
|
||||
int snd_pcm_hw_params_set_period_size_integer(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_set_mode_t mode);
|
||||
int snd_pcm_hw_params_set_period_size_integer(snd_pcm_t *pcm, snd_pcm_hw_params_t *params);
|
||||
|
||||
unsigned int snd_pcm_hw_params_get_periods(const snd_pcm_hw_params_t *params, int *dir);
|
||||
unsigned int snd_pcm_hw_params_get_periods_min(const snd_pcm_hw_params_t *params, int *dir);
|
||||
unsigned int snd_pcm_hw_params_get_periods_max(const snd_pcm_hw_params_t *params, int *dir);
|
||||
int snd_pcm_hw_params_set_periods(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_set_mode_t mode, unsigned int val, int dir);
|
||||
int snd_pcm_hw_params_set_periods_min(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_set_mode_t mode, unsigned int *val, int *dir);
|
||||
int snd_pcm_hw_params_set_periods_max(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_set_mode_t mode, unsigned int *val, int *dir);
|
||||
int snd_pcm_hw_params_set_periods_minmax(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_set_mode_t mode, unsigned int *min, int *mindir, unsigned int *max, int *maxdir);
|
||||
int snd_pcm_hw_params_test_periods(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int val, int dir);
|
||||
int snd_pcm_hw_params_set_periods(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int val, int dir);
|
||||
int snd_pcm_hw_params_set_periods_min(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int *val, int *dir);
|
||||
int snd_pcm_hw_params_set_periods_max(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int *val, int *dir);
|
||||
int snd_pcm_hw_params_set_periods_minmax(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int *min, int *mindir, unsigned int *max, int *maxdir);
|
||||
unsigned int snd_pcm_hw_params_set_periods_near(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int val, int *dir);
|
||||
unsigned int snd_pcm_hw_params_set_periods_first(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, int *dir);
|
||||
unsigned int snd_pcm_hw_params_set_periods_last(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, int *dir);
|
||||
int snd_pcm_hw_params_set_periods_integer(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_set_mode_t mode);
|
||||
int snd_pcm_hw_params_set_periods_integer(snd_pcm_t *pcm, snd_pcm_hw_params_t *params);
|
||||
|
||||
unsigned int snd_pcm_hw_params_get_buffer_time(const snd_pcm_hw_params_t *params, int *dir);
|
||||
unsigned int snd_pcm_hw_params_get_buffer_time_min(const snd_pcm_hw_params_t *params, int *dir);
|
||||
unsigned int snd_pcm_hw_params_get_buffer_time_max(const snd_pcm_hw_params_t *params, int *dir);
|
||||
int snd_pcm_hw_params_set_buffer_time(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_set_mode_t mode, unsigned int val, int dir);
|
||||
int snd_pcm_hw_params_set_buffer_time_min(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_set_mode_t mode, unsigned int *val, int *dir);
|
||||
int snd_pcm_hw_params_set_buffer_time_max(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_set_mode_t mode, unsigned int *val, int *dir);
|
||||
int snd_pcm_hw_params_set_buffer_time_minmax(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_set_mode_t mode, unsigned int *min, int *mindir, unsigned int *max, int *maxdir);
|
||||
int snd_pcm_hw_params_test_buffer_time(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int val, int dir);
|
||||
int snd_pcm_hw_params_set_buffer_time(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int val, int dir);
|
||||
int snd_pcm_hw_params_set_buffer_time_min(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int *val, int *dir);
|
||||
int snd_pcm_hw_params_set_buffer_time_max(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int *val, int *dir);
|
||||
int snd_pcm_hw_params_set_buffer_time_minmax(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int *min, int *mindir, unsigned int *max, int *maxdir);
|
||||
unsigned int snd_pcm_hw_params_set_buffer_time_near(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int val, int *dir);
|
||||
unsigned int snd_pcm_hw_params_set_buffer_time_first(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, int *dir);
|
||||
unsigned int snd_pcm_hw_params_set_buffer_time_last(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, int *dir);
|
||||
|
|
@ -134,10 +144,11 @@ unsigned int snd_pcm_hw_params_set_buffer_time_last(snd_pcm_t *pcm, snd_pcm_hw_p
|
|||
snd_pcm_uframes_t snd_pcm_hw_params_get_buffer_size(const snd_pcm_hw_params_t *params);
|
||||
snd_pcm_uframes_t snd_pcm_hw_params_get_buffer_size_min(const snd_pcm_hw_params_t *params);
|
||||
snd_pcm_uframes_t snd_pcm_hw_params_get_buffer_size_max(const snd_pcm_hw_params_t *params);
|
||||
int snd_pcm_hw_params_set_buffer_size(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_set_mode_t mode, snd_pcm_uframes_t val);
|
||||
int snd_pcm_hw_params_set_buffer_size_min(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_set_mode_t mode, snd_pcm_uframes_t *val);
|
||||
int snd_pcm_hw_params_set_buffer_size_max(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_set_mode_t mode, snd_pcm_uframes_t *val);
|
||||
int snd_pcm_hw_params_set_buffer_size_minmax(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_set_mode_t mode, snd_pcm_uframes_t *min, snd_pcm_uframes_t *max);
|
||||
int snd_pcm_hw_params_test_buffer_size(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_uframes_t val);
|
||||
int snd_pcm_hw_params_set_buffer_size(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_uframes_t val);
|
||||
int snd_pcm_hw_params_set_buffer_size_min(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_uframes_t *val);
|
||||
int snd_pcm_hw_params_set_buffer_size_max(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_uframes_t *val);
|
||||
int snd_pcm_hw_params_set_buffer_size_minmax(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_uframes_t *min, snd_pcm_uframes_t *max);
|
||||
snd_pcm_uframes_t snd_pcm_hw_params_set_buffer_size_near(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_uframes_t val);
|
||||
snd_pcm_uframes_t snd_pcm_hw_params_set_buffer_size_first(snd_pcm_t *pcm, snd_pcm_hw_params_t *params);
|
||||
snd_pcm_uframes_t snd_pcm_hw_params_set_buffer_size_last(snd_pcm_t *pcm, snd_pcm_hw_params_t *params);
|
||||
|
|
@ -145,16 +156,17 @@ snd_pcm_uframes_t snd_pcm_hw_params_set_buffer_size_last(snd_pcm_t *pcm, snd_pcm
|
|||
unsigned int snd_pcm_hw_params_get_tick_time(const snd_pcm_hw_params_t *params, int *dir);
|
||||
unsigned int snd_pcm_hw_params_get_tick_time_min(const snd_pcm_hw_params_t *params, int *dir);
|
||||
unsigned int snd_pcm_hw_params_get_tick_time_max(const snd_pcm_hw_params_t *params, int *dir);
|
||||
int snd_pcm_hw_params_set_tick_time(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_set_mode_t mode, unsigned int val, int dir);
|
||||
int snd_pcm_hw_params_set_tick_time_min(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_set_mode_t mode, unsigned int *val, int *dir);
|
||||
int snd_pcm_hw_params_set_tick_time_max(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_set_mode_t mode, unsigned int *val, int *dir);
|
||||
int snd_pcm_hw_params_set_tick_time_minmax(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_set_mode_t mode, unsigned int *min, int *mindir, unsigned int *max, int *maxdir);
|
||||
int snd_pcm_hw_params_test_tick_time(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int val, int dir);
|
||||
int snd_pcm_hw_params_set_tick_time(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int val, int dir);
|
||||
int snd_pcm_hw_params_set_tick_time_min(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int *val, int *dir);
|
||||
int snd_pcm_hw_params_set_tick_time_max(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int *val, int *dir);
|
||||
int snd_pcm_hw_params_set_tick_time_minmax(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int *min, int *mindir, unsigned int *max, int *maxdir);
|
||||
unsigned int snd_pcm_hw_params_set_tick_time_near(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int val, int *dir);
|
||||
unsigned int snd_pcm_hw_params_set_tick_time_first(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, int *dir);
|
||||
unsigned int snd_pcm_hw_params_set_tick_time_last(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, int *dir);
|
||||
|
||||
size_t snd_pcm_sw_params_sizeof();
|
||||
#define snd_pcm_sw_params_alloca(ptr) ({assert(ptr); *ptr = (snd_pcm_sw_params_t *) alloca(snd_pcm_sw_params_sizeof()); 0;})
|
||||
#define snd_pcm_sw_params_alloca(ptr) ({ assert(ptr); *ptr = (snd_pcm_sw_params_t *) alloca(snd_pcm_sw_params_sizeof()); memset(*ptr, 0, snd_pcm_sw_params_sizeof()); 0; })
|
||||
int snd_pcm_sw_params_malloc(snd_pcm_sw_params_t **ptr);
|
||||
void snd_pcm_sw_params_free(snd_pcm_sw_params_t *obj);
|
||||
void snd_pcm_sw_params_copy(snd_pcm_sw_params_t *dst, const snd_pcm_sw_params_t *src);
|
||||
|
|
@ -186,42 +198,8 @@ snd_pcm_uframes_t snd_pcm_sw_params_get_silence_threshold(const snd_pcm_sw_param
|
|||
int snd_pcm_sw_params_set_silence_size(snd_pcm_t *pcm, snd_pcm_sw_params_t *params, snd_pcm_uframes_t val);
|
||||
snd_pcm_uframes_t snd_pcm_sw_params_get_silence_size(const snd_pcm_sw_params_t *params);
|
||||
|
||||
size_t snd_pcm_info_sizeof();
|
||||
#define snd_pcm_info_alloca(ptr) ({assert(ptr); *ptr = (snd_pcm_info_t *) alloca(snd_pcm_info_sizeof()); 0;})
|
||||
int snd_pcm_info_malloc(snd_pcm_info_t **ptr);
|
||||
void snd_pcm_info_free(snd_pcm_info_t *obj);
|
||||
void snd_pcm_info_copy(snd_pcm_info_t *dst, const snd_pcm_info_t *src);
|
||||
|
||||
unsigned int snd_pcm_info_get_device(const snd_pcm_info_t *obj);
|
||||
|
||||
unsigned int snd_pcm_info_get_subdevice(const snd_pcm_info_t *obj);
|
||||
|
||||
snd_pcm_stream_t snd_pcm_info_get_stream(const snd_pcm_info_t *obj);
|
||||
|
||||
int snd_pcm_info_get_card(const snd_pcm_info_t *obj);
|
||||
|
||||
const char * snd_pcm_info_get_id(const snd_pcm_info_t *obj);
|
||||
|
||||
const char * snd_pcm_info_get_name(const snd_pcm_info_t *obj);
|
||||
|
||||
const char * snd_pcm_info_get_subdevice_name(const snd_pcm_info_t *obj);
|
||||
|
||||
snd_pcm_class_t snd_pcm_info_get_class(const snd_pcm_info_t *obj);
|
||||
|
||||
snd_pcm_subclass_t snd_pcm_info_get_subclass(const snd_pcm_info_t *obj);
|
||||
|
||||
unsigned int snd_pcm_info_get_subdevices_count(const snd_pcm_info_t *obj);
|
||||
|
||||
unsigned int snd_pcm_info_get_subdevices_avail(const snd_pcm_info_t *obj);
|
||||
|
||||
void snd_pcm_info_set_device(snd_pcm_info_t *obj, unsigned int val);
|
||||
|
||||
void snd_pcm_info_set_subdevice(snd_pcm_info_t *obj, unsigned int val);
|
||||
|
||||
void snd_pcm_info_set_stream(snd_pcm_info_t *obj, snd_pcm_stream_t val);
|
||||
|
||||
size_t snd_pcm_status_sizeof();
|
||||
#define snd_pcm_status_alloca(ptr) ({assert(ptr); *ptr = (snd_pcm_status_t *) alloca(snd_pcm_status_sizeof()); 0;})
|
||||
#define snd_pcm_status_alloca(ptr) ({ assert(ptr); *ptr = (snd_pcm_status_t *) alloca(snd_pcm_status_sizeof()); memset(*ptr, 0, snd_pcm_status_sizeof()); 0; })
|
||||
int snd_pcm_status_malloc(snd_pcm_status_t **ptr);
|
||||
void snd_pcm_status_free(snd_pcm_status_t *obj);
|
||||
void snd_pcm_status_copy(snd_pcm_status_t *dst, const snd_pcm_status_t *src);
|
||||
|
|
@ -238,6 +216,40 @@ snd_pcm_uframes_t snd_pcm_status_get_avail(const snd_pcm_status_t *obj);
|
|||
|
||||
snd_pcm_uframes_t snd_pcm_status_get_avail_max(const snd_pcm_status_t *obj);
|
||||
|
||||
size_t snd_pcm_info_sizeof();
|
||||
#define snd_pcm_info_alloca(ptr) ({ assert(ptr); *ptr = (snd_pcm_info_t *) alloca(snd_pcm_info_sizeof()); memset(*ptr, 0, snd_pcm_info_sizeof()); 0; })
|
||||
int snd_pcm_info_malloc(snd_pcm_info_t **ptr);
|
||||
void snd_pcm_info_free(snd_pcm_info_t *obj);
|
||||
void snd_pcm_info_copy(snd_pcm_info_t *dst, const snd_pcm_info_t *src);
|
||||
|
||||
unsigned int snd_pcm_info_get_device(const snd_pcm_info_t *obj);
|
||||
|
||||
unsigned int snd_pcm_info_get_subdevice(const snd_pcm_info_t *obj);
|
||||
|
||||
snd_pcm_stream_t snd_pcm_info_get_stream(const snd_pcm_info_t *obj);
|
||||
|
||||
int snd_pcm_info_get_card(const snd_pcm_info_t *obj);
|
||||
|
||||
const char *snd_pcm_info_get_id(const snd_pcm_info_t *obj);
|
||||
|
||||
const char *snd_pcm_info_get_name(const snd_pcm_info_t *obj);
|
||||
|
||||
const char *snd_pcm_info_get_subdevice_name(const snd_pcm_info_t *obj);
|
||||
|
||||
snd_pcm_class_t snd_pcm_info_get_class(const snd_pcm_info_t *obj);
|
||||
|
||||
snd_pcm_subclass_t snd_pcm_info_get_subclass(const snd_pcm_info_t *obj);
|
||||
|
||||
unsigned int snd_pcm_info_get_subdevices_count(const snd_pcm_info_t *obj);
|
||||
|
||||
unsigned int snd_pcm_info_get_subdevices_avail(const snd_pcm_info_t *obj);
|
||||
|
||||
void snd_pcm_info_set_device(snd_pcm_info_t *obj, unsigned int val);
|
||||
|
||||
void snd_pcm_info_set_subdevice(snd_pcm_info_t *obj, unsigned int val);
|
||||
|
||||
void snd_pcm_info_set_stream(snd_pcm_info_t *obj, snd_pcm_stream_t val);
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
|
|
|||
|
|
@ -17,6 +17,7 @@ typedef enum sndrv_rawmidi_stream snd_rawmidi_stream_t;
|
|||
|
||||
#define SND_RAWMIDI_STREAM_OUTPUT ((snd_rawmidi_stream_t) SNDRV_RAWMIDI_STREAM_OUTPUT)
|
||||
#define SND_RAWMIDI_STREAM_INPUT ((snd_rawmidi_stream_t) SNDRV_RAWMIDI_STREAM_INPUT)
|
||||
#define SND_RAWMIDI_STREAM_LAST ((snd_rawmidi_stream_t) SNDRV_RAWMIDI_STREAM_LAST)
|
||||
|
||||
#define SND_RAWMIDI_INFO_OUTPUT SNDRV_RAWMIDI_INFO_OUTPUT
|
||||
#define SND_RAWMIDI_INFO_INPUT SNDRV_RAWMIDI_INFO_INPUT
|
||||
|
|
|
|||
|
|
@ -3,7 +3,7 @@ extern "C" {
|
|||
#endif
|
||||
|
||||
size_t snd_rawmidi_params_sizeof();
|
||||
#define snd_rawmidi_params_alloca(ptr) ({assert(ptr); *ptr = (snd_rawmidi_params_t *) alloca(snd_rawmidi_params_sizeof()); 0;})
|
||||
#define snd_rawmidi_params_alloca(ptr) ({ assert(ptr); *ptr = (snd_rawmidi_params_t *) alloca(snd_rawmidi_params_sizeof()); memset(*ptr, 0, snd_rawmidi_params_sizeof()); 0; })
|
||||
int snd_rawmidi_params_malloc(snd_rawmidi_params_t **ptr);
|
||||
void snd_rawmidi_params_free(snd_rawmidi_params_t *obj);
|
||||
void snd_rawmidi_params_copy(snd_rawmidi_params_t *dst, const snd_rawmidi_params_t *src);
|
||||
|
|
@ -18,7 +18,7 @@ int snd_rawmidi_params_set_no_active_sensing(snd_rawmidi_t *rmidi, snd_rawmidi_p
|
|||
int snd_rawmidi_params_get_no_active_sensing(const snd_rawmidi_params_t *params);
|
||||
|
||||
size_t snd_rawmidi_info_sizeof();
|
||||
#define snd_rawmidi_info_alloca(ptr) ({assert(ptr); *ptr = (snd_rawmidi_info_t *) alloca(snd_rawmidi_info_sizeof()); 0;})
|
||||
#define snd_rawmidi_info_alloca(ptr) ({ assert(ptr); *ptr = (snd_rawmidi_info_t *) alloca(snd_rawmidi_info_sizeof()); memset(*ptr, 0, snd_rawmidi_info_sizeof()); 0; })
|
||||
int snd_rawmidi_info_malloc(snd_rawmidi_info_t **ptr);
|
||||
void snd_rawmidi_info_free(snd_rawmidi_info_t *obj);
|
||||
void snd_rawmidi_info_copy(snd_rawmidi_info_t *dst, const snd_rawmidi_info_t *src);
|
||||
|
|
@ -33,11 +33,11 @@ int snd_rawmidi_info_get_card(const snd_rawmidi_info_t *obj);
|
|||
|
||||
unsigned int snd_rawmidi_info_get_flags(const snd_rawmidi_info_t *obj);
|
||||
|
||||
const char * snd_rawmidi_info_get_id(const snd_rawmidi_info_t *obj);
|
||||
const char *snd_rawmidi_info_get_id(const snd_rawmidi_info_t *obj);
|
||||
|
||||
const char * snd_rawmidi_info_get_name(const snd_rawmidi_info_t *obj);
|
||||
const char *snd_rawmidi_info_get_name(const snd_rawmidi_info_t *obj);
|
||||
|
||||
const char * snd_rawmidi_info_get_subdevice_name(const snd_rawmidi_info_t *obj);
|
||||
const char *snd_rawmidi_info_get_subdevice_name(const snd_rawmidi_info_t *obj);
|
||||
|
||||
unsigned int snd_rawmidi_info_get_subdevices_count(const snd_rawmidi_info_t *obj);
|
||||
|
||||
|
|
@ -50,7 +50,7 @@ void snd_rawmidi_info_set_subdevice(snd_rawmidi_info_t *obj, unsigned int val);
|
|||
void snd_rawmidi_info_set_stream(snd_rawmidi_info_t *obj, snd_rawmidi_stream_t val);
|
||||
|
||||
size_t snd_rawmidi_status_sizeof();
|
||||
#define snd_rawmidi_status_alloca(ptr) ({assert(ptr); *ptr = (snd_rawmidi_status_t *) alloca(snd_rawmidi_status_sizeof()); 0;})
|
||||
#define snd_rawmidi_status_alloca(ptr) ({ assert(ptr); *ptr = (snd_rawmidi_status_t *) alloca(snd_rawmidi_status_sizeof()); memset(*ptr, 0, snd_rawmidi_status_sizeof()); 0; })
|
||||
int snd_rawmidi_status_malloc(snd_rawmidi_status_t **ptr);
|
||||
void snd_rawmidi_status_free(snd_rawmidi_status_t *obj);
|
||||
void snd_rawmidi_status_copy(snd_rawmidi_status_t *dst, const snd_rawmidi_status_t *src);
|
||||
|
|
|
|||
|
|
@ -25,10 +25,13 @@ typedef enum sndrv_timer_slave_type snd_timer_slave_type_t;
|
|||
#define SND_TIMER_TYPE_GLOBAL ((snd_timer_type_t) SNDRV_TIMER_TYPE_GLOBAL)
|
||||
#define SND_TIMER_TYPE_CARD ((snd_timer_type_t) SNDRV_TIMER_TYPE_CARD)
|
||||
#define SND_TIMER_TYPE_PCM ((snd_timer_type_t) SNDRV_TIMER_TYPE_PCM)
|
||||
#define SND_TIMER_TYPE_LAST ((snd_timer_type_t) SNDRV_TIMER_TYPE_LAST)
|
||||
|
||||
#define SND_TIMER_STYPE_NONE ((snd_timer_slave_type_t) SNDRV_TIMER_STYPE_NONE
|
||||
#define SND_TIMER_STYPE_APPLICATION ((snd_timer_slave_type_t) SNDRV_TIMER_STYPE_APPLICATION
|
||||
#define SND_TIMER_STYPE_SEQUENCER ((snd_timer_slave_type_t) SNDRV_TIMER_STYPE_SEQUENCER
|
||||
#define SND_TIMER_STYPE_OSS_SEQUENCER ((snd_timer_slave_type_t) SNDRV_TIMER_STYPE_OSS_SEQUENCER
|
||||
#define SND_TIMER_STYPE_LAST ((snd_timer_slave_type_t) SNDRV_TIMER_STYPE_LAST
|
||||
|
||||
#define SND_TIMER_GLOBAL_SYSTEM SNDRV_TIMER_GLOBAL_SYSTEM
|
||||
#define SND_TIMER_GLOBAL_RTC SNDRV_TIMER_GLOBAL_RTC
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue