crap for making portaudio (audacity) work

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);
@@ -620,6 +628,15 @@ snd_pcm_hw_params_any(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
 }
 
 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)
 {
    if (_access != SND_PCM_ACCESS_RW_INTERLEAVED)
@@ -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;
 }
 
@@ -771,6 +790,14 @@ snd_pcm_hw_params_get_rate(const snd_pcm_hw_params_t *params, unsigned int *val,
 }
 
 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)
 {
    if (dir) *dir = 0;
@@ -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; }