From bb8bbb1ade9d1512ff7c7c90560ea7154f837d17 Mon Sep 17 00:00:00 2001 From: Jari Vetoniemi Date: Thu, 1 Nov 2018 11:33:02 +0200 Subject: crap for making portaudio (audacity) work --- src/libasound.c | 261 ++++++++++++++++++++++++++++++++++++++++++++++---------- src/pcm.c | 107 ++++++++++++++++++++++- src/stubs.h | 27 ------ 3 files changed, 322 insertions(+), 73 deletions(-) diff --git a/src/libasound.c b/src/libasound.c index 66cdf2c..d21f1b9 100644 --- a/src/libasound.c +++ b/src/libasound.c @@ -12,8 +12,28 @@ #include "stubs.h" #include "symversioning-hell.h" -struct _snd_config { char noop; } s_snd_config; -struct _snd_config *snd_config = &s_snd_config; +enum { + CARD_NONE = -1, + CARD_DEFAULT, +}; + +static const char *CARD_NAMES[] = { + "sndio", // CARD_DEFAULT // hw:0 +}; + +enum { + PCM_NONE = -1, + PCM_PLAYBACK, + PCM_CAPTURE +}; + +static const struct { + const char *name; + snd_pcm_stream_t stream; +} PCMS[] = { + { .name = "playback", .stream = SND_PCM_STREAM_PLAYBACK }, // PCM_PLAYBACK // hw:?,0 + { .name = "capture", .stream = SND_PCM_STREAM_CAPTURE }, // PCM_CAPTURE // hw:?,1 +}; const char* snd_asoundlib_version(void) @@ -47,7 +67,7 @@ int snd_card_next(int *card) { if (card) { - *card = (*card == -1 ? 0 : -1); + *card = (*card + 1 >= (int)ARRAY_SIZE(CARD_NAMES) ? CARD_NONE : *card + 1); return 0; } @@ -57,8 +77,13 @@ snd_card_next(int *card) int snd_card_get_index(const char *name) { - if (!strcmp(name, "default")) - return 0; + if (!strcmp(name, "default") || !strcmp(name, "hw:0")) + return CARD_DEFAULT; + + for (unsigned int i = 0; i < ARRAY_SIZE(CARD_NAMES); ++i) { + if (!strcmp(name, CARD_NAMES[i])) + return i; + } return -1; } @@ -66,22 +91,24 @@ snd_card_get_index(const char *name) int snd_card_get_name(int card, char **name) { - if (name) *name = c_strdup("default"); + if (card < 0 || (unsigned int)card >= ARRAY_SIZE(CARD_NAMES)) + return -1; + + if (name) *name = c_strdup(CARD_NAMES[card]); return 0; } int snd_card_get_longname(int card, char **name) { - if (name) *name = c_strdup("default"); - return 0; + return snd_card_get_name(card, name); } -struct device_name_hint { char *name, *ioid; }; +struct device_name_hint { int id; }; int snd_device_name_hint(int card, const char *iface, void ***hints) { - static struct device_name_hint defaults[] = { { .name = "default", .ioid = "Output" }, { .name = "capture", .ioid = "Input" } }; + static struct device_name_hint defaults[] = { {PCM_PLAYBACK}, {PCM_CAPTURE} }; static struct device_name_hint *array[] = { &defaults[0], &defaults[1], NULL }; *hints = (void**)array; return 0; @@ -92,10 +119,13 @@ snd_device_name_get_hint(const void *hint, const char *id) { const struct device_name_hint *shint = hint; + if (shint->id < 0 || (unsigned int)shint->id >= ARRAY_SIZE(PCMS)) + return NULL; + if (!strcmp(id, "NAME")) - return c_strdup(shint->name); + return c_strdup(PCMS[shint->id].name); else if (!strcmp(id, "IOID")) - return c_strdup(shint->ioid); + return c_strdup((PCMS[shint->id].stream == SND_PCM_STREAM_PLAYBACK ? "Output" : "Input")); return NULL; } @@ -106,8 +136,55 @@ snd_device_name_free_hint(void **hints) return 0; } +struct _snd_ctl { + int id; +}; + +int +snd_ctl_open(snd_ctl_t **ctl, const char *name, int mode) +{ + int id; + if ((id = snd_card_get_index(name)) < 0) + return -1; + + if (!(*ctl = calloc(1, sizeof(**ctl)))) { + WARNX1("calloc"); + return -1; + } + + (*ctl)->id = id; + return 0; +} + +int +snd_ctl_close(snd_ctl_t *ctl) +{ + free(ctl); + return 0; +} + +snd_ctl_t* +snd_hctl_ctl(snd_hctl_t *hctl) +{ + snd_ctl_t *ctl = NULL; + snd_ctl_open(&ctl, NULL, 0); + return ctl; +} + +int +snd_ctl_pcm_next_device(snd_ctl_t *ctl, int *device) +{ + if (device) { + *device = (*device + 1 >= (int)ARRAY_SIZE(PCMS) ? PCM_NONE : *device + 1); + return 0; + } + + return -1; +} + struct _snd_pcm_info { - const char *name; + int card, id, subdevice; + snd_pcm_stream_t stream; }; size_t @@ -133,54 +210,66 @@ snd_pcm_info_free(snd_pcm_info_t *obj) free(obj); } -const char* -snd_pcm_info_get_name(const snd_pcm_info_t *obj) +void +snd_pcm_info_set_device(snd_pcm_info_t *obj, unsigned int val) { - return obj->name; + obj->id = val; } -int -snd_ctl_pcm_info(snd_ctl_t *ctl, snd_pcm_info_t *info) +void +snd_pcm_info_set_stream(snd_pcm_info_t *obj, snd_pcm_stream_t val) { - info->name = "sndio"; - return 0; + obj->stream = val; +} + +void +snd_pcm_info_set_subdevice(snd_pcm_info_t *obj, unsigned int val) +{ + obj->subdevice = val; } int -snd_ctl_pcm_next_device(snd_ctl_t *ctl, int *device) +snd_ctl_pcm_info(snd_ctl_t *ctl, snd_pcm_info_t *info) { - if (device) { - *device = (*device == -1 ? 0 : -1); - return 0; - } + if (info->id < 0 || (unsigned int)info->id >= ARRAY_SIZE(PCMS) || info->subdevice != 0) + return -1; - return -1; + info->card = ctl->id; + return (PCMS[info->id].stream == info->stream ? 0 : -1); } -struct _snd_ctl { - char noop; -}; +const char* +snd_pcm_info_get_name(const snd_pcm_info_t *obj) +{ + assert(obj->id >= 0 && (unsigned int)obj->id < ARRAY_SIZE(PCMS)); + return PCMS[obj->id].name; +} -int -snd_ctl_open(snd_ctl_t **ctl, const char *name, int mode) +unsigned int +snd_pcm_info_get_device(const snd_pcm_info_t *obj) { - if (!(*ctl = calloc(1, sizeof(**ctl)))) { - WARNX1("calloc"); - return -1; - } + return obj->id; +} +unsigned int +snd_pcm_info_get_subdevice(const snd_pcm_info_t *obj) +{ return 0; } -int -snd_ctl_close(snd_ctl_t *ctl) +snd_pcm_stream_t +snd_pcm_info_get_stream(const snd_pcm_info_t *obj) { - free(ctl); - return 0; + return obj->stream; +} + +int snd_pcm_info_get_card(const snd_pcm_info_t *obj) +{ + return obj->card; } struct _snd_ctl_card_info { - const char *name; + int id; }; size_t @@ -207,20 +296,21 @@ snd_ctl_card_info_free(snd_ctl_card_info_t *obj) int snd_ctl_card_info(snd_ctl_t *ctl, snd_ctl_card_info_t *info) { - info->name = "sndio"; + *info = (snd_ctl_card_info_t){ ctl->id }; return 0; } const char* snd_ctl_card_info_get_name(const snd_ctl_card_info_t *obj) { - return obj->name; + assert(obj->id >= 0 && (unsigned int)obj->id < ARRAY_SIZE(CARD_NAMES)); + return CARD_NAMES[obj->id]; } const char* snd_ctl_card_info_get_mixername(const snd_ctl_card_info_t *obj) { - return obj->name; + return snd_ctl_card_info_get_name(obj); } int @@ -234,3 +324,88 @@ snd_seq_query_next_client(snd_seq_t *handle, snd_seq_client_info_t *info) { return -1; } + +// snd_config insanity is needed for portaudio (e.g. used by audacity) since it has buggy code + +struct _snd_config { + const char *path; + + union { + const char *id, *str; + } v; + + enum { + TYPE_NONE, + TYPE_ID, + TYPE_STR + } type; + + snd_config_t *next; +} s_snd_config; + +snd_config_t *snd_config = &s_snd_config; + +int +snd_config_search(snd_config_t *config, const char *key, snd_config_t **result) +{ + char path[255]; + const char *cp = (config->path ? config->path : "."); + snprintf(path, sizeof(path), "%s/%s", cp, key); + + if (!strcmp(path, "./pcm")) { + static snd_config_t res = { .path = "./pcm", .v.id = "default", .type = TYPE_ID }; + if (result) *result = &res; + return 0; + } else if (!strcmp(path, "./pcm/type")) { + static snd_config_t res = { .path = "./pcm/type", .v.str = "default", .type = TYPE_STR }; + if (result) *result = &res; + return 0; + } + + return -1; +} + +snd_config_iterator_t +snd_config_iterator_first(const snd_config_t *node) +{ + return (void*)node; +} + +snd_config_iterator_t +snd_config_iterator_next(const snd_config_iterator_t iterator) +{ + const snd_config_t *cfg = (void*)iterator; + return (cfg ? (void*)cfg->next : NULL); +} + +snd_config_iterator_t +snd_config_iterator_end(const snd_config_t *node) +{ + return NULL; +} + +snd_config_t* +snd_config_iterator_entry(const snd_config_iterator_t iterator) +{ + return (void*)iterator; +} + +int +snd_config_get_id(const snd_config_t *config, const char **value) +{ + if (config->type != TYPE_ID) + return -1; + + if (value) *value = config->v.id; + return 0; +} + +int +snd_config_get_string(const snd_config_t *config, const char **value) +{ + if (config->type != TYPE_STR) + return -1; + + if (value) *value = config->v.str; + return 0; +} diff --git a/src/pcm.c b/src/pcm.c index a238e8e..177ac12 100644 --- a/src/pcm.c +++ b/src/pcm.c @@ -6,7 +6,7 @@ #include "util/dsp.h" #include "util/util.h" -static struct format_info { +static const struct format_info { const char *name; snd_pcm_format_t fmt; struct sio_enc enc; @@ -82,6 +82,12 @@ snd_pcm_format_physical_width(snd_pcm_format_t format) return (info ? (int)info->enc.bps * 8 : -1); } +ssize_t +snd_pcm_format_size(snd_pcm_format_t format, size_t samples) +{ + return samples * snd_pcm_format_physical_width(format) / 8; +} + struct _snd_pcm_hw_params { struct sio_cap cap; struct sio_par par; @@ -100,6 +106,7 @@ struct _snd_pcm_sw_params { char noop; }; struct _snd_pcm { struct _snd_pcm_hw_params hw; struct _snd_pcm_sw_params sw; + struct timespec start_time; struct sio_hdl *hdl; const char *name; snd_pcm_uframes_t position, written, avail; @@ -481,6 +488,7 @@ snd_pcm_prepare(snd_pcm_t *pcm) pcm->started = true; pcm->written = pcm->position = 0; pcm->avail = pcm->hw.par.bufsz; + clock_gettime(CLOCK_MONOTONIC, &pcm->start_time); } return (pcm->started ? 0 : -1); @@ -619,6 +627,15 @@ snd_pcm_hw_params_any(snd_pcm_t *pcm, snd_pcm_hw_params_t *params) return 0; } +int +snd_pcm_hw_params_test_access(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_access_t _access) +{ + if (_access != SND_PCM_ACCESS_RW_INTERLEAVED) + return -1; + + return 0; +} + int snd_pcm_hw_params_set_access(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_access_t _access) { @@ -643,7 +660,6 @@ snd_pcm_hw_params_get_access(const snd_pcm_hw_params_t *params, snd_pcm_access_t int snd_pcm_hw_params_malloc(snd_pcm_hw_params_t **ptr) { - // OpenAL-soft uses this :( return ((*ptr = calloc(1, sizeof(**ptr))) ? 0 : -1); } @@ -743,6 +759,7 @@ snd_pcm_hw_params_set_channels_near(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, int snd_pcm_hw_params_set_channels(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int val) { + WARNX("%u", val); return snd_pcm_hw_params_set_channels_near(pcm, params, &val); } @@ -751,6 +768,7 @@ snd_pcm_hw_params_get_channels_min(const snd_pcm_hw_params_t *params, unsigned i { const bool pb = (params->stream == SND_PCM_STREAM_PLAYBACK); if (val) *val = (pb ? params->limits.pchan[0] : params->limits.rchan[0]); + WARNX("%u", (val ? *val : 0)); return 0; } @@ -759,6 +777,7 @@ snd_pcm_hw_params_get_channels_max(const snd_pcm_hw_params_t *params, unsigned i { const bool pb = (params->stream == SND_PCM_STREAM_PLAYBACK); if (val) *val = (pb ? params->limits.pchan[1] : params->limits.rchan[1]); + WARNX("%u", (val ? *val : 0)); return 0; } @@ -770,6 +789,14 @@ snd_pcm_hw_params_get_rate(const snd_pcm_hw_params_t *params, unsigned int *val, return 0; } +int +snd_pcm_hw_params_get_rate_numden(const snd_pcm_hw_params_t *params, unsigned int *rate_num, unsigned int *rate_den) +{ + if (rate_num) *rate_num = params->par.rate; + if (rate_den) *rate_den = 1; + return 0; +} + int snd_pcm_hw_params_set_rate_near(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int *val, int *dir) { @@ -892,6 +919,22 @@ snd_pcm_hw_params_set_periods_near(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, return 0; } +int +snd_pcm_hw_params_get_periods_min(const snd_pcm_hw_params_t *params, unsigned int *val, int *dir) +{ + if (dir) *dir = 0; + if (val) *val = 2; + return 0; +} + +int +snd_pcm_hw_params_get_periods_max(const snd_pcm_hw_params_t *params, unsigned int *val, int *dir) +{ + if (dir) *dir = 0; + if (val) *val = 32; + return 0; +} + size_t snd_pcm_sw_params_sizeof(void) { @@ -901,7 +944,6 @@ snd_pcm_sw_params_sizeof(void) int snd_pcm_sw_params_malloc(snd_pcm_sw_params_t **ptr) { - // OpenAL-soft uses this :( return ((*ptr = calloc(1, sizeof(**ptr))) ? 0 : -1); } @@ -960,3 +1002,62 @@ snd_pcm_get_chmap(snd_pcm_t *pcm) return map; } + +struct _snd_pcm_status { + struct timespec start, end; + snd_pcm_sframes_t delay; +}; + +size_t +snd_pcm_status_sizeof(void) +{ + return sizeof(snd_pcm_status_t); +} + +int +snd_pcm_status_malloc(snd_pcm_status_t **ptr) +{ + return ((*ptr = calloc(1, sizeof(**ptr))) ? 0 : -1); +} + +void +snd_pcm_status_free(snd_pcm_status_t *obj) +{ + free(obj); +} + +int +snd_pcm_status(snd_pcm_t *pcm, snd_pcm_status_t *status) +{ + *status = (snd_pcm_status_t){ .start = pcm->start_time }; + snd_pcm_delay(pcm, &status->delay); + return (clock_gettime(CLOCK_MONOTONIC, &status->end) == 0 ? 0 : -1); +} + +void +snd_pcm_status_get_htstamp(const snd_pcm_status_t *obj, snd_htimestamp_t *ptr) +{ + snd_htimestamp_t ats = {0}; + if ((obj->end.tv_nsec - obj->start.tv_nsec) < 0) { + ats.tv_sec = obj->end.tv_sec - obj->start.tv_sec - 1; + ats.tv_nsec = (uint64_t)1e9 + obj->end.tv_nsec - obj->start.tv_nsec; + } else { + ats.tv_sec = obj->end.tv_sec - obj->start.tv_sec; + ats.tv_nsec = obj->end.tv_nsec - obj->start.tv_nsec; + } + *ptr = ats; +} + +void +snd_pcm_status_get_tstamp(const snd_pcm_status_t *obj, snd_timestamp_t *ptr) +{ + snd_htimestamp_t ats; + snd_pcm_status_get_htstamp(obj, &ats); + *ptr = (snd_timestamp_t){ .tv_sec = ats.tv_sec, .tv_usec = ats.tv_nsec / (uint64_t)1e3 }; +} + +snd_pcm_sframes_t +snd_pcm_status_get_delay(const snd_pcm_status_t *obj) +{ + return obj->delay; +} diff --git a/src/stubs.h b/src/stubs.h index c1a7ead..4b49cbd 100644 --- a/src/stubs.h +++ b/src/stubs.h @@ -10,7 +10,6 @@ int snd_config_update_free_global(void) { WARNX1("stub"); return -1; } int snd_config_update_ref(snd_config_t **top) { WARNX1("stub"); return -1; } void snd_config_ref(snd_config_t *top) { WARNX1("stub"); } void snd_config_unref(snd_config_t *top) { WARNX1("stub"); } -int snd_config_search(snd_config_t *config, const char *key, snd_config_t **result) { WARNX1("stub"); return -1; } int snd_config_searchv(snd_config_t *config, snd_config_t **result, ...) { WARNX1("stub"); return -1; } int snd_config_search_definition(snd_config_t *config, const char *base, const char *key, snd_config_t **result) { WARNX1("stub"); return -1; } int snd_config_expand(snd_config_t *config, snd_config_t *root, const char *args, snd_config_t *private_data, snd_config_t **result) { WARNX1("stub"); return -1; } @@ -40,19 +39,13 @@ int snd_config_set_real(snd_config_t *config, double value) { WARNX1("stub"); re int snd_config_set_string(snd_config_t *config, const char *value) { WARNX1("stub"); return -1; } int snd_config_set_ascii(snd_config_t *config, const char *ascii) { WARNX1("stub"); return -1; } int snd_config_set_pointer(snd_config_t *config, const void *ptr) { WARNX1("stub"); return -1; } -int snd_config_get_id(const snd_config_t *config, const char **value) { WARNX1("stub"); return -1; } int snd_config_get_integer(const snd_config_t *config, long *value) { WARNX1("stub"); return -1; } int snd_config_get_integer64(const snd_config_t *config, long long *value) { WARNX1("stub"); return -1; } int snd_config_get_real(const snd_config_t *config, double *value) { WARNX1("stub"); return -1; } int snd_config_get_ireal(const snd_config_t *config, double *value) { WARNX1("stub"); return -1; } -int snd_config_get_string(const snd_config_t *config, const char **value) { WARNX1("stub"); return -1; } int snd_config_get_ascii(const snd_config_t *config, char **value) { WARNX1("stub"); return -1; } int snd_config_get_pointer(const snd_config_t *config, const void **value) { WARNX1("stub"); return -1; } int snd_config_test_id(const snd_config_t *config, const char *id) { WARNX1("stub"); return -1; } -snd_config_iterator_t snd_config_iterator_first(const snd_config_t *node) { WARNX1("stub"); return NULL; } -snd_config_iterator_t snd_config_iterator_next(const snd_config_iterator_t iterator) { WARNX1("stub"); return NULL; } -snd_config_iterator_t snd_config_iterator_end(const snd_config_t *node) { WARNX1("stub"); return NULL; } -snd_config_t *snd_config_iterator_entry(const snd_config_iterator_t iterator) { WARNX1("stub"); return NULL; } int snd_config_get_bool_ascii(const char *ascii) { WARNX1("stub"); return -1; } int snd_config_get_bool(const snd_config_t *conf) { WARNX1("stub"); return -1; } int snd_config_get_ctl_iface_ascii(const char *ascii) { WARNX1("stub"); return -1; } @@ -263,7 +256,6 @@ int snd_hctl_free(snd_hctl_t *hctl) { WARNX1("stub"); return 0; } int snd_hctl_handle_events(snd_hctl_t *hctl) { WARNX1("stub"); return 0; } const char *snd_hctl_name(snd_hctl_t *hctl) { WARNX1("stub"); return NULL; } int snd_hctl_wait(snd_hctl_t *hctl, int timeout) { WARNX1("stub"); return 0; } -snd_ctl_t *snd_hctl_ctl(snd_hctl_t *hctl) { WARNX1("stub"); return NULL; } snd_hctl_elem_t *snd_hctl_elem_next(snd_hctl_elem_t *elem) { WARNX1("stub"); return NULL; } snd_hctl_elem_t *snd_hctl_elem_prev(snd_hctl_elem_t *elem) { WARNX1("stub"); return NULL; } int snd_hctl_elem_info(snd_hctl_elem_t *elem, snd_ctl_elem_info_t * info) { WARNX1("stub"); return 0; } @@ -466,7 +458,6 @@ snd_pcm_t *snd_async_handler_get_pcm(snd_async_handler_t *handler) { WARNX1("stu int snd_pcm_info(snd_pcm_t *pcm, snd_pcm_info_t *info) { WARNX1("stub"); return 0; } int snd_pcm_hw_free(snd_pcm_t *pcm) { WARNX1("stub"); return 0; } int snd_pcm_sw_params(snd_pcm_t *pcm, snd_pcm_sw_params_t *params) { WARNX1("stub"); return 0; } -int snd_pcm_status(snd_pcm_t *pcm, snd_pcm_status_t *status) { WARNX1("stub"); return 0; } int snd_pcm_hwsync(snd_pcm_t *pcm) { WARNX1("stub"); return 0; } int snd_pcm_htimestamp(snd_pcm_t *pcm, snd_pcm_uframes_t *avail, snd_htimestamp_t *tstamp) { WARNX1("stub"); return 0; } int snd_pcm_avail_delay(snd_pcm_t *pcm, snd_pcm_sframes_t *availp, snd_pcm_sframes_t *delayp) { WARNX1("stub"); return 0; } @@ -490,10 +481,6 @@ unsigned int snd_pcm_chmap_from_string(const char *str) { WARNX1("stub"); return snd_pcm_chmap_t *snd_pcm_chmap_parse_string(const char *str) { WARNX1("stub"); return NULL; } int snd_pcm_recover(snd_pcm_t *pcm, int err, int silent) { WARNX1("stub"); return 0; } void snd_pcm_info_copy(snd_pcm_info_t *dst, const snd_pcm_info_t *src) { WARNX1("stub"); } -unsigned int snd_pcm_info_get_device(const snd_pcm_info_t *obj) { WARNX1("stub"); return 0; } -unsigned int snd_pcm_info_get_subdevice(const snd_pcm_info_t *obj) { WARNX1("stub"); return 0; } -snd_pcm_stream_t snd_pcm_info_get_stream(const snd_pcm_info_t *obj) { WARNX1("stub"); return 0; } -int snd_pcm_info_get_card(const snd_pcm_info_t *obj) { WARNX1("stub"); return 0; } const char *snd_pcm_info_get_id(const snd_pcm_info_t *obj) { WARNX1("stub"); return NULL; } const char *snd_pcm_info_get_subdevice_name(const snd_pcm_info_t *obj) { WARNX1("stub"); return NULL; } snd_pcm_class_t snd_pcm_info_get_class(const snd_pcm_info_t *obj) { WARNX1("stub"); return 0; } @@ -501,9 +488,6 @@ snd_pcm_subclass_t snd_pcm_info_get_subclass(const snd_pcm_info_t *obj) { WARNX1 unsigned int snd_pcm_info_get_subdevices_count(const snd_pcm_info_t *obj) { WARNX1("stub"); return 0; } unsigned int snd_pcm_info_get_subdevices_avail(const snd_pcm_info_t *obj) { WARNX1("stub"); return 0; } snd_pcm_sync_id_t snd_pcm_info_get_sync(const snd_pcm_info_t *obj) { WARNX1("stub"); return (snd_pcm_sync_id_t){0}; } -void snd_pcm_info_set_device(snd_pcm_info_t *obj, unsigned int val) { WARNX1("stub"); } -void snd_pcm_info_set_subdevice(snd_pcm_info_t *obj, unsigned int val) { WARNX1("stub"); } -void snd_pcm_info_set_stream(snd_pcm_info_t *obj, snd_pcm_stream_t val) { WARNX1("stub"); } int snd_pcm_hw_params_can_mmap_sample_resolution(const snd_pcm_hw_params_t *params) { WARNX1("stub"); return 0; } int snd_pcm_hw_params_is_double(const snd_pcm_hw_params_t *params) { WARNX1("stub"); return 0; } int snd_pcm_hw_params_is_batch(const snd_pcm_hw_params_t *params) { WARNX1("stub"); return 0; } @@ -518,11 +502,9 @@ int snd_pcm_hw_params_can_sync_start(const snd_pcm_hw_params_t *params) { WARNX1 int snd_pcm_hw_params_can_disable_period_wakeup(const snd_pcm_hw_params_t *params) { WARNX1("stub"); return 0; } int snd_pcm_hw_params_supports_audio_wallclock_ts(const snd_pcm_hw_params_t *params) /* deprecated, use audio_ts_type */ { WARNX1("stub"); return 0; } int snd_pcm_hw_params_supports_audio_ts_type(const snd_pcm_hw_params_t *params, int type) { WARNX1("stub"); return 0; } -int snd_pcm_hw_params_get_rate_numden(const snd_pcm_hw_params_t *params, unsigned int *rate_num, unsigned int *rate_den) { WARNX1("stub"); return 0; } int snd_pcm_hw_params_get_sbits(const snd_pcm_hw_params_t *params) { WARNX1("stub"); return 0; } int snd_pcm_hw_params_get_fifo_size(const snd_pcm_hw_params_t *params) { WARNX1("stub"); return 0; } int snd_pcm_hw_params_try_explain_failure(snd_pcm_t *pcm, snd_pcm_hw_params_t *fail, snd_pcm_hw_params_t *success, unsigned int depth, snd_output_t *out) { WARNX1("stub"); return 0; } -int snd_pcm_hw_params_test_access(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_access_t _access) { WARNX1("stub"); return 0; } int snd_pcm_hw_params_set_access_first(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_access_t *_access) { WARNX1("stub"); return 0; } int snd_pcm_hw_params_set_access_last(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_access_t *_access) { WARNX1("stub"); return 0; } int snd_pcm_hw_params_set_access_mask(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_access_mask_t *mask) { WARNX1("stub"); return 0; } @@ -575,8 +557,6 @@ int snd_pcm_hw_params_set_period_size_minmax(snd_pcm_t *pcm, snd_pcm_hw_params_t 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) { WARNX1("stub"); return 0; } 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) { WARNX1("stub"); return 0; } int snd_pcm_hw_params_set_period_size_integer(snd_pcm_t *pcm, snd_pcm_hw_params_t *params) { WARNX1("stub"); return 0; } -int snd_pcm_hw_params_get_periods_min(const snd_pcm_hw_params_t *params, unsigned int *val, int *dir) { WARNX1("stub"); return 0; } -int snd_pcm_hw_params_get_periods_max(const snd_pcm_hw_params_t *params, unsigned int *val, int *dir) { WARNX1("stub"); return 0; } int snd_pcm_hw_params_test_periods(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int val, int dir) { WARNX1("stub"); return 0; } int snd_pcm_hw_params_set_periods(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int val, int dir) { WARNX1("stub"); return 0; } int snd_pcm_hw_params_set_periods_min(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int *val, int *dir) { WARNX1("stub"); return 0; } @@ -650,20 +630,14 @@ int snd_pcm_subformat_mask_test(const snd_pcm_subformat_mask_t *mask, snd_pcm_su int snd_pcm_subformat_mask_empty(const snd_pcm_subformat_mask_t *mask) { WARNX1("stub"); return 0; } void snd_pcm_subformat_mask_set(snd_pcm_subformat_mask_t *mask, snd_pcm_subformat_t val) { WARNX1("stub"); } void snd_pcm_subformat_mask_reset(snd_pcm_subformat_mask_t *mask, snd_pcm_subformat_t val) { WARNX1("stub"); } -size_t snd_pcm_status_sizeof(void) { WARNX1("stub"); return 0; } -int snd_pcm_status_malloc(snd_pcm_status_t **ptr) { WARNX1("stub"); return -1; } -void snd_pcm_status_free(snd_pcm_status_t *obj) { WARNX1("stub"); } void snd_pcm_status_copy(snd_pcm_status_t *dst, const snd_pcm_status_t *src) { WARNX1("stub"); } snd_pcm_state_t snd_pcm_status_get_state(const snd_pcm_status_t *obj) { WARNX1("stub"); return 0; } void snd_pcm_status_get_trigger_tstamp(const snd_pcm_status_t *obj, snd_timestamp_t *ptr) { WARNX1("stub"); } void snd_pcm_status_get_trigger_htstamp(const snd_pcm_status_t *obj, snd_htimestamp_t *ptr) { WARNX1("stub"); } -void snd_pcm_status_get_tstamp(const snd_pcm_status_t *obj, snd_timestamp_t *ptr) { WARNX1("stub"); } -void snd_pcm_status_get_htstamp(const snd_pcm_status_t *obj, snd_htimestamp_t *ptr) { WARNX1("stub"); } void snd_pcm_status_get_audio_htstamp(const snd_pcm_status_t *obj, snd_htimestamp_t *ptr) { WARNX1("stub"); } void snd_pcm_status_get_driver_htstamp(const snd_pcm_status_t *obj, snd_htimestamp_t *ptr) { WARNX1("stub"); } void snd_pcm_status_get_audio_htstamp_report(const snd_pcm_status_t *obj, snd_pcm_audio_tstamp_report_t *audio_tstamp_report) { WARNX1("stub"); } void snd_pcm_status_set_audio_htstamp_config(snd_pcm_status_t *obj, snd_pcm_audio_tstamp_config_t *audio_tstamp_config) { WARNX1("stub"); } -snd_pcm_sframes_t snd_pcm_status_get_delay(const snd_pcm_status_t *obj) { WARNX1("stub"); return 0; } snd_pcm_uframes_t snd_pcm_status_get_avail(const snd_pcm_status_t *obj) { WARNX1("stub"); return 0; } snd_pcm_uframes_t snd_pcm_status_get_avail_max(const snd_pcm_status_t *obj) { WARNX1("stub"); return 0; } snd_pcm_uframes_t snd_pcm_status_get_overrange(const snd_pcm_status_t *obj) { WARNX1("stub"); return 0; } @@ -696,7 +670,6 @@ int snd_pcm_format_little_endian(snd_pcm_format_t format) { WARNX1("stub"); retu int snd_pcm_format_big_endian(snd_pcm_format_t format) { WARNX1("stub"); return 0; } int snd_pcm_format_cpu_endian(snd_pcm_format_t format) { WARNX1("stub"); return 0; } snd_pcm_format_t snd_pcm_build_linear_format(int width, int pwidth, int unsignd, int big_endian) { WARNX1("stub"); return 0; } -ssize_t snd_pcm_format_size(snd_pcm_format_t format, size_t samples) { WARNX1("stub"); return 0; } uint8_t snd_pcm_format_silence(snd_pcm_format_t format) { WARNX1("stub"); return 0; } uint16_t snd_pcm_format_silence_16(snd_pcm_format_t format) { WARNX1("stub"); return 0; } uint32_t snd_pcm_format_silence_32(snd_pcm_format_t format) { WARNX1("stub"); return 0; } -- cgit v1.2.3