Global Namespace

Overview

// typedefs

typedef struct _snd_config snd_config_t;
typedef struct _snd_config_iterator* snd_config_iterator_t;
typedef struct _snd_config_update snd_config_update_t;
typedef struct _snd_ctl_card_info snd_ctl_card_info_t;
typedef struct _snd_ctl_elem_id snd_ctl_elem_id_t;
typedef struct _snd_ctl_elem_list snd_ctl_elem_list_t;
typedef struct _snd_ctl_elem_info snd_ctl_elem_info_t;
typedef struct _snd_ctl_elem_value snd_ctl_elem_value_t;
typedef struct _snd_ctl_event snd_ctl_event_t;
typedef struct _snd_ctl snd_ctl_t;
typedef struct _snd_sctl snd_sctl_t;
typedef struct _snd_hctl_elem snd_hctl_elem_t;
typedef struct _snd_hctl snd_hctl_t;

typedef int (*snd_hctl_compare_t)(
    const snd_hctl_elem_t *e1,
    const snd_hctl_elem_t *e2
    );

typedef int (*snd_hctl_callback_t)(
    snd_hctl_t *hctl,
    unsigned int mask,
    snd_hctl_elem_t *elem
    );

typedef int (*snd_hctl_elem_callback_t)(
    snd_hctl_elem_t *elem,
    unsigned int mask
    );

typedef unsigned long snd_ctl_ext_key_t;
typedef snd_ctl_ext snd_ctl_ext_t;
typedef snd_ctl_ext_callback snd_ctl_ext_callback_t;

typedef int() snd_ctl_ext_tlv_rw_t(
    snd_ctl_ext_t *ext,
    snd_ctl_ext_key_t key,
    int op_flag,
    unsigned int numid,
    unsigned int *tlv,
    unsigned int tlv_size
    );

typedef void (*snd_lib_error_handler_t)(
    const char *file,
    int line,
    const char *function,
    int err,
    const char *fmt,
    ...
    );

typedef void (*snd_local_error_handler_t)(
    const char *file,
    int line,
    const char *func,
    int err,
    const char *fmt,
    va_list arg
    );

typedef struct _snd_async_handler snd_async_handler_t;
typedef void (*snd_async_callback_t)(snd_async_handler_t *handler);
typedef struct timeval snd_timestamp_t;
typedef struct timespec snd_htimestamp_t;
typedef struct _snd_hwdep_info snd_hwdep_info_t;
typedef struct _snd_hwdep_dsp_status snd_hwdep_dsp_status_t;
typedef struct _snd_hwdep_dsp_image snd_hwdep_dsp_image_t;
typedef struct _snd_hwdep snd_hwdep_t;
typedef struct _snd_input snd_input_t;
typedef struct _snd_mixer snd_mixer_t;
typedef struct _snd_mixer_class snd_mixer_class_t;
typedef struct _snd_mixer_elem snd_mixer_elem_t;

typedef int (*snd_mixer_callback_t)(
    snd_mixer_t *ctl,
    unsigned int mask,
    snd_mixer_elem_t *elem
    );

typedef int (*snd_mixer_elem_callback_t)(
    snd_mixer_elem_t *elem,
    unsigned int mask
    );

typedef int (*snd_mixer_compare_t)(
    const snd_mixer_elem_t *e1,
    const snd_mixer_elem_t *e2
    );

typedef int (*snd_mixer_event_t)(
    snd_mixer_class_t *class_,
    unsigned int mask,
    snd_hctl_elem_t *helem,
    snd_mixer_elem_t *melem
    );

typedef struct _snd_mixer_selem_id snd_mixer_selem_id_t;
typedef struct _snd_output snd_output_t;
typedef struct _snd_pcm_info snd_pcm_info_t;
typedef struct _snd_pcm_hw_params snd_pcm_hw_params_t;
typedef struct _snd_pcm_sw_params snd_pcm_sw_params_t;
typedef struct _snd_pcm_status snd_pcm_status_t;
typedef struct _snd_pcm_access_mask snd_pcm_access_mask_t;
typedef struct _snd_pcm_format_mask snd_pcm_format_mask_t;
typedef struct _snd_pcm_subformat_mask snd_pcm_subformat_mask_t;
typedef unsigned long snd_pcm_uframes_t;
typedef long snd_pcm_sframes_t;
typedef struct _snd_pcm snd_pcm_t;
typedef enum _snd_pcm_type snd_pcm_type_t;
typedef struct _snd_pcm_scope snd_pcm_scope_t;
typedef struct _snd_pcm_hook snd_pcm_hook_t;
typedef int (*snd_pcm_hook_func_t)(snd_pcm_hook_t *hook);
typedef snd_pcm_extplug snd_pcm_extplug_t;
typedef snd_pcm_extplug_callback snd_pcm_extplug_callback_t;
typedef snd_pcm_ioplug snd_pcm_ioplug_t;
typedef snd_pcm_ioplug_callback snd_pcm_ioplug_callback_t;
typedef struct _snd_rawmidi_info snd_rawmidi_info_t;
typedef struct _snd_rawmidi_params snd_rawmidi_params_t;
typedef struct _snd_rawmidi_status snd_rawmidi_status_t;
typedef struct _snd_rawmidi snd_rawmidi_t;
typedef struct _snd_seq snd_seq_t;
typedef struct _snd_seq_system_info snd_seq_system_info_t;
typedef struct _snd_seq_client_info snd_seq_client_info_t;
typedef struct _snd_seq_client_pool snd_seq_client_pool_t;
typedef struct _snd_seq_port_info snd_seq_port_info_t;
typedef struct _snd_seq_port_subscribe snd_seq_port_subscribe_t;
typedef struct _snd_seq_query_subscribe snd_seq_query_subscribe_t;
typedef struct _snd_seq_queue_info snd_seq_queue_info_t;
typedef struct _snd_seq_queue_status snd_seq_queue_status_t;
typedef struct _snd_seq_queue_tempo snd_seq_queue_tempo_t;
typedef struct _snd_seq_queue_timer snd_seq_queue_timer_t;
typedef struct _snd_seq_remove_events snd_seq_remove_events_t;
typedef unsigned char snd_seq_event_type_t;
typedef unsigned int snd_seq_tick_time_t;
typedef snd_seq_ev_ext snd_seq_ev_ext_t;
typedef struct snd_midi_event snd_midi_event_t;
typedef struct _snd_timer_id snd_timer_id_t;
typedef struct _snd_timer_ginfo snd_timer_ginfo_t;
typedef struct _snd_timer_gparams snd_timer_gparams_t;
typedef struct _snd_timer_gstatus snd_timer_gstatus_t;
typedef struct _snd_timer_info snd_timer_info_t;
typedef struct _snd_timer_params snd_timer_params_t;
typedef struct _snd_timer_status snd_timer_status_t;
typedef struct _snd_timer_query snd_timer_query_t;
typedef struct _snd_timer snd_timer_t;
typedef struct snd_tplg snd_tplg_t;
typedef struct snd_use_case_mgr snd_use_case_mgr_t;

// enums

enum {
    SND_SEQ_EVFLG_RESULT,
    SND_SEQ_EVFLG_NOTE,
    SND_SEQ_EVFLG_CONTROL,
    SND_SEQ_EVFLG_QUEUE,
    SND_SEQ_EVFLG_SYSTEM,
    SND_SEQ_EVFLG_MESSAGE,
    SND_SEQ_EVFLG_CONNECTION,
    SND_SEQ_EVFLG_SAMPLE,
    SND_SEQ_EVFLG_USERS,
    SND_SEQ_EVFLG_INSTR,
    SND_SEQ_EVFLG_QUOTE,
    SND_SEQ_EVFLG_NONE,
    SND_SEQ_EVFLG_RAW,
    SND_SEQ_EVFLG_FIXED,
    SND_SEQ_EVFLG_VARIABLE,
    SND_SEQ_EVFLG_VARUSR,
};

enum {
    SND_SEQ_EVFLG_NOTE_ONEARG,
    SND_SEQ_EVFLG_NOTE_TWOARG,
};

enum {
    CHMAP_CTL_QUERY,
    CHMAP_CTL_GET,
    CHMAP_CTL_SET,
};

enum {
    SNDRV_TIMER_IOCTL_START_OLD    = _IO('T', 0x20),
    SNDRV_TIMER_IOCTL_STOP_OLD     = _IO('T', 0x21),
    SNDRV_TIMER_IOCTL_CONTINUE_OLD = _IO('T', 0x22),
    SNDRV_TIMER_IOCTL_PAUSE_OLD    = _IO('T', 0x23),
};

enum {
    SND_SEQ_EVFLG_QUEUE_NOARG,
    SND_SEQ_EVFLG_QUEUE_TICK,
    SND_SEQ_EVFLG_QUEUE_TIME,
    SND_SEQ_EVFLG_QUEUE_VALUE,
};

enum {
    SND_PCM_EXTPLUG_HW_FORMAT,
    SND_PCM_EXTPLUG_HW_CHANNELS,
    SND_PCM_EXTPLUG_HW_PARAMS,
};

enum {
    SND_PCM_IOPLUG_HW_ACCESS       = 0,
    SND_PCM_IOPLUG_HW_FORMAT,
    SND_PCM_IOPLUG_HW_CHANNELS,
    SND_PCM_IOPLUG_HW_RATE,
    SND_PCM_IOPLUG_HW_PERIOD_BYTES,
    SND_PCM_IOPLUG_HW_BUFFER_BYTES,
    SND_PCM_IOPLUG_HW_PERIODS,
    SND_PCM_IOPLUG_HW_PARAMS,
};

enum _snd_pcm_type;
enum snd_config_type_t;
enum snd_ctl_elem_iface_t;
enum snd_ctl_elem_type_t;
enum snd_ctl_event_type_t;
enum snd_ctl_ext_access_t;
enum snd_ctl_type_t;
enum snd_hwdep_iface_t;
enum snd_hwdep_type_t;
enum snd_input_type_t;
enum snd_mixer_elem_type_t;
enum snd_mixer_selem_channel_id_t;
enum snd_mixer_selem_regopt_abstract;
enum snd_output_type_t;
enum snd_pcm_access_t;
enum snd_pcm_chmap_position;
enum snd_pcm_chmap_type;
enum snd_pcm_class_t;
enum snd_pcm_format_t;
enum snd_pcm_hook_type_t;
enum snd_pcm_start_t;
enum snd_pcm_state_t;
enum snd_pcm_stream_t;
enum snd_pcm_subclass_t;
enum snd_pcm_subformat_t;
enum snd_pcm_tstamp_t;
enum snd_pcm_tstamp_type_t;
enum snd_pcm_xrun_t;
enum snd_rawmidi_stream_t;
enum snd_rawmidi_type_t;
enum snd_seq_client_type_t;
enum snd_seq_event_type;
enum snd_seq_query_subs_type_t;
enum snd_seq_queue_timer_type_t;
enum snd_seq_type_t;
enum snd_spcm_duplex_type_t;
enum snd_spcm_latency_t;
enum snd_spcm_xrun_type_t;
enum snd_timer_class_t;
enum snd_timer_event_t;
enum snd_timer_slave_class_t;
enum snd_timer_type_t;
enum snd_tplg_type;

// structs

struct ctl_access_elem;
struct snd_aes_iec958_t;
struct snd_ctl_ext;
struct snd_ctl_ext_callback;
struct snd_devname;
struct snd_mixer_selem_regopt;
struct snd_pcm_audio_tstamp_config_t;
struct snd_pcm_audio_tstamp_report_t;
struct snd_pcm_channel_area_t;
struct snd_pcm_chmap_query_t;
struct snd_pcm_chmap_t;
struct snd_pcm_extplug;
struct snd_pcm_extplug_callback;
struct snd_pcm_ioplug;
struct snd_pcm_ioplug_callback;
struct snd_pcm_scope_ops_t;
struct snd_seq_addr_t;
struct snd_seq_connect_t;
struct snd_seq_ev_ctrl_t;
struct snd_seq_ev_ext;
struct snd_seq_ev_note_t;
struct snd_seq_ev_queue_control_t;
struct snd_seq_ev_raw32_t;
struct snd_seq_ev_raw8_t;
struct snd_seq_event_t;
struct snd_seq_queue_skew_t;
struct snd_seq_real_time_t;
struct snd_seq_result_t;
struct snd_timer_read_t;
struct snd_timer_tread_t;
struct snd_tplg_bytes_template;
struct snd_tplg_channel_elem;
struct snd_tplg_channel_map_template;
struct snd_tplg_channel_template;
struct snd_tplg_ctl_template;
struct snd_tplg_dai_template;
struct snd_tplg_enum_template;
struct snd_tplg_graph_elem;
struct snd_tplg_graph_template;
struct snd_tplg_hw_config_template;
struct snd_tplg_io_ops_template;
struct snd_tplg_link_template;
struct snd_tplg_mixer_template;
struct snd_tplg_obj_template;
struct snd_tplg_obj_template_t;
struct snd_tplg_pcm_template;
struct snd_tplg_pdata_template;
struct snd_tplg_stream_caps_template;
struct snd_tplg_stream_template;
struct snd_tplg_tlv_dbscale_template;
struct snd_tplg_tlv_template;
struct snd_tplg_widget_template;

// unions

union snd_pcm_sync_id_t;
union snd_seq_timestamp_t;

// global variables

