Add ABI-compatible libasound.so support

Create an ABI-compatible libasound, as an opt-in of the original
alsa-lib.

43 files changed, 1649 insertions, 1203 deletions

diff --git a/configure.ac b/configure.ac
index 5bb0961..d600332 100644
--- a/configure.ac
+++ b/configure.ac
@@ -88,7 +88,7 @@ AC_ARG_ENABLE(async,
 
 AC_ARG_ENABLE(libasound,
   AS_HELP_STRING([--enable-libasound],
-		 [build a symlink to libasound.so]),
+		 [build a ABI-compatible libasound.so]),
   libasound="$enableval", libasound="no")
 
 AC_ARG_ENABLE(everything,
@@ -139,7 +139,7 @@ else
 fi
 AC_SUBST(SALSA_HAS_DUMMY_CONF)
 
-AM_CONDITIONAL(LINK_LIBASOUND, test "$libasound" = "yes")
+AM_CONDITIONAL(COMPAT_ABI, test "$libasound" = "yes")
 
 AC_ARG_ENABLE(deprecated,
   AS_HELP_STRING([--disable-deprecated],
@@ -194,5 +194,5 @@ echo "  - ALSA-config dummy interface: $sndconf"
 echo "  - ALSA-sequencer dummy interface: $sndseq"
 echo "  - TLV (dB) support: $tlv"
 echo "  - Async handler support: $async"
-echo "  - Make libasound.so symlink: $libasound"
+echo "  - Make ABI-compatible libasound.so: $libasound"
 echo "  - Mark deprecated attribute: $markdeprecated"
diff --git a/src/Makefile.am b/src/Makefile.am
index 6b4ec1a..0afe8ac 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -21,7 +21,13 @@ if BUILD_TIMER
 libsalsa_la_SOURCES += timer.c
 endif
 
-libsalsa_la_LDFLAGS = -version-info 0:1:0
+if COMPAT_ABI
+VSYMS = -Wl,--version-script=Versions
+else
+VSYMS =
+endif
+
+libsalsa_la_LDFLAGS = -version-info 0:1:0 $(VSYMS) -Wl,-Bsymbolic-functions
 
 alsaincludedir = $(includedir)/alsa
 
@@ -58,12 +64,34 @@ endif
 
 noinst_HEADERS = local.h 
 
-EXTRA_DIST = asoundlib-head.h asoundlib-tail.h recipe.h.in version.h.in
+EXTRA_DIST = asoundlib-head.h asoundlib-tail.h recipe.h.in version.h.in Versions
 
 DISTCLEANFILES = asoundlib.h recipe.h version.h
 
-if LINK_LIBASOUND
-install-exec-hook: libsalsa.la
-	rm -f $(DESTDIR)$(libdir)/libasound.so
-	$(LN_S) libsalsa.so $(DESTDIR)$(libdir)/libasound.so
+if COMPAT_ABI
+lib_LTLIBRARIES += libasound.la
+libasound_la_SOURCES = ctl_abi.c input_abi.c output_abi.c global_abi.c error_abi.c
+if BUILD_PCM
+libasound_la_SOURCES += pcm_abi.c
+endif
+if BUILD_MIXER
+libasound_la_SOURCES += hctl_abi.c mixer_abi.c
+endif
+if BUILD_RAWMIDI
+libasound_la_SOURCES += rawmidi_abi.c
+endif
+if BUILD_HWDEP
+libasound_la_SOURCES += hwdep_abi.c
+endif
+if BUILD_TIMER
+libasound_la_SOURCES += timer_abi.c
+endif
+if BUILD_CONF
+libasound_la_SOURCES += conf_abi.c
+endif
+
+libasound_la_SOURCES += $(libsalsa_la_SOURCES)
+
+libasound_la_LDFLAGS = -version-info 2:0:0 $(VSYMS) -Wl,-Bsymbolic-functions
+
 endif
diff --git a/src/Versions b/src/Versions
new file mode 100644
index 0000000..a0c919c
--- /dev/null
+++ b/src/Versions
@@ -0,0 +1,134 @@
+ALSA_0.9 {
+  global:
+    snd_*;
+
+    _snd_*_open;
+    _snd_*_dlsym_*;
+    _snd_*_poll_descriptor;
+    _snd_pcm_hook_*;
+
+    __snd_pcm_hw_params_*;
+    __snd_pcm_sw_params_*;
+    __snd_*_dlsym_*;
+
+    _snd_mixer_*;
+    _snd_pcm_*_names;
+    _snd_pcm_*_descriptions;
+  local:
+    *;
+};
+
+ALSA_0.9.0rc4 {
+  global:
+
+    snd_pcm_hw_params_get_access;
+    snd_pcm_hw_params_set_access_first;
+    snd_pcm_hw_params_set_access_last;
+
+    snd_pcm_hw_params_get_format;
+    snd_pcm_hw_params_set_format_first;
+    snd_pcm_hw_params_set_format_last;
+
+    snd_pcm_hw_params_get_subformat;
+    snd_pcm_hw_params_set_subformat_first;
+    snd_pcm_hw_params_set_subformat_last;
+
+    snd_pcm_hw_params_get_channels;
+    snd_pcm_hw_params_get_channels_min;
+    snd_pcm_hw_params_get_channels_max;
+    snd_pcm_hw_params_set_channels_near;
+    snd_pcm_hw_params_set_channels_first;
+    snd_pcm_hw_params_set_channels_last;
+
+    snd_pcm_hw_params_get_rate;
+    snd_pcm_hw_params_get_rate_min;
+    snd_pcm_hw_params_get_rate_max;
+    snd_pcm_hw_params_set_rate_near;
+    snd_pcm_hw_params_set_rate_first;
+    snd_pcm_hw_params_set_rate_last;
+
+    snd_pcm_hw_params_get_period_time;
+    snd_pcm_hw_params_get_period_time_min;
+    snd_pcm_hw_params_get_period_time_max;
+    snd_pcm_hw_params_set_period_time_near;
+    snd_pcm_hw_params_set_period_time_first;
+    snd_pcm_hw_params_set_period_time_last;
+
+    snd_pcm_hw_params_get_period_size;
+    snd_pcm_hw_params_get_period_size_min;
+    snd_pcm_hw_params_get_period_size_max;
+    snd_pcm_hw_params_set_period_size_near;
+    snd_pcm_hw_params_set_period_size_first;
+    snd_pcm_hw_params_set_period_size_last;
+
+    snd_pcm_hw_params_get_periods;
+    snd_pcm_hw_params_get_periods_min;
+    snd_pcm_hw_params_get_periods_max;
+    snd_pcm_hw_params_set_periods_near;
+    snd_pcm_hw_params_set_periods_first;
+    snd_pcm_hw_params_set_periods_last;
+
+    snd_pcm_hw_params_get_buffer_time;
+    snd_pcm_hw_params_get_buffer_time_min;
+    snd_pcm_hw_params_get_buffer_time_max;
+    snd_pcm_hw_params_set_buffer_time_near;
+    snd_pcm_hw_params_set_buffer_time_first;
+    snd_pcm_hw_params_set_buffer_time_last;
+
+    snd_pcm_hw_params_get_buffer_size;
+    snd_pcm_hw_params_get_buffer_size_min;
+    snd_pcm_hw_params_get_buffer_size_max;
+    snd_pcm_hw_params_set_buffer_size_near;
+    snd_pcm_hw_params_set_buffer_size_first;
+    snd_pcm_hw_params_set_buffer_size_last;
+
+    snd_pcm_hw_params_get_tick_time;
+    snd_pcm_hw_params_get_tick_time_min;
+    snd_pcm_hw_params_get_tick_time_max;
+    snd_pcm_hw_params_set_tick_time_near;
+    snd_pcm_hw_params_set_tick_time_first;
+    snd_pcm_hw_params_set_tick_time_last;
+
+} ALSA_0.9;
+
+ALSA_0.9.0rc8 {
+  global:
+
+    snd_pcm_forward;
+    snd_pcm_status_get_trigger_htstamp;
+    snd_pcm_status_get_htstamp;
+
+} ALSA_0.9.0rc4;
+
+ALSA_0.9.0 {
+  global:
+
+    snd_pcm_type_name;
+    snd_timer_query_info;
+    snd_timer_query_params;
+    snd_timer_query_status;
+    snd_timer_params_set_exclusive;
+    snd_timer_params_get_exclusive;
+    snd_timer_params_set_filter;
+    snd_timer_params_get_filter;
+} ALSA_0.9.0rc8;
+
+ALSA_0.9.3 {
+  global:
+
+    snd_ctl_elem_info_get_dimensions;
+    snd_ctl_elem_info_get_dimension;
+} ALSA_0.9.0;
+
+ALSA_0.9.5 {
+  global:
+
+    alsa_lisp;
+} ALSA_0.9.3;
+
+ALSA_0.9.7 {
+  global:
+
+    alsa_lisp_*;
+} ALSA_0.9.5;
+
diff --git a/src/conf.h b/src/conf.h
index 8d169a0..a0e0cd3 100644
--- a/src/conf.h
+++ b/src/conf.h
@@ -26,31 +26,31 @@ typedef struct _snd_config_update snd_config_update_t;
 
 extern snd_config_t *snd_config;
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_config_top(snd_config_t **config)
 {
 	return -ENXIO;
 }
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_config_load(snd_config_t *config, snd_input_t *in)
 {
 	return -ENXIO;
 }
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_config_load_override(snd_config_t *config, snd_input_t *in)
 {
 	return -ENXIO;
 }
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_config_save(snd_config_t *config, snd_output_t *out)
 {
 	return -ENXIO;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_config_update(void)
 {
 	/* an invalid address, but just mark to be non-NULL */
@@ -58,21 +58,21 @@ int snd_config_update(void)
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_config_update_r(snd_config_t **top, snd_config_update_t **update,
 			const char *path)
 {
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_config_update_free(snd_config_update_t *update)
 {
 	return 0;
 }
 
 #if SALSA_HAS_DUMMY_CONF
-static inline
+__SALSA_EXPORT_FUNC
 int snd_config_update_free_global(void)
 {
 	snd_config = NULL;
@@ -80,21 +80,21 @@ int snd_config_update_free_global(void)
 }
 #endif
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_config_search(snd_config_t *config, const char *key,
 		      snd_config_t **result)
 {
 	return -ENXIO;
 }
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_config_searchv(snd_config_t *config, 
 		       snd_config_t **result, ...)
 {
 	return -ENXIO;
 }
 	
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_config_search_definition(snd_config_t *config,
 				 const char *base, const char *key,
 				 snd_config_t **result)
@@ -102,7 +102,7 @@ int snd_config_search_definition(snd_config_t *config,
 	return -ENXIO;
 }
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_config_expand(snd_config_t *config, snd_config_t *root,
 		      const char *args, snd_config_t *private_data,
 		      snd_config_t **result)
@@ -110,238 +110,238 @@ int snd_config_expand(snd_config_t *config, snd_config_t *root,
 	return -ENXIO;
 }
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_config_evaluate(snd_config_t *config, snd_config_t *root,
 			snd_config_t *private_data, snd_config_t **result)
 {
 	return -ENXIO;
 }
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_config_add(snd_config_t *config, snd_config_t *leaf)
 {
 	return -ENXIO;
 }
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_config_delete(snd_config_t *config)
 {
 	return -ENXIO;
 }
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_config_delete_compound_members(const snd_config_t *config)
 {
 	return -ENXIO;
 }
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_config_copy(snd_config_t **dst, snd_config_t *src)
 {
 	return -ENXIO;
 }
 
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_config_make(snd_config_t **config, const char *key,
 		    snd_config_type_t type)
 {
 	return -ENXIO;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_config_make_integer(snd_config_t **config, const char *key)
 {
 	return -ENXIO;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_config_make_integer64(snd_config_t **config, const char *key)
 {
 	return -ENXIO;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_config_make_real(snd_config_t **config, const char *key)
 {
 	return -ENXIO;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_config_make_string(snd_config_t **config, const char *key)
 {
 	return -ENXIO;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_config_make_pointer(snd_config_t **config, const char *key)
 {
 	return -ENXIO;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_config_make_compound(snd_config_t **config, const char *key, int join)
 {
 	return -ENXIO;
 }
 
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_config_imake_integer(snd_config_t **config, const char *key,
 			     const long value)
 {
 	return -ENXIO;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_config_imake_integer64(snd_config_t **config, const char *key,
 			       const long long value)
 {
 	return -ENXIO;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_config_imake_real(snd_config_t **config, const char *key,
 			  const double value)
 {
 	return -ENXIO;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_config_imake_string(snd_config_t **config, const char *key,
 			    const char *ascii)
 {
 	return -ENXIO;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_config_imake_pointer(snd_config_t **config, const char *key,
 			     const void *ptr)
 {
 	return -ENXIO;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 snd_config_type_t snd_config_get_type(const snd_config_t *config)
 {
 	return SND_CONFIG_TYPE_INTEGER;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_config_set_id(snd_config_t *config, const char *id)
 {
 	return -ENXIO;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_config_set_integer(snd_config_t *config, long value)
 {
 	return -ENXIO;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_config_set_integer64(snd_config_t *config, long long value)
 {
 	return -ENXIO;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_config_set_real(snd_config_t *config, double value)
 {
 	return -ENXIO;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_config_set_string(snd_config_t *config, const char *value)
 {
 	return -ENXIO;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_config_set_ascii(snd_config_t *config, const char *ascii)
 {
 	return -ENXIO;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_config_set_pointer(snd_config_t *config, const void *ptr)
 {
 	return -ENXIO;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_config_get_id(const snd_config_t *config, const char **value)
 {
 	return -ENXIO;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_config_get_integer(const snd_config_t *config, long *value)
 {
 	return -ENXIO;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_config_get_integer64(const snd_config_t *config, long long *value)
 {
 	return -ENXIO;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_config_get_real(const snd_config_t *config, double *value)
 {
 	return -ENXIO;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_config_get_ireal(const snd_config_t *config, double *value)
 {
 	return -ENXIO;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_config_get_string(const snd_config_t *config, const char **value)
 {
 	return -ENXIO;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_config_get_ascii(const snd_config_t *config, char **value)
 {
 	return -ENXIO;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_config_get_pointer(const snd_config_t *config, const void **value)
 {
 	return -ENXIO;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_config_test_id(const snd_config_t *config, const char *id)
 {
 	return -ENXIO;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 snd_config_iterator_t snd_config_iterator_first(const snd_config_t *node)
 {
 	return NULL;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 snd_config_iterator_t snd_config_iterator_next(const snd_config_iterator_t iterator)
 {
 	return NULL;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 snd_config_iterator_t snd_config_iterator_end(const snd_config_t *node)
 {
 	return NULL;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 snd_config_t *snd_config_iterator_entry(const snd_config_iterator_t iterator)
 {
 	return NULL;
@@ -361,25 +361,25 @@ snd_config_t *snd_config_iterator_entry(const snd_config_iterator_t iterator)
 
 /* Misc functions */
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_config_get_bool_ascii(const char *ascii)
 {
 	return -ENXIO;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_config_get_bool(const snd_config_t *conf)
 {
 	return -ENXIO;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_config_get_ctl_iface_ascii(const char *ascii)
 {
 	return -ENXIO;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_config_get_ctl_iface(const snd_config_t *conf)
 {
 	return -ENXIO;
@@ -396,13 +396,13 @@ struct snd_devname {
 	snd_devname_t *next;	/**< Next pointer */
 };
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_names_list(const char *iface, snd_devname_t **list)
 {
 	return -ENXIO;
 }
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 void snd_names_list_free(snd_devname_t *list)
 {
 }
diff --git a/src/conf_abi.c b/src/conf_abi.c
new file mode 100644
index 0000000..b51b41d
--- /dev/null
+++ b/src/conf_abi.c
@@ -0,0 +1,9 @@
+#include <stdio.h>
+#include <unistd.h>
+#include "recipe.h"
+#include "global.h"
+#include "input.h"
+#include "output.h"
+#undef __SALSA_EXPORT_FUNC
+#define __SALSA_EXPORT_FUNC
+#include "conf.h"
diff --git a/src/control.h b/src/control.h
index e74f418..e004544 100644
--- a/src/control.h
+++ b/src/control.h
@@ -22,34 +22,7 @@
 #ifndef __ALSA_CONTROL_H
 #define __ALSA_CONTROL_H
 
-#include "recipe.h"
-#include "global.h"
-#include "ctl_types.h"
-
-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_ctl_open(snd_ctl_t **ctl, const char *name, int mode);
-int snd_ctl_close(snd_ctl_t *ctl);
-int snd_ctl_wait(snd_ctl_t *ctl, int timeout);
-
-#if SALSA_HAS_TLV_SUPPORT
-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);
-#endif
-
-#if SALSA_HAS_ASYNC_SUPPORT
-int snd_async_add_ctl_handler(snd_async_handler_t **handler, snd_ctl_t *ctl, 
-			      snd_async_callback_t callback,
-			      void *private_data);
-#endif
+#include "ctl_func.h"
 
 #include "ctl_macros.h"
 
@@ -60,37 +33,4 @@ int snd_async_add_ctl_handler(snd_async_handler_t **handler, snd_ctl_t *ctl,
 #define snd_ctl_elem_info_alloca(ptr)	__snd_alloca(ptr, snd_ctl_elem_info)
 #define snd_ctl_elem_value_alloca(ptr)	__snd_alloca(ptr, snd_ctl_elem_value)
 
-int snd_ctl_elem_add_integer(snd_ctl_t *ctl, const snd_ctl_elem_id_t *id,
-			     unsigned int count, long min, long max, long step);
-int snd_ctl_elem_add_integer64(snd_ctl_t *ctl, const snd_ctl_elem_id_t *id,
-			       unsigned int count, long long min, long long max,
-			       long long step);
-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_iec958(snd_ctl_t *ctl, const snd_ctl_elem_id_t *id);
-
-#if SALSA_HAS_TLV_SUPPORT
-static inline
-int snd_tlv_parse_dB_info(unsigned int *tlv, unsigned int tlv_size,
-			  unsigned int **db_tlvp)
-{
-	/* just for simplicity */
-	*db_tlvp = tlv;
-	return 0;
-}
-
-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);
-#endif
-
 #endif /* __ALSA_CONTROL_H */
diff --git a/src/ctl_abi.c b/src/ctl_abi.c
new file mode 100644
index 0000000..1dd0272
--- /dev/null
+++ b/src/ctl_abi.c
@@ -0,0 +1,4 @@
+#include "ctl_func.h"
+#undef __SALSA_EXPORT_FUNC
+#define __SALSA_EXPORT_FUNC
+#include "ctl_macros.h"
diff --git a/src/ctl_func.h b/src/ctl_func.h
new file mode 100644
index 0000000..f237d1f
--- /dev/null
+++ b/src/ctl_func.h
@@ -0,0 +1,56 @@
+/*
+ */
+
+#include "recipe.h"
+#include "global.h"
+#include "ctl_types.h"
+
+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_ctl_open(snd_ctl_t **ctl, const char *name, int mode);
+int snd_ctl_close(snd_ctl_t *ctl);
+int snd_ctl_wait(snd_ctl_t *ctl, int timeout);
+
+#if SALSA_HAS_TLV_SUPPORT
+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);
+#endif
+
+#if SALSA_HAS_ASYNC_SUPPORT
+int snd_async_add_ctl_handler(snd_async_handler_t **handler, snd_ctl_t *ctl, 
+			      snd_async_callback_t callback,
+			      void *private_data);
+#endif
+
+int snd_ctl_elem_add_integer(snd_ctl_t *ctl, const snd_ctl_elem_id_t *id,
+			     unsigned int count, long min, long max, long step);
+int snd_ctl_elem_add_integer64(snd_ctl_t *ctl, const snd_ctl_elem_id_t *id,
+			       unsigned int count, long long min, long long max,
+			       long long step);
+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_iec958(snd_ctl_t *ctl, const snd_ctl_elem_id_t *id);
+
+#if SALSA_HAS_TLV_SUPPORT
+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);
+#endif
+
diff --git a/src/ctl_macros.h b/src/ctl_macros.h
index 748c65b..b4bad35 100644
--- a/src/ctl_macros.h
+++ b/src/ctl_macros.h
@@ -26,31 +26,31 @@ struct _snd_ctl {
 };
 
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_ctl_nonblock(snd_ctl_t *ctl, int nonblock)
 {
 	return _snd_set_nonblock(ctl->fd, nonblock);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 const char *snd_ctl_name(snd_ctl_t *ctl)
 {
 	return ctl->name;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 snd_ctl_type_t snd_ctl_type(snd_ctl_t *ctl)
 {
 	return ctl->type;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_ctl_poll_descriptors_count(snd_ctl_t *ctl)
 {
 	return 1;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_ctl_poll_descriptors(snd_ctl_t *ctl, struct pollfd *pfds,
 			     unsigned int space)
 {
@@ -58,7 +58,7 @@ int snd_ctl_poll_descriptors(snd_ctl_t *ctl, struct pollfd *pfds,
 	return 1;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_ctl_poll_descriptors_revents(snd_ctl_t *ctl, struct pollfd *pfds,
 				     unsigned int nfds, unsigned short *revents)
 {
@@ -66,7 +66,7 @@ int snd_ctl_poll_descriptors_revents(snd_ctl_t *ctl, struct pollfd *pfds,
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_ctl_subscribe_events(snd_ctl_t *ctl, int subscribe)
 {
 	if (ioctl(ctl->fd, SNDRV_CTL_IOCTL_SUBSCRIBE_EVENTS, &subscribe) < 0)
@@ -74,7 +74,7 @@ int snd_ctl_subscribe_events(snd_ctl_t *ctl, int subscribe)
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_ctl_card_info(snd_ctl_t *ctl, snd_ctl_card_info_t *info)
 {
 	if (ioctl(ctl->fd, SNDRV_CTL_IOCTL_CARD_INFO, info) < 0)
@@ -82,7 +82,7 @@ int snd_ctl_card_info(snd_ctl_t *ctl, snd_ctl_card_info_t *info)
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_ctl_elem_list(snd_ctl_t *ctl, snd_ctl_elem_list_t *list)
 {
 	if (ioctl(ctl->fd, SNDRV_CTL_IOCTL_ELEM_LIST, list) < 0)
@@ -90,7 +90,7 @@ int snd_ctl_elem_list(snd_ctl_t *ctl, snd_ctl_elem_list_t *list)
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_ctl_elem_info(snd_ctl_t *ctl, snd_ctl_elem_info_t *info)
 {
 	if (ioctl(ctl->fd, SNDRV_CTL_IOCTL_ELEM_INFO, info) < 0)
@@ -98,7 +98,7 @@ int snd_ctl_elem_info(snd_ctl_t *ctl, snd_ctl_elem_info_t *info)
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_ctl_elem_add(snd_ctl_t *ctl, snd_ctl_elem_info_t *info)
 {
 	if (ioctl(ctl->fd, SNDRV_CTL_IOCTL_ELEM_ADD, info) < 0)
@@ -106,7 +106,7 @@ int snd_ctl_elem_add(snd_ctl_t *ctl, snd_ctl_elem_info_t *info)
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_ctl_elem_remove(snd_ctl_t *ctl, snd_ctl_elem_id_t *id)
 {
 	if (ioctl(ctl->fd, SNDRV_CTL_IOCTL_ELEM_REMOVE, id) < 0)
@@ -114,7 +114,7 @@ int snd_ctl_elem_remove(snd_ctl_t *ctl, snd_ctl_elem_id_t *id)
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_ctl_elem_read(snd_ctl_t *ctl, snd_ctl_elem_value_t *control)
 {
 	if (ioctl(ctl->fd, SNDRV_CTL_IOCTL_ELEM_READ, control) < 0)
@@ -122,7 +122,7 @@ int snd_ctl_elem_read(snd_ctl_t *ctl, snd_ctl_elem_value_t *control)
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_ctl_elem_write(snd_ctl_t *ctl, snd_ctl_elem_value_t *control)
 {
 	if (ioctl(ctl->fd, SNDRV_CTL_IOCTL_ELEM_WRITE, control) < 0)
@@ -130,7 +130,7 @@ int snd_ctl_elem_write(snd_ctl_t *ctl, snd_ctl_elem_value_t *control)
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_ctl_elem_lock(snd_ctl_t *ctl, snd_ctl_elem_id_t *id)
 {
 	if (ioctl(ctl->fd, SNDRV_CTL_IOCTL_ELEM_LOCK, id) < 0)
@@ -138,7 +138,7 @@ int snd_ctl_elem_lock(snd_ctl_t *ctl, snd_ctl_elem_id_t *id)
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_ctl_elem_unlock(snd_ctl_t *ctl, snd_ctl_elem_id_t *id)
 {
 	if (ioctl(ctl->fd, SNDRV_CTL_IOCTL_ELEM_UNLOCK, id) < 0)
@@ -146,7 +146,7 @@ int snd_ctl_elem_unlock(snd_ctl_t *ctl, snd_ctl_elem_id_t *id)
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_ctl_hwdep_next_device(snd_ctl_t *ctl, int *device)
 {
 	if (ioctl(ctl->fd, SNDRV_CTL_IOCTL_HWDEP_NEXT_DEVICE, device) < 0)
@@ -154,7 +154,7 @@ int snd_ctl_hwdep_next_device(snd_ctl_t *ctl, int *device)
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_ctl_hwdep_info(snd_ctl_t *ctl, snd_hwdep_info_t * info)
 {
 	if (ioctl(ctl->fd, SNDRV_CTL_IOCTL_HWDEP_INFO, info) < 0)
@@ -162,7 +162,7 @@ int snd_ctl_hwdep_info(snd_ctl_t *ctl, snd_hwdep_info_t * info)
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_ctl_pcm_next_device(snd_ctl_t *ctl, int * device)
 {
 	if (ioctl(ctl->fd, SNDRV_CTL_IOCTL_PCM_NEXT_DEVICE, device) < 0)
@@ -170,7 +170,7 @@ int snd_ctl_pcm_next_device(snd_ctl_t *ctl, int * device)
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_ctl_pcm_info(snd_ctl_t *ctl, snd_pcm_info_t * info)
 {
 	if (ioctl(ctl->fd, SNDRV_CTL_IOCTL_PCM_INFO, info) < 0)
@@ -178,7 +178,7 @@ int snd_ctl_pcm_info(snd_ctl_t *ctl, snd_pcm_info_t * info)
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_ctl_pcm_prefer_subdevice(snd_ctl_t *ctl, int subdev)
 {
 	if (ioctl(ctl->fd, SNDRV_CTL_IOCTL_PCM_PREFER_SUBDEVICE, &subdev) < 0)
@@ -186,7 +186,7 @@ int snd_ctl_pcm_prefer_subdevice(snd_ctl_t *ctl, int subdev)
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_ctl_rawmidi_next_device(snd_ctl_t *ctl, int * device)
 {
 	if (ioctl(ctl->fd, SNDRV_CTL_IOCTL_RAWMIDI_NEXT_DEVICE, device) < 0)
@@ -194,7 +194,7 @@ int snd_ctl_rawmidi_next_device(snd_ctl_t *ctl, int * device)
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_ctl_rawmidi_info(snd_ctl_t *ctl, snd_rawmidi_info_t * info)
 {
 	if (ioctl(ctl->fd, SNDRV_CTL_IOCTL_RAWMIDI_INFO, info) < 0)
@@ -202,7 +202,7 @@ int snd_ctl_rawmidi_info(snd_ctl_t *ctl, snd_rawmidi_info_t * info)
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_ctl_rawmidi_prefer_subdevice(snd_ctl_t *ctl, int subdev)
 {
 	if (ioctl(ctl->fd, SNDRV_CTL_IOCTL_RAWMIDI_PREFER_SUBDEVICE, &subdev) < 0)
@@ -210,7 +210,7 @@ int snd_ctl_rawmidi_prefer_subdevice(snd_ctl_t *ctl, int subdev)
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_ctl_read(snd_ctl_t *ctl, snd_ctl_event_t *event)
 {
 	ssize_t res = read(ctl->fd, event, sizeof(*event));
@@ -228,7 +228,7 @@ extern const char *_snd_ctl_event_type_names[];
 #define snd_ctl_elem_iface_name(iface)	_snd_ctl_elem_iface_names[iface]
 #define snd_ctl_event_type_name(type)	_snd_ctl_event_type_names[type]
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_ctl_elem_list_alloc_space(snd_ctl_elem_list_t *obj,
 				  unsigned int entries)
 {
@@ -243,7 +243,7 @@ int snd_ctl_elem_list_alloc_space(snd_ctl_elem_list_t *obj,
 	return 0;
 }  
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_ctl_elem_list_free_space(snd_ctl_elem_list_t *obj)
 {
 	free(obj->pids);
@@ -251,50 +251,50 @@ void snd_ctl_elem_list_free_space(snd_ctl_elem_list_t *obj)
 	obj->space = 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_ctl_event_elem_get_mask(const snd_ctl_event_t *obj)
 {
 	return obj->data.elem.mask;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_ctl_event_elem_get_id(const snd_ctl_event_t *obj,
 			       snd_ctl_elem_id_t *ptr)
 {
 	*ptr = obj->data.elem.id;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_ctl_event_elem_get_numid(const snd_ctl_event_t *obj)
 {
 	return obj->data.elem.id.numid;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 snd_ctl_elem_iface_t snd_ctl_event_elem_get_interface(const snd_ctl_event_t *obj)
 {
 	return (snd_ctl_elem_iface_t)obj->data.elem.id.iface;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_ctl_event_elem_get_device(const snd_ctl_event_t *obj)
 {
 	return obj->data.elem.id.device;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_ctl_event_elem_get_subdevice(const snd_ctl_event_t *obj)
 {
 	return obj->data.elem.id.subdevice;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 const char *snd_ctl_event_elem_get_name(const snd_ctl_event_t *obj)
 {
 	return (const char *)obj->data.elem.id.name;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_ctl_event_elem_get_index(const snd_ctl_event_t *obj)
 {
 	return obj->data.elem.id.index;
@@ -302,74 +302,74 @@ unsigned int snd_ctl_event_elem_get_index(const snd_ctl_event_t *obj)
 
 __snd_define_type(snd_ctl_elem_id);
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_ctl_elem_id_get_numid(const snd_ctl_elem_id_t *obj)
 {
 	return obj->numid;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 snd_ctl_elem_iface_t snd_ctl_elem_id_get_interface(const snd_ctl_elem_id_t *obj)
 {
 	return (snd_ctl_elem_iface_t)obj->iface;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_ctl_elem_id_get_device(const snd_ctl_elem_id_t *obj)
 {
 	return obj->device;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_ctl_elem_id_get_subdevice(const snd_ctl_elem_id_t *obj)
 {
 	return obj->subdevice;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 const char *snd_ctl_elem_id_get_name(const snd_ctl_elem_id_t *obj)
 {
 	return (const char *)obj->name;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_ctl_elem_id_get_index(const snd_ctl_elem_id_t *obj)
 {
 	return obj->index;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_ctl_elem_id_set_numid(snd_ctl_elem_id_t *obj, unsigned int val)
 {
 	obj->numid = val;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_ctl_elem_id_set_interface(snd_ctl_elem_id_t *obj,
 				   snd_ctl_elem_iface_t val)
 {
 	obj->iface = val;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_ctl_elem_id_set_device(snd_ctl_elem_id_t *obj, unsigned int val)
 {
 	obj->device = val;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_ctl_elem_id_set_subdevice(snd_ctl_elem_id_t *obj, unsigned int val)
 {
 	obj->subdevice = val;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_ctl_elem_id_set_name(snd_ctl_elem_id_t *obj, const char *val)
 {
 	strncpy((char *)obj->name, val, sizeof(obj->name));
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_ctl_elem_id_set_index(snd_ctl_elem_id_t *obj, unsigned int val)
 {
 	obj->index = val;
@@ -377,43 +377,43 @@ void snd_ctl_elem_id_set_index(snd_ctl_elem_id_t *obj, unsigned int val)
 
 __snd_define_type(snd_ctl_card_info);
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_ctl_card_info_get_card(const snd_ctl_card_info_t *obj)
 {
 	return obj->card;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 const char *snd_ctl_card_info_get_id(const snd_ctl_card_info_t *obj)
 {
 	return (const char *)obj->id;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 const char *snd_ctl_card_info_get_driver(const snd_ctl_card_info_t *obj)
 {
 	return (const char *)obj->driver;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 const char *snd_ctl_card_info_get_name(const snd_ctl_card_info_t *obj)
 {
 	return (const char *)obj->name;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 const char *snd_ctl_card_info_get_longname(const snd_ctl_card_info_t *obj)
 {
 	return (const char *)obj->longname;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 const char *snd_ctl_card_info_get_mixername(const snd_ctl_card_info_t *obj)
 {
 	return (const char *)obj->mixername;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 const char *snd_ctl_card_info_get_components(const snd_ctl_card_info_t *obj)
 {
 	return (const char *)obj->components;
@@ -421,7 +421,7 @@ const char *snd_ctl_card_info_get_components(const snd_ctl_card_info_t *obj)
 
 __snd_define_type(snd_ctl_event);
 
-static inline
+__SALSA_EXPORT_FUNC
 snd_ctl_event_type_t snd_ctl_event_get_type(const snd_ctl_event_t *obj)
 {
 	return (snd_ctl_event_type_t) obj->type;
@@ -429,67 +429,67 @@ snd_ctl_event_type_t snd_ctl_event_get_type(const snd_ctl_event_t *obj)
 
 __snd_define_type(snd_ctl_elem_list);
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_ctl_elem_list_set_offset(snd_ctl_elem_list_t *obj, unsigned int val)
 {
 	obj->offset = val;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_ctl_elem_list_get_used(const snd_ctl_elem_list_t *obj)
 {
 	return obj->used;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_ctl_elem_list_get_count(const snd_ctl_elem_list_t *obj)
 {
 	return obj->count;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_ctl_elem_list_get_id(const snd_ctl_elem_list_t *obj,
 			      unsigned int idx, snd_ctl_elem_id_t *ptr)
 {
 	*ptr = obj->pids[idx];
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_ctl_elem_list_get_numid(const snd_ctl_elem_list_t *obj,
 					 unsigned int idx)
 {
 	return obj->pids[idx].numid;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 snd_ctl_elem_iface_t snd_ctl_elem_list_get_interface(const snd_ctl_elem_list_t *obj,
 						     unsigned int idx)
 {
 	return (snd_ctl_elem_iface_t) obj->pids[idx].iface;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_ctl_elem_list_get_device(const snd_ctl_elem_list_t *obj,
 					  unsigned int idx)
 {
 	return obj->pids[idx].device;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_ctl_elem_list_get_subdevice(const snd_ctl_elem_list_t *obj,
 					     unsigned int idx)
 {
 	return obj->pids[idx].subdevice;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 const char *snd_ctl_elem_list_get_name(const snd_ctl_elem_list_t *obj,
 				       unsigned int idx)
 {
 	return (const char *)obj->pids[idx].name;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_ctl_elem_list_get_index(const snd_ctl_elem_list_t *obj,
 					 unsigned int idx)
 {
@@ -498,55 +498,55 @@ unsigned int snd_ctl_elem_list_get_index(const snd_ctl_elem_list_t *obj,
 
 __snd_define_type(snd_ctl_elem_info);
 
-static inline
+__SALSA_EXPORT_FUNC
 snd_ctl_elem_type_t snd_ctl_elem_info_get_type(const snd_ctl_elem_info_t *obj)
 {
 	return (snd_ctl_elem_type_t) obj->type;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_ctl_elem_info_is_readable(const snd_ctl_elem_info_t *obj)
 {
 	return !!(obj->access & SNDRV_CTL_ELEM_ACCESS_READ);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_ctl_elem_info_is_writable(const snd_ctl_elem_info_t *obj)
 {
 	return !!(obj->access & SNDRV_CTL_ELEM_ACCESS_WRITE);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_ctl_elem_info_is_volatile(const snd_ctl_elem_info_t *obj)
 {
 	return !!(obj->access & SNDRV_CTL_ELEM_ACCESS_VOLATILE);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_ctl_elem_info_is_inactive(const snd_ctl_elem_info_t *obj)
 {
 	return !!(obj->access & SNDRV_CTL_ELEM_ACCESS_INACTIVE);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_ctl_elem_info_is_locked(const snd_ctl_elem_info_t *obj)
 {
 	return !!(obj->access & SNDRV_CTL_ELEM_ACCESS_LOCK);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_ctl_elem_info_is_owner(const snd_ctl_elem_info_t *obj)
 {
 	return !!(obj->access & SNDRV_CTL_ELEM_ACCESS_OWNER);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_ctl_elem_info_is_user(const snd_ctl_elem_info_t *obj)
 {
 	return !!(obj->access & SNDRV_CTL_ELEM_ACCESS_USER);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_ctl_elem_info_is_tlv_readable(const snd_ctl_elem_info_t *obj)
 {
 #if SALSA_HAS_TLV_SUPPORT
@@ -556,7 +556,7 @@ int snd_ctl_elem_info_is_tlv_readable(const snd_ctl_elem_info_t *obj)
 #endif
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_ctl_elem_info_is_tlv_writable(const snd_ctl_elem_info_t *obj)
 {
 #if SALSA_HAS_TLV_SUPPORT
@@ -566,7 +566,7 @@ int snd_ctl_elem_info_is_tlv_writable(const snd_ctl_elem_info_t *obj)
 #endif
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_ctl_elem_info_is_tlv_commandable(const snd_ctl_elem_info_t *obj)
 {
 #if SALSA_HAS_TLV_SUPPORT
@@ -576,73 +576,73 @@ int snd_ctl_elem_info_is_tlv_commandable(const snd_ctl_elem_info_t *obj)
 #endif
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 pid_t snd_ctl_elem_info_get_owner(const snd_ctl_elem_info_t *obj)
 {
 	return obj->owner;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_ctl_elem_info_get_count(const snd_ctl_elem_info_t *obj)
 {
 	return obj->count;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 long snd_ctl_elem_info_get_min(const snd_ctl_elem_info_t *obj)
 {
 	return obj->value.integer.min;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 long snd_ctl_elem_info_get_max(const snd_ctl_elem_info_t *obj)
 {
 	return obj->value.integer.max;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 long snd_ctl_elem_info_get_step(const snd_ctl_elem_info_t *obj)
 {
 	return obj->value.integer.step;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 long long snd_ctl_elem_info_get_min64(const snd_ctl_elem_info_t *obj)
 {
 	return obj->value.integer64.min;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 long long snd_ctl_elem_info_get_max64(const snd_ctl_elem_info_t *obj)
 {
 	return obj->value.integer64.max;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 long long snd_ctl_elem_info_get_step64(const snd_ctl_elem_info_t *obj)
 {
 	return obj->value.integer64.step;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_ctl_elem_info_get_items(const snd_ctl_elem_info_t *obj)
 {
 	return obj->value.enumerated.items;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_ctl_elem_info_set_item(snd_ctl_elem_info_t *obj, unsigned int val)
 {
 	obj->value.enumerated.item = val;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 const char *snd_ctl_elem_info_get_item_name(const snd_ctl_elem_info_t *obj)
 {
 	return obj->value.enumerated.name;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_ctl_elem_info_get_dimensions(const snd_ctl_elem_info_t *obj)
 {
 	int i;
@@ -652,7 +652,7 @@ int snd_ctl_elem_info_get_dimensions(const snd_ctl_elem_info_t *obj)
 	return i + 1;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_ctl_elem_info_get_dimension(const snd_ctl_elem_info_t *obj,
 				    unsigned int idx)
 {
@@ -661,274 +661,274 @@ int snd_ctl_elem_info_get_dimension(const snd_ctl_elem_info_t *obj,
 	return obj->dimen.d[idx];
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_ctl_elem_info_get_id(const snd_ctl_elem_info_t *obj,
 			      snd_ctl_elem_id_t *ptr)
 {
 	*ptr = obj->id;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_ctl_elem_info_get_numid(const snd_ctl_elem_info_t *obj)
 {
 	return obj->id.numid;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 snd_ctl_elem_iface_t snd_ctl_elem_info_get_interface(const snd_ctl_elem_info_t *obj)
 {
 	return (snd_ctl_elem_iface_t) obj->id.iface;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_ctl_elem_info_get_device(const snd_ctl_elem_info_t *obj)
 {
 	return obj->id.device;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_ctl_elem_info_get_subdevice(const snd_ctl_elem_info_t *obj)
 {
 	return obj->id.subdevice;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 const char *snd_ctl_elem_info_get_name(const snd_ctl_elem_info_t *obj)
 {
 	return (const char *)obj->id.name;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_ctl_elem_info_get_index(const snd_ctl_elem_info_t *obj)
 {
 	return obj->id.index;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_ctl_elem_info_set_id(snd_ctl_elem_info_t *obj,
 			      const snd_ctl_elem_id_t *ptr)
 {
 	obj->id = *ptr;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_ctl_elem_info_set_numid(snd_ctl_elem_info_t *obj, unsigned int val)
 {
 	obj->id.numid = val;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_ctl_elem_info_set_interface(snd_ctl_elem_info_t *obj,
 				     snd_ctl_elem_iface_t val)
 {
 	obj->id.iface = val;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_ctl_elem_info_set_device(snd_ctl_elem_info_t *obj, unsigned int val)
 {
 	obj->id.device = val;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_ctl_elem_info_set_subdevice(snd_ctl_elem_info_t *obj,
 				     unsigned int val)
 {
 	obj->id.subdevice = val;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_ctl_elem_info_set_name(snd_ctl_elem_info_t *obj, const char *val)
 {
 	strncpy((char *)obj->id.name, val, sizeof(obj->id.name));
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_ctl_elem_info_set_index(snd_ctl_elem_info_t *obj, unsigned int val)
 {
 	obj->id.index = val;
 }
 
 __snd_define_type(snd_ctl_elem_value);
-static inline
+__SALSA_EXPORT_FUNC
 void snd_ctl_elem_value_get_id(const snd_ctl_elem_value_t *obj,
 			       snd_ctl_elem_id_t *ptr)
 {
 	*ptr = obj->id;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_ctl_elem_value_get_numid(const snd_ctl_elem_value_t *obj)
 {
 	return obj->id.numid;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 snd_ctl_elem_iface_t snd_ctl_elem_value_get_interface(const snd_ctl_elem_value_t *obj)
 {
 	return (snd_ctl_elem_iface_t) obj->id.iface;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_ctl_elem_value_get_device(const snd_ctl_elem_value_t *obj)
 {
 	return obj->id.device;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_ctl_elem_value_get_subdevice(const snd_ctl_elem_value_t *obj)
 {
 	return obj->id.subdevice;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 const char *snd_ctl_elem_value_get_name(const snd_ctl_elem_value_t *obj)
 {
 	return (const char *)obj->id.name;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_ctl_elem_value_get_index(const snd_ctl_elem_value_t *obj)
 {
 	return obj->id.index;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_ctl_elem_value_set_id(snd_ctl_elem_value_t *obj,
 			       const snd_ctl_elem_id_t *ptr)
 {
 	obj->id = *ptr;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_ctl_elem_value_set_numid(snd_ctl_elem_value_t *obj, unsigned int val)
 {
 	obj->id.numid = val;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_ctl_elem_value_set_interface(snd_ctl_elem_value_t *obj,
 				      snd_ctl_elem_iface_t val)
 {
 	obj->id.iface = val;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_ctl_elem_value_set_device(snd_ctl_elem_value_t *obj, unsigned int val)
 {
 	obj->id.device = val;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_ctl_elem_value_set_subdevice(snd_ctl_elem_value_t *obj,
 				      unsigned int val)
 {
 	obj->id.subdevice = val;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_ctl_elem_value_set_name(snd_ctl_elem_value_t *obj, const char *val)
 {
 	strncpy((char *)obj->id.name, val, sizeof(obj->id.name));
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_ctl_elem_value_set_index(snd_ctl_elem_value_t *obj, unsigned int val)
 {
 	obj->id.index = val;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_ctl_elem_value_get_boolean(const snd_ctl_elem_value_t *obj,
 				   unsigned int idx)
 {
 	return obj->value.integer.value[idx];
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 long snd_ctl_elem_value_get_integer(const snd_ctl_elem_value_t *obj,
 				    unsigned int idx)
 {
 	return obj->value.integer.value[idx];
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 long long snd_ctl_elem_value_get_integer64(const snd_ctl_elem_value_t *obj,
 					   unsigned int idx)
 {
 	return obj->value.integer64.value[idx];
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_ctl_elem_value_get_enumerated(const snd_ctl_elem_value_t *obj,
 					       unsigned int idx)
 {
 	return obj->value.enumerated.item[idx];
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned char snd_ctl_elem_value_get_byte(const snd_ctl_elem_value_t *obj,
 					  unsigned int idx)
 {
 	return obj->value.bytes.data[idx];
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_ctl_elem_value_set_boolean(snd_ctl_elem_value_t *obj,
 				    unsigned int idx, long val)
 {
 	obj->value.integer.value[idx] = val;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_ctl_elem_value_set_integer(snd_ctl_elem_value_t *obj,
 				    unsigned int idx, long val)
 {
 	obj->value.integer.value[idx] = val;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_ctl_elem_value_set_integer64(snd_ctl_elem_value_t *obj,
 				      unsigned int idx, long long val)
 {
 	obj->value.integer64.value[idx] = val;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_ctl_elem_value_set_enumerated(snd_ctl_elem_value_t *obj,
 				       unsigned int idx, unsigned int val)
 {
 	obj->value.enumerated.item[idx] = val;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_ctl_elem_value_set_byte(snd_ctl_elem_value_t *obj, unsigned int idx,
 				 unsigned char val)
 {
 	obj->value.bytes.data[idx] = val;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_ctl_elem_set_bytes(snd_ctl_elem_value_t *obj, void *data, size_t size)
 {
 	if (size < sizeof(obj->value.bytes.data))
 		memcpy(obj->value.bytes.data, data, size);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 const void * snd_ctl_elem_value_get_bytes(const snd_ctl_elem_value_t *obj)
 {
 	return obj->value.bytes.data;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_ctl_elem_value_get_iec958(const snd_ctl_elem_value_t *obj,
 				   snd_aes_iec958_t *ptr)
 {
 	memcpy(ptr, &obj->value.iec958, sizeof(*ptr));
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_ctl_elem_value_set_iec958(snd_ctl_elem_value_t *obj,
 				   const snd_aes_iec958_t *ptr)
 {
@@ -938,70 +938,70 @@ void snd_ctl_elem_value_set_iec958(snd_ctl_elem_value_t *obj,
 /*
  */
 #if !SALSA_HAS_TLV_SUPPORT
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_ctl_elem_tlv_read(snd_ctl_t *ctl, const snd_ctl_elem_id_t *id,
 			  unsigned int *tlv, unsigned int tlv_size)
 {
 	return -ENXIO;
 }
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_ctl_elem_tlv_write(snd_ctl_t *ctl, const snd_ctl_elem_id_t *id,
 			   const unsigned int *tlv)
 {
 	return -ENXIO;
 }
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_ctl_elem_tlv_command(snd_ctl_t *ctl, const snd_ctl_elem_id_t *id,
 			     const unsigned int *tlv)
 {
 	return -ENXIO;
 }
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_tlv_parse_dB_info(unsigned int *tlv, unsigned int tlv_size,
 			  unsigned int **db_tlvp)
 {
 	return -ENXIO;
 }
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_tlv_get_dB_range(unsigned int *tlv, long rangemin, long rangemax,
 			 long *min, long *max)
 {
 	return -ENXIO;
 }
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_tlv_convert_to_dB(unsigned int *tlv, long rangemin, long rangemax,
 			  long volume, long *db_gain)
 {
 	return -ENXIO;
 }
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_tlv_convert_from_dB(unsigned int *tlv, long rangemin, long rangemax,
 			    long db_gain, long *value, int xdir)
 {
 	return -ENXIO;
 }
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_ctl_get_dB_range(snd_ctl_t *ctl, const snd_ctl_elem_id_t *id,
 			 long *min, long *max)
 {
 	return -ENXIO;
 }
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_ctl_convert_to_dB(snd_ctl_t *ctl, const snd_ctl_elem_id_t *id,
 			  long volume, long *db_gain)
 {
 	return -ENXIO;
 }
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_ctl_convert_from_dB(snd_ctl_t *ctl, const snd_ctl_elem_id_t *id,
 			    long db_gain, long *value, int xdir)
 {
@@ -1013,37 +1013,37 @@ int snd_ctl_convert_from_dB(snd_ctl_t *ctl, const snd_ctl_elem_id_t *id,
  * not implemented yet
  */
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_ctl_open_lconf(snd_ctl_t **ctlp, const char *name,
 		       int mode, snd_config_t *lconf)
 {
 	return -ENXIO;
 }
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_ctl_set_power_state(snd_ctl_t *ctl, unsigned int state)
 {
 	return -ENXIO;
 }
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_ctl_get_power_state(snd_ctl_t *ctl, unsigned int *state)
 {
 	return -ENXIO;
 }
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_device_name_hint(int card, const char *iface, void ***hints)
 {
 	return -ENXIO;
 }
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_device_name_free_hint(void **hints)
 {
 	return 0;
 }
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 char *snd_device_name_get_hint(const void *hint, const char *id)
 {
 	return NULL;
@@ -1051,7 +1051,7 @@ char *snd_device_name_get_hint(const void *hint, const char *id)
 
 #if SALSA_HAS_ASYNC_SUPPORT
 
-static inline
+__SALSA_EXPORT_FUNC
 snd_ctl_t *snd_async_handler_get_ctl(snd_async_handler_t *handler)
 {
 	return (snd_ctl_t *) handler->rec;
@@ -1059,7 +1059,7 @@ snd_ctl_t *snd_async_handler_get_ctl(snd_async_handler_t *handler)
 
 #else
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_async_add_ctl_handler(snd_async_handler_t **handler, snd_ctl_t *ctl, 
 			      snd_async_callback_t callback,
 			      void *private_data)
@@ -1067,7 +1067,7 @@ int snd_async_add_ctl_handler(snd_async_handler_t **handler, snd_ctl_t *ctl,
 	return -ENXIO;
 }
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 snd_ctl_t *snd_async_handler_get_ctl(snd_async_handler_t *handler)
 {
 	return NULL;
@@ -1075,4 +1075,15 @@ snd_ctl_t *snd_async_handler_get_ctl(snd_async_handler_t *handler)
 
 #endif /* SALSA_HAS_ASYNC_SUPPORT */
 
+#if SALSA_HAS_TLV_SUPPORT
+__SALSA_EXPORT_FUNC
+int snd_tlv_parse_dB_info(unsigned int *tlv, unsigned int tlv_size,
+			  unsigned int **db_tlvp)
+{
+	/* just for simplicity */
+	*db_tlvp = tlv;
+	return 0;
+}
+#endif /* SALSA_HAS_TLV_SUPPORT */
+
 #endif /* __ALSA_CTL_MACROS_H */
diff --git a/src/error.h b/src/error.h
index 22bdd56..c6447bd 100644
--- a/src/error.h
+++ b/src/error.h
@@ -24,7 +24,7 @@
 
 typedef void (*snd_lib_error_handler_t)(const char *file, int line, const char *function, int err, const char *fmt, ...) /* __attribute__ ((format (printf, 5, 6))) */;
 
-static inline
+__SALSA_EXPORT_FUNC
 const char *snd_strerror(int errnum)
 {
 	if (errnum < 0)
@@ -32,7 +32,7 @@ const char *snd_strerror(int errnum)
 	return (const char *) strerror(errnum);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_lib_error_set_handler(snd_lib_error_handler_t handler)
 {
 	return 0;
diff --git a/src/error_abi.c b/src/error_abi.c
new file mode 100644
index 0000000..bbb43a9
--- /dev/null
+++ b/src/error_abi.c
@@ -0,0 +1,5 @@
+#include "recipe.h"
+#include "global.h"
+#undef __SALSA_EXPORT_FUNC
+#define __SALSA_EXPORT_FUNC
+#include "error.h"
diff --git a/src/global.h b/src/global.h
index 2b749a0..68d78fa 100644
--- a/src/global.h
+++ b/src/global.h
@@ -39,6 +39,10 @@ typedef struct _snd_rawmidi snd_rawmidi_t;
 typedef struct _snd_hwdep snd_hwdep_t;
 typedef struct _snd_seq snd_seq_t;
 
+#ifndef __SALSA_EXPORT_FUNC
+#define __SALSA_EXPORT_FUNC	static inline
+#endif
+
 #ifndef ATTRIBUTE_UNUSED
 /** do not print warning (gcc) when function parameter is not used */
 #define ATTRIBUTE_UNUSED __attribute__ ((__unused__))
@@ -77,13 +81,13 @@ int snd_async_del_handler(snd_async_handler_t *handler);
 #define snd_async_handler_get_signo(h)	-1
 #define snd_async_handler_get_fd(h)	-1
 #define snd_async_handler_get_callback_private(h)	NULL
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_async_add_handler(snd_async_handler_t **handler, int fd, 
 			  snd_async_callback_t callback, void *private_data)
 {
 	return -ENXIO;
 }
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_async_del_handler(snd_async_handler_t *handler)
 {
 	return -ENXIO;
@@ -96,7 +100,7 @@ int _snd_set_nonblock(int fd, int nonblock);
 
 #if !SALSA_HAS_DUMMY_CONF
 /* the global function defined here */
-static inline
+__SALSA_EXPORT_FUNC
 int snd_config_update_free_global(void)
 {
 	return 0;
@@ -107,13 +111,13 @@ int snd_config_update_free_global(void)
  * helper macros
  */
 #define __snd_sizeof(type)		 \
-static inline size_t type##_sizeof(void) \
+__SALSA_EXPORT_FUNC size_t type##_sizeof(void) \
 {					 \
 	return sizeof(type##_t);	 \
 }
 
 #define __snd_malloc(type)			\
-static inline int type##_malloc(type##_t **ptr) \
+__SALSA_EXPORT_FUNC int type##_malloc(type##_t **ptr) \
 {						 \
 	*ptr = (type##_t *)calloc(1, sizeof(**ptr)); \
 	if (!*ptr)				 \
@@ -122,19 +126,19 @@ static inline int type##_malloc(type##_t **ptr) \
 }
 
 #define __snd_free(type)			\
-static inline void type##_free(type##_t *obj)	\
+__SALSA_EXPORT_FUNC void type##_free(type##_t *obj)	\
 {						\
 	free(obj);				\
 }
 
 #define __snd_clear(type)				\
-static inline void type##_clear(type##_t *obj)		\
+__SALSA_EXPORT_FUNC void type##_clear(type##_t *obj)		\
 {							\
 	memset(obj, 0, sizeof(type##_t));		\
 }
 
 #define __snd_copy(type)					   \
-static inline void type##_copy(type##_t *dst, const type##_t *src) \
+__SALSA_EXPORT_FUNC void type##_copy(type##_t *dst, const type##_t *src) \
 {								   \
 	*dst = *src;						   \
 }
diff --git a/src/global_abi.c b/src/global_abi.c
new file mode 100644
index 0000000..168e1a4
--- /dev/null
+++ b/src/global_abi.c
@@ -0,0 +1,28 @@
+#include "recipe.h"
+#include <errno.h>
+
+/* async helpers */
+typedef struct _snd_async_handler snd_async_handler_t;
+typedef void (*snd_async_callback_t)(snd_async_handler_t *handler);
+
+#if !SALSA_HAS_ASYNC_SUPPORT
+
+int snd_async_add_handler(snd_async_handler_t **handler, int fd, 
+			  snd_async_callback_t callback, void *private_data)
+{
+	return -ENXIO;
+}
+
+int snd_async_del_handler(snd_async_handler_t *handler)
+{
+	return -ENXIO;
+}
+
+#endif /* !SALSA_HAS_ASYNC_SUPPORT */
+
+#if !SALSA_HAS_DUMMY_CONF
+int snd_config_update_free_global(void)
+{
+	return 0;
+}
+#endif /* !SALSA_HAS_DUMMY_CONF */
diff --git a/src/hcontrol.h b/src/hcontrol.h
index 5c41941..7de57a6 100644
--- a/src/hcontrol.h
+++ b/src/hcontrol.h
@@ -22,16 +22,7 @@
 #ifndef __ALSA_HCONTROL_H
 #define __ALSA_HCONTROL_H
 
-#include "control.h"
-#include "hctl_types.h"
-
-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);
-snd_hctl_elem_t *snd_hctl_find_elem(snd_hctl_t *hctl, const snd_ctl_elem_id_t *id);
-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);
+#include "hctl_func.h"
 
 #include "hctl_macros.h"
 
diff --git a/src/hctl_abi.c b/src/hctl_abi.c
new file mode 100644
index 0000000..121215f
--- /dev/null
+++ b/src/hctl_abi.c
@@ -0,0 +1,4 @@
+#include "hctl_func.h"
+#undef __SALSA_EXPORT_FUNC
+#define __SALSA_EXPORT_FUNC
+#include "hctl_macros.h"
diff --git a/src/hctl_func.h b/src/hctl_func.h
new file mode 100644
index 0000000..7cea5e5
--- /dev/null
+++ b/src/hctl_func.h
@@ -0,0 +1,13 @@
+/*
+ */
+
+#include "control.h"
+#include "hctl_types.h"
+
+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);
+snd_hctl_elem_t *snd_hctl_find_elem(snd_hctl_t *hctl, const snd_ctl_elem_id_t *id);
+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);
diff --git a/src/hctl_macros.h b/src/hctl_macros.h
index a57775f..8d31e1c 100644
--- a/src/hctl_macros.h
+++ b/src/hctl_macros.h
@@ -32,7 +32,7 @@ struct _snd_hctl_elem {
 };
 
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_hctl_wait(snd_hctl_t *hctl, int timeout)
 {
 	int err;
@@ -42,87 +42,87 @@ int snd_hctl_wait(snd_hctl_t *hctl, int timeout)
 	return err;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 const char *snd_hctl_name(snd_hctl_t *hctl)
 {
 	return snd_ctl_name(hctl->ctl);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_hctl_nonblock(snd_hctl_t *hctl, int nonblock)
 {
 	return snd_ctl_nonblock(hctl->ctl, nonblock);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_hctl_set_compare(snd_hctl_t *hctl, snd_hctl_compare_t compare)
 {
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_hctl_poll_descriptors_count(snd_hctl_t *hctl)
 {
 	return snd_ctl_poll_descriptors_count(hctl->ctl);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_hctl_poll_descriptors(snd_hctl_t *hctl, struct pollfd *pfds, unsigned int space)
 {
 	return snd_ctl_poll_descriptors(hctl->ctl, pfds, space);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_hctl_poll_descriptors_revents(snd_hctl_t *hctl, struct pollfd *pfds, unsigned int nfds, unsigned short *revents)
 {
 	return snd_ctl_poll_descriptors_revents(hctl->ctl, pfds, nfds, revents);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_hctl_set_callback(snd_hctl_t *hctl, snd_hctl_callback_t callback)
 {
 	hctl->callback = callback;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_hctl_set_callback_private(snd_hctl_t *hctl, void *callback_private)
 {
 	hctl->callback_private = callback_private;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void *snd_hctl_get_callback_private(snd_hctl_t *hctl)
 {
 	return hctl->callback_private;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_hctl_get_count(snd_hctl_t *hctl)
 {
 	return hctl->count;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 snd_ctl_t *snd_hctl_ctl(snd_hctl_t *hctl)
 {
 	return hctl->ctl;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_hctl_elem_info(snd_hctl_elem_t *elem, snd_ctl_elem_info_t *info)
 {
 	info->id = elem->id;
 	return snd_ctl_elem_info(elem->hctl->ctl, info);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_hctl_elem_read(snd_hctl_elem_t *elem, snd_ctl_elem_value_t *value)
 {
 	value->id = elem->id;
 	return snd_ctl_elem_read(elem->hctl->ctl, value);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_hctl_elem_write(snd_hctl_elem_t *elem, snd_ctl_elem_value_t *value)
 {
 	value->id = elem->id;
@@ -130,20 +130,20 @@ int snd_hctl_elem_write(snd_hctl_elem_t *elem, snd_ctl_elem_value_t *value)
 }
 
 #if SALSA_HAS_TLV_SUPPORT
-static inline
+__SALSA_EXPORT_FUNC
 int snd_hctl_elem_tlv_read(snd_hctl_elem_t *elem, unsigned int *tlv,
 			   unsigned int tlv_size)
 {
 	return snd_ctl_elem_tlv_read(elem->hctl->ctl, &elem->id, tlv, tlv_size);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_hctl_elem_tlv_write(snd_hctl_elem_t *elem, const unsigned int *tlv)
 {
 	return snd_ctl_elem_tlv_write(elem->hctl->ctl, &elem->id, tlv);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_hctl_elem_tlv_command(snd_hctl_elem_t *elem, const unsigned int *tlv)
 {
 	return snd_ctl_elem_tlv_command(elem->hctl->ctl, &elem->id, tlv);
@@ -151,111 +151,111 @@ int snd_hctl_elem_tlv_command(snd_hctl_elem_t *elem, const unsigned int *tlv)
 
 #else /* SALSA_HAS_TLV_SUPPORT */
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_hctl_elem_tlv_read(snd_hctl_elem_t *elem, unsigned int *tlv,
 			   unsigned int tlv_size)
 {
 	return -ENXIO;
 }
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_hctl_elem_tlv_write(snd_hctl_elem_t *elem, const unsigned int *tlv)
 {
 	return -ENXIO;
 }
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_hctl_elem_tlv_command(snd_hctl_elem_t *elem, const unsigned int *tlv)
 {
 	return -ENXIO;
 }
 #endif /* SALSA_HAS_TLV_SUPPORT */
 
-static inline
+__SALSA_EXPORT_FUNC
 snd_hctl_t *snd_hctl_elem_get_hctl(snd_hctl_elem_t *elem)
 {
 	return elem->hctl;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_hctl_elem_get_id(const snd_hctl_elem_t *obj, snd_ctl_elem_id_t *ptr)
 {
 	*ptr = obj->id;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_hctl_elem_get_numid(const snd_hctl_elem_t *obj)
 {
 	return obj->id.numid;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 snd_ctl_elem_iface_t snd_hctl_elem_get_interface(const snd_hctl_elem_t *obj)
 {
 	return (snd_ctl_elem_iface_t) obj->id.iface;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_hctl_elem_get_device(const snd_hctl_elem_t *obj)
 {
 	return obj->id.device;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_hctl_elem_get_subdevice(const snd_hctl_elem_t *obj)
 {
 	return obj->id.subdevice;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 const char *snd_hctl_elem_get_name(const snd_hctl_elem_t *obj)
 {
 	return (const char *)obj->id.name;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_hctl_elem_get_index(const snd_hctl_elem_t *obj)
 {
 	return obj->id.index;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_hctl_elem_set_callback(snd_hctl_elem_t *obj,
 				snd_hctl_elem_callback_t val)
 {
 	obj->callback = val;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_hctl_elem_set_callback_private(snd_hctl_elem_t *obj, void * val)
 {
 	obj->callback_private = val;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void *snd_hctl_elem_get_callback_private(const snd_hctl_elem_t *obj)
 {
 	return obj->callback_private;
 }
-static inline
+__SALSA_EXPORT_FUNC
 snd_hctl_elem_t *snd_hctl_first_elem(snd_hctl_t *hctl)
 {
 	return hctl->first_elem;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 snd_hctl_elem_t *snd_hctl_last_elem(snd_hctl_t *hctl)
 {
 	return hctl->last_elem;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 snd_hctl_elem_t *snd_hctl_elem_next(snd_hctl_elem_t *elem)
 {
 	return elem->next;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 snd_hctl_elem_t *snd_hctl_elem_prev(snd_hctl_elem_t *elem)
 {
 	return elem->prev;
@@ -266,7 +266,7 @@ snd_hctl_elem_t *snd_hctl_elem_prev(snd_hctl_elem_t *elem)
  * not implemented yet
  */
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_hctl_async(snd_hctl_t *hctl, int sig, pid_t pid)
 {
 	return -ENXIO;
diff --git a/src/hwdep.h b/src/hwdep.h
index be32303..b9d37be 100644
--- a/src/hwdep.h
+++ b/src/hwdep.h
@@ -22,12 +22,7 @@
 #ifndef __ALSA_HWDEP_H
 #define __ALSA_HWDEP_H
 
-#include "recipe.h"
-#include "global.h"
-#include "hwdep_types.h"
-
-int snd_hwdep_open(snd_hwdep_t **hwdep, const char *name, int mode);
-int snd_hwdep_close(snd_hwdep_t *hwdep);
+#include "hwdep_func.h"
 
 #include "hwdep_macros.h"
 
diff --git a/src/hwdep_abi.c b/src/hwdep_abi.c
new file mode 100644
index 0000000..4cd364a
--- /dev/null
+++ b/src/hwdep_abi.c
@@ -0,0 +1,4 @@
+#include "hwdep_func.h"
+#undef __SALSA_EXPORT_FUNC
+#define __SALSA_EXPORT_FUNC
+#include "hwdep_macros.h"
diff --git a/src/hwdep_func.h b/src/hwdep_func.h
new file mode 100644
index 0000000..154c91c
--- /dev/null
+++ b/src/hwdep_func.h
@@ -0,0 +1,9 @@
+/*
+ */
+
+#include "recipe.h"
+#include "global.h"
+#include "hwdep_types.h"
+
+int snd_hwdep_open(snd_hwdep_t **hwdep, const char *name, int mode);
+int snd_hwdep_close(snd_hwdep_t *hwdep);
diff --git a/src/hwdep_macros.h b/src/hwdep_macros.h
index c41ee0e..6a52c68 100644
--- a/src/hwdep_macros.h
+++ b/src/hwdep_macros.h
@@ -9,6 +9,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <errno.h>
+#include <unistd.h>
 #include <sys/ioctl.h>
 #include <sys/poll.h>
 
@@ -21,19 +22,19 @@ struct _snd_hwdep {
 };
 
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_hwdep_nonblock(snd_hwdep_t *hwdep, int nonblock)
 {
 	return _snd_set_nonblock(hwdep->fd, nonblock);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_hwdep_poll_descriptors_count(snd_rawmidi_t *rmidi)
 {
 	return 1;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_hwdep_poll_descriptors(snd_hwdep_t *hwdep, struct pollfd *pfds,
 			       unsigned int space)
 {
@@ -41,7 +42,7 @@ int snd_hwdep_poll_descriptors(snd_hwdep_t *hwdep, struct pollfd *pfds,
 	return 1;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_hwdep_poll_descriptors_revents(snd_hwdep_t *hwdep, struct pollfd *pfds,
 				       unsigned int nfds,
 				       unsigned short *revents)
@@ -50,7 +51,7 @@ int snd_hwdep_poll_descriptors_revents(snd_hwdep_t *hwdep, struct pollfd *pfds,
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_hwdep_info(snd_hwdep_t *hwdep, snd_hwdep_info_t * info)
 {
 	if (ioctl(hwdep->fd, SNDRV_HWDEP_IOCTL_INFO, info) < 0)
@@ -58,7 +59,7 @@ int snd_hwdep_info(snd_hwdep_t *hwdep, snd_hwdep_info_t * info)
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_hwdep_ioctl(snd_hwdep_t *hwdep, unsigned int request, void * arg)
 {
 	if (ioctl(hwdep->fd, request, arg) < 0)
@@ -66,19 +67,19 @@ int snd_hwdep_ioctl(snd_hwdep_t *hwdep, unsigned int request, void * arg)
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_hwdep_dsp_status(snd_hwdep_t *hwdep, snd_hwdep_dsp_status_t *status)
 {
 	return snd_hwdep_ioctl(hwdep, SNDRV_HWDEP_IOCTL_DSP_STATUS, status);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_hwdep_dsp_load(snd_hwdep_t *hwdep, snd_hwdep_dsp_image_t *block)
 {
 	return snd_hwdep_ioctl(hwdep, SNDRV_HWDEP_IOCTL_DSP_LOAD, block);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 ssize_t snd_hwdep_write(snd_hwdep_t *hwdep, const void *buffer, size_t size)
 {
 	ssize_t result;
@@ -88,7 +89,7 @@ ssize_t snd_hwdep_write(snd_hwdep_t *hwdep, const void *buffer, size_t size)
 	return result;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 ssize_t snd_hwdep_read(snd_hwdep_t *hwdep, void *buffer, size_t size)
 {
 	ssize_t result;
@@ -100,37 +101,37 @@ ssize_t snd_hwdep_read(snd_hwdep_t *hwdep, void *buffer, size_t size)
 
 __snd_define_type(snd_hwdep_info);
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_hwdep_info_get_device(const snd_hwdep_info_t *obj)
 {
 	return obj->device;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_hwdep_info_get_card(const snd_hwdep_info_t *obj)
 {
 	return obj->card;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 const char *snd_hwdep_info_get_id(const snd_hwdep_info_t *obj)
 {
 	return (const char *)obj->id;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 const char *snd_hwdep_info_get_name(const snd_hwdep_info_t *obj)
 {
 	return (const char *)obj->name;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 snd_hwdep_iface_t snd_hwdep_info_get_iface(const snd_hwdep_info_t *obj)
 {
 	return (snd_hwdep_iface_t) obj->iface;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_hwdep_info_set_device(snd_hwdep_info_t *obj, unsigned int val)
 {
 	obj->device = val;
@@ -138,31 +139,31 @@ void snd_hwdep_info_set_device(snd_hwdep_info_t *obj, unsigned int val)
 
 __snd_define_type(snd_hwdep_dsp_status);
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_hwdep_dsp_status_get_version(const snd_hwdep_dsp_status_t *obj)
 {
 	return obj->version;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 const char *snd_hwdep_dsp_status_get_id(const snd_hwdep_dsp_status_t *obj)
 {
 	return (const char *)obj->id;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_hwdep_dsp_status_get_num_dsps(const snd_hwdep_dsp_status_t *obj)
 {
 	return obj->num_dsps;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_hwdep_dsp_status_get_dsp_loaded(const snd_hwdep_dsp_status_t *obj)
 {
 	return obj->dsp_loaded;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_hwdep_dsp_status_get_chip_ready(const snd_hwdep_dsp_status_t *obj)
 {
 	return obj->chip_ready;
@@ -170,50 +171,50 @@ unsigned int snd_hwdep_dsp_status_get_chip_ready(const snd_hwdep_dsp_status_t *o
 
 __snd_define_type(snd_hwdep_dsp_image);
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_hwdep_dsp_image_get_index(const snd_hwdep_dsp_image_t *obj)
 {
 	return obj->index;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 const char *snd_hwdep_dsp_image_get_name(const snd_hwdep_dsp_image_t *obj)
 {
 	return (const char *)obj->name;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 const void *snd_hwdep_dsp_image_get_image(const snd_hwdep_dsp_image_t *obj)
 {
 	return (const void *)obj->image;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 size_t snd_hwdep_dsp_image_get_length(const snd_hwdep_dsp_image_t *obj)
 {
 	return obj->length;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_hwdep_dsp_image_set_index(snd_hwdep_dsp_image_t *obj, unsigned int _index)
 {
 	obj->index = _index;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_hwdep_dsp_image_set_name(snd_hwdep_dsp_image_t *obj, const char *name)
 {
 	strncpy((char *)obj->name, name, sizeof(obj->name));
 	obj->name[sizeof(obj->name)-1] = 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_hwdep_dsp_image_set_image(snd_hwdep_dsp_image_t *obj, void *buffer)
 {
 	obj->image = (unsigned char *) buffer;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_hwdep_dsp_image_set_length(snd_hwdep_dsp_image_t *obj, size_t length)
 {
 	obj->length = length;
diff --git a/src/input.h b/src/input.h
index db8ff65..1502f35 100644
--- a/src/input.h
+++ b/src/input.h
@@ -33,7 +33,7 @@ typedef enum _snd_input_type {
 	SND_INPUT_STDIO,
 } snd_input_type_t;
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_input_stdio_open(snd_input_t **inputp, const char *file, const char *mode)
 {
 	if ((*inputp = fopen(file, mode)) == NULL)
@@ -41,7 +41,7 @@ int snd_input_stdio_open(snd_input_t **inputp, const char *file, const char *mod
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_input_stdio_attach(snd_input_t **inputp, FILE *fp, int _close)
 {
 	*inputp = fp;
@@ -54,7 +54,7 @@ int snd_input_stdio_attach(snd_input_t **inputp, FILE *fp, int _close)
 #define snd_input_getc(input)		getc(input)
 #define snd_input_ungetc(input,c)	ungetc(c, input)
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_input_buffer_open(snd_input_t **inputp, const char *buffer,
 			  ssize_t size)
 {
diff --git a/src/input_abi.c b/src/input_abi.c
new file mode 100644
index 0000000..d23cffc
--- /dev/null
+++ b/src/input_abi.c
@@ -0,0 +1,64 @@
+/*
+ */
+
+#include <stdio.h>
+#include <errno.h>
+#include <stdarg.h>
+#include <unistd.h>
+
+typedef FILE snd_input_t;
+
+/** Input type. */
+typedef enum _snd_input_type {
+	/** Input from a stdio stream. */
+	SND_INPUT_STDIO,
+} snd_input_type_t;
+
+int snd_input_stdio_open(snd_input_t **inputp, const char *file, const char *mode)
+{
+	if ((*inputp = fopen(file, mode)) == NULL)
+		return -errno;
+	return 0;
+}
+
+int snd_input_stdio_attach(snd_input_t **inputp, FILE *fp, int _close)
+{
+	*inputp = fp;
+	return 0;
+}
+	
+int snd_input_close(snd_input_t *input)
+{
+	return fclose(input);
+}
+
+int snd_input_scanf(snd_input_t *input, const char *fmt, ...)
+{
+	va_list ap;
+	int ret;
+	va_start(ap, fmt);
+	ret = vfscanf(input, fmt, ap);
+	va_end(ap);
+	return ret;
+}
+
+char *snd_input_gets(snd_input_t *input, char *str, int size)
+{
+	return fgets(str, size, input);
+}
+
+int snd_input_getc(snd_input_t *input)
+{
+	return getc(input);
+}
+
+int snd_input_ungetc(snd_input_t *input, int c)
+{
+	return ungetc(c, input);
+}
+
+int snd_input_buffer_open(snd_input_t **inputp, const char *buffer,
+			  ssize_t size)
+{
+	return -ENXIO;
+}
diff --git a/src/mixer.h b/src/mixer.h
index 3fbafa4..7ba61b1 100644
--- a/src/mixer.h
+++ b/src/mixer.h
@@ -22,52 +22,7 @@
 #ifndef __ALSA_MIXER_H
 #define __ALSA_MIXER_H
 
-#include "hcontrol.h"
-#include "mixer_types.h"
-
-int snd_mixer_open(snd_mixer_t **mixer, int mode);
-int snd_mixer_close(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_load(snd_mixer_t *mixer);
-void snd_mixer_free(snd_mixer_t *mixer);
-
-int snd_mixer_selem_register(snd_mixer_t *mixer,
-			     struct snd_mixer_selem_regopt *options,
-			     snd_mixer_class_t **classp);
-snd_mixer_elem_t *snd_mixer_find_selem(snd_mixer_t *mixer,
-				       const snd_mixer_selem_id_t *id);
-
-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_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_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_set_playback_volume_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_set_enum_item(snd_mixer_elem_t *elem,
-				  snd_mixer_selem_channel_id_t channel,
-				  unsigned int idx);
-int snd_mixer_selem_get_enum_item_name(snd_mixer_elem_t *elem,
-				       unsigned int idx,
-				       size_t maxlen, char *str);
+#include "mixer_func.h"
 
 #include "mixer_macros.h"
 
diff --git a/src/mixer_abi.c b/src/mixer_abi.c
new file mode 100644
index 0000000..de52426
--- /dev/null
+++ b/src/mixer_abi.c
@@ -0,0 +1,4 @@
+#include "mixer_func.h"
+#undef __SALSA_EXPORT_FUNC
+#define __SALSA_EXPORT_FUNC
+#include "mixer_macros.h"
diff --git a/src/mixer_func.h b/src/mixer_func.h
new file mode 100644
index 0000000..9a86401
--- /dev/null
+++ b/src/mixer_func.h
@@ -0,0 +1,49 @@
+/*
+ */
+
+#include "hcontrol.h"
+#include "mixer_types.h"
+
+int snd_mixer_open(snd_mixer_t **mixer, int mode);
+int snd_mixer_close(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_load(snd_mixer_t *mixer);
+void snd_mixer_free(snd_mixer_t *mixer);
+
+int snd_mixer_selem_register(snd_mixer_t *mixer,
+			     struct snd_mixer_selem_regopt *options,
+			     snd_mixer_class_t **classp);
+snd_mixer_elem_t *snd_mixer_find_selem(snd_mixer_t *mixer,
+				       const snd_mixer_selem_id_t *id);
+
+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_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_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_set_playback_volume_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_set_enum_item(snd_mixer_elem_t *elem,
+				  snd_mixer_selem_channel_id_t channel,
+				  unsigned int idx);
+int snd_mixer_selem_get_enum_item_name(snd_mixer_elem_t *elem,
+				       unsigned int idx,
+				       size_t maxlen, char *str);
diff --git a/src/mixer_macros.h b/src/mixer_macros.h
index fde782b..4b41ab1 100644
--- a/src/mixer_macros.h
+++ b/src/mixer_macros.h
@@ -89,20 +89,20 @@ struct _snd_mixer_elem {
 };
 
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_mixer_poll_descriptors_count(snd_mixer_t *mixer)
 {
 	return 1;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_mixer_poll_descriptors(snd_mixer_t *mixer, struct pollfd *pfds,
 			       unsigned int space)
 {
 	return snd_hctl_poll_descriptors(mixer->hctl, pfds, space);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_mixer_poll_descriptors_revents(snd_mixer_t *mixer, struct pollfd *pfds,
 				       unsigned int nfds,
 				       unsigned short *revents)
@@ -110,19 +110,19 @@ int snd_mixer_poll_descriptors_revents(snd_mixer_t *mixer, struct pollfd *pfds,
 	return snd_hctl_poll_descriptors_revents(mixer->hctl, pfds, nfds, revents);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 snd_mixer_elem_t *snd_mixer_first_elem(snd_mixer_t *mixer)
 {
 	return mixer->pelems[0];
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 snd_mixer_elem_t *snd_mixer_last_elem(snd_mixer_t *mixer)
 {
 	return mixer->pelems[mixer->count - 1];
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 snd_mixer_elem_t *snd_mixer_elem_next(snd_mixer_elem_t *elem)
 {
 	if (elem->index == (unsigned int)elem->mixer->count - 1)
@@ -130,7 +130,7 @@ snd_mixer_elem_t *snd_mixer_elem_next(snd_mixer_elem_t *elem)
 	return elem->mixer->pelems[elem->index + 1];
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 snd_mixer_elem_t *snd_mixer_elem_prev(snd_mixer_elem_t *elem)
 {
 	if (!elem->index)
@@ -138,63 +138,63 @@ snd_mixer_elem_t *snd_mixer_elem_prev(snd_mixer_elem_t *elem)
 	return elem->mixer->pelems[elem->index - 1];
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_mixer_set_callback(snd_mixer_t *obj, snd_mixer_callback_t val)
 {
 	obj->callback = val;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_mixer_set_callback_private(snd_mixer_t *mixer, void * val)
 {
 	mixer->callback_private = val;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void * snd_mixer_get_callback_private(const snd_mixer_t *mixer)
 {
 	return mixer->callback_private;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_mixer_get_count(const snd_mixer_t *mixer)
 {
 	return mixer->count;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_mixer_elem_set_callback(snd_mixer_elem_t *mixer,
 				 snd_mixer_elem_callback_t val)
 {
 	mixer->callback = val;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_mixer_elem_set_callback_private(snd_mixer_elem_t *mixer, void * val)
 {
 	mixer->callback_private = val;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void * snd_mixer_elem_get_callback_private(const snd_mixer_elem_t *mixer)
 {
 	return mixer->callback_private;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 snd_mixer_elem_type_t snd_mixer_elem_get_type(const snd_mixer_elem_t *mixer)
 {
 	return SND_MIXER_ELEM_SIMPLE;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_mixer_set_compare(snd_mixer_t *mixer, snd_mixer_compare_t compare)
 {
 	mixer->compare = compare;
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_mixer_wait(snd_mixer_t *mixer, int timeout)
 {
 	struct pollfd pfd;
@@ -206,19 +206,19 @@ int snd_mixer_wait(snd_mixer_t *mixer, int timeout)
 
 int _snd_mixer_elem_throw_event(snd_mixer_elem_t *elem, unsigned int mask);
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_mixer_elem_info(snd_mixer_elem_t *elem)
 {
 	return _snd_mixer_elem_throw_event(elem, SND_CTL_EVENT_MASK_INFO);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_mixer_elem_value(snd_mixer_elem_t *elem)
 {
 	return _snd_mixer_elem_throw_event(elem, SND_CTL_EVENT_MASK_VALUE);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_mixer_get_hctl(snd_mixer_t *mixer, const char *name, snd_hctl_t **hctl)
 {
 	if (mixer->hctl) {
@@ -228,32 +228,32 @@ int snd_mixer_get_hctl(snd_mixer_t *mixer, const char *name, snd_hctl_t **hctl)
 	return -ENOENT;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_mixer_selem_get_id(snd_mixer_elem_t *elem,
 			    snd_mixer_selem_id_t *id)
 {
 	*id = elem->sid;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 const char *snd_mixer_selem_get_name(snd_mixer_elem_t *elem)
 {
 	return elem->sid.name;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_mixer_selem_get_index(snd_mixer_elem_t *elem)
 {
 	return elem->sid.index;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_mixer_selem_has_common_volume(snd_mixer_elem_t *elem)
 {
 	return !!(elem->caps & SND_SM_CAP_GVOLUME);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_mixer_selem_has_common_switch(snd_mixer_elem_t *elem)
 {
 	return !!(elem->caps & SND_SM_CAP_GSWITCH);
@@ -261,7 +261,7 @@ int snd_mixer_selem_has_common_switch(snd_mixer_elem_t *elem)
 
 extern const char *_snd_mixer_selem_channels[];
 
-static inline
+__SALSA_EXPORT_FUNC
 const char *snd_mixer_selem_channel_name(snd_mixer_selem_channel_id_t channel)
 {
 	const char *p;
@@ -269,26 +269,26 @@ const char *snd_mixer_selem_channel_name(snd_mixer_selem_channel_id_t channel)
 	return p ? p : "?";
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_mixer_selem_is_active(snd_mixer_elem_t *elem)
 {
 	return !elem->inactive;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_mixer_selem_is_playback_mono(snd_mixer_elem_t *elem)
 {
 	return elem->channels[SND_PCM_STREAM_PLAYBACK] == 1;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_mixer_selem_has_playback_channel(snd_mixer_elem_t *elem,
 					 snd_mixer_selem_channel_id_t channel)
 {
 	return (unsigned int)channel < elem->channels[SND_PCM_STREAM_PLAYBACK];
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int _snd_mixer_selem_get_volume_range(snd_mixer_elem_t *elem, int type,
 				      long *min, long *max)
 {
@@ -300,7 +300,7 @@ int _snd_mixer_selem_get_volume_range(snd_mixer_elem_t *elem, int type,
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_mixer_selem_get_playback_volume_range(snd_mixer_elem_t *elem,
 					      long *min, long *max)
 {
@@ -308,53 +308,53 @@ int snd_mixer_selem_get_playback_volume_range(snd_mixer_elem_t *elem,
 						 min, max);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_mixer_selem_has_playback_volume(snd_mixer_elem_t *elem)
 {
 	return elem->items[SND_SELEM_ITEM_PVOLUME] != NULL;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int _snd_mixer_selem_has_joined(snd_mixer_elem_t *elem, int type, int str)
 {
 	snd_selem_item_head_t *head = (snd_selem_item_head_t *)elem->items[type];
 	return head && (head->channels < elem->channels[str]);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_mixer_selem_has_playback_volume_joined(snd_mixer_elem_t *elem)
 {
 	return _snd_mixer_selem_has_joined(elem, SND_SELEM_ITEM_PVOLUME,
 					   SND_PCM_STREAM_PLAYBACK);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_mixer_selem_has_playback_switch(snd_mixer_elem_t *elem)
 {
 	return elem->items[SND_SELEM_ITEM_PSWITCH] != NULL;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_mixer_selem_has_playback_switch_joined(snd_mixer_elem_t *elem)
 {
 	return _snd_mixer_selem_has_joined(elem, SND_SELEM_ITEM_PSWITCH,
 					   SND_PCM_STREAM_PLAYBACK);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_mixer_selem_is_capture_mono(snd_mixer_elem_t *elem)
 {
 	return elem->channels[SND_PCM_STREAM_CAPTURE] == 1;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_mixer_selem_has_capture_channel(snd_mixer_elem_t *elem,
 					snd_mixer_selem_channel_id_t channel)
 {
 	return (unsigned int)channel < elem->channels[SND_PCM_STREAM_CAPTURE];
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_mixer_selem_get_capture_volume_range(snd_mixer_elem_t *elem,
 					     long *min, long *max)
 {
@@ -362,45 +362,45 @@ int snd_mixer_selem_get_capture_volume_range(snd_mixer_elem_t *elem,
 						 min, max);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_mixer_selem_has_capture_volume(snd_mixer_elem_t *elem)
 {
 	return elem->items[SND_SELEM_ITEM_CVOLUME] != NULL;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_mixer_selem_has_capture_volume_joined(snd_mixer_elem_t *elem)
 {
 	return _snd_mixer_selem_has_joined(elem, SND_SELEM_ITEM_CVOLUME,
 					   SND_PCM_STREAM_CAPTURE);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_mixer_selem_has_capture_switch(snd_mixer_elem_t *elem)
 {
 	return elem->items[SND_SELEM_ITEM_CSWITCH] != NULL;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_mixer_selem_has_capture_switch_joined(snd_mixer_elem_t *elem)
 {
 	return _snd_mixer_selem_has_joined(elem, SND_SELEM_ITEM_CSWITCH,
 					   SND_PCM_STREAM_CAPTURE);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_mixer_selem_has_capture_switch_exclusive(snd_mixer_elem_t *elem)
 {
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_mixer_selem_get_capture_group(snd_mixer_elem_t *elem)
 {
 	return -EINVAL;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int _snd_mixer_selem_get_volume(snd_mixer_elem_t *elem, int type,
 				snd_mixer_selem_channel_id_t channel,
 				long *value)
@@ -415,7 +415,7 @@ int _snd_mixer_selem_get_volume(snd_mixer_elem_t *elem, int type,
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_mixer_selem_get_playback_volume(snd_mixer_elem_t *elem,
 					snd_mixer_selem_channel_id_t channel,
 					long *value)
@@ -424,7 +424,7 @@ int snd_mixer_selem_get_playback_volume(snd_mixer_elem_t *elem,
 					   channel, value);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int _snd_mixer_selem_get_switch(snd_mixer_elem_t *elem, int type,
 				snd_mixer_selem_channel_id_t channel,
 				int *value)
@@ -439,7 +439,7 @@ int _snd_mixer_selem_get_switch(snd_mixer_elem_t *elem, int type,
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_mixer_selem_get_playback_switch(snd_mixer_elem_t *elem,
 					snd_mixer_selem_channel_id_t channel,
 					int *value)
@@ -448,7 +448,7 @@ int snd_mixer_selem_get_playback_switch(snd_mixer_elem_t *elem,
 					   channel, value);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_mixer_selem_get_capture_volume(snd_mixer_elem_t *elem,
 				       snd_mixer_selem_channel_id_t channel,
 				       long *value)
@@ -457,7 +457,7 @@ int snd_mixer_selem_get_capture_volume(snd_mixer_elem_t *elem,
 					   channel, value);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_mixer_selem_get_capture_switch(snd_mixer_elem_t *elem,
 				       snd_mixer_selem_channel_id_t channel,
 				       int *value)
@@ -466,7 +466,7 @@ int snd_mixer_selem_get_capture_switch(snd_mixer_elem_t *elem,
 					   channel, value);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_mixer_selem_is_enumerated(snd_mixer_elem_t *elem)
 {
 	snd_selem_enum_item_t *eitem =
@@ -474,19 +474,19 @@ int snd_mixer_selem_is_enumerated(snd_mixer_elem_t *elem)
 	return eitem != NULL;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_mixer_selem_is_enum_playback(snd_mixer_elem_t *elem)
 {
 	return !!(elem->caps & SND_SM_CAP_PENUM);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_mixer_selem_is_enum_capture(snd_mixer_elem_t *elem)
 {
 	return !!(elem->caps & SND_SM_CAP_CENUM);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_mixer_selem_get_enum_items(snd_mixer_elem_t *elem)
 {
 	snd_selem_enum_item_t *eitem =
@@ -496,7 +496,7 @@ int snd_mixer_selem_get_enum_items(snd_mixer_elem_t *elem)
 	return eitem->items;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_mixer_selem_get_enum_item(snd_mixer_elem_t *elem,
 				  snd_mixer_selem_channel_id_t channel,
 				  unsigned int *itemp)
@@ -515,26 +515,26 @@ int snd_mixer_selem_get_enum_item(snd_mixer_elem_t *elem,
 
 __snd_define_type(snd_mixer_selem_id);
 
-static inline
+__SALSA_EXPORT_FUNC
 const char *snd_mixer_selem_id_get_name(const snd_mixer_selem_id_t *obj)
 {
 	return obj->name;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_mixer_selem_id_get_index(const snd_mixer_selem_id_t *obj)
 {
 	return obj->index;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_mixer_selem_id_set_name(snd_mixer_selem_id_t *obj, const char *val)
 {
 	strncpy(obj->name, val, sizeof(obj->name));
 	obj->name[sizeof(obj->name)-1] = '\0';
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_mixer_selem_id_set_index(snd_mixer_selem_id_t *obj, unsigned int val)
 {
 	obj->index = val;
@@ -552,7 +552,7 @@ extern int _snd_selem_vol_get_dB(snd_selem_vol_item_t *item, int channel,
 extern int _snd_selem_vol_set_dB(snd_selem_vol_item_t *item,
 				 snd_mixer_selem_channel_id_t channel,
 				 long db_gain, int xdir);
-static inline
+__SALSA_EXPORT_FUNC
 int snd_mixer_selem_get_playback_dB_range(snd_mixer_elem_t *elem,
 					  long *min, long *max)
 {
@@ -560,7 +560,7 @@ int snd_mixer_selem_get_playback_dB_range(snd_mixer_elem_t *elem,
 					   min, max);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_mixer_selem_get_playback_dB(snd_mixer_elem_t *elem,
 				    snd_mixer_selem_channel_id_t channel,
 				    long *value)
@@ -569,7 +569,7 @@ int snd_mixer_selem_get_playback_dB(snd_mixer_elem_t *elem,
 				     channel, value);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_mixer_selem_set_playback_dB(snd_mixer_elem_t *elem,
 				    snd_mixer_selem_channel_id_t channel,
 				    long value, int dir)
@@ -578,7 +578,7 @@ int snd_mixer_selem_set_playback_dB(snd_mixer_elem_t *elem,
 				     channel, value, dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_mixer_selem_set_playback_dB_all(snd_mixer_elem_t *elem, long value,
 					int dir)
 {
@@ -598,7 +598,7 @@ int snd_mixer_selem_set_playback_dB_all(snd_mixer_elem_t *elem, long value,
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_mixer_selem_get_capture_dB_range(snd_mixer_elem_t *elem,
 					 long *min, long *max)
 {
@@ -606,7 +606,7 @@ int snd_mixer_selem_get_capture_dB_range(snd_mixer_elem_t *elem,
 					   min, max);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_mixer_selem_get_capture_dB(snd_mixer_elem_t *elem,
 				   snd_mixer_selem_channel_id_t channel,
 				   long *value)
@@ -615,7 +615,7 @@ int snd_mixer_selem_get_capture_dB(snd_mixer_elem_t *elem,
 				     channel, value);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_mixer_selem_set_capture_dB(snd_mixer_elem_t *elem,
 				   snd_mixer_selem_channel_id_t channel,
 				   long value, int dir)
@@ -624,7 +624,7 @@ int snd_mixer_selem_set_capture_dB(snd_mixer_elem_t *elem,
 				     channel, value, dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_mixer_selem_set_capture_dB_all(snd_mixer_elem_t *elem, long value,
 				       int dir)
 {
@@ -645,14 +645,14 @@ int snd_mixer_selem_set_capture_dB_all(snd_mixer_elem_t *elem, long value,
 }
 
 #else /* SALSA_HAS_TLV_SUPPORT */
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_mixer_selem_get_playback_dB_range(snd_mixer_elem_t *elem,
 					  long *min, long *max)
 {
 	return -ENXIO;
 }
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_mixer_selem_get_playback_dB(snd_mixer_elem_t *elem,
 				    snd_mixer_selem_channel_id_t channel,
 				    long *value)
@@ -660,7 +660,7 @@ int snd_mixer_selem_get_playback_dB(snd_mixer_elem_t *elem,
 	return -ENXIO;
 }
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_mixer_selem_set_playback_dB(snd_mixer_elem_t *elem,
 				    snd_mixer_selem_channel_id_t channel,
 				    long value, int dir)
@@ -668,21 +668,21 @@ int snd_mixer_selem_set_playback_dB(snd_mixer_elem_t *elem,
 	return -ENXIO;
 }
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_mixer_selem_set_playback_dB_all(snd_mixer_elem_t *elem, long value,
 					int dir)
 {
 	return -ENXIO;
 }
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_mixer_selem_get_capture_dB_range(snd_mixer_elem_t *elem,
 					 long *min, long *max)
 {
 	return -ENXIO;
 }
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_mixer_selem_get_capture_dB(snd_mixer_elem_t *elem,
 				   snd_mixer_selem_channel_id_t channel,
 				   long *value)
@@ -690,7 +690,7 @@ int snd_mixer_selem_get_capture_dB(snd_mixer_elem_t *elem,
 	return -ENXIO;
 }
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_mixer_selem_set_capture_dB(snd_mixer_elem_t *elem,
 				   snd_mixer_selem_channel_id_t channel,
 				   long value, int dir)
@@ -698,7 +698,7 @@ int snd_mixer_selem_set_capture_dB(snd_mixer_elem_t *elem,
 	return -ENXIO;
 }
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_mixer_selem_set_capture_dB_all(snd_mixer_elem_t *elem, long value,
 				       int dir)
 {
diff --git a/src/output.h b/src/output.h
index 1290a9c..a2d3186 100644
--- a/src/output.h
+++ b/src/output.h
@@ -32,7 +32,7 @@ typedef enum _snd_output_type {
 	/* SND_OUTPUT_BUFFER */
 } snd_output_type_t;
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_output_stdio_open(snd_output_t **outputp, const char *file, const char *mode)
 {
 	if ((*outputp = fopen(file, mode)) == NULL)
@@ -40,7 +40,7 @@ int snd_output_stdio_open(snd_output_t **outputp, const char *file, const char *
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_output_stdio_attach(snd_output_t **outputp, FILE *fp, int _close)
 {
 	*outputp = fp;
@@ -53,13 +53,13 @@ int snd_output_stdio_attach(snd_output_t **outputp, FILE *fp, int _close)
 #define snd_output_putc(out, c)			putc(c, out)
 #define snd_output_flush(out)			fflush(out)
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_output_buffer_open(snd_output_t **outputp)
 {
 	return -ENXIO;
 }
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 size_t snd_output_buffer_string(snd_output_t *output, char **buf)
 {
 	return 0;
diff --git a/src/output_abi.c b/src/output_abi.c
new file mode 100644
index 0000000..bb689af
--- /dev/null
+++ b/src/output_abi.c
@@ -0,0 +1,67 @@
+/*
+ */
+
+#include <stdio.h>
+#include <errno.h>
+#include <stdarg.h>
+#include <unistd.h>
+
+typedef FILE snd_output_t;
+
+typedef enum _snd_output_type {
+	SND_OUTPUT_STDIO,
+	/* SND_OUTPUT_BUFFER */
+} snd_output_type_t;
+
+int snd_output_stdio_open(snd_output_t **outputp, const char *file, const char *mode)
+{
+	if ((*outputp = fopen(file, mode)) == NULL)
+		return -errno;
+	return 0;
+}
+
+int snd_output_stdio_attach(snd_output_t **outputp, FILE *fp, int _close)
+{
+	*outputp = fp;
+	return 0;
+}
+
+int snd_output_close(snd_output_t *out)
+{
+	return fclose(out);
+}
+
+int snd_output_printf(snd_output_t *out, const char *fmt, ...)
+{
+	va_list ap;
+	int ret;
+	va_start(ap, fmt);
+	ret = vfprintf(out, fmt, ap);
+	va_end(ap);
+	return ret;
+}
+
+int snd_output_puts(snd_output_t *out, const char *str)
+{
+	return fputs(str, out);
+}
+
+int snd_output_putc(snd_output_t *out, int c)
+{
+	return putc(c, out);
+}
+
+int snd_output_flush(snd_output_t *out)
+{
+	return fflush(out);
+}
+
+int snd_output_buffer_open(snd_output_t **outputp)
+{
+	return -ENXIO;
+}
+
+size_t snd_output_buffer_string(snd_output_t *output, char **buf)
+{
+	return 0;
+}
diff --git a/src/pcm.h b/src/pcm.h
index bc7cbd0..cbe827d 100644
--- a/src/pcm.h
+++ b/src/pcm.h
@@ -22,96 +22,7 @@
 #ifndef __ALSA_PCM_H_INC
 #define __ALSA_PCM_H_INC
 
-#include "recipe.h"
-#include "global.h"
-#include "output.h"
-#include "pcm_types.h"
-
-int snd_pcm_open(snd_pcm_t **pcm, const char *name, 
-		 snd_pcm_stream_t stream, int mode);
-int snd_pcm_close(snd_pcm_t *pcm);
-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_hw_params_any(snd_pcm_t *pcm, snd_pcm_hw_params_t *params);
-int snd_pcm_hw_params_get_min_align(const snd_pcm_hw_params_t *params,
-				    snd_pcm_uframes_t *val);
-int snd_pcm_sw_params(snd_pcm_t *pcm, snd_pcm_sw_params_t *params);
-
-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_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_recover(snd_pcm_t *pcm, int err, int silent);
-
-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);
-
-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);	/* in bits */
-int snd_pcm_format_physical_width(snd_pcm_format_t format);	/* in bits */
-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);
-uint8_t snd_pcm_format_silence(snd_pcm_format_t format);
-uint16_t snd_pcm_format_silence_16(snd_pcm_format_t format);
-uint32_t snd_pcm_format_silence_32(snd_pcm_format_t format);
-uint64_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_format_t snd_pcm_format_value(const char* name);
-
-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);
-
-#if SALSA_HAS_ASYNC_SUPPORT
-int snd_async_add_pcm_handler(snd_async_handler_t **handler, snd_pcm_t *pcm, 
-			      snd_async_callback_t callback,
-			      void *private_data);
-#endif
+#include "pcm_func.h"
 
 #include "pcm_macros.h"
 
diff --git a/src/pcm_abi.c b/src/pcm_abi.c
new file mode 100644
index 0000000..e53eb6d
--- /dev/null
+++ b/src/pcm_abi.c
@@ -0,0 +1,5 @@
+#include "pcm_func.h"
+#undef __SALSA_EXPORT_FUNC
+#define __SALSA_EXPORT_FUNC
+#include "pcm_macros.h"
+
diff --git a/src/pcm_func.h b/src/pcm_func.h
new file mode 100644
index 0000000..6b8a00a
--- /dev/null
+++ b/src/pcm_func.h
@@ -0,0 +1,93 @@
+/*
+ */
+
+#include "recipe.h"
+#include "global.h"
+#include "output.h"
+#include "pcm_types.h"
+
+int snd_pcm_open(snd_pcm_t **pcm, const char *name, 
+		 snd_pcm_stream_t stream, int mode);
+int snd_pcm_close(snd_pcm_t *pcm);
+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_hw_params_any(snd_pcm_t *pcm, snd_pcm_hw_params_t *params);
+int snd_pcm_hw_params_get_min_align(const snd_pcm_hw_params_t *params,
+				    snd_pcm_uframes_t *val);
+int snd_pcm_sw_params(snd_pcm_t *pcm, snd_pcm_sw_params_t *params);
+
+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_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_recover(snd_pcm_t *pcm, int err, int silent);
+
+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);
+
+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);	/* in bits */
+int snd_pcm_format_physical_width(snd_pcm_format_t format);	/* in bits */
+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);
+uint8_t snd_pcm_format_silence(snd_pcm_format_t format);
+uint16_t snd_pcm_format_silence_16(snd_pcm_format_t format);
+uint32_t snd_pcm_format_silence_32(snd_pcm_format_t format);
+uint64_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_format_t snd_pcm_format_value(const char* name);
+
+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);
+
+#if SALSA_HAS_ASYNC_SUPPORT
+int snd_async_add_pcm_handler(snd_async_handler_t **handler, snd_pcm_t *pcm, 
+			      snd_async_callback_t callback,
+			      void *private_data);
+#endif
diff --git a/src/pcm_macros.h b/src/pcm_macros.h
index c2a9a06..04484ad 100644
--- a/src/pcm_macros.h
+++ b/src/pcm_macros.h
@@ -72,37 +72,37 @@ struct _snd_pcm {
  * Macros
  */
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_nonblock(snd_pcm_t *pcm, int nonblock)
 {
 	return _snd_set_nonblock(pcm->fd, nonblock);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 const char *snd_pcm_name(snd_pcm_t *pcm)
 {
 	return pcm->name;
 }
 	
-static inline
+__SALSA_EXPORT_FUNC
 snd_pcm_type_t snd_pcm_type(snd_pcm_t *pcm)
 {
 	return pcm->type;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 snd_pcm_stream_t snd_pcm_stream(snd_pcm_t *pcm)
 {
 	return pcm->stream;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_poll_descriptors_count(snd_pcm_t *pcm)
 {
 	return 1;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_poll_descriptors(snd_pcm_t *pcm, struct pollfd *pfds,
 			     unsigned int space)
 {
@@ -110,7 +110,7 @@ int snd_pcm_poll_descriptors(snd_pcm_t *pcm, struct pollfd *pfds,
 	return 1;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_poll_descriptors_revents(snd_pcm_t *pcm, struct pollfd *pfds,
 				     unsigned int nfds,
 				     unsigned short *revents)
@@ -119,7 +119,7 @@ int snd_pcm_poll_descriptors_revents(snd_pcm_t *pcm, struct pollfd *pfds,
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_info(snd_pcm_t *pcm, snd_pcm_info_t *info)
 {
 	if (ioctl(pcm->fd, SNDRV_PCM_IOCTL_INFO, info) < 0)
@@ -127,7 +127,7 @@ int snd_pcm_info(snd_pcm_t *pcm, snd_pcm_info_t *info)
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_current(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
 {
 	if (!pcm->setup)
@@ -136,7 +136,7 @@ int snd_pcm_hw_params_current(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
 	return 0;
 } 
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_status(snd_pcm_t *pcm, snd_pcm_status_t *status)
 {
 	if (ioctl(pcm->fd, SNDRV_PCM_IOCTL_STATUS, status) < 0)
@@ -144,7 +144,7 @@ int snd_pcm_status(snd_pcm_t *pcm, snd_pcm_status_t *status)
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int _snd_pcm_sync_ptr(snd_pcm_t *pcm, int flags)
 {
 	if (pcm->sync_ptr) {
@@ -156,7 +156,7 @@ int _snd_pcm_sync_ptr(snd_pcm_t *pcm, int flags)
 }
 
 
-static inline
+__SALSA_EXPORT_FUNC
 snd_pcm_state_t snd_pcm_state(snd_pcm_t *pcm)
 {
 	_snd_pcm_sync_ptr(pcm, SNDRV_PCM_SYNC_PTR_APPL);
@@ -164,7 +164,7 @@ snd_pcm_state_t snd_pcm_state(snd_pcm_t *pcm)
 }
 
 /* for internal use only */
-static inline
+__SALSA_EXPORT_FUNC
 int _snd_pcm_hwsync(snd_pcm_t *pcm)
 {
 	if (pcm->sync_ptr)
@@ -175,14 +175,14 @@ int _snd_pcm_hwsync(snd_pcm_t *pcm)
 }
 
 /* exported: snd_pcm_hwsync() is now deprecated */
-static inline
+__SALSA_EXPORT_FUNC
 __attribute__ ((deprecated))
 int snd_pcm_hwsync(snd_pcm_t *pcm)
 {
 	return _snd_pcm_hwsync(pcm);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 snd_pcm_sframes_t snd_pcm_avail(snd_pcm_t *pcm)
 {
 	int err = _snd_pcm_hwsync(pcm);
@@ -191,7 +191,7 @@ snd_pcm_sframes_t snd_pcm_avail(snd_pcm_t *pcm)
 	return snd_pcm_avail_update(pcm);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_delay(snd_pcm_t *pcm, snd_pcm_sframes_t *delayp)
 {
 	if (ioctl(pcm->fd, SNDRV_PCM_IOCTL_DELAY, delayp) < 0)
@@ -199,7 +199,7 @@ int snd_pcm_delay(snd_pcm_t *pcm, snd_pcm_sframes_t *delayp)
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_resume(snd_pcm_t *pcm)
 {
 	if (ioctl(pcm->fd, SNDRV_PCM_IOCTL_RESUME) < 0)
@@ -207,7 +207,7 @@ int snd_pcm_resume(snd_pcm_t *pcm)
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_prepare(snd_pcm_t *pcm)
 {
 	if (ioctl(pcm->fd, SNDRV_PCM_IOCTL_PREPARE) < 0)
@@ -215,7 +215,7 @@ int snd_pcm_prepare(snd_pcm_t *pcm)
 	return _snd_pcm_sync_ptr(pcm, SNDRV_PCM_SYNC_PTR_APPL);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_reset(snd_pcm_t *pcm)
 {
 	if (ioctl(pcm->fd, SNDRV_PCM_IOCTL_RESET) < 0)
@@ -223,7 +223,7 @@ int snd_pcm_reset(snd_pcm_t *pcm)
 	return _snd_pcm_sync_ptr(pcm, SNDRV_PCM_SYNC_PTR_APPL);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_start(snd_pcm_t *pcm)
 {
 	_snd_pcm_sync_ptr(pcm, 0);
@@ -232,7 +232,7 @@ int snd_pcm_start(snd_pcm_t *pcm)
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_drop(snd_pcm_t *pcm)
 {
 	if (ioctl(pcm->fd, SNDRV_PCM_IOCTL_DROP) < 0)
@@ -240,7 +240,7 @@ int snd_pcm_drop(snd_pcm_t *pcm)
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_drain(snd_pcm_t *pcm)
 {
 	if (ioctl(pcm->fd, SNDRV_PCM_IOCTL_DRAIN) < 0)
@@ -248,7 +248,7 @@ int snd_pcm_drain(snd_pcm_t *pcm)
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_pause(snd_pcm_t *pcm, int enable)
 {
 	if (ioctl(pcm->fd, SNDRV_PCM_IOCTL_PAUSE, enable) < 0)
@@ -256,7 +256,7 @@ int snd_pcm_pause(snd_pcm_t *pcm, int enable)
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 snd_pcm_sframes_t snd_pcm_rewind(snd_pcm_t *pcm, snd_pcm_uframes_t frames)
 {
 	if (frames == 0)
@@ -267,7 +267,7 @@ snd_pcm_sframes_t snd_pcm_rewind(snd_pcm_t *pcm, snd_pcm_uframes_t frames)
 	return frames;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 snd_pcm_sframes_t snd_pcm_forward(snd_pcm_t *pcm, snd_pcm_uframes_t frames)
 {
 	if (frames == 0)
@@ -278,7 +278,7 @@ snd_pcm_sframes_t snd_pcm_forward(snd_pcm_t *pcm, snd_pcm_uframes_t frames)
 	return frames;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_link(snd_pcm_t *pcm1, snd_pcm_t *pcm2)
 {
 	if (ioctl(pcm1->fd, SNDRV_PCM_IOCTL_LINK, pcm2->fd) < 0)
@@ -286,7 +286,7 @@ int snd_pcm_link(snd_pcm_t *pcm1, snd_pcm_t *pcm2)
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_unlink(snd_pcm_t *pcm)
 {
 	if (ioctl(pcm->fd, SNDRV_PCM_IOCTL_UNLINK) < 0)
@@ -305,102 +305,145 @@ extern const char *_snd_pcm_subformat_names[] ;
 extern const char *_snd_pcm_subformat_descriptions[];
 extern const char *_snd_pcm_tstamp_mode_names[];
 
-#define snd_pcm_stream_name(stream)	_snd_pcm_stream_names[stream]
-#define snd_pcm_access_name(acc)	_snd_pcm_access_names[acc]
-#define snd_pcm_format_name(format)	_snd_pcm_format_names[format]
-#define snd_pcm_format_description(format) _snd_pcm_format_descriptions[format]
-#define snd_pcm_subformat_name(subformat) _snd_pcm_subformat_names[subformat]
-#define snd_pcm_subformat_description(subformat) \
-	_snd_pcm_subformat_descriptions[subformat]
-#define snd_pcm_tstamp_mode_name(mode)	_snd_pcm_tstamp_mode_names[mode]
-#define snd_pcm_state_name(state)	_snd_pcm_state_names[state]
-#define snd_pcm_type_name(type)		_snd_pcm_type_names[type]
-
-static inline
+__SALSA_EXPORT_FUNC
+const char *snd_pcm_stream_name(snd_pcm_stream_t stream)
+{
+	return _snd_pcm_stream_names[stream];
+}
+
+__SALSA_EXPORT_FUNC
+const char *snd_pcm_access_name(snd_pcm_access_t acc)
+{
+	return _snd_pcm_access_names[acc];
+}
+
+__SALSA_EXPORT_FUNC
+const char *snd_pcm_format_name(snd_pcm_format_t format)
+{
+	return _snd_pcm_format_names[format];
+}
+
+__SALSA_EXPORT_FUNC
+const char * snd_pcm_format_description(snd_pcm_format_t format)
+{
+	return _snd_pcm_format_descriptions[format];
+}
+
+__SALSA_EXPORT_FUNC
+const char *snd_pcm_subformat_name(snd_pcm_subformat_t subformat)
+{
+	return _snd_pcm_subformat_names[subformat];
+}
+
+__SALSA_EXPORT_FUNC
+const char *snd_pcm_subformat_description(snd_pcm_subformat_t subformat)
+{
+	return _snd_pcm_subformat_descriptions[subformat];
+}
+
+__SALSA_EXPORT_FUNC
+const char *snd_pcm_tstamp_mode_name(snd_pcm_tstamp_t mode)
+{
+	return _snd_pcm_tstamp_mode_names[mode];
+}
+
+__SALSA_EXPORT_FUNC
+const char *snd_pcm_state_name(snd_pcm_state_t state)
+{
+	return _snd_pcm_state_names[state];
+}
+
+__SALSA_EXPORT_FUNC
+const char *snd_pcm_type_name(snd_pcm_type_t type)
+{
+	return _snd_pcm_type_names[type];
+}
+
+__SALSA_EXPORT_FUNC
 snd_pcm_sframes_t snd_pcm_bytes_to_frames(snd_pcm_t *pcm, ssize_t bytes)
 {
 	return bytes * 8 / pcm->frame_bits;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 ssize_t snd_pcm_frames_to_bytes(snd_pcm_t *pcm, snd_pcm_sframes_t frames)
 {
 	return frames * pcm->frame_bits / 8;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 long snd_pcm_bytes_to_samples(snd_pcm_t *pcm, ssize_t bytes)
 {
 	return bytes * 8 / pcm->sample_bits;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 ssize_t snd_pcm_samples_to_bytes(snd_pcm_t *pcm, long samples)
 {
 	return samples * pcm->sample_bits / 8;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_can_mmap_sample_resolution(const snd_pcm_hw_params_t *params)
 {
 	return !!(params->info & SNDRV_PCM_INFO_MMAP_VALID);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_is_double(const snd_pcm_hw_params_t *params)
 {
 	return !!(params->info & SNDRV_PCM_INFO_DOUBLE);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_is_batch(const snd_pcm_hw_params_t *params)
 {
 	return !!(params->info & SNDRV_PCM_INFO_BATCH);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_is_block_transfer(const snd_pcm_hw_params_t *params)
 {
 	return !!(params->info & SNDRV_PCM_INFO_BLOCK_TRANSFER);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_can_overrange(const snd_pcm_hw_params_t *params)
 {
 	return !!(params->info & SNDRV_PCM_INFO_OVERRANGE);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_can_pause(const snd_pcm_hw_params_t *params)
 {
 	return !!(params->info & SNDRV_PCM_INFO_PAUSE);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_can_resume(const snd_pcm_hw_params_t *params)
 {
 	return !!(params->info & SNDRV_PCM_INFO_RESUME);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_is_half_duplex(const snd_pcm_hw_params_t *params)
 {
 	return !!(params->info & SNDRV_PCM_INFO_HALF_DUPLEX);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_is_joint_duplex(const snd_pcm_hw_params_t *params)
 {
 	return !!(params->info & SNDRV_PCM_INFO_JOINT_DUPLEX);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_can_sync_start(const snd_pcm_hw_params_t *params)
 {
 	return !!(params->info & SNDRV_PCM_INFO_SYNC_START);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_get_rate_numden(const snd_pcm_hw_params_t *params,
 				      unsigned int *rate_num,
 				      unsigned int *rate_den)
@@ -410,13 +453,13 @@ int snd_pcm_hw_params_get_rate_numden(const snd_pcm_hw_params_t *params,
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_get_sbits(const snd_pcm_hw_params_t *params)
 {
 	return params->msbits;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_get_fifo_size(const snd_pcm_hw_params_t *params)
 {
 	return params->fifo_size;
@@ -459,31 +502,31 @@ extern int _snd_pcm_hw_param_set_last(snd_pcm_t *pcm, snd_pcm_hw_params_t *param
 #define MASK_OFS(i)	((i) >> 5)
 #define MASK_BIT(i)	(1U << ((i) & 31))
 
-static inline
+__SALSA_EXPORT_FUNC
 void _snd_mask_none(snd_mask_t *mask)
 {
 	memset(mask, 0, sizeof(*mask));
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void _snd_mask_any(snd_mask_t *mask)
 {
 	memset(mask, 0xff, sizeof(*mask));
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void _snd_mask_set(snd_mask_t *mask, unsigned int val)
 {
 	mask->bits[MASK_OFS(val)] |= MASK_BIT(val);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void _snd_mask_reset(snd_mask_t *mask, unsigned int val)
 {
 	mask->bits[MASK_OFS(val)] &= ~MASK_BIT(val);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int _snd_mask_test(const snd_mask_t *mask, unsigned int val)
 {
 	return mask->bits[MASK_OFS(val)] & MASK_BIT(val);
@@ -491,7 +534,7 @@ int _snd_mask_test(const snd_mask_t *mask, unsigned int val)
 
 #define SND_MASK_MAX	SNDRV_MASK_MAX
 
-static inline
+__SALSA_EXPORT_FUNC
 int _snd_mask_empty(const snd_mask_t *mask)
 {
 	int i;
@@ -508,7 +551,7 @@ int _snd_mask_empty(const snd_mask_t *mask)
 #if __WORDSIZE == 64
 
 #define DEFINE_GET64(name) \
-static inline \
+__SALSA_EXPORT_FUNC \
 int __snd_pcm_hw_param_ ## name ##64\
 (const snd_pcm_hw_params_t *params, int type, unsigned long *val, int *dir)\
 {\
@@ -529,7 +572,7 @@ DEFINE_GET64(get_max);
 	__snd_pcm_hw_param_get_max64(params, type, (unsigned long *)(ptr), dir)
 
 #define DEFINE_SET64(name) \
-static inline \
+__SALSA_EXPORT_FUNC \
 int __snd_pcm_hw_param_ ## name ## 64(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,\
 				    int type, unsigned long *val, int *dir)\
 {\
@@ -554,7 +597,7 @@ DEFINE_SET64(set_last);
 #define _snd_pcm_hw_param_set_last64(pcm, params, type, ptr, dir) \
 	__snd_pcm_hw_param_set_last64(pcm, params, type, (unsigned long *)(ptr), dir)
 
-static inline
+__SALSA_EXPORT_FUNC
 int __snd_pcm_hw_param_set_minmax64(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 				   int type,
 				   unsigned long *minval, int *mindir,
@@ -602,37 +645,37 @@ int __snd_pcm_hw_param_set_minmax64(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 
 __snd_define_type(snd_pcm_access_mask);
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_pcm_access_mask_none(snd_pcm_access_mask_t *mask)
 {
 	_snd_mask_none((snd_mask_t *) mask);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_pcm_access_mask_any(snd_pcm_access_mask_t *mask)
 {
 	_snd_mask_any((snd_mask_t *) mask);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_access_mask_test(const snd_pcm_access_mask_t *mask, snd_pcm_access_t val)
 {
 	return _snd_mask_test((const snd_mask_t *) mask, (unsigned long) val);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_access_mask_empty(const snd_pcm_access_mask_t *mask)
 {
 	return _snd_mask_empty((const snd_mask_t *) mask);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_pcm_access_mask_set(snd_pcm_access_mask_t *mask, snd_pcm_access_t val)
 {
 	_snd_mask_set((snd_mask_t *) mask, (unsigned long) val);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_pcm_access_mask_reset(snd_pcm_access_mask_t *mask, snd_pcm_access_t val)
 {
 	_snd_mask_reset((snd_mask_t *) mask, (unsigned long) val);
@@ -640,37 +683,37 @@ void snd_pcm_access_mask_reset(snd_pcm_access_mask_t *mask, snd_pcm_access_t val
 
 __snd_define_type(snd_pcm_format_mask);
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_pcm_format_mask_none(snd_pcm_format_mask_t *mask)
 {
 	_snd_mask_none((snd_mask_t *) mask);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_pcm_format_mask_any(snd_pcm_format_mask_t *mask)
 {
 	_snd_mask_any((snd_mask_t *) mask);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_format_mask_test(const snd_pcm_format_mask_t *mask, snd_pcm_format_t val)
 {
 	return _snd_mask_test((const snd_mask_t *) mask, (unsigned long) val);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_format_mask_empty(const snd_pcm_format_mask_t *mask)
 {
 	return _snd_mask_empty((const snd_mask_t *) mask);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_pcm_format_mask_set(snd_pcm_format_mask_t *mask, snd_pcm_format_t val)
 {
 	_snd_mask_set((snd_mask_t *) mask, (unsigned long) val);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_pcm_format_mask_reset(snd_pcm_format_mask_t *mask, snd_pcm_format_t val)
 {
 	_snd_mask_reset((snd_mask_t *) mask, (unsigned long) val);
@@ -679,39 +722,39 @@ void snd_pcm_format_mask_reset(snd_pcm_format_mask_t *mask, snd_pcm_format_t val
 
 __snd_define_type(snd_pcm_subformat_mask);
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_pcm_subformat_mask_none(snd_pcm_subformat_mask_t *mask)
 {
 	_snd_mask_none((snd_mask_t *) mask);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_pcm_subformat_mask_any(snd_pcm_subformat_mask_t *mask)
 {
 	_snd_mask_any((snd_mask_t *) mask);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_subformat_mask_test(const snd_pcm_subformat_mask_t *mask,
 				snd_pcm_subformat_t val)
 {
 	return _snd_mask_test((const snd_mask_t *) mask, (unsigned long) val);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_subformat_mask_empty(const snd_pcm_subformat_mask_t *mask)
 {
 	return _snd_mask_empty((const snd_mask_t *) mask);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_pcm_subformat_mask_set(snd_pcm_subformat_mask_t *mask,
 				snd_pcm_subformat_t val)
 {
 	_snd_mask_set((snd_mask_t *) mask, (unsigned long) val);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_pcm_subformat_mask_reset(snd_pcm_subformat_mask_t *mask,
 				  snd_pcm_subformat_t val)
 {
@@ -721,7 +764,7 @@ void snd_pcm_subformat_mask_reset(snd_pcm_subformat_mask_t *mask,
 
 __snd_define_type(snd_pcm_hw_params);
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_get_access(const snd_pcm_hw_params_t *params,
 				 snd_pcm_access_t *access)
 {
@@ -729,7 +772,7 @@ int snd_pcm_hw_params_get_access(const snd_pcm_hw_params_t *params,
 				    (unsigned int *)access, NULL);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_test_access(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 				  snd_pcm_access_t access)
 {
@@ -737,7 +780,7 @@ int snd_pcm_hw_params_test_access(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 				      access, NULL);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_access(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 				 snd_pcm_access_t access)
 {
@@ -745,7 +788,7 @@ int snd_pcm_hw_params_set_access(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 				    access, 0);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_access_first(snd_pcm_t *pcm,
 				       snd_pcm_hw_params_t *params,
 				       snd_pcm_access_t *access)
@@ -755,7 +798,7 @@ int snd_pcm_hw_params_set_access_first(snd_pcm_t *pcm,
 					   (unsigned int *)access, NULL);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_access_last(snd_pcm_t *pcm,
 				      snd_pcm_hw_params_t *params,
 				      snd_pcm_access_t *access)
@@ -765,7 +808,7 @@ int snd_pcm_hw_params_set_access_last(snd_pcm_t *pcm,
 					  (unsigned int *)access, NULL);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_access_mask(snd_pcm_t *pcm,
 				      snd_pcm_hw_params_t *params,
 				      snd_pcm_access_mask_t *mask)
@@ -775,7 +818,7 @@ int snd_pcm_hw_params_set_access_mask(snd_pcm_t *pcm,
 					 (snd_mask_t *) mask);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_get_access_mask(snd_pcm_hw_params_t *params,
 				      snd_pcm_access_mask_t *mask)
 {
@@ -786,7 +829,7 @@ int snd_pcm_hw_params_get_access_mask(snd_pcm_hw_params_t *params,
 }
 
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_get_format(const snd_pcm_hw_params_t *params,
 				 snd_pcm_format_t *format)
 {
@@ -794,7 +837,7 @@ int snd_pcm_hw_params_get_format(const snd_pcm_hw_params_t *params,
 				    (unsigned int *)format, NULL);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_test_format(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 				  snd_pcm_format_t format)
 {
@@ -802,7 +845,7 @@ int snd_pcm_hw_params_test_format(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 				      format, NULL);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_format(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 				 snd_pcm_format_t format)
 {
@@ -810,7 +853,7 @@ int snd_pcm_hw_params_set_format(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 				    format, 0);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_format_first(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 				       snd_pcm_format_t *format)
 {
@@ -818,7 +861,7 @@ int snd_pcm_hw_params_set_format_first(snd_pcm_t *pcm, snd_pcm_hw_params_t *para
 					  (unsigned int *)format, NULL);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_format_last(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 				      snd_pcm_format_t *format)
 {
@@ -826,7 +869,7 @@ int snd_pcm_hw_params_set_format_last(snd_pcm_t *pcm, snd_pcm_hw_params_t *param
 					 (unsigned int *)format, NULL);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_format_mask(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 				      snd_pcm_format_mask_t *mask)
 {
@@ -834,7 +877,7 @@ int snd_pcm_hw_params_set_format_mask(snd_pcm_t *pcm, snd_pcm_hw_params_t *param
 					 (snd_mask_t *) mask);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_pcm_hw_params_get_format_mask(snd_pcm_hw_params_t *params,
 				       snd_pcm_format_mask_t *mask)
 {
@@ -842,7 +885,7 @@ void snd_pcm_hw_params_get_format_mask(snd_pcm_hw_params_t *params,
 }
 
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_get_subformat(const snd_pcm_hw_params_t *params,
 				    snd_pcm_subformat_t *subformat)
 {
@@ -850,7 +893,7 @@ int snd_pcm_hw_params_get_subformat(const snd_pcm_hw_params_t *params,
 				     (unsigned int *)subformat, NULL);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_test_subformat(snd_pcm_t *pcm,
 				     snd_pcm_hw_params_t *params,
 				     snd_pcm_subformat_t subformat)
@@ -859,7 +902,7 @@ int snd_pcm_hw_params_test_subformat(snd_pcm_t *pcm,
 				      subformat, NULL);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_subformat(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 				    snd_pcm_subformat_t subformat)
 {
@@ -867,7 +910,7 @@ int snd_pcm_hw_params_set_subformat(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 				     subformat, 0);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_subformat_first(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 					  snd_pcm_subformat_t *subformat)
 {
@@ -876,7 +919,7 @@ int snd_pcm_hw_params_set_subformat_first(snd_pcm_t *pcm, snd_pcm_hw_params_t *p
 					   (unsigned int *)subformat, NULL);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_subformat_last(snd_pcm_t *pcm,
 					 snd_pcm_hw_params_t *params,
 					 snd_pcm_subformat_t *subformat)
@@ -886,7 +929,7 @@ int snd_pcm_hw_params_set_subformat_last(snd_pcm_t *pcm,
 					  (unsigned int *)subformat, NULL);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_subformat_mask(snd_pcm_t *pcm,
 					 snd_pcm_hw_params_t *params,
 					 snd_pcm_subformat_mask_t *mask)
@@ -896,7 +939,7 @@ int snd_pcm_hw_params_set_subformat_mask(snd_pcm_t *pcm,
 					  (snd_mask_t *) mask);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_pcm_hw_params_get_subformat_mask(snd_pcm_hw_params_t *params,
 					  snd_pcm_subformat_mask_t *mask)
 {
@@ -904,28 +947,28 @@ void snd_pcm_hw_params_get_subformat_mask(snd_pcm_hw_params_t *params,
 }
 
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_get_channels(const snd_pcm_hw_params_t *params,
 				   unsigned int *val)
 {
 	return _snd_pcm_hw_param_get(params, SNDRV_PCM_HW_PARAM_CHANNELS, val, NULL);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_get_channels_min(const snd_pcm_hw_params_t *params,
 				       unsigned int *val)
 {
 	return _snd_pcm_hw_param_get_min(params, SNDRV_PCM_HW_PARAM_CHANNELS, val, NULL);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_get_channels_max(const snd_pcm_hw_params_t *params,
 				       unsigned int *val)
 {
 	return _snd_pcm_hw_param_get_max(params, SNDRV_PCM_HW_PARAM_CHANNELS, val, NULL);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_test_channels(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 				    unsigned int val)
 {
@@ -933,7 +976,7 @@ int snd_pcm_hw_params_test_channels(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 				      SNDRV_PCM_HW_PARAM_CHANNELS, val, NULL);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_channels(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 				   unsigned int val)
 {
@@ -941,7 +984,7 @@ int snd_pcm_hw_params_set_channels(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 				    SNDRV_PCM_HW_PARAM_CHANNELS, val, 0);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_channels_min(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 				       unsigned int *val)
 {
@@ -949,7 +992,7 @@ int snd_pcm_hw_params_set_channels_min(snd_pcm_t *pcm, snd_pcm_hw_params_t *para
 					val, NULL);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_channels_max(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 				       unsigned int *val)
 {
@@ -957,7 +1000,7 @@ int snd_pcm_hw_params_set_channels_max(snd_pcm_t *pcm, snd_pcm_hw_params_t *para
 					val, NULL);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_channels_minmax(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 					  unsigned int *min, unsigned int *max)
 {
@@ -965,7 +1008,7 @@ int snd_pcm_hw_params_set_channels_minmax(snd_pcm_t *pcm, snd_pcm_hw_params_t *p
 					   min, NULL, max, NULL);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_channels_near(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 					unsigned int *val)
 {
@@ -973,7 +1016,7 @@ int snd_pcm_hw_params_set_channels_near(snd_pcm_t *pcm, snd_pcm_hw_params_t *par
 					 val, NULL);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_channels_first(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 					 unsigned int *val)
 {
@@ -981,7 +1024,7 @@ int snd_pcm_hw_params_set_channels_first(snd_pcm_t *pcm, snd_pcm_hw_params_t *pa
 					  val, NULL);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_channels_last(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 					unsigned int *val)
 {
@@ -990,28 +1033,28 @@ int snd_pcm_hw_params_set_channels_last(snd_pcm_t *pcm, snd_pcm_hw_params_t *par
 }
 
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_get_rate(const snd_pcm_hw_params_t *params, unsigned int *val,
 			       int *dir)
 {
 	return _snd_pcm_hw_param_get(params, SNDRV_PCM_HW_PARAM_RATE, val, dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_get_rate_min(const snd_pcm_hw_params_t *params,
 				   unsigned int *val, int *dir)
 {
 	return _snd_pcm_hw_param_get_min(params, SNDRV_PCM_HW_PARAM_RATE, val, dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_get_rate_max(const snd_pcm_hw_params_t *params,
 				   unsigned int *val, int *dir)
 {
 	return _snd_pcm_hw_param_get_max(params, SNDRV_PCM_HW_PARAM_RATE, val, dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_test_rate(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 				unsigned int val, int dir)
 {
@@ -1019,7 +1062,7 @@ int snd_pcm_hw_params_test_rate(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 				      val, &dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_rate(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 			       unsigned int val, int dir)
 {
@@ -1027,7 +1070,7 @@ int snd_pcm_hw_params_set_rate(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 				    val, dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_rate_min(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 				   unsigned int *val, int *dir)
 {
@@ -1035,7 +1078,7 @@ int snd_pcm_hw_params_set_rate_min(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 					val, dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_rate_max(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 				   unsigned int *val, int *dir)
 {
@@ -1043,7 +1086,7 @@ int snd_pcm_hw_params_set_rate_max(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 					val, dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 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)
@@ -1052,14 +1095,14 @@ int snd_pcm_hw_params_set_rate_minmax(snd_pcm_t *pcm, snd_pcm_hw_params_t *param
 					   min, mindir, max, maxdir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_rate_near(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 				    unsigned int *val, int *dir)
 {
 	return _snd_pcm_hw_param_set_near(pcm, params, SNDRV_PCM_HW_PARAM_RATE, val, dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_rate_first(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 				     unsigned int *val, int *dir)
 {
@@ -1067,49 +1110,49 @@ int snd_pcm_hw_params_set_rate_first(snd_pcm_t *pcm, snd_pcm_hw_params_t *params
 					  val, dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_rate_last(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 				    unsigned int *val, int *dir)
 {
 	return _snd_pcm_hw_param_set_last(pcm, params, SNDRV_PCM_HW_PARAM_RATE, val, dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_rate_resample(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 					unsigned int val)
 {
 	return val ? -EINVAL : 0;  /* don't support plug layer */
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_get_rate_resample(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 					unsigned int *val)
 {
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_export_buffer(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 					unsigned int val)
 {
 	return -EINVAL;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_get_export_buffer(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 					unsigned int *val)
 {
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_get_period_time(const snd_pcm_hw_params_t *params,
 				      unsigned int *val, int *dir)
 {
 	return _snd_pcm_hw_param_get(params, SNDRV_PCM_HW_PARAM_PERIOD_TIME, val, dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_get_period_time_min(const snd_pcm_hw_params_t *params,
 					  unsigned int *val, int *dir)
 {
@@ -1117,7 +1160,7 @@ int snd_pcm_hw_params_get_period_time_min(const snd_pcm_hw_params_t *params,
 					val, dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_get_period_time_max(const snd_pcm_hw_params_t *params,
 					  unsigned int *val, int *dir)
 {
@@ -1125,7 +1168,7 @@ int snd_pcm_hw_params_get_period_time_max(const snd_pcm_hw_params_t *params,
 					val, dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_test_period_time(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 				       unsigned int val, int dir)
 {
@@ -1133,7 +1176,7 @@ int snd_pcm_hw_params_test_period_time(snd_pcm_t *pcm, snd_pcm_hw_params_t *para
 				      SNDRV_PCM_HW_PARAM_PERIOD_TIME, val, &dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_period_time(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 				      unsigned int val, int dir)
 {
@@ -1142,7 +1185,7 @@ int snd_pcm_hw_params_set_period_time(snd_pcm_t *pcm, snd_pcm_hw_params_t *param
 }
 
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_period_time_min(snd_pcm_t *pcm,
 					  snd_pcm_hw_params_t *params,
 					  unsigned int *val, int *dir)
@@ -1151,7 +1194,7 @@ int snd_pcm_hw_params_set_period_time_min(snd_pcm_t *pcm,
 					val, dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_period_time_max(snd_pcm_t *pcm,
 					  snd_pcm_hw_params_t *params,
 					  unsigned int *val, int *dir)
@@ -1160,7 +1203,7 @@ int snd_pcm_hw_params_set_period_time_max(snd_pcm_t *pcm,
 					val, dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_period_time_minmax(snd_pcm_t *pcm,
 					     snd_pcm_hw_params_t *params,
 					     unsigned int *min, int *mindir,
@@ -1170,7 +1213,7 @@ int snd_pcm_hw_params_set_period_time_minmax(snd_pcm_t *pcm,
 					   min, mindir, max, maxdir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_period_time_near(snd_pcm_t *pcm,
 					   snd_pcm_hw_params_t *params,
 					   unsigned int *val, int *dir)
@@ -1179,7 +1222,7 @@ int snd_pcm_hw_params_set_period_time_near(snd_pcm_t *pcm,
 					 val, dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_period_time_first(snd_pcm_t *pcm,
 					    snd_pcm_hw_params_t *params,
 					    unsigned int *val, int *dir)
@@ -1188,7 +1231,7 @@ int snd_pcm_hw_params_set_period_time_first(snd_pcm_t *pcm,
 					  val, dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_period_time_last(snd_pcm_t *pcm,
 					   snd_pcm_hw_params_t *params,
 					   unsigned int *val, int *dir)
@@ -1198,7 +1241,7 @@ int snd_pcm_hw_params_set_period_time_last(snd_pcm_t *pcm,
 }
 
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_get_period_size(const snd_pcm_hw_params_t *params,
 				      snd_pcm_uframes_t *val, int *dir)
 {
@@ -1206,7 +1249,7 @@ int snd_pcm_hw_params_get_period_size(const snd_pcm_hw_params_t *params,
 				      val, dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_get_period_size_min(const snd_pcm_hw_params_t *params,
 					  snd_pcm_uframes_t *val, int *dir)
 {
@@ -1214,7 +1257,7 @@ int snd_pcm_hw_params_get_period_size_min(const snd_pcm_hw_params_t *params,
 					  val, dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_get_period_size_max(const snd_pcm_hw_params_t *params,
 					  snd_pcm_uframes_t *val, int *dir)
 {
@@ -1222,7 +1265,7 @@ int snd_pcm_hw_params_get_period_size_max(const snd_pcm_hw_params_t *params,
 					   val, dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 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)
 {
@@ -1230,7 +1273,7 @@ int snd_pcm_hw_params_test_period_size(snd_pcm_t *pcm, snd_pcm_hw_params_t *para
 				      SNDRV_PCM_HW_PARAM_PERIOD_SIZE, val, &dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 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)
 {
@@ -1238,7 +1281,7 @@ int snd_pcm_hw_params_set_period_size(snd_pcm_t *pcm, snd_pcm_hw_params_t *param
 				    SNDRV_PCM_HW_PARAM_PERIOD_SIZE, val, dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 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)
 {
@@ -1246,7 +1289,7 @@ int snd_pcm_hw_params_set_period_size_min(snd_pcm_t *pcm, snd_pcm_hw_params_t *p
 					  val, dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 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)
 {
@@ -1254,7 +1297,7 @@ int snd_pcm_hw_params_set_period_size_max(snd_pcm_t *pcm, snd_pcm_hw_params_t *p
 					val, dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 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,
@@ -1264,7 +1307,7 @@ int snd_pcm_hw_params_set_period_size_minmax(snd_pcm_t *pcm,
 					     min, mindir, max, maxdir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 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)
@@ -1273,7 +1316,7 @@ int snd_pcm_hw_params_set_period_size_near(snd_pcm_t *pcm,
 					   val, dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 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)
@@ -1282,7 +1325,7 @@ int snd_pcm_hw_params_set_period_size_first(snd_pcm_t *pcm,
 					    val, dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 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)
@@ -1291,7 +1334,7 @@ int snd_pcm_hw_params_set_period_size_last(snd_pcm_t *pcm,
 					   val, dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_period_size_integer(snd_pcm_t *pcm,
 					      snd_pcm_hw_params_t *params)
 {
@@ -1300,28 +1343,28 @@ int snd_pcm_hw_params_set_period_size_integer(snd_pcm_t *pcm,
 }
 
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_get_periods(const snd_pcm_hw_params_t *params,
 				  unsigned int *val, int *dir)
 {
 	return _snd_pcm_hw_param_get(params, SNDRV_PCM_HW_PARAM_PERIODS, val, dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_get_periods_min(const snd_pcm_hw_params_t *params,
 				      unsigned int *val, int *dir)
 {
 	return _snd_pcm_hw_param_get_min(params, SNDRV_PCM_HW_PARAM_PERIODS, val, dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_get_periods_max(const snd_pcm_hw_params_t *params,
 				      unsigned int *val, int *dir)
 {
 	return _snd_pcm_hw_param_get_max(params, SNDRV_PCM_HW_PARAM_PERIODS, val, dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_test_periods(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 				   unsigned int val, int dir)
 {
@@ -1329,7 +1372,7 @@ int snd_pcm_hw_params_test_periods(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 				      SNDRV_PCM_HW_PARAM_PERIODS, val, &dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_periods(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 				  unsigned int val, int dir)
 {
@@ -1337,7 +1380,7 @@ int snd_pcm_hw_params_set_periods(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 				    SNDRV_PCM_HW_PARAM_PERIODS, val, dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_periods_min(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 				      unsigned int *val, int *dir)
 {
@@ -1345,7 +1388,7 @@ int snd_pcm_hw_params_set_periods_min(snd_pcm_t *pcm, snd_pcm_hw_params_t *param
 					SNDRV_PCM_HW_PARAM_PERIODS, val, dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_periods_max(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 				      unsigned int *val, int *dir)
 {
@@ -1354,7 +1397,7 @@ int snd_pcm_hw_params_set_periods_max(snd_pcm_t *pcm, snd_pcm_hw_params_t *param
 }
 
 
-static inline
+__SALSA_EXPORT_FUNC
 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)
@@ -1364,7 +1407,7 @@ int snd_pcm_hw_params_set_periods_minmax(snd_pcm_t *pcm, snd_pcm_hw_params_t *pa
 					   min, mindir, max, maxdir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_periods_near(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 				       unsigned int *val, int *dir)
 {
@@ -1372,7 +1415,7 @@ int snd_pcm_hw_params_set_periods_near(snd_pcm_t *pcm, snd_pcm_hw_params_t *para
 					 val, dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_periods_first(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 					unsigned int *val, int *dir)
 {
@@ -1380,7 +1423,7 @@ int snd_pcm_hw_params_set_periods_first(snd_pcm_t *pcm, snd_pcm_hw_params_t *par
 					  val, dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_periods_last(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 				       unsigned int *val, int *dir)
 {
@@ -1388,7 +1431,7 @@ int snd_pcm_hw_params_set_periods_last(snd_pcm_t *pcm, snd_pcm_hw_params_t *para
 					 val, dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_periods_integer(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
 {
 	return _snd_pcm_hw_param_set_integer(pcm, params,
@@ -1396,14 +1439,14 @@ int snd_pcm_hw_params_set_periods_integer(snd_pcm_t *pcm, snd_pcm_hw_params_t *p
 }
 
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_get_buffer_time(const snd_pcm_hw_params_t *params,
 				      unsigned int *val, int *dir)
 {
 	return _snd_pcm_hw_param_get(params, SNDRV_PCM_HW_PARAM_BUFFER_TIME, val, dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_get_buffer_time_min(const snd_pcm_hw_params_t *params,
 					  unsigned int *val, int *dir)
 {
@@ -1411,7 +1454,7 @@ int snd_pcm_hw_params_get_buffer_time_min(const snd_pcm_hw_params_t *params,
 					val, dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_get_buffer_time_max(const snd_pcm_hw_params_t *params,
 					  unsigned int *val, int *dir)
 {
@@ -1419,7 +1462,7 @@ int snd_pcm_hw_params_get_buffer_time_max(const snd_pcm_hw_params_t *params,
 					val, dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_test_buffer_time(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 				       unsigned int val, int dir)
 {
@@ -1427,7 +1470,7 @@ int snd_pcm_hw_params_test_buffer_time(snd_pcm_t *pcm, snd_pcm_hw_params_t *para
 				      SNDRV_PCM_HW_PARAM_BUFFER_TIME, val, &dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_buffer_time(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 				      unsigned int val, int dir)
 {
@@ -1435,7 +1478,7 @@ int snd_pcm_hw_params_set_buffer_time(snd_pcm_t *pcm, snd_pcm_hw_params_t *param
 				    SNDRV_PCM_HW_PARAM_BUFFER_TIME, val, dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_buffer_time_min(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 					  unsigned int *val, int *dir)
 {
@@ -1443,7 +1486,7 @@ int snd_pcm_hw_params_set_buffer_time_min(snd_pcm_t *pcm, snd_pcm_hw_params_t *p
 					SNDRV_PCM_HW_PARAM_BUFFER_TIME, val, dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_buffer_time_max(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 					  unsigned int *val, int *dir)
 {
@@ -1451,7 +1494,7 @@ int snd_pcm_hw_params_set_buffer_time_max(snd_pcm_t *pcm, snd_pcm_hw_params_t *p
 					SNDRV_PCM_HW_PARAM_BUFFER_TIME, val, dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_buffer_time_minmax(snd_pcm_t *pcm,
 					     snd_pcm_hw_params_t *params,
 					     unsigned int *min, int *mindir,
@@ -1462,7 +1505,7 @@ int snd_pcm_hw_params_set_buffer_time_minmax(snd_pcm_t *pcm,
 					   min, mindir, max, maxdir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_buffer_time_near(snd_pcm_t *pcm,
 					   snd_pcm_hw_params_t *params,
 					   unsigned int *val, int *dir)
@@ -1471,7 +1514,7 @@ int snd_pcm_hw_params_set_buffer_time_near(snd_pcm_t *pcm,
 					 val, dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_buffer_time_first(snd_pcm_t *pcm,
 					    snd_pcm_hw_params_t *params,
 					    unsigned int *val, int *dir)
@@ -1480,7 +1523,7 @@ int snd_pcm_hw_params_set_buffer_time_first(snd_pcm_t *pcm,
 					  val, dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_buffer_time_last(snd_pcm_t *pcm,
 					   snd_pcm_hw_params_t *params,
 					   unsigned int *val, int *dir)
@@ -1490,7 +1533,7 @@ int snd_pcm_hw_params_set_buffer_time_last(snd_pcm_t *pcm,
 }
 
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_get_buffer_size(const snd_pcm_hw_params_t *params,
 				      snd_pcm_uframes_t *val)
 {
@@ -1498,7 +1541,7 @@ int snd_pcm_hw_params_get_buffer_size(const snd_pcm_hw_params_t *params,
 				      val, NULL);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_get_buffer_size_min(const snd_pcm_hw_params_t *params,
 					  snd_pcm_uframes_t *val)
 {
@@ -1506,7 +1549,7 @@ int snd_pcm_hw_params_get_buffer_size_min(const snd_pcm_hw_params_t *params,
 					  val, NULL);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_get_buffer_size_max(const snd_pcm_hw_params_t *params,
 					  snd_pcm_uframes_t *val)
 {
@@ -1514,7 +1557,7 @@ int snd_pcm_hw_params_get_buffer_size_max(const snd_pcm_hw_params_t *params,
 					  val, NULL);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_test_buffer_size(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 				       snd_pcm_uframes_t val)
 {
@@ -1522,7 +1565,7 @@ int snd_pcm_hw_params_test_buffer_size(snd_pcm_t *pcm, snd_pcm_hw_params_t *para
 				      SNDRV_PCM_HW_PARAM_BUFFER_SIZE, val, 0);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_buffer_size(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 				      snd_pcm_uframes_t val)
 {
@@ -1530,7 +1573,7 @@ int snd_pcm_hw_params_set_buffer_size(snd_pcm_t *pcm, snd_pcm_hw_params_t *param
 				    SNDRV_PCM_HW_PARAM_BUFFER_SIZE, val, 0);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_buffer_size_min(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 					  snd_pcm_uframes_t *val)
 {
@@ -1538,7 +1581,7 @@ int snd_pcm_hw_params_set_buffer_size_min(snd_pcm_t *pcm, snd_pcm_hw_params_t *p
 					  val, NULL);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_buffer_size_max(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 					  snd_pcm_uframes_t *val)
 {
@@ -1546,7 +1589,7 @@ int snd_pcm_hw_params_set_buffer_size_max(snd_pcm_t *pcm, snd_pcm_hw_params_t *p
 					  val, NULL);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_buffer_size_minmax64(snd_pcm_t *pcm,
 					       snd_pcm_hw_params_t *params,
 					       snd_pcm_uframes_t *min,
@@ -1557,7 +1600,7 @@ int snd_pcm_hw_params_set_buffer_size_minmax64(snd_pcm_t *pcm,
 					     min, NULL, max, NULL);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_buffer_size_near(snd_pcm_t *pcm,
 					   snd_pcm_hw_params_t *params,
 					   snd_pcm_uframes_t *val)
@@ -1566,7 +1609,7 @@ int snd_pcm_hw_params_set_buffer_size_near(snd_pcm_t *pcm,
 					   val, NULL);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_buffer_size_first(snd_pcm_t *pcm,
 					    snd_pcm_hw_params_t *params,
 					    snd_pcm_uframes_t *val)
@@ -1575,7 +1618,7 @@ int snd_pcm_hw_params_set_buffer_size_first(snd_pcm_t *pcm,
 					    val, NULL);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_hw_params_set_buffer_size_last(snd_pcm_t *pcm,
 					   snd_pcm_hw_params_t *params,
 					   snd_pcm_uframes_t *val)
@@ -1585,7 +1628,7 @@ int snd_pcm_hw_params_set_buffer_size_last(snd_pcm_t *pcm,
 }
 
 
-static inline
+__SALSA_EXPORT_FUNC
 __attribute__ ((deprecated))
 int snd_pcm_hw_params_get_tick_time(const snd_pcm_hw_params_t *params,
 				    unsigned int *val, int *dir)
@@ -1593,7 +1636,7 @@ int snd_pcm_hw_params_get_tick_time(const snd_pcm_hw_params_t *params,
 	return _snd_pcm_hw_param_get(params, SNDRV_PCM_HW_PARAM_TICK_TIME, val, dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 __attribute__ ((deprecated))
 int snd_pcm_hw_params_get_tick_time_min(const snd_pcm_hw_params_t *params,
 					unsigned int *val, int *dir)
@@ -1601,7 +1644,7 @@ int snd_pcm_hw_params_get_tick_time_min(const snd_pcm_hw_params_t *params,
 	return _snd_pcm_hw_param_get_min(params, SNDRV_PCM_HW_PARAM_TICK_TIME, val, dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 __attribute__ ((deprecated))
 int snd_pcm_hw_params_get_tick_time_max(const snd_pcm_hw_params_t *params,
 					unsigned int *val, int *dir)
@@ -1609,7 +1652,7 @@ int snd_pcm_hw_params_get_tick_time_max(const snd_pcm_hw_params_t *params,
 	return _snd_pcm_hw_param_get_max(params, SNDRV_PCM_HW_PARAM_TICK_TIME, val, dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 __attribute__ ((deprecated))
 int snd_pcm_hw_params_test_tick_time(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 				     unsigned int val, int dir)
@@ -1618,7 +1661,7 @@ int snd_pcm_hw_params_test_tick_time(snd_pcm_t *pcm, snd_pcm_hw_params_t *params
 				      val, &dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 __attribute__ ((deprecated))
 int snd_pcm_hw_params_set_tick_time(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 				    unsigned int val, int dir)
@@ -1627,7 +1670,7 @@ int snd_pcm_hw_params_set_tick_time(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 				    val, dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 __attribute__ ((deprecated))
 int snd_pcm_hw_params_set_tick_time_min(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 					unsigned int *val, int *dir)
@@ -1636,7 +1679,7 @@ int snd_pcm_hw_params_set_tick_time_min(snd_pcm_t *pcm, snd_pcm_hw_params_t *par
 					val, dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 __attribute__ ((deprecated))
 int snd_pcm_hw_params_set_tick_time_max(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 					unsigned int *val, int *dir)
@@ -1645,7 +1688,7 @@ int snd_pcm_hw_params_set_tick_time_max(snd_pcm_t *pcm, snd_pcm_hw_params_t *par
 					val, dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 __attribute__ ((deprecated))
 int snd_pcm_hw_params_set_tick_time_minmax(snd_pcm_t *pcm,
 					   snd_pcm_hw_params_t *params,
@@ -1656,7 +1699,7 @@ int snd_pcm_hw_params_set_tick_time_minmax(snd_pcm_t *pcm,
 					   min, mindir, max, maxdir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 __attribute__ ((deprecated))
 int snd_pcm_hw_params_set_tick_time_near(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 					 unsigned int *val, int *dir)
@@ -1665,7 +1708,7 @@ int snd_pcm_hw_params_set_tick_time_near(snd_pcm_t *pcm, snd_pcm_hw_params_t *pa
 					 val, dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 __attribute__ ((deprecated))
 int snd_pcm_hw_params_set_tick_time_first(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 					  unsigned int *val, int *dir)
@@ -1674,7 +1717,7 @@ int snd_pcm_hw_params_set_tick_time_first(snd_pcm_t *pcm, snd_pcm_hw_params_t *p
 					  val, dir);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 __attribute__ ((deprecated))
 int snd_pcm_hw_params_set_tick_time_last(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 					 unsigned int *val, int *dir)
@@ -1684,7 +1727,7 @@ int snd_pcm_hw_params_set_tick_time_last(snd_pcm_t *pcm, snd_pcm_hw_params_t *pa
 }
 
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_sw_params_current(snd_pcm_t *pcm, snd_pcm_sw_params_t *params)
 {
 	*params = pcm->sw_params;
@@ -1693,7 +1736,7 @@ int snd_pcm_sw_params_current(snd_pcm_t *pcm, snd_pcm_sw_params_t *params)
 
 __snd_define_type(snd_pcm_sw_params);
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_sw_params_get_boundary(const snd_pcm_sw_params_t *params,
 				   snd_pcm_uframes_t *val)
 {
@@ -1701,7 +1744,7 @@ int snd_pcm_sw_params_get_boundary(const snd_pcm_sw_params_t *params,
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_sw_params_set_tstamp_mode(snd_pcm_t *pcm, snd_pcm_sw_params_t *params,
 				      snd_pcm_tstamp_t val)
 {
@@ -1709,7 +1752,7 @@ int snd_pcm_sw_params_set_tstamp_mode(snd_pcm_t *pcm, snd_pcm_sw_params_t *param
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_sw_params_get_tstamp_mode(const snd_pcm_sw_params_t *params,
 				      snd_pcm_tstamp_t *val)
 {
@@ -1717,7 +1760,7 @@ int snd_pcm_sw_params_get_tstamp_mode(const snd_pcm_sw_params_t *params,
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 __attribute__ ((deprecated))
 int snd_pcm_sw_params_set_sleep_min(snd_pcm_t *pcm, snd_pcm_sw_params_t *params,
 				    unsigned int val)
@@ -1726,7 +1769,7 @@ int snd_pcm_sw_params_set_sleep_min(snd_pcm_t *pcm, snd_pcm_sw_params_t *params,
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 __attribute__ ((deprecated))
 int snd_pcm_sw_params_get_sleep_min(const snd_pcm_sw_params_t *params,
 				    unsigned int *val)
@@ -1735,7 +1778,7 @@ int snd_pcm_sw_params_get_sleep_min(const snd_pcm_sw_params_t *params,
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_sw_params_set_avail_min(snd_pcm_t *pcm, snd_pcm_sw_params_t *params,
 				    snd_pcm_uframes_t val)
 {
@@ -1749,7 +1792,7 @@ int snd_pcm_sw_params_set_avail_min(snd_pcm_t *pcm, snd_pcm_sw_params_t *params,
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_sw_params_get_avail_min(const snd_pcm_sw_params_t *params,
 				    snd_pcm_uframes_t *val)
 {
@@ -1758,7 +1801,7 @@ int snd_pcm_sw_params_get_avail_min(const snd_pcm_sw_params_t *params,
 }
 
 
-static inline
+__SALSA_EXPORT_FUNC
 __attribute__ ((deprecated))
 int snd_pcm_sw_params_set_xfer_align(snd_pcm_t *pcm, snd_pcm_sw_params_t *params,
 				     snd_pcm_uframes_t val)
@@ -1767,7 +1810,7 @@ int snd_pcm_sw_params_set_xfer_align(snd_pcm_t *pcm, snd_pcm_sw_params_t *params
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 __attribute__ ((deprecated))
 int snd_pcm_sw_params_get_xfer_align(const snd_pcm_sw_params_t *params,
 				     snd_pcm_uframes_t *val)
@@ -1777,7 +1820,7 @@ int snd_pcm_sw_params_get_xfer_align(const snd_pcm_sw_params_t *params,
 }
 
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_sw_params_set_start_threshold(snd_pcm_t *pcm, snd_pcm_sw_params_t *params,
 					  snd_pcm_uframes_t val)
 {
@@ -1785,7 +1828,7 @@ int snd_pcm_sw_params_set_start_threshold(snd_pcm_t *pcm, snd_pcm_sw_params_t *p
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_sw_params_get_start_threshold(const snd_pcm_sw_params_t *params,
 					  snd_pcm_uframes_t *val)
 {
@@ -1794,7 +1837,7 @@ int snd_pcm_sw_params_get_start_threshold(const snd_pcm_sw_params_t *params,
 }
 
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_sw_params_set_stop_threshold(snd_pcm_t *pcm, snd_pcm_sw_params_t *params,
 					 snd_pcm_uframes_t val)
 {
@@ -1802,7 +1845,7 @@ int snd_pcm_sw_params_set_stop_threshold(snd_pcm_t *pcm, snd_pcm_sw_params_t *pa
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_sw_params_get_stop_threshold(const snd_pcm_sw_params_t *params,
 					 snd_pcm_uframes_t *val)
 {
@@ -1811,7 +1854,7 @@ int snd_pcm_sw_params_get_stop_threshold(const snd_pcm_sw_params_t *params,
 }
 
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_sw_params_set_silence_threshold(snd_pcm_t *pcm,
 					    snd_pcm_sw_params_t *params,
 					    snd_pcm_uframes_t val)
@@ -1820,7 +1863,7 @@ int snd_pcm_sw_params_set_silence_threshold(snd_pcm_t *pcm,
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_sw_params_get_silence_threshold(const snd_pcm_sw_params_t *params,
 					    snd_pcm_uframes_t *val)
 {
@@ -1829,7 +1872,7 @@ int snd_pcm_sw_params_get_silence_threshold(const snd_pcm_sw_params_t *params,
 }
 
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_sw_params_set_silence_size(snd_pcm_t *pcm, snd_pcm_sw_params_t *params,
 				       snd_pcm_uframes_t val)
 {
@@ -1837,7 +1880,7 @@ int snd_pcm_sw_params_set_silence_size(snd_pcm_t *pcm, snd_pcm_sw_params_t *para
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_sw_params_get_silence_size(const snd_pcm_sw_params_t *params,
 				       snd_pcm_uframes_t *val)
 {
@@ -1848,13 +1891,13 @@ int snd_pcm_sw_params_get_silence_size(const snd_pcm_sw_params_t *params,
 
 __snd_define_type(snd_pcm_status);
 
-static inline
+__SALSA_EXPORT_FUNC
 snd_pcm_state_t snd_pcm_status_get_state(const snd_pcm_status_t *obj)
 {
 	return (snd_pcm_state_t) obj->state;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_pcm_status_get_trigger_tstamp(const snd_pcm_status_t *obj,
 				       snd_timestamp_t *ptr)
 {
@@ -1862,45 +1905,45 @@ void snd_pcm_status_get_trigger_tstamp(const snd_pcm_status_t *obj,
 	ptr->tv_usec = obj->trigger_tstamp.tv_nsec / 1000L;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_pcm_status_get_trigger_htstamp(const snd_pcm_status_t *obj,
 					snd_htimestamp_t *ptr)
 {
 	*ptr = obj->trigger_tstamp;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_pcm_status_get_tstamp(const snd_pcm_status_t *obj, snd_timestamp_t *ptr)
 {
 	ptr->tv_sec = obj->tstamp.tv_sec;
 	ptr->tv_usec = obj->tstamp.tv_nsec / 1000L;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_pcm_status_get_htstamp(const snd_pcm_status_t *obj, snd_htimestamp_t *ptr)
 {
 	*ptr = obj->tstamp;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 snd_pcm_sframes_t snd_pcm_status_get_delay(const snd_pcm_status_t *obj)
 {
 	return obj->delay;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 snd_pcm_uframes_t snd_pcm_status_get_avail(const snd_pcm_status_t *obj)
 {
 	return obj->avail;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 snd_pcm_uframes_t snd_pcm_status_get_avail_max(const snd_pcm_status_t *obj)
 {
 	return obj->avail_max;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 snd_pcm_uframes_t snd_pcm_status_get_overrange(const snd_pcm_status_t *obj)
 {
 	return obj->overrange;
@@ -1908,73 +1951,73 @@ snd_pcm_uframes_t snd_pcm_status_get_overrange(const snd_pcm_status_t *obj)
 
 __snd_define_type(snd_pcm_info);
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_pcm_info_get_device(const snd_pcm_info_t *obj)
 {
 	return obj->device;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_pcm_info_get_subdevice(const snd_pcm_info_t *obj)
 {
 	return obj->subdevice;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 snd_pcm_stream_t snd_pcm_info_get_stream(const snd_pcm_info_t *obj)
 {
 	return (snd_pcm_stream_t) obj->stream;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_info_get_card(const snd_pcm_info_t *obj)
 {
 	return obj->card;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 const char *snd_pcm_info_get_id(const snd_pcm_info_t *obj)
 {
 	return (const char *)obj->id;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 const char *snd_pcm_info_get_name(const snd_pcm_info_t *obj)
 {
 	return (const char *)obj->name;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 const char *snd_pcm_info_get_subdevice_name(const snd_pcm_info_t *obj)
 {
 	return (const char *)obj->subname;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 snd_pcm_class_t snd_pcm_info_get_class(const snd_pcm_info_t *obj)
 {
 	return (snd_pcm_class_t) obj->dev_class;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 snd_pcm_subclass_t snd_pcm_info_get_subclass(const snd_pcm_info_t *obj)
 {
 	return (snd_pcm_subclass_t) obj->dev_subclass;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_pcm_info_get_subdevices_count(const snd_pcm_info_t *obj)
 {
 	return obj->subdevices_count;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_pcm_info_get_subdevices_avail(const snd_pcm_info_t *obj)
 {
 	return obj->subdevices_avail;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 snd_pcm_sync_id_t snd_pcm_info_get_sync(const snd_pcm_info_t *obj)
 {
 	snd_pcm_sync_id_t res;
@@ -1982,25 +2025,25 @@ snd_pcm_sync_id_t snd_pcm_info_get_sync(const snd_pcm_info_t *obj)
 	return res;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_pcm_info_set_device(snd_pcm_info_t *obj, unsigned int val)
 {
 	obj->device = val;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_pcm_info_set_subdevice(snd_pcm_info_t *obj, unsigned int val)
 {
 	obj->subdevice = val;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_pcm_info_set_stream(snd_pcm_info_t *obj, snd_pcm_stream_t val)
 {
 	obj->stream = val;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_htimestamp(snd_pcm_t *pcm, snd_pcm_uframes_t *avail,
 		       snd_htimestamp_t *tstamp)
 {
@@ -2013,7 +2056,7 @@ int snd_pcm_htimestamp(snd_pcm_t *pcm, snd_pcm_uframes_t *avail,
 /*
  * helper functions
  */
-static inline
+__SALSA_EXPORT_FUNC
 int snd_pcm_get_params(snd_pcm_t *pcm,
                        snd_pcm_uframes_t *buffer_size,
                        snd_pcm_uframes_t *period_size)
@@ -2029,7 +2072,7 @@ int snd_pcm_get_params(snd_pcm_t *pcm,
  * not implemented yet
  */
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_pcm_open_lconf(snd_pcm_t **pcm, const char *name, 
 		       snd_pcm_stream_t stream, int mode,
 		       snd_config_t *lconf)
@@ -2037,35 +2080,35 @@ int snd_pcm_open_lconf(snd_pcm_t **pcm, const char *name,
 	return -ENXIO;
 }
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 snd_pcm_sframes_t snd_pcm_mmap_writei(snd_pcm_t *pcm, const void *buffer,
 				      snd_pcm_uframes_t size)
 {
 	return -ENXIO;
 }
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 snd_pcm_sframes_t snd_pcm_mmap_writen(snd_pcm_t *pcm, void **bufs,
 				      snd_pcm_uframes_t size)
 {
 	return -ENXIO;
 }
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 snd_pcm_sframes_t snd_pcm_mmap_readi(snd_pcm_t *pcm, void *buffer,
 				     snd_pcm_uframes_t size)
 {
 	return -ENXIO;
 }
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 snd_pcm_sframes_t snd_pcm_mmap_readn(snd_pcm_t *pcm, void **bufs,
 				     snd_pcm_uframes_t size)
 {
 	return -ENXIO;
 }
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_pcm_set_params(snd_pcm_t *pcm,
                        snd_pcm_format_t format,
                        snd_pcm_access_t access,
@@ -2079,7 +2122,7 @@ int snd_pcm_set_params(snd_pcm_t *pcm,
 
 #if SALSA_HAS_ASYNC_SUPPORT
 
-static inline
+__SALSA_EXPORT_FUNC
 snd_pcm_t *snd_async_handler_get_pcm(snd_async_handler_t *handler)
 {
 	return (snd_pcm_t *) handler->rec;
@@ -2087,7 +2130,7 @@ snd_pcm_t *snd_async_handler_get_pcm(snd_async_handler_t *handler)
 
 #else /* !SALSA_HAS_ASYNC_SUPPORT */
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_async_add_pcm_handler(snd_async_handler_t **handler, snd_pcm_t *pcm, 
 			      snd_async_callback_t callback,
 			      void *private_data)
@@ -2095,7 +2138,7 @@ int snd_async_add_pcm_handler(snd_async_handler_t **handler, snd_pcm_t *pcm,
 	return -ENXIO;
 }
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 snd_pcm_t *snd_async_handler_get_pcm(snd_async_handler_t *handler)
 {
 	return NULL;
diff --git a/src/rawmidi.h b/src/rawmidi.h
index a17c843..2c3607d 100644
--- a/src/rawmidi.h
+++ b/src/rawmidi.h
@@ -22,13 +22,7 @@
 #ifndef __ALSA_RAWMIDI_H
 #define __ALSA_RAWMIDI_H
 
-#include "recipe.h"
-#include "global.h"
-#include "rawmidi_types.h"
-
-int snd_rawmidi_open(snd_rawmidi_t **in_rmidi, snd_rawmidi_t **out_rmidi,
-		     const char *name, int mode);
-int snd_rawmidi_close(snd_rawmidi_t *rmidi);
+#include "rawmidi_func.h"
 
 #include "rawmidi_macros.h"
 
diff --git a/src/rawmidi_abi.c b/src/rawmidi_abi.c
new file mode 100644
index 0000000..deeae47
--- /dev/null
+++ b/src/rawmidi_abi.c
@@ -0,0 +1,4 @@
+#include "rawmidi_func.h"
+#undef __SALSA_EXPORT_FUNC
+#define __SALSA_EXPORT_FUNC
+#include "rawmidi_macros.h"
diff --git a/src/rawmidi_func.h b/src/rawmidi_func.h
new file mode 100644
index 0000000..4c84236
--- /dev/null
+++ b/src/rawmidi_func.h
@@ -0,0 +1,11 @@
+/*
+ */
+
+#include "recipe.h"
+#include "global.h"
+#include "rawmidi_types.h"
+
+int snd_rawmidi_open(snd_rawmidi_t **in_rmidi, snd_rawmidi_t **out_rmidi,
+		     const char *name, int mode);
+int snd_rawmidi_close(snd_rawmidi_t *rmidi);
+
diff --git a/src/rawmidi_macros.h b/src/rawmidi_macros.h
index 0743428..f535354 100644
--- a/src/rawmidi_macros.h
+++ b/src/rawmidi_macros.h
@@ -9,6 +9,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <errno.h>
+#include <unistd.h>
 #include <sys/ioctl.h>
 #include <sys/poll.h>
 
@@ -31,26 +32,26 @@ struct _snd_rawmidi {
 /*
  */
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_rawmidi_open_lconf(snd_rawmidi_t **in_rmidi, snd_rawmidi_t **out_rmidi,
 			   const char *name, int mode, snd_config_t *lconf)
 {
 	return -ENXIO;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_rawmidi_nonblock(snd_rawmidi_t *rmidi, int nonblock)
 {
 	return _snd_set_nonblock(rmidi->fd, nonblock);
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_rawmidi_poll_descriptors_count(snd_rawmidi_t *rmidi)
 {
 	return 1;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_rawmidi_poll_descriptors(snd_rawmidi_t *rmidi, struct pollfd *pfds,
 				 unsigned int space)
 {
@@ -58,7 +59,7 @@ int snd_rawmidi_poll_descriptors(snd_rawmidi_t *rmidi, struct pollfd *pfds,
 	return 1;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_rawmidi_poll_descriptors_revents(snd_rawmidi_t *rawmidi,
 					 struct pollfd *pfds,
 					 unsigned int nfds,
@@ -70,86 +71,86 @@ int snd_rawmidi_poll_descriptors_revents(snd_rawmidi_t *rawmidi,
 
 __snd_define_type(snd_rawmidi_info);
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_rawmidi_info_get_device(const snd_rawmidi_info_t *obj)
 {
 	return obj->device;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_rawmidi_info_get_subdevice(const snd_rawmidi_info_t *obj)
 {
 	return obj->subdevice;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 snd_rawmidi_stream_t snd_rawmidi_info_get_stream(const snd_rawmidi_info_t *obj)
 {
 	return (snd_rawmidi_stream_t) obj->stream;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_rawmidi_info_get_card(const snd_rawmidi_info_t *obj)
 {
 	return obj->card;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_rawmidi_info_get_flags(const snd_rawmidi_info_t *obj)
 {
 	return obj->flags;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 const char *snd_rawmidi_info_get_id(const snd_rawmidi_info_t *obj)
 {
 	return (const char *)obj->id;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 const char *snd_rawmidi_info_get_name(const snd_rawmidi_info_t *obj)
 {
 	return (const char *)obj->name;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 const char *snd_rawmidi_info_get_subdevice_name(const snd_rawmidi_info_t *obj)
 {
 	return (const char *)obj->subname;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_rawmidi_info_get_subdevices_count(const snd_rawmidi_info_t *obj)
 {
 	return obj->subdevices_count;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_rawmidi_info_get_subdevices_avail(const snd_rawmidi_info_t *obj)
 {
 	return obj->subdevices_avail;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_rawmidi_info_set_device(snd_rawmidi_info_t *obj, unsigned int val)
 {
 	obj->device = val;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_rawmidi_info_set_subdevice(snd_rawmidi_info_t *obj, unsigned int val)
 {
 	obj->subdevice = val;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_rawmidi_info_set_stream(snd_rawmidi_info_t *obj,
 				 snd_rawmidi_stream_t val)
 {
 	obj->stream = val;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_rawmidi_info(snd_rawmidi_t *rmidi, snd_rawmidi_info_t * info)
 {
 	info->stream = rmidi->stream;
@@ -160,7 +161,7 @@ int snd_rawmidi_info(snd_rawmidi_t *rmidi, snd_rawmidi_info_t * info)
 
 __snd_define_type(snd_rawmidi_params);
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_rawmidi_params_set_buffer_size(snd_rawmidi_t *rmidi,
 				       snd_rawmidi_params_t *params,
 				       size_t val)
@@ -169,13 +170,13 @@ int snd_rawmidi_params_set_buffer_size(snd_rawmidi_t *rmidi,
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 size_t snd_rawmidi_params_get_buffer_size(const snd_rawmidi_params_t *params)
 {
 	return params->buffer_size;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_rawmidi_params_set_avail_min(snd_rawmidi_t *rmidi,
 				     snd_rawmidi_params_t *params, size_t val)
 {
@@ -183,13 +184,13 @@ int snd_rawmidi_params_set_avail_min(snd_rawmidi_t *rmidi,
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 size_t snd_rawmidi_params_get_avail_min(const snd_rawmidi_params_t *params)
 {
 	return params->avail_min;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_rawmidi_params_set_no_active_sensing(snd_rawmidi_t *rmidi,
 					     snd_rawmidi_params_t *params,
 					     int val)
@@ -198,13 +199,13 @@ int snd_rawmidi_params_set_no_active_sensing(snd_rawmidi_t *rmidi,
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_rawmidi_params_get_no_active_sensing(const snd_rawmidi_params_t *params)
 {
 	return params->no_active_sensing;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_rawmidi_params(snd_rawmidi_t *rmidi, snd_rawmidi_params_t * params)
 {
 	params->stream = rmidi->stream;
@@ -214,7 +215,7 @@ int snd_rawmidi_params(snd_rawmidi_t *rmidi, snd_rawmidi_params_t * params)
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_rawmidi_params_current(snd_rawmidi_t *rmidi,
 			       snd_rawmidi_params_t *params)
 {
@@ -224,26 +225,26 @@ int snd_rawmidi_params_current(snd_rawmidi_t *rmidi,
 
 __snd_define_type(snd_rawmidi_status);
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_rawmidi_status_get_tstamp(const snd_rawmidi_status_t *obj,
 				   snd_htimestamp_t *ptr)
 {
 	*ptr = obj->tstamp;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 size_t snd_rawmidi_status_get_avail(const snd_rawmidi_status_t *obj)
 {
 	return obj->avail;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 size_t snd_rawmidi_status_get_xruns(const snd_rawmidi_status_t *obj)
 {
 	return obj->xruns;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_rawmidi_status(snd_rawmidi_t *rmidi, snd_rawmidi_status_t * status)
 {
 	status->stream = rmidi->stream;
@@ -252,7 +253,7 @@ int snd_rawmidi_status(snd_rawmidi_t *rmidi, snd_rawmidi_status_t * status)
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_rawmidi_drain(snd_rawmidi_t *rmidi)
 {
 	int str = rmidi->stream;
@@ -261,7 +262,7 @@ int snd_rawmidi_drain(snd_rawmidi_t *rmidi)
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_rawmidi_drop(snd_rawmidi_t *rmidi)
 {
 	int str = rmidi->stream;
@@ -270,7 +271,7 @@ int snd_rawmidi_drop(snd_rawmidi_t *rmidi)
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 ssize_t snd_rawmidi_write(snd_rawmidi_t *rmidi, const void *buffer,
 			  size_t size)
 {
@@ -281,7 +282,7 @@ ssize_t snd_rawmidi_write(snd_rawmidi_t *rmidi, const void *buffer,
 	return result;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 ssize_t snd_rawmidi_read(snd_rawmidi_t *rmidi, void *buffer, size_t size)
 {
 	ssize_t result;
@@ -291,19 +292,19 @@ ssize_t snd_rawmidi_read(snd_rawmidi_t *rmidi, void *buffer, size_t size)
 	return result;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 const char *snd_rawmidi_name(snd_rawmidi_t *rmidi)
 {
 	return rmidi->hw->name;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 snd_rawmidi_type_t snd_rawmidi_type(snd_rawmidi_t *rmidi)
 {
 	return rmidi->hw->type;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 snd_rawmidi_stream_t snd_rawmidi_stream(snd_rawmidi_t *rmidi)
 {
 	return rmidi->stream;
diff --git a/src/seq.h b/src/seq.h
index 238f67c..e54db21 100644
--- a/src/seq.h
+++ b/src/seq.h
@@ -24,77 +24,77 @@ typedef enum _snd_seq_type {
 
 /*
  */
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_seq_open(snd_seq_t **handle, const char *name, int streams, int mode)
 {
 	return -ENXIO;
 }
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_seq_open_lconf(snd_seq_t **handle, const char *name, int streams,
 		       int mode, snd_config_t *lconf)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 const char *snd_seq_name(snd_seq_t *seq)
 {
 	return NULL;
 }
-static inline
+__SALSA_EXPORT_FUNC
 snd_seq_type_t snd_seq_type(snd_seq_t *seq)
 {
 	return SND_SEQ_TYPE_HW;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_close(snd_seq_t *handle)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_poll_descriptors_count(snd_seq_t *handle, short events)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_poll_descriptors(snd_seq_t *handle, struct pollfd *pfds,
 			     unsigned int space, short events)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_poll_descriptors_revents(snd_seq_t *seq, struct pollfd *pfds,
 				     unsigned int nfds, unsigned short *revents)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_nonblock(snd_seq_t *handle, int nonblock)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_client_id(snd_seq_t *handle)
 {
 	return -ENXIO;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 size_t snd_seq_get_output_buffer_size(snd_seq_t *handle)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 size_t snd_seq_get_input_buffer_size(snd_seq_t *handle)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_set_output_buffer_size(snd_seq_t *handle, size_t size)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_set_input_buffer_size(snd_seq_t *handle, size_t size)
 {
 	return -ENXIO;
@@ -103,60 +103,60 @@ int snd_seq_set_input_buffer_size(snd_seq_t *handle, size_t size)
 /** system information container */
 typedef struct _snd_seq_system_info snd_seq_system_info_t;
 
-static inline
+__SALSA_EXPORT_FUNC
 size_t snd_seq_system_info_sizeof(void)
 {
 	return 0;
 }
 /** allocate a #snd_seq_system_info_t container on stack */
 #define snd_seq_system_info_alloca(ptr) 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_system_info_malloc(snd_seq_system_info_t **ptr)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_system_info_free(snd_seq_system_info_t *ptr)
 {
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_system_info_copy(snd_seq_system_info_t *dst,
 			      const snd_seq_system_info_t *src)
 {
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_system_info_get_queues(const snd_seq_system_info_t *info)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_system_info_get_clients(const snd_seq_system_info_t *info)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_system_info_get_ports(const snd_seq_system_info_t *info)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_system_info_get_channels(const snd_seq_system_info_t *info)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_system_info_get_cur_clients(const snd_seq_system_info_t *info)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_system_info_get_cur_queues(const snd_seq_system_info_t *info)
 {
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_system_info(snd_seq_t *handle, snd_seq_system_info_t *info)
 {
 	return -ENXIO;
@@ -171,7 +171,7 @@ typedef enum snd_seq_client_type {
 	SND_SEQ_KERNEL_CLIENT   = 2	/**< kernel client */
 } snd_seq_client_type_t;
                         
-static inline
+__SALSA_EXPORT_FUNC
 size_t snd_seq_client_info_sizeof(void)
 {
 	return 0;
@@ -179,99 +179,99 @@ size_t snd_seq_client_info_sizeof(void)
 /** allocate a #snd_seq_client_info_t container on stack */
 #define snd_seq_client_info_alloca(ptr)
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_client_info_malloc(snd_seq_client_info_t **ptr)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_client_info_free(snd_seq_client_info_t *ptr)
 {
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_client_info_copy(snd_seq_client_info_t *dst,
 			      const snd_seq_client_info_t *src)
 {
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_client_info_get_client(const snd_seq_client_info_t *info)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 snd_seq_client_type_t snd_seq_client_info_get_type(const snd_seq_client_info_t *info)
 {
 	return SND_SEQ_USER_CLIENT;
 }
-static inline
+__SALSA_EXPORT_FUNC
 const char *snd_seq_client_info_get_name(snd_seq_client_info_t *info)
 {
 	return NULL;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_client_info_get_broadcast_filter(const snd_seq_client_info_t *info)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_client_info_get_error_bounce(const snd_seq_client_info_t *info)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 const unsigned char *snd_seq_client_info_get_event_filter(const snd_seq_client_info_t *info)
 {
 	return NULL;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_client_info_get_num_ports(const snd_seq_client_info_t *info)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_client_info_get_event_lost(const snd_seq_client_info_t *info)
 {
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_client_info_set_client(snd_seq_client_info_t *info, int client)
 {
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_client_info_set_name(snd_seq_client_info_t *info, const char *name)
 {
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_client_info_set_broadcast_filter(snd_seq_client_info_t *info, int val)
 {
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_client_info_set_error_bounce(snd_seq_client_info_t *info, int val)
 {
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_client_info_set_event_filter(snd_seq_client_info_t *info, unsigned char *filter)
 {
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_get_client_info(snd_seq_t *handle, snd_seq_client_info_t *info)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_get_any_client_info(snd_seq_t *handle, int client, snd_seq_client_info_t *info)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_set_client_info(snd_seq_t *handle, snd_seq_client_info_t *info)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_query_next_client(snd_seq_t *handle, snd_seq_client_info_t *info)
 {
 	return -ENXIO;
@@ -283,7 +283,7 @@ int snd_seq_query_next_client(snd_seq_t *handle, snd_seq_client_info_t *info)
 /** client pool information container */
 typedef struct _snd_seq_client_pool snd_seq_client_pool_t;
 
-static inline
+__SALSA_EXPORT_FUNC
 size_t snd_seq_client_pool_sizeof(void)
 {
 	return 0;
@@ -291,71 +291,71 @@ size_t snd_seq_client_pool_sizeof(void)
 /** allocate a #snd_seq_client_pool_t container on stack */
 #define snd_seq_client_pool_alloca(ptr)
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_client_pool_malloc(snd_seq_client_pool_t **ptr)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_client_pool_free(snd_seq_client_pool_t *ptr)
 {
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_client_pool_copy(snd_seq_client_pool_t *dst,
 			      const snd_seq_client_pool_t *src)
 {
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_client_pool_get_client(const snd_seq_client_pool_t *info)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 size_t snd_seq_client_pool_get_output_pool(const snd_seq_client_pool_t *info)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 size_t snd_seq_client_pool_get_input_pool(const snd_seq_client_pool_t *info)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 size_t snd_seq_client_pool_get_output_room(const snd_seq_client_pool_t *info)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 size_t snd_seq_client_pool_get_output_free(const snd_seq_client_pool_t *info)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 size_t snd_seq_client_pool_get_input_free(const snd_seq_client_pool_t *info)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_client_pool_set_output_pool(snd_seq_client_pool_t *info,
 					 size_t size)
 {
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_client_pool_set_input_pool(snd_seq_client_pool_t *info, size_t size)
 {
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_client_pool_set_output_room(snd_seq_client_pool_t *info, size_t size)
 {
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_get_client_pool(snd_seq_t *handle, snd_seq_client_pool_t *info)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_set_client_pool(snd_seq_t *handle, snd_seq_client_pool_t *info)
 {
 	return -ENXIO;
@@ -419,7 +419,7 @@ typedef struct _snd_seq_port_info snd_seq_port_info_t;
 #define SND_SEQ_PORT_TYPE_APPLICATION	(1<<20)
 
 
-static inline
+__SALSA_EXPORT_FUNC
 size_t snd_seq_port_info_sizeof(void)
 {
 	return 0;
@@ -427,184 +427,184 @@ size_t snd_seq_port_info_sizeof(void)
 /** allocate a #snd_seq_port_info_t container on stack */
 #define snd_seq_port_info_alloca(ptr)
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_port_info_malloc(snd_seq_port_info_t **ptr)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_port_info_free(snd_seq_port_info_t *ptr)
 {
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_port_info_copy(snd_seq_port_info_t *dst,
 			    const snd_seq_port_info_t *src)
 {
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_port_info_get_client(const snd_seq_port_info_t *info)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_port_info_get_port(const snd_seq_port_info_t *info)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 const snd_seq_addr_t *snd_seq_port_info_get_addr(const snd_seq_port_info_t *info)
 {
 	return NULL;
 }
-static inline
+__SALSA_EXPORT_FUNC
 const char *snd_seq_port_info_get_name(const snd_seq_port_info_t *info)
 {
 	return NULL;
 }
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_seq_port_info_get_capability(const snd_seq_port_info_t *info)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_seq_port_info_get_type(const snd_seq_port_info_t *info)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_port_info_get_midi_channels(const snd_seq_port_info_t *info)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_port_info_get_midi_voices(const snd_seq_port_info_t *info)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_port_info_get_synth_voices(const snd_seq_port_info_t *info)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_port_info_get_read_use(const snd_seq_port_info_t *info)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_port_info_get_write_use(const snd_seq_port_info_t *info)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_port_info_get_port_specified(const snd_seq_port_info_t *info)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_port_info_get_timestamping(const snd_seq_port_info_t *info)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_port_info_get_timestamp_real(const snd_seq_port_info_t *info)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_port_info_get_timestamp_queue(const snd_seq_port_info_t *info)
 {
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_port_info_set_client(snd_seq_port_info_t *info, int client)
 {
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_port_info_set_port(snd_seq_port_info_t *info, int port)
 {
 
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_port_info_set_addr(snd_seq_port_info_t *info,
 				const snd_seq_addr_t *addr)
 {
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_port_info_set_name(snd_seq_port_info_t *info, const char *name)
 {
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_port_info_set_capability(snd_seq_port_info_t *info,
 				      unsigned int capability)
 {
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_port_info_set_type(snd_seq_port_info_t *info, unsigned int type)
 {
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_port_info_set_midi_channels(snd_seq_port_info_t *info,
 					 int channels)
 {
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_port_info_set_midi_voices(snd_seq_port_info_t *info, int voices)
 {
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_port_info_set_synth_voices(snd_seq_port_info_t *info, int voices)
 {
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_port_info_set_port_specified(snd_seq_port_info_t *info, int val)
 {
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_port_info_set_timestamping(snd_seq_port_info_t *info, int enable)
 {
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_port_info_set_timestamp_real(snd_seq_port_info_t *info,
 					  int realtime)
 {
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_port_info_set_timestamp_queue(snd_seq_port_info_t *info, int queue)
 {
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_create_port(snd_seq_t *handle, snd_seq_port_info_t *info)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_delete_port(snd_seq_t *handle, int port)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_get_port_info(snd_seq_t *handle, int port,
 			  snd_seq_port_info_t *info)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_get_any_port_info(snd_seq_t *handle, int client, int port,
 			      snd_seq_port_info_t *info)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_set_port_info(snd_seq_t *handle, int port,
 			  snd_seq_port_info_t *info)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_query_next_port(snd_seq_t *handle, snd_seq_port_info_t *info)
 {
 	return -ENXIO;
@@ -613,7 +613,7 @@ int snd_seq_query_next_port(snd_seq_t *handle, snd_seq_port_info_t *info)
 /** port subscription container */
 typedef struct _snd_seq_port_subscribe snd_seq_port_subscribe_t;
 
-static inline
+__SALSA_EXPORT_FUNC
 size_t snd_seq_port_subscribe_sizeof(void)
 {
 	return 0;
@@ -621,94 +621,94 @@ size_t snd_seq_port_subscribe_sizeof(void)
 /** allocate a #snd_seq_port_subscribe_t container on stack */
 #define snd_seq_port_subscribe_alloca(ptr)
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_port_subscribe_malloc(snd_seq_port_subscribe_t **ptr)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_port_subscribe_free(snd_seq_port_subscribe_t *ptr)
 {
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_port_subscribe_copy(snd_seq_port_subscribe_t *dst,
 				 const snd_seq_port_subscribe_t *src)
 {
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 const snd_seq_addr_t *snd_seq_port_subscribe_get_sender(const snd_seq_port_subscribe_t *info)
 {
 	return NULL;
 }
-static inline
+__SALSA_EXPORT_FUNC
 const snd_seq_addr_t *snd_seq_port_subscribe_get_dest(const snd_seq_port_subscribe_t *info)
 {
 	return NULL;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_port_subscribe_get_queue(const snd_seq_port_subscribe_t *info)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_port_subscribe_get_exclusive(const snd_seq_port_subscribe_t *info)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_port_subscribe_get_time_update(const snd_seq_port_subscribe_t *info)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_port_subscribe_get_time_real(const snd_seq_port_subscribe_t *info)
 {
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_port_subscribe_set_sender(snd_seq_port_subscribe_t *info,
 				       const snd_seq_addr_t *addr)
 {
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_port_subscribe_set_dest(snd_seq_port_subscribe_t *info,
 				     const snd_seq_addr_t *addr)
 {
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_port_subscribe_set_queue(snd_seq_port_subscribe_t *info, int q)
 {
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_port_subscribe_set_exclusive(snd_seq_port_subscribe_t *info,
 					  int val)
 {
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_port_subscribe_set_time_update(snd_seq_port_subscribe_t *info,
 					    int val)
 {
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_port_subscribe_set_time_real(snd_seq_port_subscribe_t *info,
 					  int val)
 {
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_get_port_subscription(snd_seq_t *handle,
 				  snd_seq_port_subscribe_t *sub)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_subscribe_port(snd_seq_t *handle, snd_seq_port_subscribe_t *sub)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_unsubscribe_port(snd_seq_t *handle, snd_seq_port_subscribe_t *sub)
 {
 	return -ENXIO;
@@ -726,7 +726,7 @@ typedef enum {
 	SND_SEQ_QUERY_SUBS_WRITE	/**< query write subscriptions */
 } snd_seq_query_subs_type_t;
 
-static inline
+__SALSA_EXPORT_FUNC
 size_t snd_seq_query_subscribe_sizeof(void)
 {
 	return 0;
@@ -734,103 +734,103 @@ size_t snd_seq_query_subscribe_sizeof(void)
 /** allocate a #snd_seq_query_subscribe_t container on stack */
 #define snd_seq_query_subscribe_alloca(ptr)
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_query_subscribe_malloc(snd_seq_query_subscribe_t **ptr)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_query_subscribe_free(snd_seq_query_subscribe_t *ptr)
 {
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_query_subscribe_copy(snd_seq_query_subscribe_t *dst,
 				  const snd_seq_query_subscribe_t *src)
 {
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_query_subscribe_get_client(const snd_seq_query_subscribe_t *info)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_query_subscribe_get_port(const snd_seq_query_subscribe_t *info)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 const snd_seq_addr_t *snd_seq_query_subscribe_get_root(const snd_seq_query_subscribe_t *info)
 {
 	return NULL;
 }
-static inline
+__SALSA_EXPORT_FUNC
 snd_seq_query_subs_type_t snd_seq_query_subscribe_get_type(const snd_seq_query_subscribe_t *info)
 {
 	return SND_SEQ_QUERY_SUBS_READ;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_query_subscribe_get_index(const snd_seq_query_subscribe_t *info)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_query_subscribe_get_num_subs(const snd_seq_query_subscribe_t *info)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 const snd_seq_addr_t *snd_seq_query_subscribe_get_addr(const snd_seq_query_subscribe_t *info)
 {
 	return NULL;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_query_subscribe_get_queue(const snd_seq_query_subscribe_t *info)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_query_subscribe_get_exclusive(const snd_seq_query_subscribe_t *info)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_query_subscribe_get_time_update(const snd_seq_query_subscribe_t *info)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_query_subscribe_get_time_real(const snd_seq_query_subscribe_t *info)
 {
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_query_subscribe_set_client(snd_seq_query_subscribe_t *info,
 					int client)
 {
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_query_subscribe_set_port(snd_seq_query_subscribe_t *info, int port)
 {
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_query_subscribe_set_root(snd_seq_query_subscribe_t *info,
 				      const snd_seq_addr_t *addr)
 {
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_query_subscribe_set_type(snd_seq_query_subscribe_t *info,
 				      snd_seq_query_subs_type_t type)
 {
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_query_subscribe_set_index(snd_seq_query_subscribe_t *info,
 				       int _index)
 {
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_query_port_subscribers(snd_seq_t *seq,
 				   snd_seq_query_subscribe_t * subs)
 {
@@ -849,7 +849,7 @@ typedef struct _snd_seq_queue_timer snd_seq_queue_timer_t;
 /** special queue ids */
 #define SND_SEQ_QUEUE_DIRECT		253	/**< direct dispatch */
 
-static inline
+__SALSA_EXPORT_FUNC
 size_t snd_seq_queue_info_sizeof(void)
 {
 	return 0;
@@ -857,106 +857,106 @@ size_t snd_seq_queue_info_sizeof(void)
 /** allocate a #snd_seq_queue_info_t container on stack */
 #define snd_seq_queue_info_alloca(ptr)
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_queue_info_malloc(snd_seq_queue_info_t **ptr)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_queue_info_free(snd_seq_queue_info_t *ptr)
 {
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_queue_info_copy(snd_seq_queue_info_t *dst,
 			     const snd_seq_queue_info_t *src)
 {
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_queue_info_get_queue(const snd_seq_queue_info_t *info)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 const char *snd_seq_queue_info_get_name(const snd_seq_queue_info_t *info)
 {
 	return NULL;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_queue_info_get_owner(const snd_seq_queue_info_t *info)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_queue_info_get_locked(const snd_seq_queue_info_t *info)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_seq_queue_info_get_flags(const snd_seq_queue_info_t *info)
 {
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_queue_info_set_name(snd_seq_queue_info_t *info, const char *name)
 {
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_queue_info_set_owner(snd_seq_queue_info_t *info, int owner)
 {
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_queue_info_set_locked(snd_seq_queue_info_t *info, int locked)
 {
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_queue_info_set_flags(snd_seq_queue_info_t *info, unsigned int flags)
 {
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_create_queue(snd_seq_t *seq, snd_seq_queue_info_t *info)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_alloc_named_queue(snd_seq_t *seq, const char *name)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_alloc_queue(snd_seq_t *handle)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_free_queue(snd_seq_t *handle, int q)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_get_queue_info(snd_seq_t *seq, int q, snd_seq_queue_info_t *info)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_set_queue_info(snd_seq_t *seq, int q, snd_seq_queue_info_t *info)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_query_named_queue(snd_seq_t *seq, const char *name)
 {
 	return -ENXIO;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_get_queue_usage(snd_seq_t *handle, int q)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_set_queue_usage(snd_seq_t *handle, int q, int used)
 {
 	return -ENXIO;
@@ -964,7 +964,7 @@ int snd_seq_set_queue_usage(snd_seq_t *handle, int q, int used)
 
 /*
  */
-static inline
+__SALSA_EXPORT_FUNC
 size_t snd_seq_queue_status_sizeof(void)
 {
 	return 0;
@@ -972,48 +972,48 @@ size_t snd_seq_queue_status_sizeof(void)
 /** allocate a #snd_seq_queue_status_t container on stack */
 #define snd_seq_queue_status_alloca(ptr)
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_queue_status_malloc(snd_seq_queue_status_t **ptr)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_queue_status_free(snd_seq_queue_status_t *ptr)
 {
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_queue_status_copy(snd_seq_queue_status_t *dst,
 			       const snd_seq_queue_status_t *src)
 {
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_queue_status_get_queue(const snd_seq_queue_status_t *info)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_queue_status_get_events(const snd_seq_queue_status_t *info)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 snd_seq_tick_time_t snd_seq_queue_status_get_tick_time(const snd_seq_queue_status_t *info)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 const snd_seq_real_time_t *snd_seq_queue_status_get_real_time(const snd_seq_queue_status_t *info)
 {
 	return NULL;
 }
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_seq_queue_status_get_status(const snd_seq_queue_status_t *info)
 {
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_get_queue_status(snd_seq_t *handle, int q,
 			     snd_seq_queue_status_t *status)
 {
@@ -1022,7 +1022,7 @@ int snd_seq_get_queue_status(snd_seq_t *handle, int q,
 
 /*
  */
-static inline
+__SALSA_EXPORT_FUNC
 size_t snd_seq_queue_tempo_sizeof(void)
 {
 	return 0;
@@ -1030,73 +1030,73 @@ size_t snd_seq_queue_tempo_sizeof(void)
 /** allocate a #snd_seq_queue_tempo_t container on stack */
 #define snd_seq_queue_tempo_alloca(ptr)
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_queue_tempo_malloc(snd_seq_queue_tempo_t **ptr)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_queue_tempo_free(snd_seq_queue_tempo_t *ptr)
 {
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_queue_tempo_copy(snd_seq_queue_tempo_t *dst,
 			      const snd_seq_queue_tempo_t *src)
 {
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_queue_tempo_get_queue(const snd_seq_queue_tempo_t *info)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_seq_queue_tempo_get_tempo(const snd_seq_queue_tempo_t *info)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_queue_tempo_get_ppq(const snd_seq_queue_tempo_t *info)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_seq_queue_tempo_get_skew(const snd_seq_queue_tempo_t *info)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_seq_queue_tempo_get_skew_base(const snd_seq_queue_tempo_t *info)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_queue_tempo_set_tempo(snd_seq_queue_tempo_t *info,
 				   unsigned int tempo)
 {
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_queue_tempo_set_ppq(snd_seq_queue_tempo_t *info, int ppq)
 {
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_queue_tempo_set_skew(snd_seq_queue_tempo_t *info,
 				  unsigned int skew)
 {
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_queue_tempo_set_skew_base(snd_seq_queue_tempo_t *info,
 				       unsigned int base)
 {
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_get_queue_tempo(snd_seq_t *handle, int q,
 			    snd_seq_queue_tempo_t *tempo)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_set_queue_tempo(snd_seq_t *handle, int q,
 			    snd_seq_queue_tempo_t *tempo)
 {
@@ -1113,7 +1113,7 @@ typedef enum {
 	SND_SEQ_TIMER_MIDI_TICK = 2	/* Midi Timer Tick (TICK event */
 } snd_seq_queue_timer_type_t;
 
-static inline
+__SALSA_EXPORT_FUNC
 size_t snd_seq_queue_timer_sizeof(void)
 {
 	return 0;
@@ -1121,65 +1121,65 @@ size_t snd_seq_queue_timer_sizeof(void)
 /** allocate a #snd_seq_queue_timer_t container on stack */
 #define snd_seq_queue_timer_alloca(ptr)
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_queue_timer_malloc(snd_seq_queue_timer_t **ptr)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_queue_timer_free(snd_seq_queue_timer_t *ptr)
 {
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_queue_timer_copy(snd_seq_queue_timer_t *dst,
 			      const snd_seq_queue_timer_t *src)
 {
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_queue_timer_get_queue(const snd_seq_queue_timer_t *info)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 snd_seq_queue_timer_type_t snd_seq_queue_timer_get_type(const snd_seq_queue_timer_t *info)
 {
 	return SND_SEQ_TIMER_ALSA;
 }
-static inline
+__SALSA_EXPORT_FUNC
 const snd_timer_id_t *snd_seq_queue_timer_get_id(const snd_seq_queue_timer_t *info)
 {
 	return NULL;
 }
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_seq_queue_timer_get_resolution(const snd_seq_queue_timer_t *info)
 {
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_queue_timer_set_type(snd_seq_queue_timer_t *info,
 				  snd_seq_queue_timer_type_t type)
 {
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_queue_timer_set_id(snd_seq_queue_timer_t *info,
 				const snd_timer_id_t *id)
 {
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_queue_timer_set_resolution(snd_seq_queue_timer_t *info,
 					unsigned int resolution)
 {
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_get_queue_timer(snd_seq_t *handle, int q,
 			    snd_seq_queue_timer_t *timer)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_set_queue_timer(snd_seq_t *handle, int q,
 			    snd_seq_queue_timer_t *timer)
 {
@@ -1187,72 +1187,72 @@ int snd_seq_set_queue_timer(snd_seq_t *handle, int q,
 }
 
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_free_event(snd_seq_event_t *ev)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 ssize_t snd_seq_event_length(snd_seq_event_t *ev)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_event_output(snd_seq_t *handle, snd_seq_event_t *ev)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_event_output_buffer(snd_seq_t *handle, snd_seq_event_t *ev)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_event_output_direct(snd_seq_t *handle, snd_seq_event_t *ev)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_event_input(snd_seq_t *handle, snd_seq_event_t **ev)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_event_input_pending(snd_seq_t *seq, int fetch_sequencer)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_drain_output(snd_seq_t *handle)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_event_output_pending(snd_seq_t *seq)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_extract_output(snd_seq_t *handle, snd_seq_event_t **ev)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_drop_output(snd_seq_t *handle)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_drop_output_buffer(snd_seq_t *handle)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_drop_input(snd_seq_t *handle)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_drop_input_buffer(snd_seq_t *handle)
 {
 	return -ENXIO;
@@ -1273,7 +1273,7 @@ typedef struct _snd_seq_remove_events snd_seq_remove_events_t;
 #define SND_SEQ_REMOVE_IGNORE_OFF 	(1<<8)	/**< Do not flush off events */
 #define SND_SEQ_REMOVE_TAG_MATCH 	(1<<9)	/**< Restrict to events with given tag */
 
-static inline
+__SALSA_EXPORT_FUNC
 size_t snd_seq_remove_events_sizeof(void)
 {
 	return 0;
@@ -1281,108 +1281,108 @@ size_t snd_seq_remove_events_sizeof(void)
 /** allocate a #snd_seq_remove_events_t container on stack */
 #define snd_seq_remove_events_alloca(ptr)
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_remove_events_malloc(snd_seq_remove_events_t **ptr)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_remove_events_free(snd_seq_remove_events_t *ptr)
 {
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_remove_events_copy(snd_seq_remove_events_t *dst,
 				const snd_seq_remove_events_t *src)
 {
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_seq_remove_events_get_condition(const snd_seq_remove_events_t *info)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_remove_events_get_queue(const snd_seq_remove_events_t *info)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 const snd_seq_timestamp_t *snd_seq_remove_events_get_time(const snd_seq_remove_events_t *info)
 {
 	return NULL;
 }
-static inline
+__SALSA_EXPORT_FUNC
 const snd_seq_addr_t *snd_seq_remove_events_get_dest(const snd_seq_remove_events_t *info)
 {
 	return NULL;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_remove_events_get_channel(const snd_seq_remove_events_t *info)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_remove_events_get_event_type(const snd_seq_remove_events_t *info)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_remove_events_get_tag(const snd_seq_remove_events_t *info)
 {
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_remove_events_set_condition(snd_seq_remove_events_t *info,
 					 unsigned int flags)
 {
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_remove_events_set_queue(snd_seq_remove_events_t *info, int queue)
 {
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_remove_events_set_time(snd_seq_remove_events_t *info,
 				    const snd_seq_timestamp_t *time)
 {
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_remove_events_set_dest(snd_seq_remove_events_t *info,
 				    const snd_seq_addr_t *addr)
 {
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_remove_events_set_channel(snd_seq_remove_events_t *info,
 				       int channel)
 {
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_remove_events_set_event_type(snd_seq_remove_events_t *info,
 					  int type)
 {
 }
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_remove_events_set_tag(snd_seq_remove_events_t *info, int tag)
 {
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_remove_events(snd_seq_t *handle, snd_seq_remove_events_t *info)
 {
 	return -ENXIO;
 }
 
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_seq_set_bit(int nr, void *array)
 {
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_change_bit(int nr, void *array)
 {
 	return 0;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_get_bit(int nr, void *array)
 {
 	return 0;
diff --git a/src/seqmid.h b/src/seqmid.h
index 275c355..5ab9e87 100644
--- a/src/seqmid.h
+++ b/src/seqmid.h
@@ -22,7 +22,7 @@
 #define snd_seq_ev_set_queue_pos_real(ev, q, rtime)
 #define snd_seq_ev_set_queue_pos_tick(ev, q, ttime)
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_control_queue(snd_seq_t *seq, int q, int type, int value,
 			  snd_seq_event_t *ev)
 {
@@ -37,86 +37,86 @@ int snd_seq_control_queue(snd_seq_t *seq, int q, int type, int value,
 #define snd_seq_change_queue_tempo(seq, q, tempo, ev) \
 	snd_seq_control_queue(seq, q, SND_SEQ_EVENT_TEMPO, tempo, ev)
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_create_simple_port(snd_seq_t *seq, const char *name,
 			       unsigned int caps, unsigned int type)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_delete_simple_port(snd_seq_t *seq, int port)
 {
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_connect_from(snd_seq_t *seq, int my_port, int src_client,
 			 int src_port)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_connect_to(snd_seq_t *seq, int my_port, int dest_client,
 		       int dest_port)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_disconnect_from(snd_seq_t *seq, int my_port, int src_client,
 			    int src_port)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_disconnect_to(snd_seq_t *seq, int my_port, int dest_client,
 			  int dest_port)
 {
 	return -ENXIO;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_set_client_name(snd_seq_t *seq, const char *name)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_set_client_event_filter(snd_seq_t *seq, int event_type)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_set_client_pool_output(snd_seq_t *seq, size_t size)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_set_client_pool_output_room(snd_seq_t *seq, size_t size)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_set_client_pool_input(snd_seq_t *seq, size_t size)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_sync_output_queue(snd_seq_t *seq)
 {
 	return -ENXIO;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_parse_address(snd_seq_t *seq, snd_seq_addr_t *addr, const char *str)
 {
 	return -ENXIO;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_reset_pool_output(snd_seq_t *seq)
 {
 	return -ENXIO;
 }
-static inline
+__SALSA_EXPORT_FUNC
 int snd_seq_reset_pool_input(snd_seq_t *seq)
 {
 	return -ENXIO;
diff --git a/src/timer.h b/src/timer.h
index c884e1f..c70e8e0 100644
--- a/src/timer.h
+++ b/src/timer.h
@@ -22,13 +22,7 @@
 #ifndef __ALSA_TIMER_H
 #define __ALSA_TIMER_H
 
-#include "recipe.h"
-#include "global.h"
-#include "timer_types.h"
-
-
-int snd_timer_open(snd_timer_t **handle, const char *name, int mode);
-int snd_timer_close(snd_timer_t *handle);
+#include "timer_func.h"
 
 #include "timer_macros.h"
 
diff --git a/src/timer_abi.c b/src/timer_abi.c
new file mode 100644
index 0000000..e579523
--- /dev/null
+++ b/src/timer_abi.c
@@ -0,0 +1,4 @@
+#include "timer_func.h"
+#undef __SALSA_EXPORT_FUNC
+#define __SALSA_EXPORT_FUNC
+#include "timer_macros.h"
diff --git a/src/timer_func.h b/src/timer_func.h
new file mode 100644
index 0000000..7942b19
--- /dev/null
+++ b/src/timer_func.h
@@ -0,0 +1,10 @@
+/*
+ */
+
+#include "recipe.h"
+#include "global.h"
+#include "hcontrol.h"
+#include "timer_types.h"
+
+int snd_timer_open(snd_timer_t **handle, const char *name, int mode);
+int snd_timer_close(snd_timer_t *handle);
diff --git a/src/timer_macros.h b/src/timer_macros.h
index 89695c8..a1837e7 100644
--- a/src/timer_macros.h
+++ b/src/timer_macros.h
@@ -9,6 +9,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <errno.h>
+#include <unistd.h>
 #include <sys/ioctl.h>
 #include <sys/poll.h>
 
@@ -24,7 +25,7 @@ struct _snd_timer {
 /*
  */
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_timer_nonblock(snd_timer_t *timer, int nonblock)
 {
 	int err = _snd_set_nonblock(timer->fd, nonblock);
@@ -37,27 +38,27 @@ int snd_timer_nonblock(snd_timer_t *timer, int nonblock)
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_timer_poll_descriptors_count(snd_timer_t *handle)
 {
 	return 1;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_timer_poll_descriptors(snd_timer_t *handle, struct pollfd *pfds, unsigned int space)
 {
 	*pfds = handle->pollfd;
 	return 1;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_timer_poll_descriptors_revents(snd_timer_t *timer, struct pollfd *pfds, unsigned int nfds, unsigned short *revents)
 {
 	*revents = pfds->events;
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_timer_info(snd_timer_t *handle, snd_timer_info_t *info)
 {
 	if (ioctl(handle->fd, SNDRV_TIMER_IOCTL_INFO, info) < 0)
@@ -65,7 +66,7 @@ int snd_timer_info(snd_timer_t *handle, snd_timer_info_t *info)
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_timer_params(snd_timer_t *handle, snd_timer_params_t *params)
 {
 	if (ioctl(handle->fd, SNDRV_TIMER_IOCTL_PARAMS, params) < 0)
@@ -73,7 +74,7 @@ int snd_timer_params(snd_timer_t *handle, snd_timer_params_t *params)
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_timer_status(snd_timer_t *handle, snd_timer_status_t *status)
 {
 	if (ioctl(handle->fd, SNDRV_TIMER_IOCTL_STATUS, status) < 0)
@@ -81,7 +82,7 @@ int snd_timer_status(snd_timer_t *handle, snd_timer_status_t *status)
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_timer_start(snd_timer_t *handle)
 {
 	if (ioctl(handle->fd, SNDRV_TIMER_IOCTL_START) < 0)
@@ -89,7 +90,7 @@ int snd_timer_start(snd_timer_t *handle)
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_timer_stop(snd_timer_t *handle)
 {
 	if (ioctl(handle->fd, SNDRV_TIMER_IOCTL_STOP) < 0)
@@ -97,7 +98,7 @@ int snd_timer_stop(snd_timer_t *handle)
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_timer_continue(snd_timer_t *handle)
 {
 	if (ioctl(handle->fd, SNDRV_TIMER_IOCTL_CONTINUE) < 0)
@@ -105,7 +106,7 @@ int snd_timer_continue(snd_timer_t *handle)
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 ssize_t snd_timer_read(snd_timer_t *handle, void *buffer, size_t size)
 {
 	ssize_t result;
@@ -117,61 +118,61 @@ ssize_t snd_timer_read(snd_timer_t *handle, void *buffer, size_t size)
 
 __snd_define_type(snd_timer_id);
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_timer_id_set_class(snd_timer_id_t *id, int dev_class)
 {
 	id->dev_class = dev_class;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_timer_id_get_class(snd_timer_id_t *id)
 {
 	return id->dev_class;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_timer_id_set_sclass(snd_timer_id_t *id, int dev_sclass)
 {
 	id->dev_sclass = dev_sclass;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_timer_id_get_sclass(snd_timer_id_t *id)
 {
 	return id->dev_sclass;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_timer_id_set_card(snd_timer_id_t *id, int card)
 {
 	id->card = card;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_timer_id_get_card(snd_timer_id_t *id)
 {
 	return id->card;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_timer_id_set_device(snd_timer_id_t *id, int device)
 {
 	id->device = device;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_timer_id_get_device(snd_timer_id_t *id)
 {
 	return id->device;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_timer_id_set_subdevice(snd_timer_id_t *id, int subdevice)
 {
 	id->subdevice = subdevice;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_timer_id_get_subdevice(snd_timer_id_t *id)
 {
 	return id->subdevice;
@@ -179,62 +180,62 @@ int snd_timer_id_get_subdevice(snd_timer_id_t *id)
 
 __snd_define_type(snd_timer_ginfo);
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_timer_ginfo_set_tid(snd_timer_ginfo_t *obj, snd_timer_id_t *tid)
 {
 	obj->tid = *tid;
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 snd_timer_id_t *snd_timer_ginfo_get_tid(snd_timer_ginfo_t *obj)
 {
 	return &obj->tid;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_timer_ginfo_get_flags(snd_timer_ginfo_t *obj)
 {
 	return obj->flags;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_timer_ginfo_get_card(snd_timer_ginfo_t *obj)
 {
 	return obj->card;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 char *snd_timer_ginfo_get_id(snd_timer_ginfo_t *obj)
 {
 	return (char *)obj->id;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 char *snd_timer_ginfo_get_name(snd_timer_ginfo_t *obj)
 {
 	return (char *)obj->name;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned long snd_timer_ginfo_get_resolution(snd_timer_ginfo_t *obj)
 {
 	return obj->resolution;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned long snd_timer_ginfo_get_resolution_min(snd_timer_ginfo_t *obj)
 {
 	return obj->resolution_min;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned long snd_timer_ginfo_get_resolution_max(snd_timer_ginfo_t *obj)
 {
 	return obj->resolution_max;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_timer_ginfo_get_clients(snd_timer_ginfo_t *obj)
 {
 	return obj->clients;
@@ -242,31 +243,31 @@ unsigned int snd_timer_ginfo_get_clients(snd_timer_ginfo_t *obj)
 
 __snd_define_type(snd_timer_info);
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_timer_info_is_slave(snd_timer_info_t * info)
 {
 	return info->flags & SNDRV_TIMER_FLG_SLAVE ? 1 : 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_timer_info_get_card(snd_timer_info_t * info)
 {
 	return info->card;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 const char *snd_timer_info_get_id(snd_timer_info_t * info)
 {
 	return (const char *)info->id;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 const char *snd_timer_info_get_name(snd_timer_info_t * info)
 {
 	return (const char *)info->name;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 long snd_timer_info_get_resolution(snd_timer_info_t * info)
 {
 	return info->resolution;
@@ -274,7 +275,7 @@ long snd_timer_info_get_resolution(snd_timer_info_t * info)
 
 __snd_define_type(snd_timer_params);
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_timer_params_set_auto_start(snd_timer_params_t * params,
 				    int auto_start)
 {
@@ -285,13 +286,13 @@ int snd_timer_params_set_auto_start(snd_timer_params_t * params,
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_timer_params_get_auto_start(snd_timer_params_t * params)
 {
 	return params->flags & SNDRV_TIMER_PSFLG_AUTO ? 1 : 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_timer_params_set_exclusive(snd_timer_params_t * params, int exclusive)
 {
 	if (exclusive)
@@ -301,13 +302,13 @@ int snd_timer_params_set_exclusive(snd_timer_params_t * params, int exclusive)
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_timer_params_get_exclusive(snd_timer_params_t * params)
 {
 	return params->flags & SNDRV_TIMER_PSFLG_EXCLUSIVE ? 1 : 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_timer_params_set_early_event(snd_timer_params_t * params,
 				     int early_event)
 {
@@ -318,45 +319,45 @@ int snd_timer_params_set_early_event(snd_timer_params_t * params,
 	return 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 int snd_timer_params_get_early_event(snd_timer_params_t * params)
 {
 	return params->flags & SNDRV_TIMER_PSFLG_EARLY_EVENT ? 1 : 0;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_timer_params_set_ticks(snd_timer_params_t * params, long ticks)
 {
 	params->ticks = ticks;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 long snd_timer_params_get_ticks(snd_timer_params_t * params)
 {
 	return params->ticks;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_timer_params_set_queue_size(snd_timer_params_t * params,
 				     long queue_size)
 {
 	params->queue_size = queue_size;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 long snd_timer_params_get_queue_size(snd_timer_params_t * params)
 {
 	return params->queue_size;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 void snd_timer_params_set_filter(snd_timer_params_t * params,
 				 unsigned int filter)
 {
 	params->filter = filter;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 unsigned int snd_timer_params_get_filter(snd_timer_params_t * params)
 {
 	return params->filter;
@@ -364,31 +365,31 @@ unsigned int snd_timer_params_get_filter(snd_timer_params_t * params)
 
 __snd_define_type(snd_timer_status);
 
-static inline
+__SALSA_EXPORT_FUNC
 snd_htimestamp_t snd_timer_status_get_timestamp(snd_timer_status_t * status)
 {
 	return status->tstamp;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 long snd_timer_status_get_resolution(snd_timer_status_t * status)
 {
 	return status->resolution;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 long snd_timer_status_get_lost(snd_timer_status_t * status)
 {
 	return status->lost;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 long snd_timer_status_get_overrun(snd_timer_status_t * status)
 {
 	return status->overrun;
 }
 
-static inline
+__SALSA_EXPORT_FUNC
 long snd_timer_status_get_queue(snd_timer_status_t * status)
 {
 	return status->queue;
@@ -397,59 +398,59 @@ long snd_timer_status_get_queue(snd_timer_status_t * status)
 /*
  * not implemented
  */
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_timer_query_open(snd_timer_query_t **handle, const char *name, int mode)
 {
 	return -ENXIO;
 }
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_timer_query_open_lconf(snd_timer_query_t **handle, const char *name,
 			       int mode, snd_config_t *lconf)
 {
 	return -ENXIO;
 }
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_timer_query_close(snd_timer_query_t *handle)
 {
 	return 0;
 }
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_timer_query_next_device(snd_timer_query_t *handle, snd_timer_id_t *tid)
 {
 	return -ENXIO;
 }
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_timer_query_info(snd_timer_query_t *handle, snd_timer_ginfo_t *info)
 {
 	return -ENXIO;
 }
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_timer_query_params(snd_timer_query_t *handle,
 			   snd_timer_gparams_t *params)
 {
 	return -ENXIO;
 }
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_timer_query_status(snd_timer_query_t *handle,
 			   snd_timer_gstatus_t *status)
 {
 	return -ENXIO;
 }
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_timer_open_lconf(snd_timer_t **handle, const char *name, int mode,
 			 snd_config_t *lconf)
 {
 	return -ENXIO;
 }
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 int snd_async_add_timer_handler(snd_async_handler_t **handler,
 				snd_timer_t *timer,
 				snd_async_callback_t callback,
@@ -458,7 +459,7 @@ int snd_async_add_timer_handler(snd_async_handler_t **handler,
 	return -ENXIO;
 }
 
-static inline __SALSA_NOT_IMPLEMENTED
+__SALSA_EXPORT_FUNC __SALSA_NOT_IMPLEMENTED
 snd_timer_t *snd_async_handler_get_timer(snd_async_handler_t *handler)
 {
 	return NULL;