snd_config_t* snd_config;
snd_lib_error_handler_t snd_lib_error;
const unsigned int snd_seq_event_types[];
unsigned int len;
void* ptr;
static struct sigaction previous_action;
static const int snd_async_signo = SIGIO;
static snd_config_update_t* snd_config_global_update = NULL;
static const char*const build_in_ctls[] = {  "hw", "shm", NULL };
static const snd_ctl_ops_t snd_ctl_ext_ops;
static const snd_ctl_ops_t snd_ctl_hw_ops = {    .close = snd_ctl_hw_close,  .nonblock = snd_ctl_hw_nonblock,    .async = snd_ctl_hw_async,  .subscribe_events = snd_ctl_hw_subscribe_events,    .card_info = snd_ctl_hw_card_info,  .element_list = snd_ctl_hw_elem_list,   .element_info = snd_ctl_hw_elem_info,   .element_add = snd_ctl_hw_elem_add,     .element_replace = snd_ctl_hw_elem_replace,     .element_remove = snd_ctl_hw_elem_remove,   .element_read = snd_ctl_hw_elem_read,   .element_write = snd_ctl_hw_elem_write,     .element_lock = snd_ctl_hw_elem_lock,   .element_unlock = snd_ctl_hw_elem_unlock,   .element_tlv = snd_ctl_hw_elem_tlv,     .hwdep_next_device = snd_ctl_hw_hwdep_next_device,  .hwdep_info = snd_ctl_hw_hwdep_info,    .pcm_next_device = snd_ctl_hw_pcm_next_device,  .pcm_info = snd_ctl_hw_pcm_info,    .pcm_prefer_subdevice = snd_ctl_hw_pcm_prefer_subdevice,    .rawmidi_next_device = snd_ctl_hw_rawmidi_next_device,  .rawmidi_info = snd_ctl_hw_rawmidi_info,    .rawmidi_prefer_subdevice = snd_ctl_hw_rawmidi_prefer_subdevice,    .set_power_state = snd_ctl_hw_set_power_state,  .get_power_state = snd_ctl_hw_get_power_state,  .read = snd_ctl_hw_read, };
static const snd_ctl_ops_t snd_ctl_shm_ops = {  .close = snd_ctl_shm_close,     .nonblock = snd_ctl_shm_nonblock,   .async = snd_ctl_shm_async,     .subscribe_events = snd_ctl_shm_subscribe_events,   .card_info = snd_ctl_shm_card_info,     .element_list = snd_ctl_shm_elem_list,  .element_info = snd_ctl_shm_elem_info,  .element_read = snd_ctl_shm_elem_read,  .element_write = snd_ctl_shm_elem_write,    .element_lock = snd_ctl_shm_elem_lock,  .element_unlock = snd_ctl_shm_elem_unlock,  .hwdep_next_device = snd_ctl_shm_hwdep_next_device,     .hwdep_info = snd_ctl_shm_hwdep_info,   .pcm_next_device = snd_ctl_shm_pcm_next_device,     .pcm_info = snd_ctl_shm_pcm_info,   .pcm_prefer_subdevice = snd_ctl_shm_pcm_prefer_subdevice,   .rawmidi_next_device = snd_ctl_shm_rawmidi_next_device,     .rawmidi_info = snd_ctl_shm_rawmidi_info,   .rawmidi_prefer_subdevice = snd_ctl_shm_rawmidi_prefer_subdevice,   .set_power_state = snd_ctl_shm_set_power_state,     .get_power_state = snd_ctl_shm_get_power_state,     .read = snd_ctl_shm_read, };
& _snd_module_control_shm;
& _snd_module_control_ext;
static snd_hctl_t* compare_hctl;
static const char* snd_error_codes[] = {  "Sound protocol is not compatible" };
static TLS_PFX snd_local_error_handler_t local_error = NULL;
snd_lib_error_handler_t snd_err_msg = snd_err_msg_default;
static const snd_hwdep_ops_t snd_hwdep_hw_ops = {  .close = snd_hwdep_hw_close,    .nonblock = snd_hwdep_hw_nonblock,  .info = snd_hwdep_hw_info,  .ioctl = snd_hwdep_hw_ioctl,    .write = snd_hwdep_hw_write,    .read = snd_hwdep_hw_read, };
static struct sm_elem_ops simple_none_ops = {   .is     = is_ops,   .get_range  = get_range_ops,    .get_dB_range   = get_dB_range_ops,     .set_range  = set_range_ops,    .ask_vol_dB = ask_vol_dB_ops,   .ask_dB_vol = ask_dB_vol_ops,   .get_volume = get_volume_ops,   .get_dB     = get_dB_ops,   .set_volume = set_volume_ops,   .set_dB     = set_dB_ops,   .get_switch = get_switch_ops,   .set_switch = set_switch_ops,   .enum_item_name = enum_item_name_ops,   .get_enum_item  = get_enum_item_ops,    .set_enum_item  = set_enum_item_ops };
static const char*const build_in_pcms[] = {     "adpcm", "alaw", "copy", "dmix", "file", "hooks", "hw", "ladspa", "lfloat",     "linear", "meter", "mulaw", "multi", "null", "empty", "plug", "rate", "route", "share",     "shm", "dsnoop", "dshare", "asym", "iec958", "softvol", "mmap_emul",    NULL };
static const char* chmap_long_names[SND_CHMAP_LAST+1];
static const char IndexAdjust[8] = { -1, -1, -1, -1, 2, 4, 6, 8 };
static const short StepSize[89] = {   7, 8, 9, 10, 11, 12, 13, 14, 16, 17,    19, 21, 23, 25, 28, 31, 34, 37, 41, 45,     50, 55, 60, 66, 73, 80, 88, 97, 107, 118,   130, 143, 157, 173, 190, 209, 230, 253, 279, 307,   337, 371, 408, 449, 494, 544, 598, 658, 724, 796,   876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066,   2272, 2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358,     5894, 6484, 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899,     15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767 };
static const snd_pcm_ops_t snd_pcm_adpcm_ops = {  .close = snd_pcm_generic_close,     .info = snd_pcm_generic_info,   .hw_refine = snd_pcm_adpcm_hw_refine,   .hw_params = snd_pcm_adpcm_hw_params,   .hw_free = snd_pcm_adpcm_hw_free,   .sw_params = snd_pcm_generic_sw_params,     .channel_info = snd_pcm_generic_channel_info,   .dump = snd_pcm_adpcm_dump,     .nonblock = snd_pcm_generic_nonblock,   .async = snd_pcm_generic_async,     .mmap = snd_pcm_generic_mmap,   .munmap = snd_pcm_generic_munmap,   .query_chmaps = snd_pcm_generic_query_chmaps,   .get_chmap = snd_pcm_generic_get_chmap,     .set_chmap = snd_pcm_generic_set_chmap, };
static const snd_pcm_ops_t snd_pcm_alaw_ops = {    .close = snd_pcm_generic_close,     .info = snd_pcm_generic_info,   .hw_refine = snd_pcm_alaw_hw_refine,    .hw_params = snd_pcm_alaw_hw_params,    .hw_free = snd_pcm_generic_hw_free,     .sw_params = snd_pcm_generic_sw_params,     .channel_info = snd_pcm_generic_channel_info,   .dump = snd_pcm_alaw_dump,  .nonblock = snd_pcm_generic_nonblock,   .async = snd_pcm_generic_async,     .mmap = snd_pcm_generic_mmap,   .munmap = snd_pcm_generic_munmap,   .query_chmaps = snd_pcm_generic_query_chmaps,   .get_chmap = snd_pcm_generic_get_chmap,     .set_chmap = snd_pcm_generic_set_chmap, };
static const snd_pcm_ops_t snd_pcm_copy_ops = {    .close = snd_pcm_generic_close,     .info = snd_pcm_generic_info,   .hw_refine = snd_pcm_copy_hw_refine,    .hw_params = snd_pcm_copy_hw_params,    .hw_free = snd_pcm_generic_hw_free,     .sw_params = snd_pcm_generic_sw_params,     .channel_info = snd_pcm_generic_channel_info,   .dump = snd_pcm_copy_dump,  .nonblock = snd_pcm_generic_nonblock,   .async = snd_pcm_generic_async,     .mmap = snd_pcm_generic_mmap,   .munmap = snd_pcm_generic_munmap,   .query_chmaps = snd_pcm_generic_query_chmaps,   .get_chmap = snd_pcm_generic_get_chmap,     .set_chmap = snd_pcm_generic_set_chmap, };
static const snd_pcm_ops_t snd_pcm_dmix_ops = {    .close = snd_pcm_dmix_close,    .info = snd_pcm_direct_info,    .hw_refine = snd_pcm_direct_hw_refine,  .hw_params = snd_pcm_direct_hw_params,  .hw_free = snd_pcm_direct_hw_free,  .sw_params = snd_pcm_direct_sw_params,  .channel_info = snd_pcm_direct_channel_info,    .dump = snd_pcm_dmix_dump,  .nonblock = snd_pcm_direct_nonblock,    .async = snd_pcm_direct_async,  .mmap = snd_pcm_direct_mmap,    .munmap = snd_pcm_direct_munmap,    .query_chmaps = snd_pcm_direct_query_chmaps,    .get_chmap = snd_pcm_direct_get_chmap,  .set_chmap = snd_pcm_direct_set_chmap, };
static const snd_pcm_fast_ops_t snd_pcm_dmix_fast_ops = {  .status = snd_pcm_dmix_status,  .state = snd_pcm_dmix_state,    .hwsync = snd_pcm_dmix_hwsync,  .delay = snd_pcm_dmix_delay,    .prepare = snd_pcm_direct_prepare,  .reset = snd_pcm_dmix_reset,    .start = snd_pcm_dmix_start,    .drop = snd_pcm_dmix_drop,  .drain = snd_pcm_dmix_drain,    .pause = snd_pcm_dmix_pause,    .rewindable = snd_pcm_dmix_rewindable,  .rewind = snd_pcm_dmix_rewind,  .forwardable = snd_pcm_dmix_forwardable,    .forward = snd_pcm_dmix_forward,    .resume = snd_pcm_direct_resume,    .link = NULL,   .link_slaves = NULL,    .unlink = NULL,     .writei = snd_pcm_mmap_writei,     .writen = snd_pcm_mmap_writen,     .readi = snd_pcm_dmix_readi,    .readn = snd_pcm_dmix_readn,    .avail_update = snd_pcm_dmix_avail_update,  .mmap_commit = snd_pcm_dmix_mmap_commit,    .htimestamp = snd_pcm_dmix_htimestamp,  .poll_descriptors = NULL,   .poll_descriptors_count = NULL,     .poll_revents = snd_pcm_dmix_poll_revents, };
static const snd_pcm_ops_t snd_pcm_dshare_ops = {    .close = snd_pcm_dshare_close,  .info = snd_pcm_direct_info,    .hw_refine = snd_pcm_direct_hw_refine,  .hw_params = snd_pcm_direct_hw_params,  .hw_free = snd_pcm_direct_hw_free,  .sw_params = snd_pcm_direct_sw_params,  .channel_info = snd_pcm_direct_channel_info,    .dump = snd_pcm_dshare_dump,    .nonblock = snd_pcm_direct_nonblock,    .async = snd_pcm_direct_async,  .mmap = snd_pcm_direct_mmap,    .munmap = snd_pcm_direct_munmap,    .get_chmap = snd_pcm_direct_get_chmap,  .set_chmap = snd_pcm_direct_set_chmap, };
static const snd_pcm_fast_ops_t snd_pcm_dshare_fast_ops = {  .status = snd_pcm_dshare_status,    .state = snd_pcm_dshare_state,  .hwsync = snd_pcm_dshare_hwsync,    .delay = snd_pcm_dshare_delay,  .prepare = snd_pcm_direct_prepare,  .reset = snd_pcm_dshare_reset,  .start = snd_pcm_dshare_start,  .drop = snd_pcm_dshare_drop,    .drain = snd_pcm_dshare_drain,  .pause = snd_pcm_dshare_pause,  .rewindable = snd_pcm_dshare_rewindable,    .rewind = snd_pcm_dshare_rewind,    .forwardable = snd_pcm_dshare_forwardable,  .forward = snd_pcm_dshare_forward,  .resume = snd_pcm_direct_resume,    .link = NULL,   .link_slaves = NULL,    .unlink = NULL,     .writei = snd_pcm_mmap_writei,     .writen = snd_pcm_mmap_writen,     .readi = snd_pcm_dshare_readi,  .readn = snd_pcm_dshare_readn,  .avail_update = snd_pcm_dshare_avail_update,    .mmap_commit = snd_pcm_dshare_mmap_commit,  .htimestamp = snd_pcm_dshare_htimestamp,    .poll_descriptors = NULL,   .poll_descriptors_count = NULL,     .poll_revents = snd_pcm_direct_poll_revents, };
static const snd_pcm_ops_t snd_pcm_dsnoop_ops = {    .close = snd_pcm_dsnoop_close,  .info = snd_pcm_direct_info,    .hw_refine = snd_pcm_direct_hw_refine,  .hw_params = snd_pcm_direct_hw_params,  .hw_free = snd_pcm_direct_hw_free,  .sw_params = snd_pcm_direct_sw_params,  .channel_info = snd_pcm_direct_channel_info,    .dump = snd_pcm_dsnoop_dump,    .nonblock = snd_pcm_direct_nonblock,    .async = snd_pcm_direct_async,  .mmap = snd_pcm_direct_mmap,    .munmap = snd_pcm_direct_munmap,    .query_chmaps = snd_pcm_direct_query_chmaps,    .get_chmap = snd_pcm_direct_get_chmap,  .set_chmap = snd_pcm_direct_set_chmap, };
static const snd_pcm_fast_ops_t snd_pcm_dsnoop_fast_ops = {  .status = snd_pcm_dsnoop_status,    .state = snd_pcm_dsnoop_state,  .hwsync = snd_pcm_dsnoop_hwsync,    .delay = snd_pcm_dsnoop_delay,  .prepare = snd_pcm_direct_prepare,  .reset = snd_pcm_dsnoop_reset,  .start = snd_pcm_dsnoop_start,  .drop = snd_pcm_dsnoop_drop,    .drain = snd_pcm_dsnoop_drain,  .pause = snd_pcm_dsnoop_pause,  .rewindable = snd_pcm_dsnoop_rewindable,    .rewind = snd_pcm_dsnoop_rewind,    .forwardable = snd_pcm_dsnoop_forwardable,  .forward = snd_pcm_dsnoop_forward,  .resume = snd_pcm_direct_resume,    .link = NULL,   .link_slaves = NULL,    .unlink = NULL,     .writei = snd_pcm_dsnoop_writei,    .writen = snd_pcm_dsnoop_writen,    .readi = snd_pcm_mmap_readi,   .readn = snd_pcm_mmap_readn,   .avail_update = snd_pcm_dsnoop_avail_update,    .mmap_commit = snd_pcm_dsnoop_mmap_commit,  .htimestamp = snd_pcm_dsnoop_htimestamp,    .poll_descriptors = NULL,   .poll_descriptors_count = NULL,     .poll_revents = snd_pcm_direct_poll_revents, };
static const snd_pcm_ops_t snd_pcm_file_ops = {    .close = snd_pcm_file_close,    .info = snd_pcm_generic_info,   .hw_refine = snd_pcm_generic_hw_refine,     .hw_params = snd_pcm_file_hw_params,    .hw_free = snd_pcm_file_hw_free,    .sw_params = snd_pcm_generic_sw_params,     .channel_info = snd_pcm_generic_channel_info,   .dump = snd_pcm_file_dump,  .nonblock = snd_pcm_generic_nonblock,   .async = snd_pcm_generic_async,     .mmap = snd_pcm_generic_mmap,   .munmap = snd_pcm_generic_munmap,   .query_chmaps = snd_pcm_generic_query_chmaps,   .get_chmap = snd_pcm_generic_get_chmap,     .set_chmap = snd_pcm_generic_set_chmap, };
static const snd_pcm_fast_ops_t snd_pcm_file_fast_ops = {  .status = snd_pcm_generic_status,   .state = snd_pcm_generic_state,     .hwsync = snd_pcm_generic_hwsync,   .delay = snd_pcm_generic_delay,     .prepare = snd_pcm_generic_prepare,     .reset = snd_pcm_file_reset,    .start = snd_pcm_generic_start,     .drop = snd_pcm_file_drop,  .drain = snd_pcm_file_drain,    .pause = snd_pcm_generic_pause,     .rewindable = snd_pcm_file_rewindable,  .rewind = snd_pcm_file_rewind,  .forwardable = snd_pcm_file_forwardable,    .forward = snd_pcm_file_forward,    .resume = snd_pcm_generic_resume,   .link = snd_pcm_generic_link,   .link_slaves = snd_pcm_generic_link_slaves,     .unlink = snd_pcm_generic_unlink,   .writei = snd_pcm_file_writei,  .writen = snd_pcm_file_writen,  .readi = snd_pcm_file_readi,    .readn = snd_pcm_file_readn,    .avail_update = snd_pcm_generic_avail_update,   .mmap_commit = snd_pcm_file_mmap_commit,    .poll_descriptors_count = snd_pcm_generic_poll_descriptors_count,   .poll_descriptors = snd_pcm_generic_poll_descriptors,   .poll_revents = snd_pcm_generic_poll_revents,   .htimestamp = snd_pcm_generic_real_htimestamp, };
static const snd_pcm_ops_t snd_pcm_hooks_ops = {  .close = snd_pcm_hooks_close,   .info = snd_pcm_generic_info,   .hw_refine = snd_pcm_generic_hw_refine,     .hw_params = snd_pcm_hooks_hw_params,   .hw_free = snd_pcm_hooks_hw_free,   .sw_params = snd_pcm_generic_sw_params,     .channel_info = snd_pcm_generic_channel_info,   .dump = snd_pcm_hooks_dump,     .nonblock = snd_pcm_generic_nonblock,   .async = snd_pcm_generic_async,     .mmap = snd_pcm_generic_mmap,   .munmap = snd_pcm_generic_munmap,   .query_chmaps = snd_pcm_generic_query_chmaps,   .get_chmap = snd_pcm_generic_get_chmap,     .set_chmap = snd_pcm_generic_set_chmap, };
static const snd_pcm_fast_ops_t snd_pcm_hooks_fast_ops;
static const snd_pcm_ops_t snd_pcm_hw_ops = {    .close = snd_pcm_hw_close,  .info = snd_pcm_hw_info,    .hw_refine = snd_pcm_hw_hw_refine,  .hw_params = snd_pcm_hw_hw_params,  .hw_free = snd_pcm_hw_hw_free,  .sw_params = snd_pcm_hw_sw_params,  .channel_info = snd_pcm_hw_channel_info,    .dump = snd_pcm_hw_dump,    .nonblock = snd_pcm_hw_nonblock,    .async = snd_pcm_hw_async,  .mmap = snd_pcm_hw_mmap,    .munmap = snd_pcm_hw_munmap,    .query_chmaps = snd_pcm_hw_query_chmaps,    .get_chmap = snd_pcm_hw_get_chmap,  .set_chmap = snd_pcm_hw_set_chmap, };
static const snd_pcm_fast_ops_t snd_pcm_hw_fast_ops = {  .status = snd_pcm_hw_status,    .state = snd_pcm_hw_state,  .hwsync = snd_pcm_hw_hwsync,    .delay = snd_pcm_hw_delay,  .prepare = snd_pcm_hw_prepare,  .reset = snd_pcm_hw_reset,  .start = snd_pcm_hw_start,  .drop = snd_pcm_hw_drop,    .drain = snd_pcm_hw_drain,  .pause = snd_pcm_hw_pause,  .rewindable = snd_pcm_hw_rewindable,    .rewind = snd_pcm_hw_rewind,    .forwardable = snd_pcm_hw_forwardable,  .forward = snd_pcm_hw_forward,  .resume = snd_pcm_hw_resume,    .link = snd_pcm_hw_link,    .link_slaves = snd_pcm_hw_link_slaves,  .unlink = snd_pcm_hw_unlink,    .writei = snd_pcm_hw_writei,    .writen = snd_pcm_hw_writen,    .readi = snd_pcm_hw_readi,  .readn = snd_pcm_hw_readn,  .avail_update = snd_pcm_hw_avail_update,    .mmap_commit = snd_pcm_hw_mmap_commit,  .htimestamp = snd_pcm_hw_htimestamp,    .poll_descriptors = NULL,   .poll_descriptors_count = NULL,     .poll_revents = NULL, };
static const snd_pcm_fast_ops_t snd_pcm_hw_fast_ops_timer = {    .status = snd_pcm_hw_status,    .state = snd_pcm_hw_state,  .hwsync = snd_pcm_hw_hwsync,    .delay = snd_pcm_hw_delay,  .prepare = snd_pcm_hw_prepare,  .reset = snd_pcm_hw_reset,  .start = snd_pcm_hw_start,  .drop = snd_pcm_hw_drop,    .drain = snd_pcm_hw_drain,  .pause = snd_pcm_hw_pause,  .rewindable = snd_pcm_hw_rewindable,    .rewind = snd_pcm_hw_rewind,    .forwardable = snd_pcm_hw_forwardable,  .forward = snd_pcm_hw_forward,  .resume = snd_pcm_hw_resume,    .link = snd_pcm_hw_link,    .link_slaves = snd_pcm_hw_link_slaves,  .unlink = snd_pcm_hw_unlink,    .writei = snd_pcm_hw_writei,    .writen = snd_pcm_hw_writen,    .readi = snd_pcm_hw_readi,  .readn = snd_pcm_hw_readn,  .avail_update = snd_pcm_hw_avail_update,    .mmap_commit = snd_pcm_hw_mmap_commit,  .htimestamp = snd_pcm_hw_htimestamp,    .poll_descriptors = snd_pcm_hw_poll_descriptors,    .poll_descriptors_count = snd_pcm_hw_poll_descriptors_count,    .poll_revents = snd_pcm_hw_poll_revents, };
static const snd_pcm_ops_t snd_pcm_iec958_ops = {    .close = snd_pcm_generic_close,     .info = snd_pcm_generic_info,   .hw_refine = snd_pcm_iec958_hw_refine,  .hw_params = snd_pcm_iec958_hw_params,  .hw_free = snd_pcm_generic_hw_free,     .sw_params = snd_pcm_generic_sw_params,     .channel_info = snd_pcm_generic_channel_info,   .dump = snd_pcm_iec958_dump,    .nonblock = snd_pcm_generic_nonblock,   .async = snd_pcm_generic_async,     .mmap = snd_pcm_generic_mmap,   .munmap = snd_pcm_generic_munmap,   .query_chmaps = snd_pcm_generic_query_chmaps,   .get_chmap = snd_pcm_generic_get_chmap,     .set_chmap = snd_pcm_generic_set_chmap, };
static const snd_pcm_ops_t snd_pcm_ladspa_ops = {    .close = snd_pcm_ladspa_close,  .info = snd_pcm_generic_info,   .hw_refine = snd_pcm_ladspa_hw_refine,  .hw_params = snd_pcm_ladspa_hw_params,  .hw_free = snd_pcm_ladspa_hw_free,  .sw_params = snd_pcm_generic_sw_params,     .channel_info = snd_pcm_generic_channel_info,   .dump = snd_pcm_ladspa_dump,    .nonblock = snd_pcm_generic_nonblock,   .async = snd_pcm_generic_async,     .mmap = snd_pcm_generic_mmap,   .munmap = snd_pcm_generic_munmap,   .query_chmaps = snd_pcm_generic_query_chmaps,   .get_chmap = snd_pcm_generic_get_chmap,     .set_chmap = snd_pcm_generic_set_chmap, };
static const snd_pcm_ops_t snd_pcm_lfloat_ops = {    .close = snd_pcm_generic_close,     .info = snd_pcm_generic_info,   .hw_refine = snd_pcm_lfloat_hw_refine,  .hw_params = snd_pcm_lfloat_hw_params,  .hw_free = snd_pcm_generic_hw_free,     .sw_params = snd_pcm_generic_sw_params,     .channel_info = snd_pcm_generic_channel_info,   .dump = snd_pcm_lfloat_dump,    .nonblock = snd_pcm_generic_nonblock,   .async = snd_pcm_generic_async,     .mmap = snd_pcm_generic_mmap,   .munmap = snd_pcm_generic_munmap,   .query_chmaps = snd_pcm_generic_query_chmaps,   .get_chmap = snd_pcm_generic_get_chmap,     .set_chmap = snd_pcm_generic_set_chmap, };
static const snd_pcm_ops_t snd_pcm_linear_ops = {    .close = snd_pcm_generic_close,     .info = snd_pcm_generic_info,   .hw_refine = snd_pcm_linear_hw_refine,  .hw_params = snd_pcm_linear_hw_params,  .hw_free = snd_pcm_generic_hw_free,     .sw_params = snd_pcm_generic_sw_params,     .channel_info = snd_pcm_generic_channel_info,   .dump = snd_pcm_linear_dump,    .nonblock = snd_pcm_generic_nonblock,   .async = snd_pcm_generic_async,     .mmap = snd_pcm_generic_mmap,   .munmap = snd_pcm_generic_munmap,   .query_chmaps = snd_pcm_generic_query_chmaps,   .get_chmap = snd_pcm_generic_get_chmap,     .set_chmap = snd_pcm_generic_set_chmap, };
static const int linear_formats[4][2][2] = {   { { SNDRV_PCM_FORMAT_S8, SNDRV_PCM_FORMAT_S8 },       { SNDRV_PCM_FORMAT_U8, SNDRV_PCM_FORMAT_U8 } },   { { SNDRV_PCM_FORMAT_S16_LE, SNDRV_PCM_FORMAT_S16_BE },       { SNDRV_PCM_FORMAT_U16_LE, SNDRV_PCM_FORMAT_U16_BE } },   { { SNDRV_PCM_FORMAT_S24_LE, SNDRV_PCM_FORMAT_S24_BE },       { SNDRV_PCM_FORMAT_U24_LE, SNDRV_PCM_FORMAT_U24_BE } },   { { SNDRV_PCM_FORMAT_S32_LE, SNDRV_PCM_FORMAT_S32_BE },       { SNDRV_PCM_FORMAT_U32_LE, SNDRV_PCM_FORMAT_U32_BE } } };
static const int linear24_formats[3][2][2] = {     { { SNDRV_PCM_FORMAT_S24_3LE, SNDRV_PCM_FORMAT_S24_3BE },     { SNDRV_PCM_FORMAT_U24_3LE, SNDRV_PCM_FORMAT_U24_3BE } },     { { SNDRV_PCM_FORMAT_S20_3LE, SNDRV_PCM_FORMAT_S20_3BE },     { SNDRV_PCM_FORMAT_U20_3LE, SNDRV_PCM_FORMAT_U20_3BE } },     { { SNDRV_PCM_FORMAT_S18_3LE, SNDRV_PCM_FORMAT_S18_3BE },     { SNDRV_PCM_FORMAT_U18_3LE, SNDRV_PCM_FORMAT_U18_3BE } }, };
static const snd_pcm_ops_t snd_pcm_mmap_emul_ops = {     .close = snd_pcm_generic_close,     .info = snd_pcm_generic_info,   .hw_refine = snd_pcm_mmap_emul_hw_refine,   .hw_params = snd_pcm_mmap_emul_hw_params,   .hw_free = snd_pcm_generic_hw_free,     .sw_params = snd_pcm_mmap_emul_sw_params,   .channel_info = snd_pcm_generic_channel_info,   .dump = snd_pcm_mmap_emul_dump,     .nonblock = snd_pcm_generic_nonblock,   .async = snd_pcm_generic_async,     .mmap = snd_pcm_generic_mmap,   .munmap = snd_pcm_generic_munmap,   .query_chmaps = snd_pcm_generic_query_chmaps,   .get_chmap = snd_pcm_generic_get_chmap,     .set_chmap = snd_pcm_generic_set_chmap, };
static const snd_pcm_fast_ops_t snd_pcm_mmap_emul_fast_ops;
static const snd_pcm_ops_t snd_pcm_mulaw_ops = {  .close = snd_pcm_generic_close,     .info = snd_pcm_generic_info,   .hw_refine = snd_pcm_mulaw_hw_refine,   .hw_params = snd_pcm_mulaw_hw_params,   .hw_free = snd_pcm_generic_hw_free,     .sw_params = snd_pcm_generic_sw_params,     .channel_info = snd_pcm_generic_channel_info,   .dump = snd_pcm_mulaw_dump,     .nonblock = snd_pcm_generic_nonblock,   .async = snd_pcm_generic_async,     .mmap = snd_pcm_generic_mmap,   .munmap = snd_pcm_generic_munmap,   .get_chmap = snd_pcm_generic_get_chmap,     .set_chmap = snd_pcm_generic_set_chmap, };
static const snd_pcm_ops_t snd_pcm_multi_ops = {  .close = snd_pcm_multi_close,   .info = snd_pcm_multi_info,     .hw_refine = snd_pcm_multi_hw_refine,   .hw_params = snd_pcm_multi_hw_params,   .hw_free = snd_pcm_multi_hw_free,   .sw_params = snd_pcm_multi_sw_params,   .channel_info = snd_pcm_multi_channel_info,     .dump = snd_pcm_multi_dump,     .nonblock = snd_pcm_multi_nonblock,     .async = snd_pcm_multi_async,   .mmap = snd_pcm_multi_mmap,     .munmap = snd_pcm_multi_munmap,     .query_chmaps = snd_pcm_multi_query_chmaps,     .get_chmap = snd_pcm_multi_get_chmap,   .set_chmap = snd_pcm_multi_set_chmap, };
static const snd_pcm_fast_ops_t snd_pcm_multi_fast_ops;
static const snd_pcm_ops_t snd_pcm_null_ops = {    .close = snd_pcm_null_close,    .info = snd_pcm_null_info,  .hw_refine = snd_pcm_null_hw_refine,    .hw_params = snd_pcm_null_hw_params,    .hw_free = snd_pcm_null_hw_free,    .sw_params = snd_pcm_null_sw_params,    .channel_info = snd_pcm_generic_channel_info,   .dump = snd_pcm_null_dump,  .nonblock = snd_pcm_null_nonblock,  .async = snd_pcm_null_async,    .mmap = snd_pcm_generic_mmap,   .munmap = snd_pcm_generic_munmap,   .query_chmaps = snd_pcm_null_query_chmaps,  .get_chmap = snd_pcm_null_get_chmap,    .set_chmap = NULL, };
static const snd_pcm_fast_ops_t snd_pcm_null_fast_ops = {  .status = snd_pcm_null_status,  .state = snd_pcm_null_state,    .hwsync = snd_pcm_null_hwsync,  .delay = snd_pcm_null_delay,    .prepare = snd_pcm_null_prepare,    .reset = snd_pcm_null_reset,    .start = snd_pcm_null_start,    .drop = snd_pcm_null_drop,  .drain = snd_pcm_null_drain,    .pause = snd_pcm_null_pause,    .rewindable = snd_pcm_null_rewindable,  .rewind = snd_pcm_null_rewind,  .forwardable = snd_pcm_null_forwardable,    .forward = snd_pcm_null_forward,    .resume = snd_pcm_null_resume,  .writei = snd_pcm_null_writei,  .writen = snd_pcm_null_writen,  .readi = snd_pcm_null_readi,    .readn = snd_pcm_null_readn,    .avail_update = snd_pcm_null_avail_update,  .mmap_commit = snd_pcm_null_mmap_commit,    .htimestamp = snd_pcm_generic_real_htimestamp, };
static const snd_pcm_format_t linear_preferred_formats[];
static const char linear_format_widths[32] = {     0, 0, 0, 0, 0, 0, 0, 1,     0, 0, 0, 0, 0, 0, 0, 1,     0, 1, 0, 1, 0, 0, 0, 1,     0, 0, 0, 0, 0, 0, 0, 1, };
static const snd_pcm_ops_t snd_pcm_plug_ops = {    .close = snd_pcm_plug_close,    .info = snd_pcm_plug_info,  .hw_refine = snd_pcm_plug_hw_refine,    .hw_params = snd_pcm_plug_hw_params,    .hw_free = snd_pcm_plug_hw_free,    .sw_params = snd_pcm_generic_sw_params,     .channel_info = snd_pcm_generic_channel_info,   .dump = snd_pcm_plug_dump,  .nonblock = snd_pcm_generic_nonblock,   .async = snd_pcm_generic_async,     .mmap = snd_pcm_generic_mmap,   .munmap = snd_pcm_generic_munmap,   .query_chmaps = snd_pcm_generic_query_chmaps,   .get_chmap = snd_pcm_generic_get_chmap,     .set_chmap = snd_pcm_generic_set_chmap, };
static const snd_pcm_fast_ops_t snd_pcm_rate_fast_ops = {  .status = snd_pcm_rate_status,  .state = snd_pcm_rate_state,    .hwsync = snd_pcm_rate_hwsync,  .delay = snd_pcm_rate_delay,    .prepare = snd_pcm_rate_prepare,    .reset = snd_pcm_rate_reset,    .start = snd_pcm_rate_start,    .drop = snd_pcm_generic_drop,   .drain = snd_pcm_rate_drain,    .pause = snd_pcm_generic_pause,     .rewindable = snd_pcm_rate_rewindable,  .rewind = snd_pcm_rate_rewind,  .forwardable = snd_pcm_rate_forwardable,    .forward = snd_pcm_rate_forward,    .resume = snd_pcm_generic_resume,   .writei = snd_pcm_mmap_writei,     .writen = snd_pcm_mmap_writen,     .readi = snd_pcm_mmap_readi,   .readn = snd_pcm_mmap_readn,   .avail_update = snd_pcm_rate_avail_update,  .mmap_commit = snd_pcm_rate_mmap_commit,    .htimestamp = snd_pcm_rate_htimestamp,  .poll_descriptors_count = snd_pcm_generic_poll_descriptors_count,   .poll_descriptors = snd_pcm_generic_poll_descriptors,   .poll_revents = snd_pcm_rate_poll_revents,  .may_wait_for_avail_min = snd_pcm_generic_may_wait_for_avail_min, };
static const snd_pcm_ops_t snd_pcm_rate_ops = {    .close = snd_pcm_rate_close,    .info = snd_pcm_generic_info,   .hw_refine = snd_pcm_rate_hw_refine,    .hw_params = snd_pcm_rate_hw_params,    .hw_free = snd_pcm_rate_hw_free,    .sw_params = snd_pcm_rate_sw_params,    .channel_info = snd_pcm_generic_channel_info,   .dump = snd_pcm_rate_dump,  .nonblock = snd_pcm_generic_nonblock,   .async = snd_pcm_generic_async,     .mmap = snd_pcm_generic_mmap,   .munmap = snd_pcm_generic_munmap,   .query_chmaps = snd_pcm_generic_query_chmaps,   .get_chmap = snd_pcm_generic_get_chmap,     .set_chmap = snd_pcm_generic_set_chmap, };
static const char*const default_rate_plugins[] = {     "speexrate", "linear", NULL };
static const snd_pcm_ops_t snd_pcm_route_ops = {  .close = snd_pcm_route_close,   .info = snd_pcm_generic_info,   .hw_refine = snd_pcm_route_hw_refine,   .hw_params = snd_pcm_route_hw_params,   .hw_free = snd_pcm_generic_hw_free,     .sw_params = snd_pcm_generic_sw_params,     .channel_info = snd_pcm_generic_channel_info,   .dump = snd_pcm_route_dump,     .nonblock = snd_pcm_generic_nonblock,   .async = snd_pcm_generic_async,     .mmap = snd_pcm_generic_mmap,   .munmap = snd_pcm_generic_munmap,   .query_chmaps = snd_pcm_route_query_chmaps,     .get_chmap = snd_pcm_route_get_chmap,   .set_chmap = NULL,  };
static const snd_pcm_ops_t snd_pcm_share_ops = {  .close = snd_pcm_share_close,   .info = snd_pcm_share_info,     .hw_refine = snd_pcm_share_hw_refine,   .hw_params = snd_pcm_share_hw_params,   .hw_free = snd_pcm_share_hw_free,   .sw_params = snd_pcm_share_sw_params,   .channel_info = snd_pcm_share_channel_info,     .dump = snd_pcm_share_dump,     .nonblock = snd_pcm_share_nonblock,     .async = snd_pcm_share_async,   .mmap = snd_pcm_share_mmap,     .munmap = snd_pcm_share_munmap, };
static const snd_pcm_fast_ops_t snd_pcm_share_fast_ops = {    .status = snd_pcm_share_status,     .state = snd_pcm_share_state,   .hwsync = snd_pcm_share_hwsync,     .delay = snd_pcm_share_delay,   .prepare = snd_pcm_share_prepare,   .reset = snd_pcm_share_reset,   .start = snd_pcm_share_start,   .drop = snd_pcm_share_drop,     .drain = snd_pcm_share_drain,   .pause = snd_pcm_share_pause,   .writei = snd_pcm_mmap_writei,     .writen = snd_pcm_mmap_writen,     .readi = snd_pcm_mmap_readi,   .readn = snd_pcm_mmap_readn,   .rewindable = snd_pcm_share_rewindable,     .rewind = snd_pcm_share_rewind,     .forwardable = snd_pcm_share_forwardable,   .forward = snd_pcm_share_forward,   .resume = snd_pcm_share_resume,     .avail_update = snd_pcm_share_avail_update,     .htimestamp = snd_pcm_share_htimestamp,     .mmap_commit = snd_pcm_share_mmap_commit, };
static const snd_pcm_ops_t snd_pcm_shm_ops = {  .close = snd_pcm_shm_close,     .info = snd_pcm_shm_info,   .hw_refine = snd_pcm_shm_hw_refine,     .hw_params = snd_pcm_shm_hw_params,     .hw_free = snd_pcm_shm_hw_free,     .sw_params = snd_pcm_shm_sw_params,     .channel_info = snd_pcm_shm_channel_info,   .dump = snd_pcm_shm_dump,   .nonblock = snd_pcm_shm_nonblock,   .async = snd_pcm_shm_async,     .mmap = snd_pcm_shm_mmap,   .munmap = snd_pcm_shm_munmap, };
static const snd_pcm_fast_ops_t snd_pcm_shm_fast_ops = {    .status = snd_pcm_shm_status,   .state = snd_pcm_shm_state,     .hwsync = snd_pcm_shm_hwsync,   .delay = snd_pcm_shm_delay,     .prepare = snd_pcm_shm_prepare,     .reset = snd_pcm_shm_reset,     .start = snd_pcm_shm_start,     .drop = snd_pcm_shm_drop,   .drain = snd_pcm_shm_drain,     .pause = snd_pcm_shm_pause,     .rewindable = snd_pcm_shm_rewindable,   .rewind = snd_pcm_shm_rewind,   .forwardable = snd_pcm_shm_forwardable,     .forward = snd_pcm_shm_forward,     .resume = snd_pcm_shm_resume,   .writei = snd_pcm_mmap_writei,     .writen = snd_pcm_mmap_writen,     .readi = snd_pcm_mmap_readi,   .readn = snd_pcm_mmap_readn,   .avail_update = snd_pcm_shm_avail_update,   .mmap_commit = snd_pcm_shm_mmap_commit,     .htimestamp = snd_pcm_shm_htimestamp, };
static const snd_pcm_ops_t snd_pcm_softvol_ops = {  .close = snd_pcm_softvol_close,     .info = snd_pcm_generic_info,   .hw_refine = snd_pcm_softvol_hw_refine,     .hw_params = snd_pcm_softvol_hw_params,     .hw_free = snd_pcm_generic_hw_free,     .sw_params = snd_pcm_generic_sw_params,     .channel_info = snd_pcm_generic_channel_info,   .dump = snd_pcm_softvol_dump,   .nonblock = snd_pcm_generic_nonblock,   .async = snd_pcm_generic_async,     .mmap = snd_pcm_generic_mmap,   .munmap = snd_pcm_generic_munmap,   .query_chmaps = snd_pcm_generic_query_chmaps,   .get_chmap = snd_pcm_generic_get_chmap,     .set_chmap = snd_pcm_generic_set_chmap, };
static const snd_rawmidi_ops_t snd_rawmidi_hw_ops = {    .close = snd_rawmidi_hw_close,  .nonblock = snd_rawmidi_hw_nonblock,    .info = snd_rawmidi_hw_info,    .params = snd_rawmidi_hw_params,    .status = snd_rawmidi_hw_status,    .drop = snd_rawmidi_hw_drop,    .drain = snd_rawmidi_hw_drain,  .write = snd_rawmidi_hw_write,  .read = snd_rawmidi_hw_read, };
static const snd_rawmidi_ops_t snd_rawmidi_virtual_ops = {     .close = snd_rawmidi_virtual_close,     .nonblock = snd_rawmidi_virtual_nonblock,   .info = snd_rawmidi_virtual_info,   .params = snd_rawmidi_virtual_params,   .status = snd_rawmidi_virtual_status,   .drop = snd_rawmidi_virtual_drop,   .drain = snd_rawmidi_virtual_drain,     .write = snd_rawmidi_virtual_write,     .read = snd_rawmidi_virtual_read, };
static const snd_seq_ops_t snd_seq_hw_ops;
static const snd_timer_ops_t snd_timer_hw_ops = {  .close = snd_timer_hw_close,    .nonblock = snd_timer_hw_nonblock,  .async = snd_timer_hw_async,    .info = snd_timer_hw_info,  .params = snd_timer_hw_params,  .status = snd_timer_hw_status,  .rt_start = snd_timer_hw_start,     .rt_stop = snd_timer_hw_stop,   .rt_continue = snd_timer_hw_continue,   .read = snd_timer_hw_read, };
static const snd_timer_query_ops_t snd_timer_query_hw_ops = {   .close = snd_timer_query_hw_close,  .next_device = snd_timer_query_hw_next_device,  .info = snd_timer_query_hw_info,    .params = snd_timer_query_hw_params,    .status = snd_timer_query_hw_status };
static const struct map_elem channel_map[];
static const struct ctl_access_elem ctl_access[] = {   {"read", SNDRV_CTL_ELEM_ACCESS_READ},   {"write", SNDRV_CTL_ELEM_ACCESS_WRITE},     {"read_write", SNDRV_CTL_ELEM_ACCESS_READWRITE},    {"volatile", SNDRV_CTL_ELEM_ACCESS_VOLATILE},   {"timestamp", SNDRV_CTL_ELEM_ACCESS_TIMESTAMP},     {"tlv_read", SNDRV_CTL_ELEM_ACCESS_TLV_READ},   {"tlv_write", SNDRV_CTL_ELEM_ACCESS_TLV_WRITE},     {"tlv_read_write", SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE},    {"tlv_command", SNDRV_CTL_ELEM_ACCESS_TLV_COMMAND},     {"inactive", SNDRV_CTL_ELEM_ACCESS_INACTIVE},   {"lock", SNDRV_CTL_ELEM_ACCESS_LOCK},   {"owner", SNDRV_CTL_ELEM_ACCESS_OWNER},     {"tlv_callback", SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK}, };
static const struct map_elem widget_map[] = {   {"input", SND_SOC_TPLG_DAPM_INPUT},     {"output", SND_SOC_TPLG_DAPM_OUTPUT},   {"mux", SND_SOC_TPLG_DAPM_MUX},     {"mixer", SND_SOC_TPLG_DAPM_MIXER},     {"pga", SND_SOC_TPLG_DAPM_PGA},     {"out_drv", SND_SOC_TPLG_DAPM_OUT_DRV},     {"adc", SND_SOC_TPLG_DAPM_ADC},     {"dac", SND_SOC_TPLG_DAPM_DAC},     {"switch", SND_SOC_TPLG_DAPM_SWITCH},   {"pre", SND_SOC_TPLG_DAPM_PRE},     {"post", SND_SOC_TPLG_DAPM_POST},   {"aif_in", SND_SOC_TPLG_DAPM_AIF_IN},   {"aif_out", SND_SOC_TPLG_DAPM_AIF_OUT},     {"dai_in", SND_SOC_TPLG_DAPM_DAI_IN},   {"dai_out", SND_SOC_TPLG_DAPM_DAI_OUT},     {"dai_link", SND_SOC_TPLG_DAPM_DAI_LINK}, };
static const struct map_elem widget_control_map[] = {   {"volsw", SND_SOC_TPLG_DAPM_CTL_VOLSW},     {"enum_double", SND_SOC_TPLG_DAPM_CTL_ENUM_DOUBLE},     {"enum_virt", SND_SOC_TPLG_DAPM_CTL_ENUM_VIRT},     {"enum_value", SND_SOC_TPLG_DAPM_CTL_ENUM_VALUE}, };
static const struct map_elem control_map[] = {   {"volsw", SND_SOC_TPLG_CTL_VOLSW},  {"volsw_sx", SND_SOC_TPLG_CTL_VOLSW_SX},    {"volsw_xr_sx", SND_SOC_TPLG_CTL_VOLSW_XR_SX},  {"enum", SND_SOC_TPLG_CTL_ENUM},    {"bytes", SND_SOC_TPLG_CTL_BYTES},  {"enum_value", SND_SOC_TPLG_CTL_ENUM_VALUE},    {"range", SND_SOC_TPLG_CTL_RANGE},  {"strobe", SND_SOC_TPLG_CTL_STROBE}, };
static const char*const component_dir[] = {  "codecs",       "dsps",         NULL,        };

// global functions

int
snd_config_top(snd_config_t** config);

int
snd_config_load(
    snd_config_t* config,
    snd_input_t* in
);

int
snd_config_load_override(
    snd_config_t* config,
    snd_input_t* in
);

int
snd_config_save(
    snd_config_t* config,
    snd_output_t* out
);

int
snd_config_update(void);

int
snd_config_update_r(
    snd_config_t** top,
    snd_config_update_t** update,
    const char* path
);

int
snd_config_update_free(snd_config_update_t* update);

int
snd_config_update_free_global(void);

int
snd_config_update_ref(snd_config_t** top);

void
snd_config_ref(snd_config_t* top);

void
snd_config_unref(snd_config_t* top);

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_search_definition(
    snd_config_t* config,
    const char* base,
    const char* key,
    snd_config_t** result
);

int
snd_config_expand(
    snd_config_t* config,
    snd_config_t* root,
    const char* args,
    snd_config_t* private_data,
    snd_config_t** result
);

int
snd_config_evaluate(
    snd_config_t* config,
    snd_config_t* root,
    snd_config_t* private_data,
    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_delete_compound_members(const snd_config_t* config);

int
snd_config_copy(
    snd_config_t** dst,
    snd_config_t* src
);

int
snd_config_make(
    snd_config_t** config,
    const char* key,
    snd_config_type_t type
);

int
snd_config_make_integer(
    snd_config_t** config,
    const char* key
);

int
snd_config_make_integer64(
    snd_config_t** config,
    const char* key
);

int
snd_config_make_real(
    snd_config_t** config,
    const char* key
);

int
snd_config_make_string(
    snd_config_t** config,
    const char* key
);

int
snd_config_make_pointer(
    snd_config_t** config,
    const char* key
);

int
snd_config_make_compound(
    snd_config_t** config,
    const char* key,
    int join
);

int
snd_config_imake_integer(
    snd_config_t** config,
    const char* key,
    const long value
);

int
snd_config_imake_integer64(
    snd_config_t** config,
    const char* key,
    const long long value
);

int
snd_config_imake_real(
    snd_config_t** config,
    const char* key,
    const double value
);

int
snd_config_imake_string(
    snd_config_t** config,
    const char* key,
    const char* ascii
);

int
snd_config_imake_pointer(
    snd_config_t** config,
    const char* key,
    const void* ptr
);

snd_config_type_t
snd_config_get_type(const snd_config_t* config);

int
snd_config_set_id(
    snd_config_t* config,
    const char* id
);

int
snd_config_set_integer(
    snd_config_t* config,
    long value
);

int
snd_config_set_integer64(
    snd_config_t* config,
    long long value
);

int
snd_config_set_real(
    snd_config_t* config,
    double value
);

int
snd_config_set_string(
    snd_config_t* config,
    const char* value
);

int
snd_config_set_ascii(
    snd_config_t* config,
    const char* ascii
);

int
snd_config_set_pointer(
    snd_config_t* config,
    const void* ptr
);

int
snd_config_get_id(
    const snd_config_t* config,
    const char** value
);

int
snd_config_get_integer(
    const snd_config_t* config,
    long* value
);

int
snd_config_get_integer64(
    const snd_config_t* config,
    long long* value
);

int
snd_config_get_real(
    const snd_config_t* config,
    double* value
);

int
snd_config_get_ireal(
    const snd_config_t* config,
    double* value
);

int
snd_config_get_string(
    const snd_config_t* config,
    const char** value
);

int
snd_config_get_ascii(
    const snd_config_t* config,
    char** value
);

int
snd_config_get_pointer(
    const snd_config_t* config,
    const void** value
);

int
snd_config_test_id(
    const snd_config_t* config,
    const char* id
);

snd_config_iterator_t
snd_config_iterator_first(const snd_config_t* node);

snd_config_iterator_t
snd_config_iterator_next(const snd_config_iterator_t iterator);

snd_config_iterator_t
snd_config_iterator_end(const snd_config_t* node);

snd_config_t*
snd_config_iterator_entry(const snd_config_iterator_t iterator);

int
snd_config_get_bool_ascii(const char* ascii);

int
snd_config_get_bool(const snd_config_t* conf);

int
snd_config_get_ctl_iface_ascii(const char* ascii);

int
snd_config_get_ctl_iface(const snd_config_t* conf);

int
snd_names_list(
    const char* iface,
    snd_devname_t** list
);

void
snd_names_list_free(snd_devname_t* list);

int
snd_card_load(int card);

int
snd_card_next(int* card);

int
snd_card_get_index(const char* name);

int
snd_card_get_name(
    int card,
    char** name
);

int
snd_card_get_longname(
    int card,
    char** name
);

int
snd_device_name_hint(
    int card,
    const char* iface,
    void*** hints
);

int
snd_device_name_free_hint(void** hints);

char*
snd_device_name_get_hint(
    const void* hint,
    const char* id
);

int
snd_ctl_open(
    snd_ctl_t** ctl,
    const char* name,
    int mode
);

int
snd_ctl_open_lconf(
    snd_ctl_t** ctl,
    const char* name,
    int mode,
    snd_config_t* lconf
);

int
snd_ctl_open_fallback(
    snd_ctl_t** ctl,
    snd_config_t* root,
    const char* name,
    const char* orig_name,
    int mode
);

int
snd_ctl_close(snd_ctl_t* ctl);

int
snd_ctl_nonblock(
    snd_ctl_t* ctl,
    int nonblock
);

static
__inline__ int
snd_ctl_abort(snd_ctl_t* ctl);

int
snd_async_add_ctl_handler(
    snd_async_handler_t** handler,
    snd_ctl_t* ctl,
    snd_async_callback_t callback,
    void* private_data
);

snd_ctl_t*
snd_async_handler_get_ctl(snd_async_handler_t* handler);

int
snd_ctl_poll_descriptors_count(snd_ctl_t* ctl);

int
snd_ctl_poll_descriptors(
    snd_ctl_t* ctl,
    struct pollfd* pfds,
    unsigned int space
);

int
snd_ctl_poll_descriptors_revents(
    snd_ctl_t* ctl,
    struct pollfd* pfds,
    unsigned int nfds,
    unsigned short* revents
);

int
snd_ctl_subscribe_events(
    snd_ctl_t* ctl,
    int subscribe
);

int
snd_ctl_card_info(
    snd_ctl_t* ctl,
    snd_ctl_card_info_t* info
);

int
snd_ctl_elem_list(
    snd_ctl_t* ctl,
    snd_ctl_elem_list_t* list
);

int
snd_ctl_elem_info(
    snd_ctl_t* ctl,
    snd_ctl_elem_info_t* info
);

int
snd_ctl_elem_read(
    snd_ctl_t* ctl,
    snd_ctl_elem_value_t* data
);

int
snd_ctl_elem_write(
    snd_ctl_t* ctl,
    snd_ctl_elem_value_t* data
);

int
snd_ctl_elem_lock(
    snd_ctl_t* ctl,
    snd_ctl_elem_id_t* id
);

int
snd_ctl_elem_unlock(
    snd_ctl_t* ctl,
    snd_ctl_elem_id_t* id
);

int
snd_ctl_elem_tlv_read(
    snd_ctl_t* ctl,
    const snd_ctl_elem_id_t* id,
    unsigned int* tlv,
    unsigned int tlv_size
);

int
snd_ctl_elem_tlv_write(
    snd_ctl_t* ctl,
    const snd_ctl_elem_id_t* id,
    const unsigned int* tlv
);

int
snd_ctl_elem_tlv_command(
    snd_ctl_t* ctl,
    const snd_ctl_elem_id_t* id,
    const unsigned int* tlv
);

int
snd_ctl_set_power_state(
    snd_ctl_t* ctl,
    unsigned int state
);

int
snd_ctl_get_power_state(
    snd_ctl_t* ctl,
    unsigned int* state
);

int
snd_ctl_read(
    snd_ctl_t* ctl,
    snd_ctl_event_t* event
);

int
snd_ctl_wait(
    snd_ctl_t* ctl,
    int timeout
);

const char*
snd_ctl_name(snd_ctl_t* ctl);

snd_ctl_type_t
snd_ctl_type(snd_ctl_t* ctl);

const char*
snd_ctl_elem_type_name(snd_ctl_elem_type_t type);

const char*
snd_ctl_elem_iface_name(snd_ctl_elem_iface_t iface);

const char*
snd_ctl_event_type_name(snd_ctl_event_type_t type);

unsigned int
snd_ctl_event_elem_get_mask(const snd_ctl_event_t* obj);

unsigned int
snd_ctl_event_elem_get_numid(const snd_ctl_event_t* obj);

void
snd_ctl_event_elem_get_id(
    const snd_ctl_event_t* obj,
    snd_ctl_elem_id_t* ptr
);

snd_ctl_elem_iface_t
snd_ctl_event_elem_get_interface(const snd_ctl_event_t* obj);

unsigned int
snd_ctl_event_elem_get_device(const snd_ctl_event_t* obj);

unsigned int
snd_ctl_event_elem_get_subdevice(const snd_ctl_event_t* obj);

const char*
snd_ctl_event_elem_get_name(const snd_ctl_event_t* obj);

unsigned int
snd_ctl_event_elem_get_index(const snd_ctl_event_t* obj);

int
snd_ctl_elem_list_alloc_space(
    snd_ctl_elem_list_t* obj,
    unsigned int entries
);

void
snd_ctl_elem_list_free_space(snd_ctl_elem_list_t* obj);

char*
snd_ctl_ascii_elem_id_get(snd_ctl_elem_id_t* id);

int
snd_ctl_ascii_elem_id_parse(
    snd_ctl_elem_id_t* dst,
    const char* str
);

int
snd_ctl_ascii_value_parse(
    snd_ctl_t* handle,
    snd_ctl_elem_value_t* dst,
    snd_ctl_elem_info_t* info,
    const char* value
);

size_t
snd_ctl_elem_id_sizeof(void);

int
snd_ctl_elem_id_malloc(snd_ctl_elem_id_t** ptr);

void
snd_ctl_elem_id_free(snd_ctl_elem_id_t* obj);

void
snd_ctl_elem_id_clear(snd_ctl_elem_id_t* obj);

void
snd_ctl_elem_id_copy(
    snd_ctl_elem_id_t* dst,
    const snd_ctl_elem_id_t* src
);

unsigned int
snd_ctl_elem_id_get_numid(const snd_ctl_elem_id_t* obj);

snd_ctl_elem_iface_t
snd_ctl_elem_id_get_interface(const snd_ctl_elem_id_t* obj);

unsigned int
snd_ctl_elem_id_get_device(const snd_ctl_elem_id_t* obj);

unsigned int
snd_ctl_elem_id_get_subdevice(const snd_ctl_elem_id_t* obj);

const char*
snd_ctl_elem_id_get_name(const snd_ctl_elem_id_t* obj);

unsigned int
snd_ctl_elem_id_get_index(const snd_ctl_elem_id_t* obj);

void
snd_ctl_elem_id_set_numid(
    snd_ctl_elem_id_t* obj,
    unsigned int val
);

void
snd_ctl_elem_id_set_interface(
    snd_ctl_elem_id_t* obj,
    snd_ctl_elem_iface_t val
);

void
snd_ctl_elem_id_set_device(
    snd_ctl_elem_id_t* obj,
    unsigned int val
);

void
snd_ctl_elem_id_set_subdevice(
    snd_ctl_elem_id_t* obj,
    unsigned int val
);

void
snd_ctl_elem_id_set_name(
    snd_ctl_elem_id_t* obj,
    const char* val
);

void
snd_ctl_elem_id_set_index(
    snd_ctl_elem_id_t* obj,
    unsigned int val
);

size_t
snd_ctl_card_info_sizeof(void);

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_clear(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_card_info_get_card(const snd_ctl_card_info_t* obj);

const char*
snd_ctl_card_info_get_id(const snd_ctl_card_info_t* obj);

const char*
snd_ctl_card_info_get_driver(const snd_ctl_card_info_t* obj);

const char*
snd_ctl_card_info_get_name(const snd_ctl_card_info_t* obj);

const char*
snd_ctl_card_info_get_longname(const snd_ctl_card_info_t* obj);

const char*
snd_ctl_card_info_get_mixername(const snd_ctl_card_info_t* obj);

const char*
snd_ctl_card_info_get_components(const snd_ctl_card_info_t* obj);

size_t
snd_ctl_event_sizeof(void);

int
snd_ctl_event_malloc(snd_ctl_event_t** ptr);

void
snd_ctl_event_free(snd_ctl_event_t* obj);

void
snd_ctl_event_clear(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);

size_t
snd_ctl_elem_list_sizeof(void);

int
snd_ctl_elem_list_malloc(snd_ctl_elem_list_t** ptr);

void
snd_ctl_elem_list_free(snd_ctl_elem_list_t* obj);

void
snd_ctl_elem_list_clear(snd_ctl_elem_list_t* obj);

void
snd_ctl_elem_list_copy(
    snd_ctl_elem_list_t* dst,
    const snd_ctl_elem_list_t* src
);

void
snd_ctl_elem_list_set_offset(
    snd_ctl_elem_list_t* obj,
    unsigned int val
);

unsigned int
snd_ctl_elem_list_get_used(const snd_ctl_elem_list_t* obj);

unsigned int
snd_ctl_elem_list_get_count(const snd_ctl_elem_list_t* obj);

void
snd_ctl_elem_list_get_id(
    const snd_ctl_elem_list_t* obj,
    unsigned int idx,
    snd_ctl_elem_id_t* ptr
);

unsigned int
snd_ctl_elem_list_get_numid(
    const snd_ctl_elem_list_t* obj,
    unsigned int idx
);

snd_ctl_elem_iface_t
snd_ctl_elem_list_get_interface(
    const snd_ctl_elem_list_t* obj,
    unsigned int idx
);

unsigned int
snd_ctl_elem_list_get_device(
    const snd_ctl_elem_list_t* obj,
    unsigned int idx
);

unsigned int
snd_ctl_elem_list_get_subdevice(
    const snd_ctl_elem_list_t* obj,
    unsigned int idx
);

const char*
snd_ctl_elem_list_get_name(
    const snd_ctl_elem_list_t* obj,
    unsigned int idx
);

unsigned int
snd_ctl_elem_list_get_index(
    const snd_ctl_elem_list_t* obj,
    unsigned int idx
);

size_t
snd_ctl_elem_info_sizeof(void);

int
snd_ctl_elem_info_malloc(snd_ctl_elem_info_t** ptr);

void
snd_ctl_elem_info_free(snd_ctl_elem_info_t* obj);

void
snd_ctl_elem_info_clear(snd_ctl_elem_info_t* obj);

void
snd_ctl_elem_info_copy(
    snd_ctl_elem_info_t* dst,
    const snd_ctl_elem_info_t* src
);

snd_ctl_elem_type_t
snd_ctl_elem_info_get_type(const snd_ctl_elem_info_t* obj);

int
snd_ctl_elem_info_is_readable(const snd_ctl_elem_info_t* obj);

int
snd_ctl_elem_info_is_writable(const snd_ctl_elem_info_t* obj);

int
snd_ctl_elem_info_is_volatile(const snd_ctl_elem_info_t* obj);

int
snd_ctl_elem_info_is_inactive(const snd_ctl_elem_info_t* obj);

int
snd_ctl_elem_info_is_locked(const snd_ctl_elem_info_t* obj);

int
snd_ctl_elem_info_is_tlv_readable(const snd_ctl_elem_info_t* obj);

int
snd_ctl_elem_info_is_tlv_writable(const snd_ctl_elem_info_t* obj);

int
snd_ctl_elem_info_is_tlv_commandable(const snd_ctl_elem_info_t* obj);

int
snd_ctl_elem_info_is_owner(const snd_ctl_elem_info_t* obj);

int
snd_ctl_elem_info_is_user(const snd_ctl_elem_info_t* obj);

pid_t
snd_ctl_elem_info_get_owner(const snd_ctl_elem_info_t* obj);

unsigned int
snd_ctl_elem_info_get_count(const snd_ctl_elem_info_t* obj);

long
snd_ctl_elem_info_get_min(const snd_ctl_elem_info_t* obj);

long
snd_ctl_elem_info_get_max(const snd_ctl_elem_info_t* obj);

long
snd_ctl_elem_info_get_step(const snd_ctl_elem_info_t* obj);

long long
snd_ctl_elem_info_get_min64(const snd_ctl_elem_info_t* obj);

long long
snd_ctl_elem_info_get_max64(const snd_ctl_elem_info_t* obj);

long long
snd_ctl_elem_info_get_step64(const snd_ctl_elem_info_t* obj);

unsigned int
snd_ctl_elem_info_get_items(const snd_ctl_elem_info_t* obj);

void
snd_ctl_elem_info_set_item(
    snd_ctl_elem_info_t* obj,
    unsigned int val
);

const char*
snd_ctl_elem_info_get_item_name(const snd_ctl_elem_info_t* obj);

int
snd_ctl_elem_info_get_dimensions(const snd_ctl_elem_info_t* obj);

int
snd_ctl_elem_info_get_dimension(
    const snd_ctl_elem_info_t* obj,
    unsigned int idx
);

int
snd_ctl_elem_info_set_dimension(
    snd_ctl_elem_info_t* info,
    const int dimension[4]
);

void
snd_ctl_elem_info_get_id(
    const snd_ctl_elem_info_t* obj,
    snd_ctl_elem_id_t* ptr
);

unsigned int
snd_ctl_elem_info_get_numid(const snd_ctl_elem_info_t* obj);

snd_ctl_elem_iface_t
snd_ctl_elem_info_get_interface(const snd_ctl_elem_info_t* obj);

unsigned int
snd_ctl_elem_info_get_device(const snd_ctl_elem_info_t* obj);

unsigned int
snd_ctl_elem_info_get_subdevice(const snd_ctl_elem_info_t* obj);

const char*
snd_ctl_elem_info_get_name(const snd_ctl_elem_info_t* obj);

unsigned int
snd_ctl_elem_info_get_index(const snd_ctl_elem_info_t* obj);

void
snd_ctl_elem_info_set_id(
    snd_ctl_elem_info_t* obj,
    const snd_ctl_elem_id_t* ptr
);

void
snd_ctl_elem_info_set_numid(
    snd_ctl_elem_info_t* obj,
    unsigned int val
);

void
snd_ctl_elem_info_set_interface(
    snd_ctl_elem_info_t* obj,
    snd_ctl_elem_iface_t val
);

void
snd_ctl_elem_info_set_device(
    snd_ctl_elem_info_t* obj,
    unsigned int val
);

void
snd_ctl_elem_info_set_subdevice(
    snd_ctl_elem_info_t* obj,
    unsigned int val
);

void
snd_ctl_elem_info_set_name(
    snd_ctl_elem_info_t* obj,
    const char* val
);

void
snd_ctl_elem_info_set_index(
    snd_ctl_elem_info_t* obj,
    unsigned int val
);

int
snd_ctl_add_integer_elem_set(
    snd_ctl_t* ctl,
    snd_ctl_elem_info_t* info,
    unsigned int element_count,
    unsigned int member_count,
    long min,
    long max,
    long step
);

int
snd_ctl_add_integer64_elem_set(
    snd_ctl_t* ctl,
    snd_ctl_elem_info_t* info,
    unsigned int element_count,
    unsigned int member_count,
    long long min,
    long long max,
    long long step
);

int
snd_ctl_add_boolean_elem_set(
    snd_ctl_t* ctl,
    snd_ctl_elem_info_t* info,
    unsigned int element_count,
    unsigned int member_count
);

int
snd_ctl_add_enumerated_elem_set(
    snd_ctl_t* ctl,
    snd_ctl_elem_info_t* info,
    unsigned int element_count,
    unsigned int member_count,
    unsigned int items,
    const char*const labels[]
);

int
snd_ctl_add_bytes_elem_set(
    snd_ctl_t* ctl,
    snd_ctl_elem_info_t* info,
    unsigned int element_count,
    unsigned int member_count
);

int
snd_ctl_elem_add_integer(
    snd_ctl_t* ctl,
    const snd_ctl_elem_id_t* id,
    unsigned int count,
    long imin,
    long imax,
    long istep
);

int
snd_ctl_elem_add_integer64(
    snd_ctl_t* ctl,
    const snd_ctl_elem_id_t* id,
    unsigned int count,
    long long imin,
    long long imax,
    long long istep
);

int
snd_ctl_elem_add_boolean(
    snd_ctl_t* ctl,
    const snd_ctl_elem_id_t* id,
    unsigned int count
);

int
snd_ctl_elem_add_enumerated(
    snd_ctl_t* ctl,
    const snd_ctl_elem_id_t* id,
    unsigned int count,
    unsigned int items,
    const char*const names[]
);

int
snd_ctl_elem_add_iec958(
    snd_ctl_t* ctl,
    const snd_ctl_elem_id_t* id
);

int
snd_ctl_elem_remove(
    snd_ctl_t* ctl,
    snd_ctl_elem_id_t* id
);

size_t
snd_ctl_elem_value_sizeof(void);

int
snd_ctl_elem_value_malloc(snd_ctl_elem_value_t** ptr);

void
snd_ctl_elem_value_free(snd_ctl_elem_value_t* obj);

void
snd_ctl_elem_value_clear(snd_ctl_elem_value_t* obj);

void
snd_ctl_elem_value_copy(
    snd_ctl_elem_value_t* dst,
    const snd_ctl_elem_value_t* src
);

int
snd_ctl_elem_value_compare(
    snd_ctl_elem_value_t* left,
    const snd_ctl_elem_value_t* right
);

void
snd_ctl_elem_value_get_id(
    const snd_ctl_elem_value_t* obj,
    snd_ctl_elem_id_t* ptr
);

unsigned int
snd_ctl_elem_value_get_numid(const snd_ctl_elem_value_t* obj);

snd_ctl_elem_iface_t
snd_ctl_elem_value_get_interface(const snd_ctl_elem_value_t* obj);

unsigned int
snd_ctl_elem_value_get_device(const snd_ctl_elem_value_t* obj);

unsigned int
snd_ctl_elem_value_get_subdevice(const snd_ctl_elem_value_t* obj);

const char*
snd_ctl_elem_value_get_name(const snd_ctl_elem_value_t* obj);

unsigned int
snd_ctl_elem_value_get_index(const snd_ctl_elem_value_t* obj);

void
snd_ctl_elem_value_set_id(
    snd_ctl_elem_value_t* obj,
    const snd_ctl_elem_id_t* ptr
);

void
snd_ctl_elem_value_set_numid(
    snd_ctl_elem_value_t* obj,
    unsigned int val
);

void
snd_ctl_elem_value_set_interface(
    snd_ctl_elem_value_t* obj,
    snd_ctl_elem_iface_t val
);

void
snd_ctl_elem_value_set_device(
    snd_ctl_elem_value_t* obj,
    unsigned int val
);

void
snd_ctl_elem_value_set_subdevice(
    snd_ctl_elem_value_t* obj,
    unsigned int val
);

void
snd_ctl_elem_value_set_name(
    snd_ctl_elem_value_t* obj,
    const char* val
);

void
snd_ctl_elem_value_set_index(
    snd_ctl_elem_value_t* obj,
    unsigned int val
);

int
snd_ctl_elem_value_get_boolean(
    const snd_ctl_elem_value_t* obj,
    unsigned int idx
);

long
snd_ctl_elem_value_get_integer(
    const snd_ctl_elem_value_t* obj,
    unsigned int idx
);

long long
snd_ctl_elem_value_get_integer64(
    const snd_ctl_elem_value_t* obj,
    unsigned int idx
);

unsigned int
snd_ctl_elem_value_get_enumerated(
    const snd_ctl_elem_value_t* obj,
    unsigned int idx
);

unsigned char
snd_ctl_elem_value_get_byte(
    const snd_ctl_elem_value_t* obj,
    unsigned int idx
);

void
snd_ctl_elem_value_set_boolean(
    snd_ctl_elem_value_t* obj,
    unsigned int idx,
    long val
);

void
snd_ctl_elem_value_set_integer(
    snd_ctl_elem_value_t* obj,
    unsigned int idx,
    long val
);

void
snd_ctl_elem_value_set_integer64(
    snd_ctl_elem_value_t* obj,
    unsigned int idx,
    long long val
);

void
snd_ctl_elem_value_set_enumerated(
    snd_ctl_elem_value_t* obj,
    unsigned int idx,
    unsigned int val
);

void
snd_ctl_elem_value_set_byte(
    snd_ctl_elem_value_t* obj,
    unsigned int idx,
    unsigned char val
);

void
snd_ctl_elem_set_bytes(
    snd_ctl_elem_value_t* obj,
    void* data,
    size_t size
);

const void*
snd_ctl_elem_value_get_bytes(const snd_ctl_elem_value_t* obj);

void
snd_ctl_elem_value_get_iec958(
    const snd_ctl_elem_value_t* obj,
    snd_aes_iec958_t* ptr
);

void
snd_ctl_elem_value_set_iec958(
    snd_ctl_elem_value_t* obj,
    const snd_aes_iec958_t* ptr
);

int
snd_tlv_parse_dB_info(
    unsigned int* tlv,
    unsigned int tlv_size,
    unsigned int** db_tlvp
);

int
snd_tlv_get_dB_range(
    unsigned int* tlv,
    long rangemin,
    long rangemax,
    long* min,
    long* max
);

int
snd_tlv_convert_to_dB(
    unsigned int* tlv,
    long rangemin,
    long rangemax,
    long volume,
    long* db_gain
);

int
snd_tlv_convert_from_dB(
    unsigned int* tlv,
    long rangemin,
    long rangemax,
    long db_gain,
    long* value,
    int xdir
);

int
snd_ctl_get_dB_range(
    snd_ctl_t* ctl,
    const snd_ctl_elem_id_t* id,
    long* min,
    long* max
);

int
snd_ctl_convert_to_dB(
    snd_ctl_t* ctl,
    const snd_ctl_elem_id_t* id,
    long volume,
    long* db_gain
);

int
snd_ctl_convert_from_dB(
    snd_ctl_t* ctl,
    const snd_ctl_elem_id_t* id,
    long db_gain,
    long* value,
    int xdir
);

int
snd_hctl_compare_fast(
    const snd_hctl_elem_t* c1,
    const snd_hctl_elem_t* c2
);

int
snd_hctl_open(
    snd_hctl_t** hctl,
    const char* name,
    int mode
);

int
snd_hctl_open_ctl(
    snd_hctl_t** hctlp,
    snd_ctl_t* ctl
);

int
snd_hctl_close(snd_hctl_t* hctl);

int
snd_hctl_nonblock(
    snd_hctl_t* hctl,
    int nonblock
);

static
__inline__ int
snd_hctl_abort(snd_hctl_t* hctl);

int
snd_hctl_poll_descriptors_count(snd_hctl_t* hctl);

int
snd_hctl_poll_descriptors(
    snd_hctl_t* hctl,
    struct pollfd* pfds,
    unsigned int space
);

int
snd_hctl_poll_descriptors_revents(
    snd_hctl_t* ctl,
    struct pollfd* pfds,
    unsigned int nfds,
    unsigned short* revents
);

unsigned int
snd_hctl_get_count(snd_hctl_t* hctl);

int
snd_hctl_set_compare(
    snd_hctl_t* hctl,
    snd_hctl_compare_t hsort
);

snd_hctl_elem_t*
snd_hctl_first_elem(snd_hctl_t* hctl);

snd_hctl_elem_t*
snd_hctl_last_elem(snd_hctl_t* hctl);

snd_hctl_elem_t*
snd_hctl_find_elem(
    snd_hctl_t* hctl,
    const snd_ctl_elem_id_t* id
);

void
snd_hctl_set_callback(
    snd_hctl_t* hctl,
    snd_hctl_callback_t callback
);

void
snd_hctl_set_callback_private(
    snd_hctl_t* hctl,
    void* data
);

void*
snd_hctl_get_callback_private(snd_hctl_t* hctl);

int
snd_hctl_load(snd_hctl_t* hctl);

int
snd_hctl_free(snd_hctl_t* hctl);

int
snd_hctl_handle_events(snd_hctl_t* hctl);

const char*
snd_hctl_name(snd_hctl_t* hctl);

int
snd_hctl_wait(
    snd_hctl_t* hctl,
    int timeout
);

snd_ctl_t*
snd_hctl_ctl(snd_hctl_t* hctl);

snd_hctl_elem_t*
snd_hctl_elem_next(snd_hctl_elem_t* elem);

snd_hctl_elem_t*
snd_hctl_elem_prev(snd_hctl_elem_t* elem);

int
snd_hctl_elem_info(
    snd_hctl_elem_t* elem,
    snd_ctl_elem_info_t* info
);

int
snd_hctl_elem_read(
    snd_hctl_elem_t* elem,
    snd_ctl_elem_value_t* value
);

int
snd_hctl_elem_write(
    snd_hctl_elem_t* elem,
    snd_ctl_elem_value_t* value
);

int
snd_hctl_elem_tlv_read(
    snd_hctl_elem_t* elem,
    unsigned int* tlv,
    unsigned int tlv_size
);

int
snd_hctl_elem_tlv_write(
    snd_hctl_elem_t* elem,
    const unsigned int* tlv
);

int
snd_hctl_elem_tlv_command(
    snd_hctl_elem_t* elem,
    const unsigned int* tlv
);

snd_hctl_t*
snd_hctl_elem_get_hctl(snd_hctl_elem_t* elem);

void
snd_hctl_elem_get_id(
    const snd_hctl_elem_t* obj,
    snd_ctl_elem_id_t* ptr
);

unsigned int
snd_hctl_elem_get_numid(const snd_hctl_elem_t* obj);

snd_ctl_elem_iface_t
snd_hctl_elem_get_interface(const snd_hctl_elem_t* obj);

unsigned int
snd_hctl_elem_get_device(const snd_hctl_elem_t* obj);

unsigned int
snd_hctl_elem_get_subdevice(const snd_hctl_elem_t* obj);

const char*
snd_hctl_elem_get_name(const snd_hctl_elem_t* obj);

unsigned int
snd_hctl_elem_get_index(const snd_hctl_elem_t* obj);

void
snd_hctl_elem_set_callback(
    snd_hctl_elem_t* obj,
    snd_hctl_elem_callback_t val
);

void*
snd_hctl_elem_get_callback_private(const snd_hctl_elem_t* obj);

void
snd_hctl_elem_set_callback_private(
    snd_hctl_elem_t* obj,
    void* val
);

int
snd_sctl_build(
    snd_sctl_t** ctl,
    snd_ctl_t* handle,
    snd_config_t* config,
    snd_config_t* private_data,
    int mode
);

int
snd_sctl_free(snd_sctl_t* handle);

int
snd_sctl_install(snd_sctl_t* handle);

int
snd_sctl_remove(snd_sctl_t* handle);

int
snd_ctl_ext_create(
    snd_ctl_ext_t* ext,
    const char* name,
    int mode
);

int
snd_ctl_ext_delete(snd_ctl_ext_t* ext);

const char*
snd_strerror(int errnum);

int
snd_lib_error_set_handler(snd_lib_error_handler_t handler);

snd_local_error_handler_t
snd_lib_error_set_local(snd_local_error_handler_t func);

const char*
snd_asoundlib_version(void);

void*
snd_dlopen(
    const char* file,
    int mode
);

void*
snd_dlsym(
    void* handle,
    const char* name,
    const char* version
);

int
snd_dlclose(void* handle);

int
snd_async_add_handler(
    snd_async_handler_t** handler,
    int fd,
    snd_async_callback_t callback,
    void* private_data
);

int
snd_async_del_handler(snd_async_handler_t* handler);

int
snd_async_handler_get_fd(snd_async_handler_t* handler);

int
snd_async_handler_get_signo(snd_async_handler_t* handler);

void*
snd_async_handler_get_callback_private(snd_async_handler_t* handler);

struct snd_shm_area*
snd_shm_area_create(
    int shmid,
    void* ptr
);

struct snd_shm_area*
snd_shm_area_share(struct snd_shm_area* area);

int
snd_shm_area_destroy(struct snd_shm_area* area);

int
snd_user_file(
    const char* file,
    char** result
);

int
snd_hwdep_open(
    snd_hwdep_t** hwdep,
    const char* name,
    int mode
);

int
snd_hwdep_close(snd_hwdep_t* hwdep);

int
snd_hwdep_poll_descriptors(
    snd_hwdep_t* hwdep,
    struct pollfd* pfds,
    unsigned int space
);

int
snd_hwdep_poll_descriptors_count(snd_hwdep_t* hwdep);

int
snd_hwdep_poll_descriptors_revents(
    snd_hwdep_t* hwdep,
    struct pollfd* pfds,
    unsigned int nfds,
    unsigned short* revents
);

int
snd_hwdep_nonblock(
    snd_hwdep_t* hwdep,
    int nonblock
);

int
snd_hwdep_info(
    snd_hwdep_t* hwdep,
    snd_hwdep_info_t* info
);

int
snd_hwdep_dsp_status(
    snd_hwdep_t* hwdep,
    snd_hwdep_dsp_status_t* status
);

int
snd_hwdep_dsp_load(
    snd_hwdep_t* hwdep,
    snd_hwdep_dsp_image_t* block
);

int
snd_hwdep_ioctl(
    snd_hwdep_t* hwdep,
    unsigned int request,
    void* arg
);

ssize_t
snd_hwdep_write(
    snd_hwdep_t* hwdep,
    const void* buffer,
    size_t size
);

ssize_t
snd_hwdep_read(
    snd_hwdep_t* hwdep,
    void* buffer,
    size_t size
);

size_t
snd_hwdep_info_sizeof(void);

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
);

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_name(const snd_hwdep_info_t* obj);

snd_hwdep_iface_t
snd_hwdep_info_get_iface(const snd_hwdep_info_t* obj);

void
snd_hwdep_info_set_device(
    snd_hwdep_info_t* obj,
    unsigned int val
);

size_t
snd_hwdep_dsp_status_sizeof(void);

int
snd_hwdep_dsp_status_malloc(snd_hwdep_dsp_status_t** ptr);

void
snd_hwdep_dsp_status_free(snd_hwdep_dsp_status_t* obj);

void
snd_hwdep_dsp_status_copy(
    snd_hwdep_dsp_status_t* dst,
    const snd_hwdep_dsp_status_t* src
);

unsigned int
snd_hwdep_dsp_status_get_version(const snd_hwdep_dsp_status_t* obj);

const char*
snd_hwdep_dsp_status_get_id(const snd_hwdep_dsp_status_t* obj);

unsigned int
snd_hwdep_dsp_status_get_num_dsps(const snd_hwdep_dsp_status_t* obj);

unsigned int
snd_hwdep_dsp_status_get_dsp_loaded(const snd_hwdep_dsp_status_t* obj);

unsigned int
snd_hwdep_dsp_status_get_chip_ready(const snd_hwdep_dsp_status_t* obj);

size_t
snd_hwdep_dsp_image_sizeof(void);

int
snd_hwdep_dsp_image_malloc(snd_hwdep_dsp_image_t** ptr);

void
snd_hwdep_dsp_image_free(snd_hwdep_dsp_image_t* obj);

void
snd_hwdep_dsp_image_copy(
    snd_hwdep_dsp_image_t* dst,
    const snd_hwdep_dsp_image_t* src
);

unsigned int
snd_hwdep_dsp_image_get_index(const snd_hwdep_dsp_image_t* obj);

const char*
snd_hwdep_dsp_image_get_name(const snd_hwdep_dsp_image_t* obj);

const void*
snd_hwdep_dsp_image_get_image(const snd_hwdep_dsp_image_t* obj);

size_t
snd_hwdep_dsp_image_get_length(const snd_hwdep_dsp_image_t* obj);

void
snd_hwdep_dsp_image_set_index(
    snd_hwdep_dsp_image_t* obj,
    unsigned int _index
);

void
snd_hwdep_dsp_image_set_name(
    snd_hwdep_dsp_image_t* obj,
    const char* name
);

void
snd_hwdep_dsp_image_set_image(
    snd_hwdep_dsp_image_t* obj,
    void* buffer
);

void
snd_hwdep_dsp_image_set_length(
    snd_hwdep_dsp_image_t* obj,
    size_t length
);

int
snd_input_stdio_open(
    snd_input_t** inputp,
    const char* file,
    const char* mode
);

int
snd_input_stdio_attach(
    snd_input_t** inputp,
    FILE* fp,
    int _close
);

int
snd_input_buffer_open(
    snd_input_t** inputp,
    const char* buffer,
    ssize_t size
);

int
snd_input_close(snd_input_t* input);

int
snd_input_scanf(
    snd_input_t* input,
    const char* format,
    ...
);

char*
snd_input_gets(
    snd_input_t* input,
    char* str,
    size_t size
);

int
snd_input_getc(snd_input_t* input);

int
snd_input_ungetc(
    snd_input_t* input,
    int c
);

int
snd_mixer_open(
    snd_mixer_t** mixer,
    int mode
);

int
snd_mixer_close(snd_mixer_t* mixer);

snd_mixer_elem_t*
snd_mixer_first_elem(snd_mixer_t* mixer);

snd_mixer_elem_t*
snd_mixer_last_elem(snd_mixer_t* mixer);

int
snd_mixer_handle_events(snd_mixer_t* mixer);

int
snd_mixer_attach(
    snd_mixer_t* mixer,
    const char* name
);

int
snd_mixer_attach_hctl(
    snd_mixer_t* mixer,
    snd_hctl_t* hctl
);

int
snd_mixer_detach(
    snd_mixer_t* mixer,
    const char* name
);

int
snd_mixer_detach_hctl(
    snd_mixer_t* mixer,
    snd_hctl_t* hctl
);

int
snd_mixer_get_hctl(
    snd_mixer_t* mixer,
    const char* name,
    snd_hctl_t** hctl
);

int
snd_mixer_poll_descriptors_count(snd_mixer_t* mixer);

int
snd_mixer_poll_descriptors(
    snd_mixer_t* mixer,
    struct pollfd* pfds,
    unsigned int space
);

int
snd_mixer_poll_descriptors_revents(
    snd_mixer_t* mixer,
    struct pollfd* pfds,
    unsigned int nfds,
    unsigned short* revents
);

int
snd_mixer_load(snd_mixer_t* mixer);

void
snd_mixer_free(snd_mixer_t* mixer);

int
snd_mixer_wait(
    snd_mixer_t* mixer,
    int timeout
);

int
snd_mixer_set_compare(
    snd_mixer_t* mixer,
    snd_mixer_compare_t msort
);

void
snd_mixer_set_callback(
    snd_mixer_t* obj,
    snd_mixer_callback_t val
);

void*
snd_mixer_get_callback_private(const snd_mixer_t* obj);

void
snd_mixer_set_callback_private(
    snd_mixer_t* obj,
    void* val
);

unsigned int
snd_mixer_get_count(const snd_mixer_t* obj);

int
snd_mixer_class_unregister(snd_mixer_class_t* clss);

snd_mixer_elem_t*
snd_mixer_elem_next(snd_mixer_elem_t* elem);

snd_mixer_elem_t*
snd_mixer_elem_prev(snd_mixer_elem_t* elem);

void
snd_mixer_elem_set_callback(
    snd_mixer_elem_t* obj,
    snd_mixer_elem_callback_t val
);

void*
snd_mixer_elem_get_callback_private(const snd_mixer_elem_t* obj);

void
snd_mixer_elem_set_callback_private(
    snd_mixer_elem_t* obj,
    void* val
);

snd_mixer_elem_type_t
snd_mixer_elem_get_type(const snd_mixer_elem_t* obj);

int
snd_mixer_class_register(
    snd_mixer_class_t* class_,
    snd_mixer_t* mixer
);

int
snd_mixer_elem_new(
    snd_mixer_elem_t** elem,
    snd_mixer_elem_type_t type,
    int compare_weight,
    void* private_data,
    void(*)(snd_mixer_elem_t*elem) private_free
);

int
snd_mixer_elem_add(
    snd_mixer_elem_t* elem,
    snd_mixer_class_t* class_
);

int
snd_mixer_elem_remove(snd_mixer_elem_t* elem);

void
snd_mixer_elem_free(snd_mixer_elem_t* elem);

int
snd_mixer_elem_info(snd_mixer_elem_t* elem);

int
snd_mixer_elem_value(snd_mixer_elem_t* elem);

int
snd_mixer_elem_attach(
    snd_mixer_elem_t* melem,
    snd_hctl_elem_t* helem
);

int
snd_mixer_elem_detach(
    snd_mixer_elem_t* melem,
    snd_hctl_elem_t* helem
);

int
snd_mixer_elem_empty(snd_mixer_elem_t* melem);

void*
snd_mixer_elem_get_private(const snd_mixer_elem_t* melem);

size_t
snd_mixer_class_sizeof(void);

int
snd_mixer_class_malloc(snd_mixer_class_t** ptr);

void
snd_mixer_class_free(snd_mixer_class_t* obj);

void
snd_mixer_class_copy(
    snd_mixer_class_t* dst,
    const snd_mixer_class_t* src
);

snd_mixer_t*
snd_mixer_class_get_mixer(const snd_mixer_class_t* class_);

snd_mixer_event_t
snd_mixer_class_get_event(const snd_mixer_class_t* class_);

void*
snd_mixer_class_get_private(const snd_mixer_class_t* class_);

snd_mixer_compare_t
snd_mixer_class_get_compare(const snd_mixer_class_t* class_);

int
snd_mixer_class_set_event(
    snd_mixer_class_t* class_,
    snd_mixer_event_t event
);

int
snd_mixer_class_set_private(
    snd_mixer_class_t* class_,
    void* private_data
);

int
snd_mixer_class_set_private_free(
    snd_mixer_class_t* class_,
    void(*)(snd_mixer_class_t*) private_free
);

int
snd_mixer_class_set_compare(
    snd_mixer_class_t* class_,
    snd_mixer_compare_t compare
);

const char*
snd_mixer_selem_channel_name(snd_mixer_selem_channel_id_t channel);

int
snd_mixer_selem_register(
    snd_mixer_t* mixer,
    struct snd_mixer_selem_regopt* options,
    snd_mixer_class_t** classp
);

void
snd_mixer_selem_get_id(
    snd_mixer_elem_t* element,
    snd_mixer_selem_id_t* id
);

const char*
snd_mixer_selem_get_name(snd_mixer_elem_t* elem);

unsigned int
snd_mixer_selem_get_index(snd_mixer_elem_t* elem);

snd_mixer_elem_t*
snd_mixer_find_selem(
    snd_mixer_t* mixer,
    const snd_mixer_selem_id_t* id
);

int
snd_mixer_selem_is_active(snd_mixer_elem_t* elem);

int
snd_mixer_selem_is_playback_mono(snd_mixer_elem_t* elem);

int
snd_mixer_selem_has_playback_channel(
    snd_mixer_elem_t* obj,
    snd_mixer_selem_channel_id_t channel
);

int
snd_mixer_selem_is_capture_mono(snd_mixer_elem_t* elem);

int
snd_mixer_selem_has_capture_channel(
    snd_mixer_elem_t* obj,
    snd_mixer_selem_channel_id_t channel
);

int
snd_mixer_selem_get_capture_group(snd_mixer_elem_t* elem);

int
snd_mixer_selem_has_common_volume(snd_mixer_elem_t* elem);

int
snd_mixer_selem_has_playback_volume(snd_mixer_elem_t* elem);

int
snd_mixer_selem_has_playback_volume_joined(snd_mixer_elem_t* elem);

int
snd_mixer_selem_has_capture_volume(snd_mixer_elem_t* elem);

int
snd_mixer_selem_has_capture_volume_joined(snd_mixer_elem_t* elem);

int
snd_mixer_selem_has_common_switch(snd_mixer_elem_t* elem);

int
snd_mixer_selem_has_playback_switch(snd_mixer_elem_t* elem);

int
snd_mixer_selem_has_playback_switch_joined(snd_mixer_elem_t* elem);

int
snd_mixer_selem_has_capture_switch(snd_mixer_elem_t* elem);

int
snd_mixer_selem_has_capture_switch_joined(snd_mixer_elem_t* elem);

int
snd_mixer_selem_has_capture_switch_exclusive(snd_mixer_elem_t* elem);

int
snd_mixer_selem_ask_playback_vol_dB(
    snd_mixer_elem_t* elem,
    long value,
    long* dBvalue
);

int
snd_mixer_selem_ask_capture_vol_dB(
    snd_mixer_elem_t* elem,
    long value,
    long* dBvalue
);

int
snd_mixer_selem_ask_playback_dB_vol(
    snd_mixer_elem_t* elem,
    long dBvalue,
    int dir,
    long* value
);

int
snd_mixer_selem_ask_capture_dB_vol(
    snd_mixer_elem_t* elem,
    long dBvalue,
    int dir,
    long* value
);

int
snd_mixer_selem_get_playback_volume(
    snd_mixer_elem_t* elem,
    snd_mixer_selem_channel_id_t channel,
    long* value
);

int
snd_mixer_selem_get_capture_volume(
    snd_mixer_elem_t* elem,
    snd_mixer_selem_channel_id_t channel,
    long* value
);

int
snd_mixer_selem_get_playback_dB(
    snd_mixer_elem_t* elem,
    snd_mixer_selem_channel_id_t channel,
    long* value
);

int
snd_mixer_selem_get_capture_dB(
    snd_mixer_elem_t* elem,
    snd_mixer_selem_channel_id_t channel,
    long* value
);

int
snd_mixer_selem_get_playback_switch(
    snd_mixer_elem_t* elem,
    snd_mixer_selem_channel_id_t channel,
    int* value
);

int
snd_mixer_selem_get_capture_switch(
    snd_mixer_elem_t* elem,
    snd_mixer_selem_channel_id_t channel,
    int* value
);

int
snd_mixer_selem_set_playback_volume(
    snd_mixer_elem_t* elem,
    snd_mixer_selem_channel_id_t channel,
    long value
);

int
snd_mixer_selem_set_capture_volume(
    snd_mixer_elem_t* elem,
    snd_mixer_selem_channel_id_t channel,
    long value
);

int
snd_mixer_selem_set_playback_dB(
    snd_mixer_elem_t* elem,
    snd_mixer_selem_channel_id_t channel,
    long value,
    int dir
);

int
snd_mixer_selem_set_capture_dB(
    snd_mixer_elem_t* elem,
    snd_mixer_selem_channel_id_t channel,
    long value,
    int dir
);

int
snd_mixer_selem_set_playback_volume_all(
    snd_mixer_elem_t* elem,
    long value
);

int
snd_mixer_selem_set_capture_volume_all(
    snd_mixer_elem_t* elem,
    long value
);

int
snd_mixer_selem_set_playback_dB_all(
    snd_mixer_elem_t* elem,
    long value,
    int dir
);

int
snd_mixer_selem_set_capture_dB_all(
    snd_mixer_elem_t* elem,
    long value,
    int dir
);

int
snd_mixer_selem_set_playback_switch(
    snd_mixer_elem_t* elem,
    snd_mixer_selem_channel_id_t channel,
    int value
);

int
snd_mixer_selem_set_capture_switch(
    snd_mixer_elem_t* elem,
    snd_mixer_selem_channel_id_t channel,
    int value
);

int
snd_mixer_selem_set_playback_switch_all(
    snd_mixer_elem_t* elem,
    int value
);

int
snd_mixer_selem_set_capture_switch_all(
    snd_mixer_elem_t* elem,
    int value
);

int
snd_mixer_selem_get_playback_volume_range(
    snd_mixer_elem_t* elem,
    long* min,
    long* max
);

int
snd_mixer_selem_get_playback_dB_range(
    snd_mixer_elem_t* elem,
    long* min,
    long* max
);

int
snd_mixer_selem_set_playback_volume_range(
    snd_mixer_elem_t* elem,
    long min,
    long max
);

int
snd_mixer_selem_get_capture_volume_range(
    snd_mixer_elem_t* elem,
    long* min,
    long* max
);

int
snd_mixer_selem_get_capture_dB_range(
    snd_mixer_elem_t* elem,
    long* min,
    long* max
);

int
snd_mixer_selem_set_capture_volume_range(
    snd_mixer_elem_t* elem,
    long min,
    long max
);

int
snd_mixer_selem_is_enumerated(snd_mixer_elem_t* elem);

int
snd_mixer_selem_is_enum_playback(snd_mixer_elem_t* elem);

int
snd_mixer_selem_is_enum_capture(snd_mixer_elem_t* elem);

int
snd_mixer_selem_get_enum_items(snd_mixer_elem_t* elem);

int
snd_mixer_selem_get_enum_item_name(
    snd_mixer_elem_t* elem,
    unsigned int idx,
    size_t maxlen,
    char* str
);

int
snd_mixer_selem_get_enum_item(
    snd_mixer_elem_t* elem,
    snd_mixer_selem_channel_id_t channel,
    unsigned int* idxp
);

int
snd_mixer_selem_set_enum_item(
    snd_mixer_elem_t* elem,
    snd_mixer_selem_channel_id_t channel,
    unsigned int idx
);

size_t
snd_mixer_selem_id_sizeof(void);

int
snd_mixer_selem_id_malloc(snd_mixer_selem_id_t** ptr);

void
snd_mixer_selem_id_free(snd_mixer_selem_id_t* obj);

void
snd_mixer_selem_id_copy(
    snd_mixer_selem_id_t* dst,
    const snd_mixer_selem_id_t* src
);

const char*
snd_mixer_selem_id_get_name(const snd_mixer_selem_id_t* obj);

unsigned int
snd_mixer_selem_id_get_index(const snd_mixer_selem_id_t* obj);

void
snd_mixer_selem_id_set_name(
    snd_mixer_selem_id_t* obj,
    const char* val
);

void
snd_mixer_selem_id_set_index(
    snd_mixer_selem_id_t* obj,
    unsigned int val
);

int
snd_output_stdio_open(
    snd_output_t** outputp,
    const char* file,
    const char* mode
);

int
snd_output_stdio_attach(
    snd_output_t** outputp,
    FILE* fp,
    int _close
);

int
snd_output_buffer_open(snd_output_t** outputp);

size_t
snd_output_buffer_string(
    snd_output_t* output,
    char** buf
);

int
snd_output_close(snd_output_t* output);

int
snd_output_printf(
    snd_output_t* output,
    const char* format,
    ...
);

int
snd_output_vprintf(
    snd_output_t* output,
    const char* format,
    va_list args
);

int
snd_output_puts(
    snd_output_t* output,
    const char* str
);

int
snd_output_putc(
    snd_output_t* output,
    int c
);

int
snd_output_flush(snd_output_t* output);

int
snd_pcm_open(
    snd_pcm_t** pcm,
    const char* name,
    snd_pcm_stream_t stream,
    int mode
);

int
snd_pcm_open_lconf(
    snd_pcm_t** pcm,
    const char* name,
    snd_pcm_stream_t stream,
    int mode,
    snd_config_t* lconf
);

int
snd_pcm_open_fallback(
    snd_pcm_t** pcm,
    snd_config_t* root,
    const char* name,
    const char* orig_name,
    snd_pcm_stream_t stream,
    int mode
);

int
snd_pcm_close(snd_pcm_t* pcm);

const char*
snd_pcm_name(snd_pcm_t* pcm);

snd_pcm_type_t
snd_pcm_type(snd_pcm_t* pcm);

snd_pcm_stream_t
snd_pcm_stream(snd_pcm_t* pcm);

int
snd_pcm_poll_descriptors_count(snd_pcm_t* pcm);

int
snd_pcm_poll_descriptors(
    snd_pcm_t* pcm,
    struct pollfd* pfds,
    unsigned int space
);

int
snd_pcm_poll_descriptors_revents(
    snd_pcm_t* pcm,
    struct pollfd* pfds,
    unsigned int nfds,
    unsigned short* revents
);

int
snd_pcm_nonblock(
    snd_pcm_t* pcm,
    int nonblock
);

static
__inline__ int
snd_pcm_abort(snd_pcm_t* pcm);

int
snd_async_add_pcm_handler(
    snd_async_handler_t** handler,
    snd_pcm_t* pcm,
    snd_async_callback_t callback,
    void* private_data
);

snd_pcm_t*
snd_async_handler_get_pcm(snd_async_handler_t* handler);

int
snd_pcm_info(
    snd_pcm_t* pcm,
    snd_pcm_info_t* info
);

int
snd_pcm_hw_params_current(
    snd_pcm_t* pcm,
    snd_pcm_hw_params_t* params
);

int
snd_pcm_hw_params(
    snd_pcm_t* pcm,
    snd_pcm_hw_params_t* params
);

int
snd_pcm_hw_free(snd_pcm_t* pcm);

int
snd_pcm_sw_params_current(
    snd_pcm_t* pcm,
    snd_pcm_sw_params_t* params
);

int
snd_pcm_sw_params(
    snd_pcm_t* pcm,
    snd_pcm_sw_params_t* params
);

int
snd_pcm_prepare(snd_pcm_t* pcm);

int
snd_pcm_reset(snd_pcm_t* pcm);

int
snd_pcm_status(
    snd_pcm_t* pcm,
    snd_pcm_status_t* status
);

int
snd_pcm_start(snd_pcm_t* pcm);

int
snd_pcm_drop(snd_pcm_t* pcm);

int
snd_pcm_drain(snd_pcm_t* pcm);

int
snd_pcm_pause(
    snd_pcm_t* pcm,
    int enable
);

snd_pcm_state_t
snd_pcm_state(snd_pcm_t* pcm);

int
snd_pcm_hwsync(snd_pcm_t* pcm);

int
snd_pcm_delay(
    snd_pcm_t* pcm,
    snd_pcm_sframes_t* delayp
);

int
snd_pcm_resume(snd_pcm_t* pcm);

int
snd_pcm_htimestamp(
    snd_pcm_t* pcm,
    snd_pcm_uframes_t* avail,
    snd_htimestamp_t* tstamp
);

snd_pcm_sframes_t
snd_pcm_avail(snd_pcm_t* pcm);

snd_pcm_sframes_t
snd_pcm_avail_update(snd_pcm_t* pcm);

int
snd_pcm_avail_delay(
    snd_pcm_t* pcm,
    snd_pcm_sframes_t* availp,
    snd_pcm_sframes_t* delayp
);

snd_pcm_sframes_t
snd_pcm_rewindable(snd_pcm_t* pcm);

snd_pcm_sframes_t
snd_pcm_rewind(
    snd_pcm_t* pcm,
    snd_pcm_uframes_t frames
);

snd_pcm_sframes_t
snd_pcm_forwardable(snd_pcm_t* pcm);

snd_pcm_sframes_t
snd_pcm_forward(
    snd_pcm_t* pcm,
    snd_pcm_uframes_t frames
);

snd_pcm_sframes_t
snd_pcm_writei(
    snd_pcm_t* pcm,
    const void* buffer,
    snd_pcm_uframes_t size
);

snd_pcm_sframes_t
snd_pcm_readi(
    snd_pcm_t* pcm,
    void* buffer,
    snd_pcm_uframes_t size
);

snd_pcm_sframes_t
snd_pcm_writen(
    snd_pcm_t* pcm,
    void** bufs,
    snd_pcm_uframes_t size
);

snd_pcm_sframes_t
snd_pcm_readn(
    snd_pcm_t* pcm,
    void** bufs,
    snd_pcm_uframes_t size
);

int
snd_pcm_wait(
    snd_pcm_t* pcm,
    int timeout
);

int
snd_pcm_link(
    snd_pcm_t* pcm1,
    snd_pcm_t* pcm2
);

int
snd_pcm_unlink(snd_pcm_t* pcm);

snd_pcm_chmap_query_t**
snd_pcm_query_chmaps(snd_pcm_t* pcm);

snd_pcm_chmap_query_t**
snd_pcm_query_chmaps_from_hw(
    int card,
    int dev,
    int subdev,
    snd_pcm_stream_t stream
);

void
snd_pcm_free_chmaps(snd_pcm_chmap_query_t** maps);

snd_pcm_chmap_t*
snd_pcm_get_chmap(snd_pcm_t* pcm);

int
snd_pcm_set_chmap(
    snd_pcm_t* pcm,
    const snd_pcm_chmap_t* map
);

const char*
snd_pcm_chmap_type_name(enum snd_pcm_chmap_type val);

const char*
snd_pcm_chmap_name(enum snd_pcm_chmap_position val);

const char*
snd_pcm_chmap_long_name(enum snd_pcm_chmap_position val);

int
snd_pcm_chmap_print(
    const snd_pcm_chmap_t* map,
    size_t maxlen,
    char* buf
);

unsigned int
snd_pcm_chmap_from_string(const char* str);

snd_pcm_chmap_t*
snd_pcm_chmap_parse_string(const char* str);

int
snd_pcm_recover(
    snd_pcm_t* pcm,
    int err,
    int silent
);

int
snd_pcm_set_params(
    snd_pcm_t* pcm,
    snd_pcm_format_t format,
    snd_pcm_access_t access,
    unsigned int channels,
    unsigned int rate,
    int soft_resample,
    unsigned int latency
);

int
snd_pcm_get_params(
    snd_pcm_t* pcm,
    snd_pcm_uframes_t* buffer_size,
    snd_pcm_uframes_t* period_size
);

size_t
snd_pcm_info_sizeof(void);

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);

snd_pcm_sync_id_t
snd_pcm_info_get_sync(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
);

int
snd_pcm_hw_params_any(
    snd_pcm_t* pcm,
    snd_pcm_hw_params_t* params
);

int
snd_pcm_hw_params_can_mmap_sample_resolution(const snd_pcm_hw_params_t* params);

int
snd_pcm_hw_params_is_double(const snd_pcm_hw_params_t* params);

int
snd_pcm_hw_params_is_batch(const snd_pcm_hw_params_t* params);

int
snd_pcm_hw_params_is_block_transfer(const snd_pcm_hw_params_t* params);

int
snd_pcm_hw_params_is_monotonic(const snd_pcm_hw_params_t* params);

int
snd_pcm_hw_params_can_overrange(const snd_pcm_hw_params_t* params);

int
snd_pcm_hw_params_can_pause(const snd_pcm_hw_params_t* params);

int
snd_pcm_hw_params_can_resume(const snd_pcm_hw_params_t* params);

int
snd_pcm_hw_params_is_half_duplex(const snd_pcm_hw_params_t* params);

int
snd_pcm_hw_params_is_joint_duplex(const snd_pcm_hw_params_t* params);

int
snd_pcm_hw_params_can_sync_start(const snd_pcm_hw_params_t* params);

int
snd_pcm_hw_params_can_disable_period_wakeup(const snd_pcm_hw_params_t* params);

int
snd_pcm_hw_params_supports_audio_wallclock_ts(const snd_pcm_hw_params_t* params);

int
snd_pcm_hw_params_supports_audio_ts_type(
    const snd_pcm_hw_params_t* params,
    int type
);

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_fifo_size(const snd_pcm_hw_params_t* params);

size_t
snd_pcm_hw_params_sizeof(void);

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
);

int
snd_pcm_hw_params_get_access(
    const snd_pcm_hw_params_t* params,
    snd_pcm_access_t* _access
);

int
snd_pcm_hw_params_test_access(
    snd_pcm_t* pcm,
    snd_pcm_hw_params_t* params,
    snd_pcm_access_t _access
);

int
snd_pcm_hw_params_set_access(
    snd_pcm_t* pcm,
    snd_pcm_hw_params_t* params,
    snd_pcm_access_t _access
);

int
snd_pcm_hw_params_set_access_first(
    snd_pcm_t* pcm,
    snd_pcm_hw_params_t* params,
    snd_pcm_access_t* _access
);

int
snd_pcm_hw_params_set_access_last(
    snd_pcm_t* pcm,
    snd_pcm_hw_params_t* params,
    snd_pcm_access_t* _access
);

int
snd_pcm_hw_params_set_access_mask(
    snd_pcm_t* pcm,
    snd_pcm_hw_params_t* params,
    snd_pcm_access_mask_t* mask
);

int
snd_pcm_hw_params_get_access_mask(
    snd_pcm_hw_params_t* params,
    snd_pcm_access_mask_t* mask
);

int
snd_pcm_hw_params_get_format(
    const snd_pcm_hw_params_t* params,
    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
);

int
snd_pcm_hw_params_set_format_first(
    snd_pcm_t* pcm,
    snd_pcm_hw_params_t* params,
    snd_pcm_format_t* format
);

int
snd_pcm_hw_params_set_format_last(
    snd_pcm_t* pcm,
    snd_pcm_hw_params_t* params,
    snd_pcm_format_t* format
);

int
snd_pcm_hw_params_set_format_mask(
    snd_pcm_t* pcm,
    snd_pcm_hw_params_t* params,
    snd_pcm_format_mask_t* mask
);

void
snd_pcm_hw_params_get_format_mask(
    snd_pcm_hw_params_t* params,
    snd_pcm_format_mask_t* mask
);

int
snd_pcm_hw_params_get_subformat(
    const snd_pcm_hw_params_t* params,
    snd_pcm_subformat_t* subformat
);

int
snd_pcm_hw_params_test_subformat(
    snd_pcm_t* pcm,
    snd_pcm_hw_params_t* params,
    snd_pcm_subformat_t subformat
);

int
snd_pcm_hw_params_set_subformat(
    snd_pcm_t* pcm,
    snd_pcm_hw_params_t* params,
    snd_pcm_subformat_t subformat
);

int
snd_pcm_hw_params_set_subformat_first(
    snd_pcm_t* pcm,
    snd_pcm_hw_params_t* params,
    snd_pcm_subformat_t* subformat
);

int
snd_pcm_hw_params_set_subformat_last(
    snd_pcm_t* pcm,
    snd_pcm_hw_params_t* params,
    snd_pcm_subformat_t* subformat
);

int
snd_pcm_hw_params_set_subformat_mask(
    snd_pcm_t* pcm,
    snd_pcm_hw_params_t* params,
    snd_pcm_subformat_mask_t* mask
);

void
snd_pcm_hw_params_get_subformat_mask(
    snd_pcm_hw_params_t* params,
    snd_pcm_subformat_mask_t* mask
);

int
snd_pcm_hw_params_get_channels(
    const snd_pcm_hw_params_t* params,
    unsigned int* val
);

int
snd_pcm_hw_params_get_channels_min(
    const snd_pcm_hw_params_t* params,
    unsigned int* val
);

int
snd_pcm_hw_params_get_channels_max(
    const snd_pcm_hw_params_t* params,
    unsigned int* val
);

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
);

int
snd_pcm_hw_params_set_channels_near(
    snd_pcm_t* pcm,
    snd_pcm_hw_params_t* params,
    unsigned int* val
);

int
snd_pcm_hw_params_set_channels_first(
    snd_pcm_t* pcm,
    snd_pcm_hw_params_t* params,
    unsigned int* val
);

int
snd_pcm_hw_params_set_channels_last(
    snd_pcm_t* pcm,
    snd_pcm_hw_params_t* params,
    unsigned int* val
);

int
snd_pcm_hw_params_get_rate(
    const snd_pcm_hw_params_t* params,
    unsigned int* val,
    int* dir
);

int
snd_pcm_hw_params_get_rate_min(
    const snd_pcm_hw_params_t* params,
    unsigned int* val,
    int* dir
);

int
snd_pcm_hw_params_get_rate_max(
    const snd_pcm_hw_params_t* params,
    unsigned int* val,
    int* dir
);

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
);

int
snd_pcm_hw_params_set_rate_near(
    snd_pcm_t* pcm,
    snd_pcm_hw_params_t* params,
    unsigned int* val,
    int* dir
);

int
snd_pcm_hw_params_set_rate_first(
    snd_pcm_t* pcm,
    snd_pcm_hw_params_t* params,
    unsigned int* val,
    int* dir
);

int
snd_pcm_hw_params_set_rate_last(
    snd_pcm_t* pcm,
    snd_pcm_hw_params_t* params,
    unsigned int* val,
    int* dir
);

int
snd_pcm_hw_params_set_rate_resample(
    snd_pcm_t* pcm,
    snd_pcm_hw_params_t* params,
    unsigned int val
);

int
snd_pcm_hw_params_get_rate_resample(
    snd_pcm_t* pcm,
    snd_pcm_hw_params_t* params,
    unsigned int* val
);

int
snd_pcm_hw_params_set_export_buffer(
    snd_pcm_t* pcm,
    snd_pcm_hw_params_t* params,
    unsigned int val
);

int
snd_pcm_hw_params_get_export_buffer(
    snd_pcm_t* pcm,
    snd_pcm_hw_params_t* params,
    unsigned int* val
);

int
snd_pcm_hw_params_set_period_wakeup(
    snd_pcm_t* pcm,
    snd_pcm_hw_params_t* params,
    unsigned int val
);

int
snd_pcm_hw_params_get_period_wakeup(
    snd_pcm_t* pcm,
    snd_pcm_hw_params_t* params,
    unsigned int* val
);

int
snd_pcm_hw_params_get_period_time(
    const snd_pcm_hw_params_t* params,
    unsigned int* val,
    int* dir
);

int
snd_pcm_hw_params_get_period_time_min(
    const snd_pcm_hw_params_t* params,
    unsigned int* val,
    int* dir
);

int
snd_pcm_hw_params_get_period_time_max(
    const snd_pcm_hw_params_t* params,
    unsigned int* val,
    int* dir
);

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
);

int
snd_pcm_hw_params_set_period_time_near(
    snd_pcm_t* pcm,
    snd_pcm_hw_params_t* params,
    unsigned int* val,
    int* dir
);

int
snd_pcm_hw_params_set_period_time_first(
    snd_pcm_t* pcm,
    snd_pcm_hw_params_t* params,
    unsigned int* val,
    int* dir
);

int
snd_pcm_hw_params_set_period_time_last(
    snd_pcm_t* pcm,
    snd_pcm_hw_params_t* params,
    unsigned int* val,
    int* dir
);

int
snd_pcm_hw_params_get_period_size(
    const snd_pcm_hw_params_t* params,
    snd_pcm_uframes_t* frames,
    int* dir
);

int
snd_pcm_hw_params_get_period_size_min(
    const snd_pcm_hw_params_t* params,
    snd_pcm_uframes_t* frames,
    int* dir
);

int
snd_pcm_hw_params_get_period_size_max(
    const snd_pcm_hw_params_t* params,
    snd_pcm_uframes_t* frames,
    int* dir
);

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
);

int
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
);

int
snd_pcm_hw_params_set_period_size_first(
    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_last(
    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_integer(
    snd_pcm_t* pcm,
    snd_pcm_hw_params_t* params
);

int
snd_pcm_hw_params_get_periods(
    const snd_pcm_hw_params_t* params,
    unsigned int* val,
    int* dir
);

int
snd_pcm_hw_params_get_periods_min(
    const snd_pcm_hw_params_t* params,
    unsigned int* val,
    int* dir
);

int
snd_pcm_hw_params_get_periods_max(
    const snd_pcm_hw_params_t* params,
    unsigned int* val,
    int* dir
);

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
);

int
snd_pcm_hw_params_set_periods_near(
    snd_pcm_t* pcm,
    snd_pcm_hw_params_t* params,
    unsigned int* val,
    int* dir
);

int
snd_pcm_hw_params_set_periods_first(
    snd_pcm_t* pcm,
    snd_pcm_hw_params_t* params,
    unsigned int* val,
    int* dir
);

int
snd_pcm_hw_params_set_periods_last(
    snd_pcm_t* pcm,
    snd_pcm_hw_params_t* params,
    unsigned int* val,
    int* dir
);

int
snd_pcm_hw_params_set_periods_integer(
    snd_pcm_t* pcm,
    snd_pcm_hw_params_t* params
);

int
snd_pcm_hw_params_get_buffer_time(
    const snd_pcm_hw_params_t* params,
    unsigned int* val,
    int* dir
);

int
snd_pcm_hw_params_get_buffer_time_min(
    const snd_pcm_hw_params_t* params,
    unsigned int* val,
    int* dir
);

int
snd_pcm_hw_params_get_buffer_time_max(
    const snd_pcm_hw_params_t* params,
    unsigned int* val,
    int* dir
);

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
);

int
snd_pcm_hw_params_set_buffer_time_near(
    snd_pcm_t* pcm,
    snd_pcm_hw_params_t* params,
    unsigned int* val,
    int* dir
);

int
snd_pcm_hw_params_set_buffer_time_first(
    snd_pcm_t* pcm,
    snd_pcm_hw_params_t* params,
    unsigned int* val,
    int* dir
);

int
snd_pcm_hw_params_set_buffer_time_last(
    snd_pcm_t* pcm,
    snd_pcm_hw_params_t* params,
    unsigned int* val,
    int* dir
);

int
snd_pcm_hw_params_get_buffer_size(
    const snd_pcm_hw_params_t* params,
    snd_pcm_uframes_t* val
);

int
snd_pcm_hw_params_get_buffer_size_min(
    const snd_pcm_hw_params_t* params,
    snd_pcm_uframes_t* val
);

int
snd_pcm_hw_params_get_buffer_size_max(
    const snd_pcm_hw_params_t* params,
    snd_pcm_uframes_t* val
);

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
);

int
snd_pcm_hw_params_set_buffer_size_near(
    snd_pcm_t* pcm,
    snd_pcm_hw_params_t* params,
    snd_pcm_uframes_t* val
);

int
snd_pcm_hw_params_set_buffer_size_first(
    snd_pcm_t* pcm,
    snd_pcm_hw_params_t* params,
    snd_pcm_uframes_t* val
);

int
snd_pcm_hw_params_set_buffer_size_last(
    snd_pcm_t* pcm,
    snd_pcm_hw_params_t* params,
    snd_pcm_uframes_t* val
);

int
snd_pcm_hw_params_get_min_align(
    const snd_pcm_hw_params_t* params,
    snd_pcm_uframes_t* val
);

size_t
snd_pcm_sw_params_sizeof(void);

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
);

int
snd_pcm_sw_params_get_boundary(
    const snd_pcm_sw_params_t* params,
    snd_pcm_uframes_t* val
);

int
snd_pcm_sw_params_set_tstamp_mode(
    snd_pcm_t* pcm,
    snd_pcm_sw_params_t* params,
    snd_pcm_tstamp_t val
);

int
snd_pcm_sw_params_get_tstamp_mode(
    const snd_pcm_sw_params_t* params,
    snd_pcm_tstamp_t* val
);

int
snd_pcm_sw_params_set_tstamp_type(
    snd_pcm_t* pcm,
    snd_pcm_sw_params_t* params,
    snd_pcm_tstamp_type_t val
);

int
snd_pcm_sw_params_get_tstamp_type(
    const snd_pcm_sw_params_t* params,
    snd_pcm_tstamp_type_t* val
);

int
snd_pcm_sw_params_set_avail_min(
    snd_pcm_t* pcm,
    snd_pcm_sw_params_t* params,
    snd_pcm_uframes_t val
);

int
snd_pcm_sw_params_get_avail_min(
    const snd_pcm_sw_params_t* params,
    snd_pcm_uframes_t* val
);

int
snd_pcm_sw_params_set_period_event(
    snd_pcm_t* pcm,
    snd_pcm_sw_params_t* params,
    int val
);

int
snd_pcm_sw_params_get_period_event(
    const snd_pcm_sw_params_t* params,
    int* val
);

int
snd_pcm_sw_params_set_start_threshold(
    snd_pcm_t* pcm,
    snd_pcm_sw_params_t* params,
    snd_pcm_uframes_t val
);

int
snd_pcm_sw_params_get_start_threshold(
    const snd_pcm_sw_params_t* paramsm,
    snd_pcm_uframes_t* val
);

int
snd_pcm_sw_params_set_stop_threshold(
    snd_pcm_t* pcm,
    snd_pcm_sw_params_t* params,
    snd_pcm_uframes_t val
);

int
snd_pcm_sw_params_get_stop_threshold(
    const snd_pcm_sw_params_t* params,
    snd_pcm_uframes_t* val
);

int
snd_pcm_sw_params_set_silence_threshold(
    snd_pcm_t* pcm,
    snd_pcm_sw_params_t* params,
    snd_pcm_uframes_t val
);

int
snd_pcm_sw_params_get_silence_threshold(
    const snd_pcm_sw_params_t* params,
    snd_pcm_uframes_t* val
);

int
snd_pcm_sw_params_set_silence_size(
    snd_pcm_t* pcm,
    snd_pcm_sw_params_t* params,
    snd_pcm_uframes_t val
);

int
snd_pcm_sw_params_get_silence_size(
    const snd_pcm_sw_params_t* params,
    snd_pcm_uframes_t* val
);

size_t
snd_pcm_access_mask_sizeof(void);

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
);

void
snd_pcm_access_mask_none(snd_pcm_access_mask_t* mask);

void
snd_pcm_access_mask_any(snd_pcm_access_mask_t* mask);

int
snd_pcm_access_mask_test(
    const snd_pcm_access_mask_t* mask,
    snd_pcm_access_t val
);

int
snd_pcm_access_mask_empty(const snd_pcm_access_mask_t* mask);

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(void);

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
);

void
snd_pcm_format_mask_none(snd_pcm_format_mask_t* mask);

void
snd_pcm_format_mask_any(snd_pcm_format_mask_t* mask);

int
snd_pcm_format_mask_test(
    const snd_pcm_format_mask_t* mask,
    snd_pcm_format_t val
);

int
snd_pcm_format_mask_empty(const snd_pcm_format_mask_t* mask);

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(void);

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
);

void
snd_pcm_subformat_mask_none(snd_pcm_subformat_mask_t* mask);

void
snd_pcm_subformat_mask_any(snd_pcm_subformat_mask_t* mask);

int
snd_pcm_subformat_mask_test(
    const snd_pcm_subformat_mask_t* mask,
    snd_pcm_subformat_t val
);

int
snd_pcm_subformat_mask_empty(const snd_pcm_subformat_mask_t* mask);

void
snd_pcm_subformat_mask_set(
    snd_pcm_subformat_mask_t* mask,
    snd_pcm_subformat_t val
);

void
snd_pcm_subformat_mask_reset(
    snd_pcm_subformat_mask_t* mask,
    snd_pcm_subformat_t val
);

size_t
snd_pcm_status_sizeof(void);

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
);

snd_pcm_state_t
snd_pcm_status_get_state(const snd_pcm_status_t* obj);

void
snd_pcm_status_get_trigger_tstamp(
    const snd_pcm_status_t* obj,
    snd_timestamp_t* ptr
);

void
snd_pcm_status_get_trigger_htstamp(
    const snd_pcm_status_t* obj,
    snd_htimestamp_t* ptr
);

void
snd_pcm_status_get_tstamp(
    const snd_pcm_status_t* obj,
    snd_timestamp_t* ptr
);

void
snd_pcm_status_get_htstamp(
    const snd_pcm_status_t* obj,
    snd_htimestamp_t* ptr
);

void
snd_pcm_status_get_audio_htstamp(
    const snd_pcm_status_t* obj,
    snd_htimestamp_t* ptr
);

void
snd_pcm_status_get_driver_htstamp(
    const snd_pcm_status_t* obj,
    snd_htimestamp_t* ptr
);

void
snd_pcm_status_get_audio_htstamp_report(
    const snd_pcm_status_t* obj,
    snd_pcm_audio_tstamp_report_t* audio_tstamp_report
);

void
snd_pcm_status_set_audio_htstamp_config(
    snd_pcm_status_t* obj,
    snd_pcm_audio_tstamp_config_t* audio_tstamp_config
);

static
void
snd_pcm_pack_audio_tstamp_config(
    unsigned int* data,
    snd_pcm_audio_tstamp_config_t* config
);

static
void
snd_pcm_unpack_audio_tstamp_report(
    unsigned int data,
    unsigned int accuracy,
    snd_pcm_audio_tstamp_report_t* report
);

snd_pcm_sframes_t
snd_pcm_status_get_delay(const snd_pcm_status_t* obj);

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);

snd_pcm_uframes_t
snd_pcm_status_get_overrange(const snd_pcm_status_t* obj);

const char*
snd_pcm_type_name(snd_pcm_type_t type);

const char*
snd_pcm_stream_name(const snd_pcm_stream_t stream);

const char*
snd_pcm_access_name(const snd_pcm_access_t _access);

const char*
snd_pcm_format_name(const snd_pcm_format_t format);

const char*
snd_pcm_format_description(const snd_pcm_format_t format);

const char*
snd_pcm_subformat_name(const snd_pcm_subformat_t subformat);

const char*
snd_pcm_subformat_description(const snd_pcm_subformat_t subformat);

snd_pcm_format_t
snd_pcm_format_value(const char* name);

const char*
snd_pcm_tstamp_mode_name(const snd_pcm_tstamp_t mode);

const char*
snd_pcm_state_name(const snd_pcm_state_t state);

int
snd_pcm_dump(
    snd_pcm_t* pcm,
    snd_output_t* out
);

int
snd_pcm_dump_hw_setup(
    snd_pcm_t* pcm,
    snd_output_t* out
);

int
snd_pcm_dump_sw_setup(
    snd_pcm_t* pcm,
    snd_output_t* out
);

int
snd_pcm_dump_setup(
    snd_pcm_t* pcm,
    snd_output_t* out
);

int
snd_pcm_hw_params_dump(
    snd_pcm_hw_params_t* params,
    snd_output_t* out
);

int
snd_pcm_sw_params_dump(
    snd_pcm_sw_params_t* params,
    snd_output_t* out
);

int
snd_pcm_status_dump(
    snd_pcm_status_t* status,
    snd_output_t* out
);

int
snd_pcm_mmap_begin(
    snd_pcm_t* pcm,
    const snd_pcm_channel_area_t** areas,
    snd_pcm_uframes_t* offset,
    snd_pcm_uframes_t* frames
);

snd_pcm_sframes_t
snd_pcm_mmap_commit(
    snd_pcm_t* pcm,
    snd_pcm_uframes_t offset,
    snd_pcm_uframes_t frames
);

snd_pcm_sframes_t
snd_pcm_mmap_writei(
    snd_pcm_t* pcm,
    const void* buffer,
    snd_pcm_uframes_t size
);

snd_pcm_sframes_t
snd_pcm_mmap_readi(
    snd_pcm_t* pcm,
    void* buffer,
    snd_pcm_uframes_t size
);

snd_pcm_sframes_t
snd_pcm_mmap_writen(
    snd_pcm_t* pcm,
    void** bufs,
    snd_pcm_uframes_t size
);

snd_pcm_sframes_t
snd_pcm_mmap_readn(
    snd_pcm_t* pcm,
    void** bufs,
    snd_pcm_uframes_t size
);

int
snd_pcm_format_signed(snd_pcm_format_t format);

int
snd_pcm_format_unsigned(snd_pcm_format_t format);

int
snd_pcm_format_linear(snd_pcm_format_t format);

int
snd_pcm_format_float(snd_pcm_format_t format);

int
snd_pcm_format_little_endian(snd_pcm_format_t format);

int
snd_pcm_format_big_endian(snd_pcm_format_t format);

int
snd_pcm_format_cpu_endian(snd_pcm_format_t format);

int
snd_pcm_format_width(snd_pcm_format_t format);

int
snd_pcm_format_physical_width(snd_pcm_format_t format);

snd_pcm_format_t
snd_pcm_build_linear_format(
    int width,
    int pwidth,
    int unsignd,
    int big_endian
);

ssize_t
snd_pcm_format_size(
    snd_pcm_format_t format,
    size_t samples
);

u_int8_t
snd_pcm_format_silence(snd_pcm_format_t format);

u_int16_t
snd_pcm_format_silence_16(snd_pcm_format_t format);

u_int32_t
snd_pcm_format_silence_32(snd_pcm_format_t format);

u_int64_t
snd_pcm_format_silence_64(snd_pcm_format_t format);

int
snd_pcm_format_set_silence(
    snd_pcm_format_t format,
    void* buf,
    unsigned int samples
);

snd_pcm_sframes_t
snd_pcm_bytes_to_frames(
    snd_pcm_t* pcm,
    ssize_t bytes
);

ssize_t
snd_pcm_frames_to_bytes(
    snd_pcm_t* pcm,
    snd_pcm_sframes_t frames
);

long
snd_pcm_bytes_to_samples(
    snd_pcm_t* pcm,
    ssize_t bytes
);

ssize_t
snd_pcm_samples_to_bytes(
    snd_pcm_t* pcm,
    long samples
);

int
snd_pcm_area_silence(
    const snd_pcm_channel_area_t* dst_channel,
    snd_pcm_uframes_t dst_offset,
    unsigned int samples,
    snd_pcm_format_t format
);

int
snd_pcm_areas_silence(
    const snd_pcm_channel_area_t* dst_channels,
    snd_pcm_uframes_t dst_offset,
    unsigned int channels,
    snd_pcm_uframes_t frames,
    snd_pcm_format_t format
);

int
snd_pcm_area_copy(
    const snd_pcm_channel_area_t* dst_channel,
    snd_pcm_uframes_t dst_offset,
    const snd_pcm_channel_area_t* src_channel,
    snd_pcm_uframes_t src_offset,
    unsigned int samples,
    snd_pcm_format_t format
);

int
snd_pcm_areas_copy(
    const snd_pcm_channel_area_t* dst_channels,
    snd_pcm_uframes_t dst_offset,
    const snd_pcm_channel_area_t* src_channels,
    snd_pcm_uframes_t src_offset,
    unsigned int channels,
    snd_pcm_uframes_t frames,
    snd_pcm_format_t format
);

snd_pcm_t*
snd_pcm_hook_get_pcm(snd_pcm_hook_t* hook);

void*
snd_pcm_hook_get_private(snd_pcm_hook_t* hook);

void
snd_pcm_hook_set_private(
    snd_pcm_hook_t* hook,
    void* private_data
);

int
snd_pcm_hook_add(
    snd_pcm_hook_t** hookp,
    snd_pcm_t* pcm,
    snd_pcm_hook_type_t type,
    snd_pcm_hook_func_t func,
    void* private_data
);

int
snd_pcm_hook_remove(snd_pcm_hook_t* hook);

snd_pcm_uframes_t
snd_pcm_meter_get_bufsize(snd_pcm_t* pcm);

unsigned int
snd_pcm_meter_get_channels(snd_pcm_t* pcm);

unsigned int
snd_pcm_meter_get_rate(snd_pcm_t* pcm);

snd_pcm_uframes_t
snd_pcm_meter_get_now(snd_pcm_t* pcm);

snd_pcm_uframes_t
snd_pcm_meter_get_boundary(snd_pcm_t* pcm);

int
snd_pcm_meter_add_scope(
    snd_pcm_t* pcm,
    snd_pcm_scope_t* scope
);

snd_pcm_scope_t*
snd_pcm_meter_search_scope(
    snd_pcm_t* pcm,
    const char* name
);

int
snd_pcm_scope_malloc(snd_pcm_scope_t** ptr);

void
snd_pcm_scope_set_ops(
    snd_pcm_scope_t* scope,
    const snd_pcm_scope_ops_t* val
);

void
snd_pcm_scope_set_name(
    snd_pcm_scope_t* scope,
    const char* val
);

const char*
snd_pcm_scope_get_name(snd_pcm_scope_t* scope);

void*
snd_pcm_scope_get_callback_private(snd_pcm_scope_t* scope);

void
snd_pcm_scope_set_callback_private(
    snd_pcm_scope_t* scope,
    void* val
);

int
snd_pcm_scope_s16_open(
    snd_pcm_t* pcm,
    const char* name,
    snd_pcm_scope_t** scopep
);

int16_t*
snd_pcm_scope_s16_get_channel_buffer(
    snd_pcm_scope_t* scope,
    unsigned int channel
);

int
snd_spcm_init(
    snd_pcm_t* pcm,
    unsigned int rate,
    unsigned int channels,
    snd_pcm_format_t format,
    snd_pcm_subformat_t subformat,
    snd_spcm_latency_t latency,
    snd_pcm_access_t _access,
    snd_spcm_xrun_type_t xrun_type
);

int
snd_spcm_init_duplex(
    snd_pcm_t* playback_pcm,
    snd_pcm_t* capture_pcm,
    unsigned int rate,
    unsigned int channels,
    snd_pcm_format_t format,
    snd_pcm_subformat_t subformat,
    snd_spcm_latency_t latency,
    snd_pcm_access_t _access,
    snd_spcm_xrun_type_t xrun_type,
    snd_spcm_duplex_type_t duplex_type
);

int
snd_spcm_init_get_params(
    snd_pcm_t* pcm,
    unsigned int* rate,
    snd_pcm_uframes_t* buffer_size,
    snd_pcm_uframes_t* period_size
);

const char*
snd_pcm_start_mode_name(snd_pcm_start_t mode);

const char*
snd_pcm_xrun_mode_name(snd_pcm_xrun_t mode);

int
snd_pcm_sw_params_set_start_mode(
    snd_pcm_t* pcm,
    snd_pcm_sw_params_t* params,
    snd_pcm_start_t val
);

snd_pcm_start_t
snd_pcm_sw_params_get_start_mode(const snd_pcm_sw_params_t* params);

int
snd_pcm_sw_params_set_xrun_mode(
    snd_pcm_t* pcm,
    snd_pcm_sw_params_t* params,
    snd_pcm_xrun_t val
);

snd_pcm_xrun_t
snd_pcm_sw_params_get_xrun_mode(const snd_pcm_sw_params_t* params);

int
snd_pcm_sw_params_set_xfer_align(
    snd_pcm_t* pcm,
    snd_pcm_sw_params_t* params,
    snd_pcm_uframes_t val
);

int
snd_pcm_sw_params_get_xfer_align(
    const snd_pcm_sw_params_t* params,
    snd_pcm_uframes_t* val
);

int
snd_pcm_sw_params_set_sleep_min(
    snd_pcm_t* pcm,
    snd_pcm_sw_params_t* params,
    unsigned int val
);

int
snd_pcm_sw_params_get_sleep_min(
    const snd_pcm_sw_params_t* params,
    unsigned int* val
);

int
snd_pcm_hw_params_get_tick_time(
    const snd_pcm_hw_params_t* params,
    unsigned int* val,
    int* dir
);

int
snd_pcm_hw_params_get_tick_time_min(
    const snd_pcm_hw_params_t* params,
    unsigned int* val,
    int* dir
);

int
snd_pcm_hw_params_get_tick_time_max(
    const snd_pcm_hw_params_t* params,
    unsigned int* val,
    int* dir
);

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
);

int
snd_pcm_hw_params_set_tick_time_near(
    snd_pcm_t* pcm,
    snd_pcm_hw_params_t* params,
    unsigned int* val,
    int* dir
);

int
snd_pcm_hw_params_set_tick_time_first(
    snd_pcm_t* pcm,
    snd_pcm_hw_params_t* params,
    unsigned int* val,
    int* dir
);

int
snd_pcm_hw_params_set_tick_time_last(
    snd_pcm_t* pcm,
    snd_pcm_hw_params_t* params,
    unsigned int* val,
    int* dir
);

int
snd_pcm_parse_control_id(
    snd_config_t* conf,
    snd_ctl_elem_id_t* ctl_id,
    int* cardp,
    int* cchannelsp,
    int* hwctlp
);

int
snd_pcm_extplug_create(
    snd_pcm_extplug_t* ext,
    const char* name,
    snd_config_t* root,
    snd_config_t* slave_conf,
    snd_pcm_stream_t stream,
    int mode
);

int
snd_pcm_extplug_delete(snd_pcm_extplug_t* ext);

void
snd_pcm_extplug_params_reset(snd_pcm_extplug_t* ext);

int
snd_pcm_extplug_set_param_list(
    snd_pcm_extplug_t* extplug,
    int type,
    unsigned int num_list,
    const unsigned int* list
);

int
snd_pcm_extplug_set_param_minmax(
    snd_pcm_extplug_t* extplug,
    int type,
    unsigned int min,
    unsigned int max
);

int
snd_pcm_extplug_set_slave_param_list(
    snd_pcm_extplug_t* extplug,
    int type,
    unsigned int num_list,
    const unsigned int* list
);

int
snd_pcm_extplug_set_slave_param_minmax(
    snd_pcm_extplug_t* extplug,
    int type,
    unsigned int min,
    unsigned int max
);

static
__inline__ int
snd_pcm_extplug_set_param(
    snd_pcm_extplug_t* extplug,
    int type,
    unsigned int val
);

static
__inline__ int
snd_pcm_extplug_set_slave_param(
    snd_pcm_extplug_t* extplug,
    int type,
    unsigned int val
);

int
snd_pcm_ioplug_create(
    snd_pcm_ioplug_t* io,
    const char* name,
    snd_pcm_stream_t stream,
    int mode
);

int
snd_pcm_ioplug_delete(snd_pcm_ioplug_t* io);

int
snd_pcm_ioplug_reinit_status(snd_pcm_ioplug_t* ioplug);

const snd_pcm_channel_area_t*
snd_pcm_ioplug_mmap_areas(snd_pcm_ioplug_t* ioplug);

void
snd_pcm_ioplug_params_reset(snd_pcm_ioplug_t* io);

int
snd_pcm_ioplug_set_param_minmax(
    snd_pcm_ioplug_t* io,
    int type,
    unsigned int min,
    unsigned int max
);

int
snd_pcm_ioplug_set_param_list(
    snd_pcm_ioplug_t* io,
    int type,
    unsigned int num_list,
    const unsigned int* list
);

int
snd_pcm_ioplug_set_state(
    snd_pcm_ioplug_t* ioplug,
    snd_pcm_state_t state
);

int
snd_rawmidi_open(
    snd_rawmidi_t** in_rmidi,
    snd_rawmidi_t** out_rmidi,
    const char* name,
    int mode
);

int
snd_rawmidi_open_lconf(
    snd_rawmidi_t** in_rmidi,
    snd_rawmidi_t** out_rmidi,
    const char* name,
    int mode,
    snd_config_t* lconf
);

int
snd_rawmidi_close(snd_rawmidi_t* rmidi);

int
snd_rawmidi_poll_descriptors_count(snd_rawmidi_t* rmidi);

int
snd_rawmidi_poll_descriptors(
    snd_rawmidi_t* rmidi,
    struct pollfd* pfds,
    unsigned int space
);

int
snd_rawmidi_poll_descriptors_revents(
    snd_rawmidi_t* rawmidi,
    struct pollfd* pfds,
    unsigned int nfds,
    unsigned short* revent
);

int
snd_rawmidi_nonblock(
    snd_rawmidi_t* rmidi,
    int nonblock
);

size_t
snd_rawmidi_info_sizeof(void);

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
);

unsigned int
snd_rawmidi_info_get_device(const snd_rawmidi_info_t* obj);

unsigned int
snd_rawmidi_info_get_subdevice(const snd_rawmidi_info_t* obj);

snd_rawmidi_stream_t
snd_rawmidi_info_get_stream(const snd_rawmidi_info_t* obj);

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_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);

unsigned int
snd_rawmidi_info_get_subdevices_avail(const snd_rawmidi_info_t* obj);

void
snd_rawmidi_info_set_device(
    snd_rawmidi_info_t* obj,
    unsigned int val
);

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
);

int
snd_rawmidi_info(
    snd_rawmidi_t* rmidi,
    snd_rawmidi_info_t* info
);

size_t
snd_rawmidi_params_sizeof(void);

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
);

int
snd_rawmidi_params_set_buffer_size(
    snd_rawmidi_t* rmidi,
    snd_rawmidi_params_t* params,
    size_t val
);

size_t
snd_rawmidi_params_get_buffer_size(const snd_rawmidi_params_t* params);

int
snd_rawmidi_params_set_avail_min(
    snd_rawmidi_t* rmidi,
    snd_rawmidi_params_t* params,
    size_t val
);

size_t
snd_rawmidi_params_get_avail_min(const snd_rawmidi_params_t* params);

int
snd_rawmidi_params_set_no_active_sensing(
    snd_rawmidi_t* rmidi,
    snd_rawmidi_params_t* params,
    int val
);

int
snd_rawmidi_params_get_no_active_sensing(const snd_rawmidi_params_t* params);

int
snd_rawmidi_params(
    snd_rawmidi_t* rmidi,
    snd_rawmidi_params_t* params
);

int
snd_rawmidi_params_current(
    snd_rawmidi_t* rmidi,
    snd_rawmidi_params_t* params
);

size_t
snd_rawmidi_status_sizeof(void);

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
);

void
snd_rawmidi_status_get_tstamp(
    const snd_rawmidi_status_t* obj,
    snd_htimestamp_t* ptr
);

size_t
snd_rawmidi_status_get_avail(const snd_rawmidi_status_t* obj);

size_t
snd_rawmidi_status_get_xruns(const snd_rawmidi_status_t* obj);

int
snd_rawmidi_status(
    snd_rawmidi_t* rmidi,
    snd_rawmidi_status_t* status
);

int
snd_rawmidi_drain(snd_rawmidi_t* rmidi);

int
snd_rawmidi_drop(snd_rawmidi_t* rmidi);

ssize_t
snd_rawmidi_write(
    snd_rawmidi_t* rmidi,
    const void* buffer,
    size_t size
);

ssize_t
snd_rawmidi_read(
    snd_rawmidi_t* rmidi,
    void* buffer,
    size_t size
);

const char*
snd_rawmidi_name(snd_rawmidi_t* rmidi);

snd_rawmidi_type_t
snd_rawmidi_type(snd_rawmidi_t* rmidi);

snd_rawmidi_stream_t
snd_rawmidi_stream(snd_rawmidi_t* rawmidi);

int
snd_seq_open(
    snd_seq_t** handle,
    const char* name,
    int streams,
    int mode
);

int
snd_seq_open_lconf(
    snd_seq_t** handle,
    const char* name,
    int streams,
    int mode,
    snd_config_t* lconf
);

const char*
snd_seq_name(snd_seq_t* seq);

snd_seq_type_t
snd_seq_type(snd_seq_t* seq);

int
snd_seq_close(snd_seq_t* handle);

int
snd_seq_poll_descriptors_count(
    snd_seq_t* handle,
    short events
);

int
snd_seq_poll_descriptors(
    snd_seq_t* handle,
    struct pollfd* pfds,
    unsigned int space,
    short events
);

int
snd_seq_poll_descriptors_revents(
    snd_seq_t* seq,
    struct pollfd* pfds,
    unsigned int nfds,
    unsigned short* revents
);

int
snd_seq_nonblock(
    snd_seq_t* handle,
    int nonblock
);

int
snd_seq_client_id(snd_seq_t* handle);

size_t
snd_seq_get_output_buffer_size(snd_seq_t* handle);

size_t
snd_seq_get_input_buffer_size(snd_seq_t* handle);

int
snd_seq_set_output_buffer_size(
    snd_seq_t* handle,
    size_t size
);

int
snd_seq_set_input_buffer_size(
    snd_seq_t* handle,
    size_t size
);

size_t
snd_seq_system_info_sizeof(void);

int
snd_seq_system_info_malloc(snd_seq_system_info_t** ptr);

void
snd_seq_system_info_free(snd_seq_system_info_t* ptr);

void
snd_seq_system_info_copy(
    snd_seq_system_info_t* dst,
    const snd_seq_system_info_t* src
);

int
snd_seq_system_info_get_queues(const snd_seq_system_info_t* info);

int
snd_seq_system_info_get_clients(const snd_seq_system_info_t* info);

int
snd_seq_system_info_get_ports(const snd_seq_system_info_t* info);

int
snd_seq_system_info_get_channels(const snd_seq_system_info_t* info);

int
snd_seq_system_info_get_cur_clients(const snd_seq_system_info_t* info);

int
snd_seq_system_info_get_cur_queues(const snd_seq_system_info_t* info);

int
snd_seq_system_info(
    snd_seq_t* handle,
    snd_seq_system_info_t* info
);

size_t
snd_seq_client_info_sizeof(void);

int
snd_seq_client_info_malloc(snd_seq_client_info_t** ptr);

void
snd_seq_client_info_free(snd_seq_client_info_t* ptr);

void
snd_seq_client_info_copy(
    snd_seq_client_info_t* dst,
    const snd_seq_client_info_t* src
);

int
snd_seq_client_info_get_client(const snd_seq_client_info_t* info);

snd_seq_client_type_t
snd_seq_client_info_get_type(const snd_seq_client_info_t* info);

const char*
snd_seq_client_info_get_name(snd_seq_client_info_t* info);

int
snd_seq_client_info_get_broadcast_filter(const snd_seq_client_info_t* info);

int
snd_seq_client_info_get_error_bounce(const snd_seq_client_info_t* info);

int
snd_seq_client_info_get_card(const snd_seq_client_info_t* info);

int
snd_seq_client_info_get_pid(const snd_seq_client_info_t* info);

const unsigned char*
snd_seq_client_info_get_event_filter(const snd_seq_client_info_t* info);

int
snd_seq_client_info_get_num_ports(const snd_seq_client_info_t* info);

int
snd_seq_client_info_get_event_lost(const snd_seq_client_info_t* info);

void
snd_seq_client_info_set_client(
    snd_seq_client_info_t* info,
    int client
);

void
snd_seq_client_info_set_name(
    snd_seq_client_info_t* info,
    const char* name
);

void
snd_seq_client_info_set_broadcast_filter(
    snd_seq_client_info_t* info,
    int val
);

void
snd_seq_client_info_set_error_bounce(
    snd_seq_client_info_t* info,
    int val
);

void
snd_seq_client_info_set_event_filter(
    snd_seq_client_info_t* info,
    unsigned char* filter
);

void
snd_seq_client_info_event_filter_clear(snd_seq_client_info_t* info);

void
snd_seq_client_info_event_filter_add(
    snd_seq_client_info_t* info,
    int event_type
);

void
snd_seq_client_info_event_filter_del(
    snd_seq_client_info_t* info,
    int event_type
);

int
snd_seq_client_info_event_filter_check(
    snd_seq_client_info_t* info,
    int event_type
);

int
snd_seq_get_client_info(
    snd_seq_t* handle,
    snd_seq_client_info_t* info
);

int
snd_seq_get_any_client_info(
    snd_seq_t* handle,
    int client,
    snd_seq_client_info_t* info
);

int
snd_seq_set_client_info(
    snd_seq_t* handle,
    snd_seq_client_info_t* info
);

int
snd_seq_query_next_client(
    snd_seq_t* handle,
    snd_seq_client_info_t* info
);

size_t
snd_seq_client_pool_sizeof(void);

int
snd_seq_client_pool_malloc(snd_seq_client_pool_t** ptr);

void
snd_seq_client_pool_free(snd_seq_client_pool_t* ptr);

void
snd_seq_client_pool_copy(
    snd_seq_client_pool_t* dst,
    const snd_seq_client_pool_t* src
);

int
snd_seq_client_pool_get_client(const snd_seq_client_pool_t* info);

size_t
snd_seq_client_pool_get_output_pool(const snd_seq_client_pool_t* info);

size_t
snd_seq_client_pool_get_input_pool(const snd_seq_client_pool_t* info);

size_t
snd_seq_client_pool_get_output_room(const snd_seq_client_pool_t* info);

size_t
snd_seq_client_pool_get_output_free(const snd_seq_client_pool_t* info);

size_t
snd_seq_client_pool_get_input_free(const snd_seq_client_pool_t* info);

void
snd_seq_client_pool_set_output_pool(
    snd_seq_client_pool_t* info,
    size_t size
);

void
snd_seq_client_pool_set_input_pool(
    snd_seq_client_pool_t* info,
    size_t size
);

void
snd_seq_client_pool_set_output_room(
    snd_seq_client_pool_t* info,
    size_t size
);

int
snd_seq_get_client_pool(
    snd_seq_t* handle,
    snd_seq_client_pool_t* info
);

int
snd_seq_set_client_pool(
    snd_seq_t* handle,
    snd_seq_client_pool_t* info
);

size_t
snd_seq_port_info_sizeof(void);

int
snd_seq_port_info_malloc(snd_seq_port_info_t** ptr);

void
snd_seq_port_info_free(snd_seq_port_info_t* ptr);

void
snd_seq_port_info_copy(
    snd_seq_port_info_t* dst,
    const snd_seq_port_info_t* src
);

int
snd_seq_port_info_get_client(const snd_seq_port_info_t* info);

int
snd_seq_port_info_get_port(const snd_seq_port_info_t* info);

const snd_seq_addr_t*
snd_seq_port_info_get_addr(const snd_seq_port_info_t* info);

const char*
snd_seq_port_info_get_name(const snd_seq_port_info_t* info);

unsigned int
snd_seq_port_info_get_capability(const snd_seq_port_info_t* info);

unsigned int
snd_seq_port_info_get_type(const snd_seq_port_info_t* info);

int
snd_seq_port_info_get_midi_channels(const snd_seq_port_info_t* info);

int
snd_seq_port_info_get_midi_voices(const snd_seq_port_info_t* info);

int
snd_seq_port_info_get_synth_voices(const snd_seq_port_info_t* info);

int
snd_seq_port_info_get_read_use(const snd_seq_port_info_t* info);

int
snd_seq_port_info_get_write_use(const snd_seq_port_info_t* info);

int
snd_seq_port_info_get_port_specified(const snd_seq_port_info_t* info);

int
snd_seq_port_info_get_timestamping(const snd_seq_port_info_t* info);

int
snd_seq_port_info_get_timestamp_real(const snd_seq_port_info_t* info);

int
snd_seq_port_info_get_timestamp_queue(const snd_seq_port_info_t* info);

void
snd_seq_port_info_set_client(
    snd_seq_port_info_t* info,
    int client
);

void
snd_seq_port_info_set_port(
    snd_seq_port_info_t* info,
    int port
);

void
snd_seq_port_info_set_addr(
    snd_seq_port_info_t* info,
    const snd_seq_addr_t* addr
);

void
snd_seq_port_info_set_name(
    snd_seq_port_info_t* info,
    const char* name
);

void
snd_seq_port_info_set_capability(
    snd_seq_port_info_t* info,
    unsigned int capability
);

void
snd_seq_port_info_set_type(
    snd_seq_port_info_t* info,
    unsigned int type
);

void
snd_seq_port_info_set_midi_channels(
    snd_seq_port_info_t* info,
    int channels
);

void
snd_seq_port_info_set_midi_voices(
    snd_seq_port_info_t* info,
    int voices
);

void
snd_seq_port_info_set_synth_voices(
    snd_seq_port_info_t* info,
    int voices
);

void
snd_seq_port_info_set_port_specified(
    snd_seq_port_info_t* info,
    int val
);

void
snd_seq_port_info_set_timestamping(
    snd_seq_port_info_t* info,
    int enable
);

void
snd_seq_port_info_set_timestamp_real(
    snd_seq_port_info_t* info,
    int realtime
);

void
snd_seq_port_info_set_timestamp_queue(
    snd_seq_port_info_t* info,
    int queue
);

int
snd_seq_create_port(
    snd_seq_t* handle,
    snd_seq_port_info_t* info
);

int
snd_seq_delete_port(
    snd_seq_t* handle,
    int port
);

int
snd_seq_get_port_info(
    snd_seq_t* handle,
    int port,
    snd_seq_port_info_t* info
);

int
snd_seq_get_any_port_info(
    snd_seq_t* handle,
    int client,
    int port,
    snd_seq_port_info_t* info
);

int
snd_seq_set_port_info(
    snd_seq_t* handle,
    int port,
    snd_seq_port_info_t* info
);

int
snd_seq_query_next_port(
    snd_seq_t* handle,
    snd_seq_port_info_t* info
);

size_t
snd_seq_port_subscribe_sizeof(void);

int
snd_seq_port_subscribe_malloc(snd_seq_port_subscribe_t** ptr);

void
snd_seq_port_subscribe_free(snd_seq_port_subscribe_t* ptr);

void
snd_seq_port_subscribe_copy(
    snd_seq_port_subscribe_t* dst,
    const snd_seq_port_subscribe_t* src
);

const snd_seq_addr_t*
snd_seq_port_subscribe_get_sender(const snd_seq_port_subscribe_t* info);

const snd_seq_addr_t*
snd_seq_port_subscribe_get_dest(const snd_seq_port_subscribe_t* info);

int
snd_seq_port_subscribe_get_queue(const snd_seq_port_subscribe_t* info);

int
snd_seq_port_subscribe_get_exclusive(const snd_seq_port_subscribe_t* info);

int
snd_seq_port_subscribe_get_time_update(const snd_seq_port_subscribe_t* info);

int
snd_seq_port_subscribe_get_time_real(const snd_seq_port_subscribe_t* info);

void
snd_seq_port_subscribe_set_sender(
    snd_seq_port_subscribe_t* info,
    const snd_seq_addr_t* addr
);

void
snd_seq_port_subscribe_set_dest(
    snd_seq_port_subscribe_t* info,
    const snd_seq_addr_t* addr
);

void
snd_seq_port_subscribe_set_queue(
    snd_seq_port_subscribe_t* info,
    int q
);

void
snd_seq_port_subscribe_set_exclusive(
    snd_seq_port_subscribe_t* info,
    int val
);

void
snd_seq_port_subscribe_set_time_update(
    snd_seq_port_subscribe_t* info,
    int val
);

void
snd_seq_port_subscribe_set_time_real(
    snd_seq_port_subscribe_t* info,
    int val
);

int
snd_seq_get_port_subscription(
    snd_seq_t* handle,
    snd_seq_port_subscribe_t* sub
);

int
snd_seq_subscribe_port(
    snd_seq_t* handle,
    snd_seq_port_subscribe_t* sub
);

int
snd_seq_unsubscribe_port(
    snd_seq_t* handle,
    snd_seq_port_subscribe_t* sub
);

size_t
snd_seq_query_subscribe_sizeof(void);

int
snd_seq_query_subscribe_malloc(snd_seq_query_subscribe_t** ptr);

void
snd_seq_query_subscribe_free(snd_seq_query_subscribe_t* ptr);

void
snd_seq_query_subscribe_copy(
    snd_seq_query_subscribe_t* dst,
    const snd_seq_query_subscribe_t* src
);

int
snd_seq_query_subscribe_get_client(const snd_seq_query_subscribe_t* info);

int
snd_seq_query_subscribe_get_port(const snd_seq_query_subscribe_t* info);

const snd_seq_addr_t*
snd_seq_query_subscribe_get_root(const snd_seq_query_subscribe_t* info);

snd_seq_query_subs_type_t
snd_seq_query_subscribe_get_type(const snd_seq_query_subscribe_t* info);

int
snd_seq_query_subscribe_get_index(const snd_seq_query_subscribe_t* info);

int
snd_seq_query_subscribe_get_num_subs(const snd_seq_query_subscribe_t* info);

const snd_seq_addr_t*
snd_seq_query_subscribe_get_addr(const snd_seq_query_subscribe_t* info);

int
snd_seq_query_subscribe_get_queue(const snd_seq_query_subscribe_t* info);

int
snd_seq_query_subscribe_get_exclusive(const snd_seq_query_subscribe_t* info);

int
snd_seq_query_subscribe_get_time_update(const snd_seq_query_subscribe_t* info);

int
snd_seq_query_subscribe_get_time_real(const snd_seq_query_subscribe_t* info);

void
snd_seq_query_subscribe_set_client(
    snd_seq_query_subscribe_t* info,
    int client
);

void
snd_seq_query_subscribe_set_port(
    snd_seq_query_subscribe_t* info,
    int port
);

void
snd_seq_query_subscribe_set_root(
    snd_seq_query_subscribe_t* info,
    const snd_seq_addr_t* addr
);

void
snd_seq_query_subscribe_set_type(
    snd_seq_query_subscribe_t* info,
    snd_seq_query_subs_type_t type
);

void
snd_seq_query_subscribe_set_index(
    snd_seq_query_subscribe_t* info,
    int _index
);

int
snd_seq_query_port_subscribers(
    snd_seq_t* seq,
    snd_seq_query_subscribe_t* subs
);

size_t
snd_seq_queue_info_sizeof(void);

int
snd_seq_queue_info_malloc(snd_seq_queue_info_t** ptr);

void
snd_seq_queue_info_free(snd_seq_queue_info_t* ptr);

void
snd_seq_queue_info_copy(
    snd_seq_queue_info_t* dst,
    const snd_seq_queue_info_t* src
);

int
snd_seq_queue_info_get_queue(const snd_seq_queue_info_t* info);

const char*
snd_seq_queue_info_get_name(const snd_seq_queue_info_t* info);

int
snd_seq_queue_info_get_owner(const snd_seq_queue_info_t* info);

int
snd_seq_queue_info_get_locked(const snd_seq_queue_info_t* info);

unsigned int
snd_seq_queue_info_get_flags(const snd_seq_queue_info_t* info);

void
snd_seq_queue_info_set_name(
    snd_seq_queue_info_t* info,
    const char* name
);

void
snd_seq_queue_info_set_owner(
    snd_seq_queue_info_t* info,
    int owner
);

void
snd_seq_queue_info_set_locked(
    snd_seq_queue_info_t* info,
    int locked
);

void
snd_seq_queue_info_set_flags(
    snd_seq_queue_info_t* info,
    unsigned int flags
);

int
snd_seq_create_queue(
    snd_seq_t* seq,
    snd_seq_queue_info_t* info
);

int
snd_seq_alloc_named_queue(
    snd_seq_t* seq,
    const char* name
);

int
snd_seq_alloc_queue(snd_seq_t* handle);

int
snd_seq_free_queue(
    snd_seq_t* handle,
    int q
);

int
snd_seq_get_queue_info(
    snd_seq_t* seq,
    int q,
    snd_seq_queue_info_t* info
);

int
snd_seq_set_queue_info(
    snd_seq_t* seq,
    int q,
    snd_seq_queue_info_t* info
);

int
snd_seq_query_named_queue(
    snd_seq_t* seq,
    const char* name
);

int
snd_seq_get_queue_usage(
    snd_seq_t* handle,
    int q
);

int
snd_seq_set_queue_usage(
    snd_seq_t* handle,
    int q,
    int used
);

size_t
snd_seq_queue_status_sizeof(void);

int
snd_seq_queue_status_malloc(snd_seq_queue_status_t** ptr);

void
snd_seq_queue_status_free(snd_seq_queue_status_t* ptr);

void
snd_seq_queue_status_copy(
    snd_seq_queue_status_t* dst,
    const snd_seq_queue_status_t* src
);

int
snd_seq_queue_status_get_queue(const snd_seq_queue_status_t* info);

int
snd_seq_queue_status_get_events(const snd_seq_queue_status_t* info);

snd_seq_tick_time_t
snd_seq_queue_status_get_tick_time(const snd_seq_queue_status_t* info);

const snd_seq_real_time_t*
snd_seq_queue_status_get_real_time(const snd_seq_queue_status_t* info);

unsigned int
snd_seq_queue_status_get_status(const snd_seq_queue_status_t* info);

int
snd_seq_get_queue_status(
    snd_seq_t* handle,
    int q,
    snd_seq_queue_status_t* status
);

size_t
snd_seq_queue_tempo_sizeof(void);

int
snd_seq_queue_tempo_malloc(snd_seq_queue_tempo_t** ptr);

void
snd_seq_queue_tempo_free(snd_seq_queue_tempo_t* ptr);

void
snd_seq_queue_tempo_copy(
    snd_seq_queue_tempo_t* dst,
    const snd_seq_queue_tempo_t* src
);

int
snd_seq_queue_tempo_get_queue(const snd_seq_queue_tempo_t* info);

unsigned int
snd_seq_queue_tempo_get_tempo(const snd_seq_queue_tempo_t* info);

int
snd_seq_queue_tempo_get_ppq(const snd_seq_queue_tempo_t* info);

unsigned int
snd_seq_queue_tempo_get_skew(const snd_seq_queue_tempo_t* info);

unsigned int
snd_seq_queue_tempo_get_skew_base(const snd_seq_queue_tempo_t* info);

void
snd_seq_queue_tempo_set_tempo(
    snd_seq_queue_tempo_t* info,
    unsigned int tempo
);

void
snd_seq_queue_tempo_set_ppq(
    snd_seq_queue_tempo_t* info,
    int ppq
);

void
snd_seq_queue_tempo_set_skew(
    snd_seq_queue_tempo_t* info,
    unsigned int skew
);

void
snd_seq_queue_tempo_set_skew_base(
    snd_seq_queue_tempo_t* info,
    unsigned int base
);

int
snd_seq_get_queue_tempo(
    snd_seq_t* handle,
    int q,
    snd_seq_queue_tempo_t* tempo
);

int
snd_seq_set_queue_tempo(
    snd_seq_t* handle,
    int q,
    snd_seq_queue_tempo_t* tempo
);

size_t
snd_seq_queue_timer_sizeof(void);

int
snd_seq_queue_timer_malloc(snd_seq_queue_timer_t** ptr);

void
snd_seq_queue_timer_free(snd_seq_queue_timer_t* ptr);

void
snd_seq_queue_timer_copy(
    snd_seq_queue_timer_t* dst,
    const snd_seq_queue_timer_t* src
);

int
snd_seq_queue_timer_get_queue(const snd_seq_queue_timer_t* info);

snd_seq_queue_timer_type_t
snd_seq_queue_timer_get_type(const snd_seq_queue_timer_t* info);

const snd_timer_id_t*
snd_seq_queue_timer_get_id(const snd_seq_queue_timer_t* info);

unsigned int
snd_seq_queue_timer_get_resolution(const snd_seq_queue_timer_t* info);

void
snd_seq_queue_timer_set_type(
    snd_seq_queue_timer_t* info,
    snd_seq_queue_timer_type_t type
);

void
snd_seq_queue_timer_set_id(
    snd_seq_queue_timer_t* info,
    const snd_timer_id_t* id
);

void
snd_seq_queue_timer_set_resolution(
    snd_seq_queue_timer_t* info,
    unsigned int resolution
);

int
snd_seq_get_queue_timer(
    snd_seq_t* handle,
    int q,
    snd_seq_queue_timer_t* timer
);

int
snd_seq_set_queue_timer(
    snd_seq_t* handle,
    int q,
    snd_seq_queue_timer_t* timer
);

int
snd_seq_free_event(snd_seq_event_t* ev);

ssize_t
snd_seq_event_length(snd_seq_event_t* ev);

int
snd_seq_event_output(
    snd_seq_t* handle,
    snd_seq_event_t* ev
);

int
snd_seq_event_output_buffer(
    snd_seq_t* handle,
    snd_seq_event_t* ev
);

int
snd_seq_event_output_direct(
    snd_seq_t* handle,
    snd_seq_event_t* ev
);

int
snd_seq_event_input(
    snd_seq_t* handle,
    snd_seq_event_t** ev
);

int
snd_seq_event_input_pending(
    snd_seq_t* seq,
    int fetch_sequencer
);

int
snd_seq_drain_output(snd_seq_t* handle);

int
snd_seq_event_output_pending(snd_seq_t* seq);

int
snd_seq_extract_output(
    snd_seq_t* handle,
    snd_seq_event_t** ev
);

int
snd_seq_drop_output(snd_seq_t* handle);

int
snd_seq_drop_output_buffer(snd_seq_t* handle);

int
snd_seq_drop_input(snd_seq_t* handle);

int
snd_seq_drop_input_buffer(snd_seq_t* handle);

size_t
snd_seq_remove_events_sizeof(void);

int
snd_seq_remove_events_malloc(snd_seq_remove_events_t** ptr);

void
snd_seq_remove_events_free(snd_seq_remove_events_t* ptr);

void
snd_seq_remove_events_copy(
    snd_seq_remove_events_t* dst,
    const snd_seq_remove_events_t* src
);

unsigned int
snd_seq_remove_events_get_condition(const snd_seq_remove_events_t* info);

int
snd_seq_remove_events_get_queue(const snd_seq_remove_events_t* info);

const snd_seq_timestamp_t*
snd_seq_remove_events_get_time(const snd_seq_remove_events_t* info);

const snd_seq_addr_t*
snd_seq_remove_events_get_dest(const snd_seq_remove_events_t* info);

int
snd_seq_remove_events_get_channel(const snd_seq_remove_events_t* info);

int
snd_seq_remove_events_get_event_type(const snd_seq_remove_events_t* info);

int
snd_seq_remove_events_get_tag(const snd_seq_remove_events_t* info);

void
snd_seq_remove_events_set_condition(
    snd_seq_remove_events_t* info,
    unsigned int flags
);

void
snd_seq_remove_events_set_queue(
    snd_seq_remove_events_t* info,
    int queue
);

void
snd_seq_remove_events_set_time(
    snd_seq_remove_events_t* info,
    const snd_seq_timestamp_t* time
);

void
snd_seq_remove_events_set_dest(
    snd_seq_remove_events_t* info,
    const snd_seq_addr_t* addr
);

void
snd_seq_remove_events_set_channel(
    snd_seq_remove_events_t* info,
    int channel
);

void
snd_seq_remove_events_set_event_type(
    snd_seq_remove_events_t* info,
    int type
);

void
snd_seq_remove_events_set_tag(
    snd_seq_remove_events_t* info,
    int tag
);

int
snd_seq_remove_events(
    snd_seq_t* handle,
    snd_seq_remove_events_t* info
);

void
snd_seq_set_bit(
    int nr,
    void* array
);

void
snd_seq_unset_bit(
    int nr,
    void* array
);

int
snd_seq_change_bit(
    int nr,
    void* array
);

int
snd_seq_get_bit(
    int nr,
    void* array
);

struct snd_seq_ev_ext
__attribute__((packed));

int
snd_midi_event_new(
    size_t bufsize,
    snd_midi_event_t** rdev
);

int
snd_midi_event_resize_buffer(
    snd_midi_event_t* dev,
    size_t bufsize
);

void
snd_midi_event_free(snd_midi_event_t* dev);

void
snd_midi_event_init(snd_midi_event_t* dev);

void
snd_midi_event_reset_encode(snd_midi_event_t* dev);

void
snd_midi_event_reset_decode(snd_midi_event_t* dev);

void
snd_midi_event_no_status(
    snd_midi_event_t* dev,
    int on
);

long
snd_midi_event_encode(
    snd_midi_event_t* dev,
    const unsigned char* buf,
    long count,
    snd_seq_event_t* ev
);

int
snd_midi_event_encode_byte(
    snd_midi_event_t* dev,
    int c,
    snd_seq_event_t* ev
);

long
snd_midi_event_decode(
    snd_midi_event_t* dev,
    unsigned char* buf,
    long count,
    const snd_seq_event_t* ev
);

int
snd_seq_control_queue(
    snd_seq_t* seq,
    int q,
    int type,
    int value,
    snd_seq_event_t* ev
);

int
snd_seq_create_simple_port(
    snd_seq_t* seq,
    const char* name,
    unsigned int caps,
    unsigned int type
);

int
snd_seq_delete_simple_port(
    snd_seq_t* seq,
    int port
);

int
snd_seq_connect_from(
    snd_seq_t* seq,
    int my_port,
    int src_client,
    int src_port
);

int
snd_seq_co