Index: include/libroar/basic.h
===================================================================
--- include/libroar/basic.h	(revision 5240)
+++ include/libroar/basic.h	(revision 5270)
@@ -58,5 +58,5 @@
  unsigned int stream;
  uint32_t pos;
- int datalen;
+ size_t datalen;
  char data[LIBROAR_BUFFER_MSGDATA];
  int16_t seq;
Index: include/libroar/config.h
===================================================================
--- include/libroar/config.h	(revision 5202)
+++ include/libroar/config.h	(revision 5270)
@@ -70,5 +70,5 @@
 
 struct roar_libroar_config_codec {
- unsigned int codec; // Codec ID
+ uint32_t codec; // Codec ID
 
  // parameters which are set:
Index: include/libroar/ltm.h
===================================================================
--- include/libroar/ltm.h	(revision 4708)
+++ include/libroar/ltm.h	(revision 5270)
@@ -140,5 +140,5 @@
  * result set was collected in the server.
  */
-int roar_ltm_get_numchans(struct roar_ltm_result * res, int streamidx);
+int roar_ltm_get_numchans(struct roar_ltm_result * res, size_t streamidx);
 
 /* Extract a single value from the result.
@@ -160,5 +160,5 @@
  * (channels are counted from zero to N-1, not from 1 to N)
  */
-int64_t roar_ltm_extract(struct roar_ltm_result * res, int mt, int streamidx, int channel);
+int64_t roar_ltm_extract(struct roar_ltm_result * res, int mt, size_t streamidx, int channel);
 
 #endif
Index: include/libroar/stream.h
===================================================================
--- include/libroar/stream.h	(revision 5238)
+++ include/libroar/stream.h	(revision 5270)
@@ -96,9 +96,9 @@
 int roar_stream_m2s     (struct roar_stream * s, struct roar_message * m);
 
-int    roar_str2codec (const char * codec) _LIBROAR_STREAM_STDATTRS _LIBROAR_ATTR_PURE;
-const char * roar_codec2str (const int    codec) _LIBROAR_ATTR_USE_RESULT _LIBROAR_ATTR_PURE;
+int32_t      roar_str2codec (const char   * codec) _LIBROAR_STREAM_STDATTRS _LIBROAR_ATTR_PURE;
+const char * roar_codec2str (const uint32_t codec) _LIBROAR_ATTR_USE_RESULT _LIBROAR_ATTR_PURE;
 
-int    roar_mime2codec (const char * mime) _LIBROAR_STREAM_STDATTRS _LIBROAR_ATTR_PURE;
-const char * roar_codec2mime (const int    codec) _LIBROAR_ATTR_USE_RESULT _LIBROAR_ATTR_PURE;
+int32_t      roar_mime2codec (const char   * mime) _LIBROAR_STREAM_STDATTRS _LIBROAR_ATTR_PURE;
+const char * roar_codec2mime (const uint32_t codec) _LIBROAR_ATTR_USE_RESULT _LIBROAR_ATTR_PURE;
 
 int32_t roar_str2rate(const char * rate) _LIBROAR_STREAM_STDATTRS _LIBROAR_ATTR_PURE;
Index: include/libroardsp/amp.h
===================================================================
--- include/libroardsp/amp.h	(revision 4708)
+++ include/libroardsp/amp.h	(revision 5270)
@@ -42,5 +42,4 @@
 int roar_amp_pcm_8bit  (int8_t  * output, int8_t  * input, int samples, int channels, struct roar_mixer_settings * set);
 int roar_amp_pcm_16bit (int16_t * output, int16_t * input, int samples, int channels, struct roar_mixer_settings * set);
-int roar_amp_pcm_24bit (void    * output, void    * input, int samples, int channels, struct roar_mixer_settings * set);
 int roar_amp_pcm_32bit (int32_t * output, int32_t * input, int samples, int channels, struct roar_mixer_settings * set);
 
Index: include/libroardsp/fader.h
===================================================================
--- include/libroardsp/fader.h	(revision 4708)
+++ include/libroardsp/fader.h	(revision 5270)
@@ -43,5 +43,5 @@
 struct roar_fader_state {
  int     rate;
- size_t  pcmoffset;
+ ssize_t pcmoffset;
  ssize_t start;
  ssize_t stop;
Index: include/libroardsp/mixer.h
===================================================================
--- include/libroardsp/mixer.h	(revision 4708)
+++ include/libroardsp/mixer.h	(revision 5270)
@@ -42,5 +42,4 @@
 int roar_mix_pcm_8bit  (int8_t  * output, int8_t  ** input, int samples);
 int roar_mix_pcm_16bit (int16_t * output, int16_t ** input, int samples);
-int roar_mix_pcm_24bit (void    * output, void    ** input, int samples);
 int roar_mix_pcm_32bit (int32_t * output, int32_t ** input, int samples);
 
Index: libroar/Makefile
===================================================================
--- libroar/Makefile	(revision 5220)
+++ libroar/Makefile	(revision 5270)
@@ -17,5 +17,5 @@
 INCLUDE = -I../include -I../include/libroar
 CFLAGS += -g -Wall $(OPTI_O) $(DEFINES) $(INCLUDE) $(INCPATH) $(SHARED_CF) $(fPIC)
-LDFLAGS+= -g $(SHARED) $(LDPATH)
+LDFLAGS+= -g -Wall $(SHARED) $(LDPATH)
 LIBS    = $(LIBROAR_NS)
 
Index: libroar/acl.c
===================================================================
--- libroar/acl.c	(revision 4708)
+++ libroar/acl.c	(revision 5270)
@@ -44,5 +44,5 @@
   return 0;
 
- if ( rule->addr && !addr )
+ if ( rule->addr && addr != NULL )
   return 0;
 
Index: libroar/authfile.c
===================================================================
--- libroar/authfile.c	(revision 4973)
+++ libroar/authfile.c	(revision 5270)
@@ -223,5 +223,5 @@
     if ( roar_vio_lseek(&(authfile->vio), 0, SEEK_SET) != 0 )
      return -1;
-    if ( roar_vio_write(&(authfile->vio), key->data, key->len) != key->len )
+    if ( roar_vio_write(&(authfile->vio), key->data, key->len) != (ssize_t)key->len )
      return -1;
     if ( roar_authfile_unlock(authfile) == -1 )
Index: libroar/config.c
===================================================================
--- libroar/config.c	(revision 5202)
+++ libroar/config.c	(revision 5270)
@@ -37,5 +37,5 @@
 
 static struct roar_libroar_config_codec *
-           roar_libroar_config_codec_get_conf(int codec, int create, struct roar_libroar_config * config);
+           roar_libroar_config_codec_get_conf(uint32_t codec, int create, struct roar_libroar_config * config);
 
 
@@ -318,6 +318,6 @@
 
 static struct roar_libroar_config_codec *
-           roar_libroar_config_codec_get_conf(int codec, int create, struct roar_libroar_config * config) {
- int i;
+           roar_libroar_config_codec_get_conf(uint32_t codec, int create, struct roar_libroar_config * config) {
+ size_t i;
  int need_new = 1;
 
@@ -337,5 +337,5 @@
    if ( config->codecs.codec[i].codec == codec )
     return &(config->codecs.codec[i]);
-   if ( config->codecs.codec[i].codec == -1 )
+   if ( config->codecs.codec[i].codec == (uint32_t)-1 )
     need_new = 0;
   }
@@ -349,5 +349,5 @@
  if ( !need_new ) {
   for (i = 0; i < config->codecs.num; i++) {
-   if ( config->codecs.codec[i].codec == -1 ) {
+   if ( config->codecs.codec[i].codec == (uint32_t)-1 ) {
     memset(&(config->codecs.codec[i]), 0, sizeof(struct roar_libroar_config_codec));
     config->codecs.codec[i].codec = codec;
@@ -368,5 +368,5 @@
  memset(&(config->codecs.codec[config->codecs.num]), 0, 16);
  for (i = config->codecs.num; i < (config->codecs.num+16); i++) {
-  config->codecs.codec[i].codec = -1;
+  config->codecs.codec[i].codec = (uint32_t)-1;
  }
 
Index: libroar/debug.c
===================================================================
--- libroar/debug.c	(revision 5201)
+++ libroar/debug.c	(revision 5270)
@@ -184,5 +184,5 @@
  ret = snprintf(buf, sizeof(buf), "(%s: %s:%lu): %s: ", prefix, file, line, typename);
 
- if ( ret > 0 && ret < sizeof(buf) ) {
+ if ( ret > 0 && ret < (int)sizeof(buf) ) {
   bufp += ret;
  } else {
Index: libroar/enumdev.c
===================================================================
--- libroar/enumdev.c	(revision 5238)
+++ libroar/enumdev.c	(revision 5270)
@@ -101,4 +101,6 @@
  int i;
 #endif
+
+ (void)flags, (void)dir, (void)socktype;
 
  if ( maxlen < 10 )
@@ -207,4 +209,6 @@
  };
 
+ (void)flags, (void)dir, (void)socktype;
+
  for (f = &(files[0]); f->file != NULL; f++) {
   if ( (inp = fopen(f->file, "r")) == NULL )
Index: libroar/env.c
===================================================================
--- libroar/env.c	(revision 5008)
+++ libroar/env.c	(revision 5270)
@@ -60,4 +60,6 @@
 const char * roar_env_get_home(int level) {
  const char * home = getenv("HOME");
+
+ (void)level;
 
  return home;
Index: libroar/error.c
===================================================================
--- libroar/error.c	(revision 5252)
+++ libroar/error.c	(revision 5270)
@@ -918,5 +918,5 @@
  static char buf[1024] = "";
  int num[8];
- int i;
+ size_t i;
  int _ra_err = roar_error;
  int _sys_err = errno;
Index: libroar/hash.c
===================================================================
--- libroar/hash.c	(revision 5188)
+++ libroar/hash.c	(revision 5270)
@@ -146,5 +146,5 @@
  int i;
 
- for (i = 0; _libroar_hashes[i].id != -1; i++)
+ for (i = 0; _libroar_hashes[i].id != (uint_least32_t)-1; i++)
   if ( _libroar_hashes[i].id == ht )
    return _libroar_hashes[i].name;
@@ -157,5 +157,5 @@
  int i;
 
- for (i = 0; _libroar_hashes[i].id != -1; i++)
+ for (i = 0; _libroar_hashes[i].id != (uint_least32_t)-1; i++)
   if ( !strcasecmp(_libroar_hashes[i].name, ht) )
    return _libroar_hashes[i].id;
@@ -168,5 +168,5 @@
  int i;
 
- for (i = 0; _libroar_hashes[i].id != -1; i++)
+ for (i = 0; _libroar_hashes[i].id != (uint_least32_t)-1; i++)
   if ( _libroar_hashes[i].id == ht )
    return _libroar_hashes[i].dlen;
Index: libroar/hash_tiger.c
===================================================================
--- libroar/hash_tiger.c	(revision 4721)
+++ libroar/hash_tiger.c	(revision 5270)
@@ -580,4 +580,5 @@
 
 int roar_hash_tiger_uninit(struct roar_hash_tiger * state) {
+ (void)state;
  return 0;
 }
@@ -667,4 +668,5 @@
 
 ssize_t roar_hash_tiger_statelen(struct roar_hash_tiger * state) {
+ (void)state;
  return PSTATE_LEN;
 }
@@ -827,4 +829,5 @@
 
 ssize_t roar_hash_tiger_blocklen(struct roar_hash_tiger * state) {
+ (void)state;
  return BLOCK_LEN;
 }
Index: libroar/libroar.c
===================================================================
--- libroar/libroar.c	(revision 5020)
+++ libroar/libroar.c	(revision 5270)
@@ -216,4 +216,7 @@
 //#define ROAR_ERR(format, args...)  roar_debug_msg(ROAR_DEBUG_TYPE_ERROR, __LINE__, __FILE__, ROAR_DBG_PREFIX, format, ## args)
 
+ // we do not support info-text at the moment.
+ (void)info;
+
  if ( func == NULL )
   func = "<unknown>";
Index: libroar/ltm.c
===================================================================
--- libroar/ltm.c	(revision 5145)
+++ libroar/ltm.c	(revision 5270)
@@ -175,5 +175,5 @@
  char * buf = NULL;
  int    ret;
- int    i;
+ size_t i;
 
  if ( con == NULL ) {
@@ -260,8 +260,8 @@
 }
 
-static int64_t * roar_ltm_get_streamptr(struct roar_ltm_result * res, int streamidx) {
+static int64_t * roar_ltm_get_streamptr(struct roar_ltm_result * res, size_t streamidx) {
  int64_t * ptr;
  int numchans;
- int i;
+ size_t i;
 
  ROAR_DBG("roar_ltm_get_streamptr(res=%p, streamidx=%i) = ?", res, streamidx);
@@ -289,5 +289,5 @@
 }
 
-int roar_ltm_get_numchans(struct roar_ltm_result * res, int streamidx) {
+int roar_ltm_get_numchans(struct roar_ltm_result * res, size_t streamidx) {
  int64_t * ptr = roar_ltm_get_streamptr(res, streamidx);
 
@@ -298,5 +298,5 @@
 }
 
-int64_t roar_ltm_extract(struct roar_ltm_result * res, int mt, int streamidx, int channel) {
+int64_t roar_ltm_extract(struct roar_ltm_result * res, int mt, size_t streamidx, int channel) {
  int64_t * ptr = roar_ltm_get_streamptr(res, streamidx);
  int numchans;
Index: libroar/memmgr.c
===================================================================
--- libroar/memmgr.c	(revision 5010)
+++ libroar/memmgr.c	(revision 5270)
@@ -366,5 +366,5 @@
   memcpy(dst+dlen, src, slen);
   dst[dlen+slen] = 0;
- } else if ( dlen != size ) {
+ } else if ( dlen != (ssize_t)size ) {
   memcpy(dst+dlen, src, size-dlen-1);
   dst[size-1] = 0;
Index: libroar/meta.c
===================================================================
--- libroar/meta.c	(revision 5054)
+++ libroar/meta.c	(revision 5270)
@@ -520,5 +520,5 @@
 
 int roar_stream_meta_list (struct roar_connection * con, struct roar_stream * s, int * types, size_t len) {
- int i;
+ size_t i;
  struct roar_message m;
 
Index: libroar/pinentry.c
===================================================================
--- libroar/pinentry.c	(revision 5016)
+++ libroar/pinentry.c	(revision 5270)
@@ -177,5 +177,5 @@
  len = strlen(cmd);
 
- if ( write(pe->out, cmd, len) != len )
+ if ( write(pe->out, cmd, len) != (ssize_t)len )
   return -1;
 
@@ -186,5 +186,5 @@
   len = strlen(args);
 
-  if ( write(pe->out, args, len) != len )
+  if ( write(pe->out, args, len) != (ssize_t)len )
    return -1;
  }
Index: libroar/proto.c
===================================================================
--- libroar/proto.c	(revision 5216)
+++ libroar/proto.c	(revision 5270)
@@ -111,10 +111,10 @@
  }
 
- if ( roar_vio_write(vio, buf, headerlen) != headerlen ) {
+ if ( roar_vio_write(vio, buf, headerlen) != (ssize_t)headerlen ) {
   return -1;
  }
 
  if ( mes->datalen != 0 ) {
-  if ( roar_vio_write(vio, data == NULL ? mes->data : data, mes->datalen) != mes->datalen ) {
+  if ( roar_vio_write(vio, data == NULL ? mes->data : data, mes->datalen) != (ssize_t)mes->datalen ) {
    return -1;
   }
@@ -122,5 +122,5 @@
 
  if ( crclen != 0 ) {
-  if ( roar_vio_write(vio, crc, crclen) != crclen ) {
+  if ( roar_vio_write(vio, crc, crclen) != (ssize_t)crclen ) {
    return -1;
   }
@@ -253,5 +253,5 @@
 
  if ( mes->datalen <= LIBROAR_BUFFER_MSGDATA ) {
-  if ( roar_vio_read(vio, mes->data, mes->datalen) == mes->datalen ) {
+  if ( roar_vio_read(vio, mes->data, mes->datalen) == (ssize_t)mes->datalen ) {
    ROAR_DBG("roar_vrecv_message2(*): Got data!");
    roar_err_clear();
@@ -285,5 +285,5 @@
   }
 
-  if ( roar_vio_read(vio, *data, mes->datalen) == mes->datalen ) {
+  if ( roar_vio_read(vio, *data, mes->datalen) == (ssize_t)mes->datalen ) {
    ROAR_DBG("roar_vrecv_message2(*): Got data!");
 
Index: libroar/roardl.c
===================================================================
--- libroar/roardl.c	(revision 5008)
+++ libroar/roardl.c	(revision 5270)
@@ -119,4 +119,6 @@
  void * ret = dlsym(_roardl2ldl(lhandle), sym);
 
+ (void)type;
+
  ROAR_DBG("roar_dl_getsym(lhandle=%p, sym='%s', type=%i) = %p", lhandle, sym, type, ret);
 
@@ -181,4 +183,5 @@
 char *                   roar_dl_errstr(struct roar_dl_lhandle * lhandle) {
 #if defined(ROAR_HAVE_LIBDL)
+ (void)lhandle;
  return dlerror();
 #else
Index: libroar/serverinfo.c
===================================================================
--- libroar/serverinfo.c	(revision 4708)
+++ libroar/serverinfo.c	(revision 5270)
@@ -155,6 +155,6 @@
  struct roar_server_info * ret = NULL;
  uint16_t * d16, * dptr;
- int idx;
- int i;
+ size_t idx;
+ size_t i;
  size_t needlen = 4;
  char * textpart;
Index: libroar/slp.c
===================================================================
--- libroar/slp.c	(revision 4805)
+++ libroar/slp.c	(revision 5270)
@@ -48,4 +48,6 @@
  struct roar_slp_cookie * self = cookie;
 
+ (void)hslp;
+
  ROAR_DBG("roar_slp_url_callback(*) = ?");
 
Index: libroar/socket.c
===================================================================
--- libroar/socket.c	(revision 5261)
+++ libroar/socket.c	(revision 5270)
@@ -1088,5 +1088,5 @@
 
  if ( app_len > 0 )
-  if ( write(fh, app, app_len) != app_len )
+  if ( write(fh, app, app_len) != (ssize_t)app_len )
    return -1;
 
Index: libroar/stream.c
===================================================================
--- libroar/stream.c	(revision 5240)
+++ libroar/stream.c	(revision 5270)
@@ -510,5 +510,5 @@
  }
 
- if ( data[1] != ROAR_STREAM_PARA_NAME ) {
+ if ( data[1] != (uint16_t)ROAR_STREAM_PARA_NAME ) {
   roar_err_set(ROAR_ERROR_TYPEMM);
   return -1;
@@ -815,5 +815,5 @@
 */
 
-static struct {
+static const struct {
  int    dir;
  const char * name;
@@ -870,8 +870,8 @@
 */
 
-static struct {
- int    codec;
- const char * name;
- const char * mime;
+static const struct {
+ const uint32_t codec;
+ const char   * name;
+ const char   * mime;
 } _libroar_codec[] = {
  // PCM:
@@ -975,6 +975,6 @@
 };
 
-int roar_str2codec(const char * codec) {
- int i;
+int32_t roar_str2codec(const char * codec) {
+ size_t i;
  int guess;
 
@@ -985,5 +985,5 @@
   return guess;
 
- for (i = 0; _libroar_codec[i].codec != -1; i++)
+ for (i = 0; _libroar_codec[i].codec != (uint32_t)-1; i++)
   if ( strcasecmp(_libroar_codec[i].name, codec) == 0 )
    return _libroar_codec[i].codec;
@@ -994,8 +994,8 @@
 
 
-const char * roar_codec2str (const int codec) {
+const char * roar_codec2str (const uint32_t codec) {
  int i;
 
- for (i = 0; _libroar_codec[i].codec != -1; i++)
+ for (i = 0; _libroar_codec[i].codec != (uint32_t)-1; i++)
   if ( _libroar_codec[i].codec == codec )
    return _libroar_codec[i].name;
@@ -1004,6 +1004,6 @@
 }
 
-int    roar_mime2codec (const char * mime) {
- int i;
+int32_t  roar_mime2codec (const char * mime) {
+ size_t i;
 
  if ( mime == NULL ) {
@@ -1017,5 +1017,5 @@
  }
 
- for (i = 0; _libroar_codec[i].codec != -1; i++)
+ for (i = 0; _libroar_codec[i].codec != (uint32_t)-1; i++)
   if ( _libroar_codec[i].mime != NULL )
    if ( strcasecmp(_libroar_codec[i].mime, mime) == 0 )
@@ -1026,8 +1026,8 @@
 }
 
-const char * roar_codec2mime (const int    codec) {
- int i;
-
- for (i = 0; _libroar_codec[i].codec != -1; i++)
+const char * roar_codec2mime (const uint32_t   codec) {
+ size_t i;
+
+ for (i = 0; _libroar_codec[i].codec != (uint32_t)-1; i++)
   if ( _libroar_codec[i].codec == codec )
    return _libroar_codec[i].mime;
@@ -1110,5 +1110,5 @@
 }
 
-static struct {
+static const struct {
  int    role;
  const char * name;
@@ -1209,5 +1209,5 @@
 }
 
-static struct {
+static const struct {
  const char * name;
  struct roar_audio_info info;
Index: libroar/trap.c
===================================================================
--- libroar/trap.c	(revision 4784)
+++ libroar/trap.c	(revision 5270)
@@ -54,5 +54,7 @@
  size_t i;
 
- for (i = 0; i < (sizeof(_libroar_trap_groups)/sizeof(*_libroar_trap_groups)) && _libroar_trap_groups[i].id != -1; i++);
+ for (i = 0;
+      i < (sizeof(_libroar_trap_groups)/sizeof(*_libroar_trap_groups)) && _libroar_trap_groups[i].id != (unsigned int)-1;
+      i++);
  if ( i == (sizeof(_libroar_trap_groups)/sizeof(*_libroar_trap_groups)) )
   return -1;
@@ -68,5 +70,7 @@
  size_t i;
 
- for (i = 0; i < (sizeof(_libroar_trap_groups)/sizeof(*_libroar_trap_groups)) && _libroar_trap_groups[i].id != -1; i++) {
+ for (i = 0;
+      i < (sizeof(_libroar_trap_groups)/sizeof(*_libroar_trap_groups)) && _libroar_trap_groups[i].id != (unsigned int)-1;
+      i++) {
   if ( _libroar_trap_groups[i].id == group )
    return _libroar_trap_groups[i].name;
@@ -79,5 +83,7 @@
  size_t i;
 
- for (i = 0; i < (sizeof(_libroar_trap_groups)/sizeof(*_libroar_trap_groups)) && _libroar_trap_groups[i].id != -1; i++) {
+ for (i = 0;
+      i < (sizeof(_libroar_trap_groups)/sizeof(*_libroar_trap_groups)) && _libroar_trap_groups[i].id != (unsigned int)-1;
+      i++) {
   if ( !strcasecmp(_libroar_trap_groups[i].name, name) )
    return _libroar_trap_groups[i].id;
@@ -128,4 +134,5 @@
  }
 #else
+ (void)group, (void)name, (void)line, (void)file, (void)prefix;
  return;
 #endif
Index: libroar/vio.c
===================================================================
--- libroar/vio.c	(revision 5260)
+++ libroar/vio.c	(revision 5270)
@@ -686,4 +686,6 @@
 // null
 ssize_t roar_vio_null_rw    (struct roar_vio_calls * vio, void *buf, size_t count) {
+ (void)count;
+
  if ( vio == NULL || buf == NULL ) {
   roar_err_set(ROAR_ERROR_FAULT);
@@ -695,4 +697,5 @@
 
 int     roar_vio_null_sync    (struct roar_vio_calls * vio) {
+ (void)vio;
  return 0;
 }
Index: libroar/vio_dstr.c
===================================================================
--- libroar/vio_dstr.c	(revision 5257)
+++ libroar/vio_dstr.c	(revision 5270)
@@ -37,5 +37,5 @@
 
 #ifndef ROAR_WITHOUT_VIO_DSTR
-struct _roar_vio_dstr_type {
+static struct _roar_vio_dstr_type {
  const int    id;
  const char * name;
Index: libroar/vio_jumbo.c
===================================================================
--- libroar/vio_jumbo.c	(revision 4708)
+++ libroar/vio_jumbo.c	(revision 5270)
@@ -147,5 +147,5 @@
 
  // TODO: do this a bit more intelergent (RE?)
- if ( roar_vio_write(self->backend, data, self->pos) != self->pos )
+ if ( roar_vio_write(self->backend, data, self->pos) != (ssize_t)self->pos )
   return -1;
 
Index: libroar/vio_misc.c
===================================================================
--- libroar/vio_misc.c	(revision 4876)
+++ libroar/vio_misc.c	(revision 5270)
@@ -55,4 +55,5 @@
 
 static off_t   roar_vio_misc_lseek   (struct roar_vio_calls * vio, off_t offset, int whence) {
+ (void)vio, (void)offset, (void)whence;
  return 0;
 }
@@ -71,4 +72,5 @@
 
 static int     roar_vio_misc_sync    (struct roar_vio_calls * vio) {
+ (void)vio;
  return 0;
 }
@@ -98,4 +100,5 @@
 
 static int     roar_vio_misc_close   (struct roar_vio_calls * vio) {
+ (void)vio;
  return 0;
 }
@@ -119,12 +122,15 @@
 
 static ssize_t roar_vio_misc_op_return_len (void * buf, size_t len, struct roar_vio_calls * vio, struct roar_vio_misc * callbacks) {
+ (void)buf, (void)vio, (void)callbacks;
  return len;
 }
 
 static ssize_t roar_vio_misc_op_return_zero(void * buf, size_t len, struct roar_vio_calls * vio, struct roar_vio_misc * callbacks) {
+ (void)buf, (void)len, (void)vio, (void)callbacks;
  return 0;
 }
 
 static ssize_t roar_vio_misc_op_zero(void * buf, size_t len, struct roar_vio_calls * vio, struct roar_vio_misc * callbacks) {
+ (void)vio, (void)callbacks;
  memset(buf, 0, len);
  return len;
@@ -133,4 +139,5 @@
 static ssize_t roar_vio_misc_op_full(void * buf, size_t len, struct roar_vio_calls * vio, struct roar_vio_misc * callbacks)
 {
+ (void)buf, (void)len, (void)vio, (void)callbacks;
  roar_err_set(ROAR_ERROR_NOSPC);
  return -1;
@@ -138,4 +145,6 @@
 
 static ssize_t roar_vio_misc_op_random_nonce(void * buf, size_t len, struct roar_vio_calls * vio, struct roar_vio_misc * callbacks) {
+ (void)vio, (void)callbacks;
+
  if ( roar_random_gen_nonce(buf, len) == -1 )
   return -1;
@@ -145,4 +154,6 @@
 
 static ssize_t roar_vio_misc_op_random_salt_nonce(void * buf, size_t len, struct roar_vio_calls * vio, struct roar_vio_misc * callbacks) {
+ (void)vio, (void)callbacks;
+
  if ( roar_random_salt_nonce(buf, len) == -1 )
   return -1;
Index: libroar/vio_pipe.c
===================================================================
--- libroar/vio_pipe.c	(revision 4708)
+++ libroar/vio_pipe.c	(revision 5270)
@@ -215,4 +215,5 @@
  // we may add fdatasync() calls here depending on the type
  // but in general they should not be needed on pipes.
+ (void)vio;
  return 0;
 }
Index: libroar/vio_stdio.c
===================================================================
--- libroar/vio_stdio.c	(revision 5088)
+++ libroar/vio_stdio.c	(revision 5270)
@@ -62,8 +62,13 @@
 #endif
 
+ // (void)flags is the the individual sections because later added APIs
+ // may require those flags.
+
  if ( calls == NULL )
   return NULL;
 
 #if defined(ROAR_HAVE_FOPENCOOKIE)
+ (void)flags;
+
  memset(&foc_funcs, 0, sizeof(cookie_io_functions_t));
 
@@ -74,4 +79,6 @@
  return fopencookie((void*) calls, "rw", foc_funcs);
 #elif defined(ROAR_HAVE_FUNOPEN)
+ (void)flags;
+
  return funopen((void*) calls, roar_vio_to_stdio_read,  roar_vio_to_stdio_write,
                                roar_vio_to_stdio_lseek, roar_vio_to_stdio_close);
Index: libroar/vio_tantalos.c
===================================================================
--- libroar/vio_tantalos.c	(revision 5028)
+++ libroar/vio_tantalos.c	(revision 5270)
@@ -62,4 +62,6 @@
  time_t now = time(NULL);
 
+ (void)dst;
+
  if ( (cookie = roar_vio_open_get_cookie(0)) == NULL )
   return -1;
Index: libroar/vio_zlib.c
===================================================================
--- libroar/vio_zlib.c	(revision 4956)
+++ libroar/vio_zlib.c	(revision 5270)
@@ -51,8 +51,10 @@
 
 static void * _zalloc(voidpf opaque, uInt items, uInt size) {
+ (void)opaque;
  return roar_mm_calloc(items, size);
 }
 
 static void _zfree(voidpf opaque, voidpf address) {
+ (void)opaque;
  roar_mm_free(address);
 }
@@ -220,5 +222,5 @@
   count -= len;
 
-  if ( len == buflen ) {
+  if ( len == (ssize_t)buflen ) {
    ret = roar_buffer_next(&(self->inbuf));
   } else {
@@ -342,5 +344,5 @@
   if ( len == -1 ) {
    return -1;
-  } else if ( len == buflen ) {
+  } else if ( len == (ssize_t)buflen ) {
    if ( roar_buffer_next(&(self->outbuf)) == -1 ) {
     roar_err_set((self->compressor_error = ROAR_ERROR_LOSTSYNC));
@@ -389,5 +391,5 @@
    len = roar_vio_write(self->next, outbuf, outlen);
 
-   if ( len < outlen ) {
+   if ( len < (ssize_t)outlen ) {
     if ( roar_buffer_new_data(&leftbuf, outlen - len, &leftbufdata) == -1 ) {
      roar_err_set((self->compressor_error = ROAR_ERROR_LOSTSYNC));
@@ -428,4 +430,5 @@
 
 static off_t   roar_vio_zlib_lseek   (struct roar_vio_calls * vio, off_t offset, int whence) {
+ (void)vio, (void)offset, (void)whence;
  roar_err_set(ROAR_ERROR_NOSYS);
  return (off_t)-1;
Index: libroar/vs.c
===================================================================
--- libroar/vs.c	(revision 5262)
+++ libroar/vs.c	(revision 5270)
@@ -160,5 +160,5 @@
  ssize_t offset;
  int cmd, subcmd;
- int i;
+ size_t i;
 
  if ( roar_recv_message(vss->con, &mes, &data) == -1 ) {
@@ -1154,5 +1154,5 @@
  }
 
- if ( channels != oldchannels )
+ if ( channels != (size_t)oldchannels )
   mode = ROAR_SET_VOL_UNMAPPED;
 
Index: libroararts/Makefile
===================================================================
--- libroararts/Makefile	(revision 4748)
+++ libroararts/Makefile	(revision 5270)
@@ -8,6 +8,6 @@
 #DEFINES        = -DDEBUG
 INCLUDE = -I../include -I../include/libroarpulse
-CFLAGS += -g -Wall $(OPTI_O) $(DEFINES) $(INCLUDE) $(INCPATH) $(SHARED_CF) $(fPIC)
-LDFLAGS+= -g $(LDPATH) -L../lib/
+CFLAGS += -g -Wall $(Wextra) $(OPTI_O) $(DEFINES) $(INCLUDE) $(INCPATH) $(SHARED_CF) $(fPIC)
+LDFLAGS+= -g -Wall $(Wextra) $(LDPATH) -L../lib/
 LIBS    = $(LIBROAR)
 
Index: libroardsp/Makefile
===================================================================
--- libroardsp/Makefile	(revision 5269)
+++ libroardsp/Makefile	(revision 5270)
@@ -17,5 +17,5 @@
 INCLUDE = -I../include -I../include/libroardsp
 CFLAGS += -g -Wall $(OPTI_O) $(DEFINES) $(INCLUDE) $(INCPATH) $(SHARED_CF) $(fPIC)
-LDFLAGS+= -g $(SHARED) -L../lib/ $(LDPATH)
+LDFLAGS+= -g -Wall $(SHARED) -L../lib/ $(LDPATH)
 
 LIBS      = $(LIBROARDSP_NS)
Index: libroardsp/alaw.c
===================================================================
--- libroardsp/alaw.c	(revision 5210)
+++ libroardsp/alaw.c	(revision 5270)
@@ -58,5 +58,5 @@
 
 #ifdef ROAR_SUPPORT_ALAW
-int16_t _roardsp_alaw2pcm16[] = {
+static const int16_t _roardsp_alaw2pcm16[] = {
 /* -------- SUN -------- */
      -5504,   -5248,   -6016,   -5760,   -4480,   -4224,   -4992,
@@ -101,5 +101,5 @@
 
 #ifdef ROAR_SUPPORT_ALAW_RW
-int8_t _roardsp_pcm132alaw[] = {
+static const int8_t _roardsp_pcm132alaw[] = {
 /* -------- SUN -------- */
    0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a,
Index: libroardsp/amp.c
===================================================================
--- libroardsp/amp.c	(revision 4708)
+++ libroardsp/amp.c	(revision 5270)
@@ -30,5 +30,4 @@
   case  8: return roar_amp_pcm_8bit (output, input, samples, channels, set); break;
   case 16: return roar_amp_pcm_16bit(output, input, samples, channels, set); break;
-  case 24: return roar_amp_pcm_24bit(output, input, samples, channels, set); break;
   case 32: return roar_amp_pcm_32bit(output, input, samples, channels, set); break;
   default: return -1;
@@ -88,8 +87,4 @@
 }
 
-int roar_amp_pcm_24bit (void    * output, void    * input, int samples, int channels, struct roar_mixer_settings * set) {
- return -1;
-}
-
 int roar_amp_pcm_32bit (int32_t * output, int32_t * input, int samples, int channels, struct roar_mixer_settings * set) {
 #ifdef ROAR_NATIVE_INT64
Index: libroardsp/channels.c
===================================================================
--- libroardsp/channels.c	(revision 4708)
+++ libroardsp/channels.c	(revision 5270)
@@ -93,6 +93,6 @@
 
 int    roardsp_chanlist2str(char * list, size_t len, char * str, size_t strlen) {
+ size_t i;
  char * name;
- int i;
 
  if ( list == NULL && len > 0 )
Index: libroardsp/filter.c
===================================================================
--- libroardsp/filter.c	(revision 5269)
+++ libroardsp/filter.c	(revision 5270)
@@ -26,5 +26,5 @@
 #include "libroardsp.h"
 
-struct _roardsp_filterlist {
+static struct _roardsp_filterlist {
  int id;
  char * name;
Index: libroardsp/filter_agc.c
===================================================================
--- libroardsp/filter_agc.c	(revision 4708)
+++ libroardsp/filter_agc.c	(revision 5270)
@@ -28,4 +28,6 @@
 int roardsp_agc_init   (struct roardsp_filter * filter, struct roar_stream * stream, int id) {
  struct roardsp_agc * self = roar_mm_malloc(sizeof(struct roardsp_agc));
+
+ (void)id;
 
  if ( self == NULL )
Index: libroardsp/filter_amp.c
===================================================================
--- libroardsp/filter_amp.c	(revision 5181)
+++ libroardsp/filter_amp.c	(revision 5270)
@@ -28,4 +28,6 @@
 int roardsp_amp_init  (struct roardsp_filter * filter, struct roar_stream * stream, int id) {
  struct roardsp_amp * self = roar_mm_malloc(sizeof(struct roardsp_amp));
+
+ (void)stream, (void)id;
 
  if ( self == NULL )
Index: libroardsp/filter_clip.c
===================================================================
--- libroardsp/filter_clip.c	(revision 5177)
+++ libroardsp/filter_clip.c	(revision 5270)
@@ -27,4 +27,6 @@
 
 int roardsp_clip_init  (struct roardsp_filter * filter, struct roar_stream * stream, int id) {
+ (void)stream, (void)id;
+
  if ( (filter->inst = roar_mm_malloc(sizeof(struct roardsp_clip))) == NULL )
   return -1;
Index: libroardsp/filter_dcblock.c
===================================================================
--- libroardsp/filter_dcblock.c	(revision 4708)
+++ libroardsp/filter_dcblock.c	(revision 5270)
@@ -29,4 +29,6 @@
  struct roardsp_dcblock * inst = roar_mm_malloc(sizeof(struct roardsp_dcblock));
 // roardsp_downmix_ctl(filter, ROARDSP_FCTL_MODE, &mode);
+
+ (void)stream, (void)id;
 
  if ( inst == NULL ) {
Index: libroardsp/filter_highp.c
===================================================================
--- libroardsp/filter_highp.c	(revision 5181)
+++ libroardsp/filter_highp.c	(revision 5270)
@@ -31,4 +31,6 @@
  struct roardsp_highp * self = roar_mm_malloc(sizeof(struct roardsp_highp));
 
+ (void)stream, (void)id;
+
  if ( self == NULL )
   return -1;
@@ -52,6 +54,6 @@
  int##bits##_t * samp = (int##bits##_t *) data; \
  register int##twobits##_t s, h; \
- int i, c; \
- int channels = filter->channels; \
+ size_t i, c; \
+ size_t channels = filter->channels; \
 \
  if ( channels > ROAR_MAX_CHANNELS ) \
Index: libroardsp/filter_lowp.c
===================================================================
--- libroardsp/filter_lowp.c	(revision 5181)
+++ libroardsp/filter_lowp.c	(revision 5270)
@@ -31,4 +31,6 @@
  struct roardsp_lowp * self = roar_mm_malloc(sizeof(struct roardsp_lowp));
 
+ (void)stream, (void)id;
+
  ROAR_DBG("roardsp_lowp_init(*): self=%p", self);
 
@@ -53,6 +55,6 @@
  int##bits##_t * samp = (int##bits##_t *) data; \
  register int##twobits##_t s; \
- int i, c; \
- int channels = filter->channels; \
+ size_t i, c; \
+ size_t channels = filter->channels; \
 \
  if ( channels > ROAR_MAX_CHANNELS ) \
Index: libroardsp/filter_quantify.c
===================================================================
--- libroardsp/filter_quantify.c	(revision 5181)
+++ libroardsp/filter_quantify.c	(revision 5270)
@@ -27,4 +27,6 @@
 
 int roardsp_quantify_init  (struct roardsp_filter * filter, struct roar_stream * stream, int id) {
+
+ (void)stream, (void)id;
 
  roardsp_filter_reset(filter, ROARDSP_RESET_FULL);
Index: libroardsp/filter_responsecurve.c
===================================================================
--- libroardsp/filter_responsecurve.c	(revision 5269)
+++ libroardsp/filter_responsecurve.c	(revision 5270)
@@ -29,4 +29,6 @@
  struct roardsp_responsecurve * self = roar_mm_malloc(sizeof(struct roardsp_responsecurve));
 
+ (void)stream, (void)id;
+
  ROAR_DBG("roardsp_responsecurve_init(filter=%p, stream=%p, id=%i) = ?", filter, stream, id);
 
@@ -50,4 +52,5 @@
 
 static double __func_pass(double i, double N) {
+ (void)N;
  return i;
 }
@@ -70,8 +73,10 @@
 
 static double __func_cos(double i, double N) {
+ (void)N;
  return 0.5 - cos(i * M_PI)/2.;
 }
 
 static double __func_icos(double i, double N) {
+ (void)N;
  return 2.*i - 0.5 + cos(i * M_PI)/2.;
 }
Index: libroardsp/filter_swap.c
===================================================================
--- libroardsp/filter_swap.c	(revision 5181)
+++ libroardsp/filter_swap.c	(revision 5270)
@@ -28,4 +28,6 @@
 int roardsp_swap_init   (struct roardsp_filter * filter, struct roar_stream * stream, int id) {
  struct roardsp_swap * inst = roar_mm_malloc(sizeof(struct roardsp_swap));
+
+ (void)stream, (void)id;
 
  ROAR_DBG("roardsp_swap_init(*): inst=%p", inst);
@@ -60,4 +62,6 @@
  size_t i; \
 \
+ (void)filter; \
+\
  for (i = 0; i < samples; i += 2) { \
   ROAR_DBG("roardsp_swap_calc*2(*): d[i]=%i, d[i+1]=%i", d[i], d[i+1]); \
@@ -75,4 +79,6 @@
 
 int roardsp_swap_ctl    (struct roardsp_filter * filter, int cmd, void * data) {
+ (void)filter, (void)cmd, (void)data;
+ roar_err_set(ROAR_ERROR_NOSYS);
  return -1;
 }
Index: libroardsp/interleave.c
===================================================================
--- libroardsp/interleave.c	(revision 4708)
+++ libroardsp/interleave.c	(revision 5270)
@@ -27,6 +27,8 @@
 
 int roar_interl_init  (struct roar_interleave * state, size_t channels, size_t bits) {
- if ( state == NULL )
+ if ( state == NULL ) {
+  roar_err_set(ROAR_ERROR_FAULT);
   return -1;
+ }
 
  // we can currently only hanle full bytes:
@@ -35,6 +37,8 @@
 
  // currently we have a channel limit
- if ( channels > ROAR_INTERLEAVE_MAX_CHANNELS )
+ if ( channels > ROAR_INTERLEAVE_MAX_CHANNELS ) {
+  roar_err_set(ROAR_ERROR_RANGE);
   return -1;
+ }
 
  memset(state, 0, sizeof(struct roar_interleave));
@@ -47,6 +51,8 @@
 
 int roar_interl_uninit(struct roar_interleave * state) {
- if ( state == NULL )
+ if ( state == NULL ) {
+  roar_err_set(ROAR_ERROR_FAULT);
   return -1;
+ }
 
  memset(state, 0, sizeof(struct roar_interleave));
@@ -56,7 +62,12 @@
 
 int roar_interl_ctl   (struct roar_interleave * state, int cmd, void * data) {
- if ( state == NULL )
+ if ( state == NULL ) {
+  roar_err_set(ROAR_ERROR_FAULT);
   return -1;
+ }
 
+ (void)state, (void)cmd, (void)data;
+
+ roar_err_set(ROAR_ERROR_NOSYS);
  return -1;
 }
@@ -68,9 +79,13 @@
  char   * ip[ROAR_INTERLEAVE_MAX_CHANNELS]; // output pointer
 
- if ( state == NULL )
+ if ( state == NULL ) {
+  roar_err_set(ROAR_ERROR_FAULT);
   return -1;
+ }
 
- if ( in == NULL || out == NULL )
+ if ( in == NULL || out == NULL ) {
+  roar_err_set(ROAR_ERROR_FAULT);
   return -1;
+ }
 
  if ( len == 0 )
Index: libroardsp/mixer.c
===================================================================
--- libroardsp/mixer.c	(revision 4708)
+++ libroardsp/mixer.c	(revision 5270)
@@ -30,5 +30,4 @@
   case  8: return roar_mix_pcm_8bit (output, (int8_t  **)input, samples); break;
   case 16: return roar_mix_pcm_16bit(output, (int16_t **)input, samples); break;
-  case 24: return roar_mix_pcm_24bit(output, input, samples); break;
   case 32: return roar_mix_pcm_32bit(output, (int32_t **)input, samples); break;
   default: return -1;
@@ -82,8 +81,4 @@
 }
 
-int roar_mix_pcm_24bit (void    * output, void    ** input, int samples) {
- return -1;
-}
-
 int roar_mix_pcm_32bit (int32_t * output, int32_t ** input, int samples) {
 #ifdef ROAR_NATIVE_INT64
Index: libroardsp/mulaw.c
===================================================================
--- libroardsp/mulaw.c	(revision 4708)
+++ libroardsp/mulaw.c	(revision 5270)
@@ -58,5 +58,5 @@
 
 #ifdef ROAR_SUPPORT_MULAW
-int16_t _roardsp_mulaw2pcm16[] = {
+static const int16_t _roardsp_mulaw2pcm16[] = {
 /* -------- SUN -------- */
     -32124,  -31100,  -30076,  -29052,  -28028,  -27004,  -25980,
@@ -101,5 +101,5 @@
 
 #ifdef ROAR_SUPPORT_MULAW_RW
-int8_t _roardsp_pcm142mulaw[] = {
+static const int8_t _roardsp_pcm142mulaw[] = {
 /* -------- SUN -------- */
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
Index: libroardsp/poly.c
===================================================================
--- libroardsp/poly.c	(revision 4881)
+++ libroardsp/poly.c	(revision 5270)
@@ -102,4 +102,5 @@
 
 int roar_math_mkpoly_5x5 (float * poly, float * data) {
+ roar_err_set(ROAR_ERROR_NOSYS);
  return -1;
 }
Index: libroardsp/synth.c
===================================================================
--- libroardsp/synth.c	(revision 4708)
+++ libroardsp/synth.c	(revision 5270)
@@ -96,5 +96,5 @@
  float cv0, cv1;
 #endif
- int i;
+ size_t i;
 
  _CHECK_PCMOUT();
@@ -133,4 +133,6 @@
 // basic SINFs:
 float roar_synth_synf_rect (float t, struct roar_synth_state * state) {
+ (void)state;
+
  t /= 2*M_PI;
  t -= (int)t;
@@ -143,4 +145,6 @@
 
 float roar_synth_synf_saw  (float t, struct roar_synth_state * state) {
+ (void)state;
+
  t /= 2*M_PI;
  t -= (int)t;
@@ -150,4 +154,6 @@
 
 float roar_synth_synf_tri  (float t, struct roar_synth_state * state) {
+ (void)state;
+
  t /= 2*M_PI;
  t -= (int)t;
@@ -160,4 +166,6 @@
 
 float roar_synth_synf_trap (float t, struct roar_synth_state * state) {
+ (void)state;
+
  t /= 2*M_PI;
  t -= (int)t;
@@ -176,4 +184,6 @@
 #ifdef ROAR_HAVE_LIBM
 float roar_synth_synf_s2s  (float t, struct roar_synth_state * state) {
+ (void)state;
+
  float sin2 = sinf(t/1.2);
 
Index: libroardsp/transcode.c
===================================================================
--- libroardsp/transcode.c	(revision 4708)
+++ libroardsp/transcode.c	(revision 5270)
@@ -264,5 +264,5 @@
    }
 
-   while ( ringstats.bytes > state->packet_len ) {
+   while ( (ssize_t)ringstats.bytes > state->packet_len ) {
     curlen = state->packet_len;
     if ( roar_buffer_shift_out(&(state->iobuffer), bufdata, &curlen) == -1 ) {
@@ -421,4 +421,5 @@
 // dummy functions used by some de/encoders:
 int roar_xcoder_dummy_inituninit(struct roar_xcoder * state) {
+ (void)state;
  return 0;
 }
@@ -426,8 +427,10 @@
 int roar_xcoder_dummy_packet_size_any(struct roar_xcoder * state, int samples) {
  // the case samples=-1/samples!=-1 based things are done in the general func
+ (void)state, (void)samples;
  return 0;
 }
 
 int roar_xcoder_dummy_proc_header(struct roar_xcoder * state) {
+ (void)state;
  return 0;
 }
Index: libroardsp/transcode_mualaw.c
===================================================================
--- libroardsp/transcode_mualaw.c	(revision 4708)
+++ libroardsp/transcode_mualaw.c	(revision 5270)
@@ -36,9 +36,9 @@
                          return -1;
 
-#define _SEND_RETURN()  if ( roar_vio_write(state->backend, iobuf, outbyte) != outbyte ) \
+#define _SEND_RETURN()  if ( roar_vio_write(state->backend, iobuf, outbyte) != (ssize_t)outbyte ) \
                          return -1; \
                         return 0;
 
-#define _READ()         if ( roar_vio_read(state->backend, iobuf, outbyte) != outbyte ) \
+#define _READ()         if ( roar_vio_read(state->backend, iobuf, outbyte) != (ssize_t)outbyte ) \
                          return -1;
 
Index: libroardsp/vio_transcode.c
===================================================================
--- libroardsp/vio_transcode.c	(revision 4708)
+++ libroardsp/vio_transcode.c	(revision 5270)
@@ -76,5 +76,5 @@
  return !ret ? count : -1;
 #else
- return !roar_xcoder_proc(vio->inst, buf, count) ? count : -1;
+ return !roar_xcoder_proc(vio->inst, buf, count) ? (ssize_t)count : -1;
 #endif
 }
@@ -137,5 +137,5 @@
   return -1;
 
- return !roar_bixcoder_read(vio->inst, buf, count) ? count : -1;
+ return !roar_bixcoder_read(vio->inst, buf, count) ? (ssize_t)count : -1;
 }
 
@@ -148,5 +148,5 @@
   return -1;
 
- return !roar_bixcoder_write(vio->inst, buf, count) ? count : -1;
+ return !roar_bixcoder_write(vio->inst, buf, count) ? (ssize_t)count : -1;
 }
 
Index: libroareio/Makefile
===================================================================
--- libroareio/Makefile	(revision 4748)
+++ libroareio/Makefile	(revision 5270)
@@ -11,6 +11,6 @@
 #DEFINES        = -DDEBUG
 INCLUDE = -I../include -I../include/libroareio
-CFLAGS += -g -Wall $(OPTI_O) $(DEFINES) $(INCLUDE) $(INCPATH) $(SHARED_CF) $(fPIC)
-LDFLAGS+= -g $(SHARED) -L../lib/ $(LDPATH)
+CFLAGS += -g -Wall $(Wextra) $(OPTI_O) $(DEFINES) $(INCLUDE) $(INCPATH) $(SHARED_CF) $(fPIC)
+LDFLAGS+= -g -Wall $(Wextra) $(SHARED) -L../lib/ $(LDPATH)
 LIBS    = $(LIBROAREIO_NS)
 
Index: libroareio/driver.c
===================================================================
--- libroareio/driver.c	(revision 5242)
+++ libroareio/driver.c	(revision 5270)
@@ -34,4 +34,6 @@
 int roar_cdriver_null(struct roar_vio_calls * calls, const char * name, const char * dev, struct roar_audio_info * info, int dir) {
  ROAR_DBG("roar_cdriver_null(calls=%p, name='%s', dev='%s', info=%p{...}, dir=%i(?)) = ?", calls, name, dev, info, dir);
+
+ (void)name, (void)dev, (void)info, (void)dir;
 
  memset(calls, 0, sizeof(struct roar_vio_calls));
Index: libroareio/driver_oss.c
===================================================================
--- libroareio/driver_oss.c	(revision 5250)
+++ libroareio/driver_oss.c	(revision 5270)
@@ -41,5 +41,5 @@
  int blocksizes[] = {11, 12, 13};
  int blocks[]     = {4, 5, 6, 3, 7, 2, 8};
- int bs, b;
+ size_t bs, b;
  int tmp;
 
@@ -63,4 +63,6 @@
  struct roar_vio_sysio_ioctl ctl;
  int tmp, ctmp;
+
+ (void)name;
 
  // preinit ctl struct, we always pass ints in tmp.
@@ -113,5 +115,5 @@
  }
 
- if ( tmp != info->channels ) {
+ if ( tmp != (int)info->channels ) {
   _err();
  }
@@ -182,5 +184,5 @@
  }
 
- if ( tmp != info->rate ) {
+ if ( tmp != (int)info->rate ) {
   _err();
  }
Index: libroareio/driver_roar.c
===================================================================
--- libroareio/driver_roar.c	(revision 5242)
+++ libroareio/driver_roar.c	(revision 5270)
@@ -28,4 +28,5 @@
 
 int roar_cdriver_roar(struct roar_vio_calls * calls, const char * name, const char * dev, struct roar_audio_info * info, int dir) {
+ (void)name;
  return roar_vio_simple_stream(calls, info->rate, info->channels, info->bits, info->codec, dev, dir, "libroareio client");
 }
Index: libroareio/ff_ssdp.c
===================================================================
--- libroareio/ff_ssdp.c	(revision 4708)
+++ libroareio/ff_ssdp.c	(revision 5270)
@@ -92,5 +92,7 @@
  return 0;
 }
+
 int  roar_ff_ssdp_read (struct roar_vio_calls * vio, struct roar_ff_ssdp * c) {
+ roar_err_set(ROAR_ERROR_NOSYS);
  return -1;
 }
Index: libroaresd/Makefile
===================================================================
--- libroaresd/Makefile	(revision 4748)
+++ libroaresd/Makefile	(revision 5270)
@@ -11,5 +11,5 @@
 INCLUDE = -I../include -I../include/libroaresd
 CFLAGS += -g -Wall $(OPTI_O) $(DEFINES) $(INCLUDE) $(INCPATH) $(SHARED_CF) $(fPIC)
-LDFLAGS+= -g $(SHARED) $(LDPATH) -L../lib/
+LDFLAGS+= -g -Wall $(SHARED) $(LDPATH) -L../lib/
 LIBS    = $(LIBROAR)
 
Index: libroaresd/esdbasic.c
===================================================================
--- libroaresd/esdbasic.c	(revision 5226)
+++ libroaresd/esdbasic.c	(revision 5270)
@@ -66,4 +66,5 @@
 /* send the authorization cookie, create one if needed */
 int esd_send_auth( int sock ) {
+ (void) sock;
  return 0;
 }
Index: libroaresd/esdctl.c
===================================================================
--- libroaresd/esdctl.c	(revision 5236)
+++ libroaresd/esdctl.c	(revision 5270)
@@ -45,7 +45,11 @@
 // so always return -1
 int esd_lock( int esd ) {
+ (void)esd;
+ errno = ENOSYS;
  return -1;
 }
 int esd_unlock( int esd ) {
+ (void)esd;
+ errno = ENOSYS;
  return -1;
 }
@@ -66,4 +70,19 @@
 
  return roar_set_standby(&con, ROAR_STANDBY_INACTIVE);
+}
+
+static void _format2str(char * buf, size_t len, esd_format_t format) {
+
+ if ( (format & ESD_BITS16) == ESD_BITS16 ) {
+  roar_mm_strlcat(buf, "16 bit ", len);
+ } else {
+  roar_mm_strlcat(buf, "8 bit ", len);
+ }
+
+ if ( (format & ESD_STEREO) == ESD_STEREO ) {
+  roar_mm_strlcat(buf, "stereo ", len);
+ } else {
+  roar_mm_strlcat(buf, "mono ", len);
+ }
 }
 
@@ -72,13 +91,5 @@
  char buf[80] = "";
 
- if ( server_info->format & ESD_BITS16 )
-  strcat(buf, "16 bit ");
- else
-  strcat(buf, "8 bit ");
-
- if ( server_info->format & ESD_STEREO )
-  strcat(buf, "stereo ");
- else
-  strcat(buf, "mono ");
+ _format2str(buf, sizeof(buf), server_info->format);
 
  printf("server version   = %i\n",        server_info->version);
@@ -87,17 +98,8 @@
 }
 
-
 void esd_print_player_info( esd_player_info_t *player_info ) {
  char buf[80] = "";
 
- if ( (player_info->format & ESD_BITS16) == ESD_BITS16 )
-  strcat(buf, "16 bit ");
- else
-  strcat(buf, "8 bit ");
-
- if ( (player_info->format & ESD_STEREO) == ESD_STEREO )
-  strcat(buf, "stereo ");
- else
-  strcat(buf, "mono ");
+ _format2str(buf, sizeof(buf), player_info->format);
 
  printf("player %i name    = %s\n",        player_info->source_id, player_info->name);
@@ -109,4 +111,14 @@
 
 void esd_print_sample_info( esd_sample_info_t *sample_info ) {
+ char buf[80] = "";
+
+ _format2str(buf, sizeof(buf), sample_info->format);
+
+ printf("sample %i name    = %s\n",        sample_info->sample_id, sample_info->name);
+ printf("sample %i format  = 0x%08x %s\n", sample_info->sample_id, sample_info->format, buf);
+ printf("sample %i rate    = %i\n",        sample_info->sample_id, sample_info->rate);
+ printf("sample %i left    = %i\n",        sample_info->sample_id, sample_info->left_vol_scale);
+ printf("sample %i right   = %i\n",        sample_info->sample_id, sample_info->right_vol_scale);
+ printf("sample %i length  = %i\n",        sample_info->sample_id, sample_info->length);
 }
 
@@ -282,4 +294,6 @@
 /* retrieve all information from server, and update until unsubsribed or closed */
 esd_info_t *esd_subscribe_all_info( int esd ) {
+ (void)esd;
+ errno = ENOSYS;
  return NULL; // Not yet implemented in upstream esd
 }
@@ -288,8 +302,12 @@
 esd_info_t *esd_update_info( int esd, esd_info_t *info,
                              esd_update_info_callbacks_t *callbacks ) {
+ (void)esd, (void)info, (void)callbacks;
+ errno = ENOSYS;
  return NULL; // Not yet implemented in upstream esd
 }
 
 esd_info_t *esd_unsubscribe_info( int esd ) {
+ (void)esd;
+ errno = ENOSYS;
  return NULL; // Not yet implemented in upstream esd
 }
@@ -362,4 +380,7 @@
 int esd_set_default_sample_pan( int esd, int sample_id,
                                 int left_scale, int right_scale ) {
+ // this is not yet implemented by the RA protocol.
+ (void)esd, (void)sample_id, (void)left_scale, (void)right_scale;
+ errno = ENOSYS;
  return -1;
 }
Index: libroaresd/esdfile.c
===================================================================
--- libroaresd/esdfile.c	(revision 4708)
+++ libroaresd/esdfile.c	(revision 5270)
@@ -47,6 +47,13 @@
 }
 int esd_play_file( const char *name_prefix, const char *filename, int fallback ) {
- // TODO: add support for fallback
- return roar_simple_play_file((char*)filename, NULL, (char*)name_prefix) == -1 ? -1 : 0;
+ int ret = roar_simple_play_file(filename, NULL, name_prefix);
+
+ if ( ret != -1 )
+  return 0;
+
+ if ( !fallback )
+  return -1;
+
+ return roar_simple_play_file(filename, "+fork", name_prefix) == -1 ? -1 : 0;
 }
 int esd_file_cache( int esd, const char *name_prefix, const char *filename ) {
Index: libroarpulse/Makefile
===================================================================
--- libroarpulse/Makefile	(revision 4748)
+++ libroarpulse/Makefile	(revision 5270)
@@ -14,6 +14,6 @@
 #DEFINES        = -DDEBUG
 INCLUDE = -I../include -I../include/libroarpulse
-CFLAGS += -g -Wall $(OPTI_O) $(DEFINES) $(INCLUDE) $(INCPATH) $(SHARED_CF) $(fPIC)
-LDFLAGS+= -g $(LDPATH) -L../lib/ -L.
+CFLAGS += -g -Wall $(Wextra) $(OPTI_O) $(DEFINES) $(INCLUDE) $(INCPATH) $(SHARED_CF) $(fPIC)
+LDFLAGS+= -g -Wall $(Wextra) $(LDPATH) -L../lib/ -L.
 LIBS    = $(LIBROAR)
 
Index: libroarpulse/context.c
===================================================================
--- libroarpulse/context.c	(revision 4708)
+++ libroarpulse/context.c	(revision 5270)
@@ -221,4 +221,5 @@
 /** Return non-zero if some data is pending to be written to the connection */
 int pa_context_is_pending(pa_context *c) {
+ (void)c;
  return 0;
 }
@@ -334,4 +335,5 @@
 /** Return the protocol version of the library. \since 0.8 */
 uint32_t pa_context_get_protocol_version(pa_context *c) {
+ (void)c;
  return 0;
 }
@@ -339,4 +341,5 @@
 /** Return the protocol version of the connected server. \since 0.8 */
 uint32_t pa_context_get_server_protocol_version(pa_context *c) {
+ (void)c;
  return 0;
 }
Index: libroarpulse/mainloop-signal.c
===================================================================
--- libroarpulse/mainloop-signal.c	(revision 4708)
+++ libroarpulse/mainloop-signal.c	(revision 5270)
@@ -77,5 +77,9 @@
  int sig;
  size_t ret;
+#endif
 
+ (void)a, (void)e, (void)f, (void)userdata;
+
+#ifdef ROAR_HAVE_PIPE
  ret = read(fd, &sig, sizeof(sig));
 
Index: libroarpulse/mainloop.c
===================================================================
--- libroarpulse/mainloop.c	(revision 4708)
+++ libroarpulse/mainloop.c	(revision 5270)
@@ -273,5 +273,6 @@
  pa_io_event_flags_t events;
  int count = 0;
- int i, h;
+ int h;
+ nfds_t i;
 
  ROAR_DBG("pa_mainloop_dispatch(m=%p) = ?", m);
Index: libroarpulse/operation.c
===================================================================
--- libroarpulse/operation.c	(revision 4708)
+++ libroarpulse/operation.c	(revision 5270)
@@ -89,4 +89,5 @@
 void pa_operation_cancel(pa_operation *o) {
  // we ignore this
+ (void)o;
 }
 
Index: libroarpulse/simple.c
===================================================================
--- libroarpulse/simple.c	(revision 5239)
+++ libroarpulse/simple.c	(revision 5270)
@@ -59,4 +59,7 @@
  int roar_dir;
  int err = ROAR_ERROR_NONE;
+
+ if ( dev != NULL || map != NULL || attr != NULL )
+  return NULL;
 
  if ( dir == PA_STREAM_PLAYBACK ) {
Index: libroarpulse/stream.c
===================================================================
--- libroarpulse/stream.c	(revision 5243)
+++ libroarpulse/stream.c	(revision 5270)
@@ -177,4 +177,5 @@
 /** Return the device (sink input or source output) index this stream is connected to */
 uint32_t pa_stream_get_index(pa_stream *s) {
+ (void)s;
  return 0;
 }
@@ -189,6 +190,8 @@
  void * data;
  size_t len;
- size_t ret;
+ ssize_t ret;
  int bufret;
+
+ (void)fd, (void)events;
 
  ROAR_DBG("_roar_pa_stream_ioecb(*) = ?");
@@ -209,5 +212,5 @@
 
      // TODO: handle errors
-     if ( ret == len ) {
+     if ( ret == (ssize_t)len ) {
       bufret = roar_buffer_next(&(s->iobuffer));
      } else {
@@ -289,5 +292,5 @@
  volume = NULL;
 
- if ( attr != NULL || flags != 0 || volume != NULL || sync_stream != NULL ) {
+ if ( dev != NULL || attr != NULL || flags != 0 || volume != NULL || sync_stream != NULL ) {
   pa_stream_set_state(s, PA_STREAM_FAILED);
   return -1;
Index: libroarpulse/timeval.c
===================================================================
--- libroarpulse/timeval.c	(revision 4708)
+++ libroarpulse/timeval.c	(revision 5270)
@@ -69,6 +69,6 @@
  tv->tv_usec += v;
 
- while ( tv->tv_usec > 1000000LLU ) {
-  tv->tv_usec -= 1000000LLU;
+ while ( tv->tv_usec > 1000000LL ) {
+  tv->tv_usec -= 1000000LL;
   tv->tv_sec  += 1;
  }
Index: libroarpulse/volume.c
===================================================================
--- libroarpulse/volume.c	(revision 4708)
+++ libroarpulse/volume.c	(revision 5270)
@@ -62,5 +62,5 @@
 /** Set the volume of all channels to the specified parameter */
 pa_cvolume* pa_cvolume_set(pa_cvolume *a, unsigned channels, pa_volume_t v) {
- int i;
+ unsigned int i;
 
  if ( a == NULL )
Index: libroaryiff/Makefile
===================================================================
--- libroaryiff/Makefile	(revision 4748)
+++ libroaryiff/Makefile	(revision 5270)
@@ -7,6 +7,6 @@
 #DEFINES        = -DDEBUG
 INCLUDE = -I../include -I../include/libroaryiff
-CFLAGS += -g -Wall $(OPTI_O) $(DEFINES) $(INCLUDE) $(INCPATH) $(SHARED_CF) $(fPIC)
-LDFLAGS+= -g $(SHARED) $(LDPATH) -L../lib/
+CFLAGS += -g -Wall $(Wextra) $(OPTI_O) $(DEFINES) $(INCLUDE) $(INCPATH) $(SHARED_CF) $(fPIC)
+LDFLAGS+= -g -Wall $(Wextra) $(SHARED) $(LDPATH) -L../lib/
 LIBS    = $(LIBROAR)
 
Index: libroaryiff/connection.c
===================================================================
--- libroaryiff/connection.c	(revision 5247)
+++ libroaryiff/connection.c	(revision 5270)
@@ -39,6 +39,6 @@
  YConnection * ycon = roar_mm_malloc(sizeof(YConnection));
  struct roar_connection con;
- char * server = (char *)con_arg;
- char * name   = "libroaryiff client";
+ const char * server = (char *)con_arg;
+ const char * name   = "libroaryiff client";
 
  memset(ycon, 0, sizeof(YConnection));
@@ -75,4 +75,9 @@
  struct roar_vio_calls vio;
 
+ // in case we started the server by using +fork we can not keep it running
+ // as it will terminate anyway. If there are any other clients (I guess
+ // this is what this option is about) it will keep running.
+ (void)no_shutdown;
+
  if ( connection == NULL )
   return;
Index: libroaryiff/events.c
===================================================================
--- libroaryiff/events.c	(revision 5035)
+++ libroaryiff/events.c	(revision 5270)
@@ -37,8 +37,11 @@
 
 // RoarAudio isn't event based, so we need to trick a lot here
+// Maybe this can be overcome with the notify API
 
 int YGetNextEvent (YConnection *con, YEvent *event, Boolean block) {
  struct roar_connection rcon;
  struct roar_stream s;
+
+ (void)block;
 
  if ( con == NULL || event == NULL )
Index: libroaryiff/file.c
===================================================================
--- libroaryiff/file.c	(revision 4708)
+++ libroaryiff/file.c	(revision 5270)
@@ -37,4 +37,6 @@
 
 int YGetSoundObjectAttributes (YConnection *con, const char *path, YEventSoundObjectAttributes *buf) {
+ (void)con;
+
  if ( buf == NULL )
   return -1;
Index: libroaryiff/stub.c
===================================================================
--- libroaryiff/stub.c	(revision 4708)
+++ libroaryiff/stub.c	(revision 5270)
@@ -38,5 +38,6 @@
 // in here only some stub functions are delcared
 
-extern void YSyncAll(YConnection *con, Boolean block) {
+void YSyncAll(YConnection *con, Boolean block) {
+ (void)con, (void)block;
 }
 
Index: roard/Makefile
===================================================================
--- roard/Makefile	(revision 5242)
+++ roard/Makefile	(revision 5270)
@@ -19,5 +19,5 @@
 INCLUDE   = -I../include -I./include
 CFLAGS   += -g -Wall $(OPTI_O) $(DEFINES) $(PKGDEFINES) $(INCLUDE) $(INCPATH)
-LDFLAGS  += -g -rdynamic -L../lib/ $(LDPATH)
+LDFLAGS  += -g -Wall -rdynamic -L../lib/ $(LDPATH)
 DRVLIBS   = $(lib_esd) $(lib_ossaudio) $(lib_ao) $(lib_shout) $(lib_sndio) $(lib_rsound) $(lib_portaudio) $(lib_pablio) $(lib_asound) $(lib_winmm) $(lib_pulse_simple) $(lib_pulse) $(lib_jack) $(lib_artsc)
 CODEC_CELT= $(lib_celt) $(lib_celt0)
Index: roard/codecfilter_alaw.c
===================================================================
--- roard/codecfilter_alaw.c	(revision 4957)
+++ roard/codecfilter_alaw.c	(revision 5270)
@@ -38,4 +38,5 @@
  struct roar_stream * s = ROAR_STREAM(info);
 
+ (void)codec, (void)filter;
 
  *inst = (CODECFILTER_USERDATA_T) info;
@@ -48,4 +49,5 @@
 
 int cf_alaw_close(CODECFILTER_USERDATA_T   inst) {
+ (void)inst;
  return 0;
 }
Index: roard/codecfilter_au.c
===================================================================
--- roard/codecfilter_au.c	(revision 5210)
+++ roard/codecfilter_au.c	(revision 5270)
@@ -34,5 +34,7 @@
  struct roar_stream * s = ROAR_STREAM(info);
 
- if ( !self )
+ (void)codec, (void)filter;
+
+ if ( self == NULL )
   return -1;
 
@@ -99,5 +101,5 @@
     return -1;
 
-   if ( stream_vio_s_read(self->stream, extra_header, header[1]) != header[1] ) {
+   if ( stream_vio_s_read(self->stream, extra_header, header[1]) != (ssize_t)header[1] ) {
     roar_mm_free(extra_header);
     return -1;
@@ -275,4 +277,6 @@
  int_least32_t type = cmd & ROAR_STREAM_CTL_TYPEMASK;
 
+ (void)data;
+
  cmd -= type;
 
Index: roard/codecfilter_celt.c
===================================================================
--- roard/codecfilter_celt.c	(revision 4957)
+++ roard/codecfilter_celt.c	(revision 5270)
@@ -37,5 +37,7 @@
  struct roar_stream * s = ROAR_STREAM(info);
 
- if ( !self )
+ (void)codec, (void)filter;
+
+ if ( self == NULL )
   return -1;
 
Index: roard/codecfilter_mulaw.c
===================================================================
--- roard/codecfilter_mulaw.c	(revision 4957)
+++ roard/codecfilter_mulaw.c	(revision 5270)
@@ -38,4 +38,5 @@
  struct roar_stream * s = ROAR_STREAM(info);
 
+ (void)codec, (void)filter;
 
  *inst = (CODECFILTER_USERDATA_T) info;
@@ -48,4 +49,5 @@
 
 int cf_mulaw_close(CODECFILTER_USERDATA_T   inst) {
+ (void)inst;
  return 0;
 }
Index: roard/codecfilter_sndfile.c
===================================================================
--- roard/codecfilter_sndfile.c	(revision 4957)
+++ roard/codecfilter_sndfile.c	(revision 5270)
@@ -32,4 +32,6 @@
                                             struct roar_codecfilter   * filter) {
  struct codecfilter_sndfile_inst * obj;
+
+ (void)codec, (void)filter;
 
  if ( (obj = (struct codecfilter_sndfile_inst *) roar_mm_malloc(sizeof(struct codecfilter_sndfile_inst))) == NULL )
Index: roard/codecfilter_vorbis.c
===================================================================
--- roard/codecfilter_vorbis.c	(revision 5218)
+++ roard/codecfilter_vorbis.c	(revision 5270)
@@ -71,5 +71,7 @@
  struct roar_stream * s = ROAR_STREAM(info);
 
- if ( !self )
+ (void)codec, (void)filter;
+
+ if ( self == NULL )
   return -1;
 
Index: roard/emul_rsound.c
===================================================================
--- roard/emul_rsound.c	(revision 4739)
+++ roard/emul_rsound.c	(revision 5270)
@@ -39,4 +39,6 @@
   char c[16];
  } buf;
+
+ (void)lsock;
 
  // TODO: add error handling
Index: roard/signals.c
===================================================================
--- roard/signals.c	(revision 4708)
+++ roard/signals.c	(revision 5270)
@@ -38,4 +38,6 @@
 
 void on_sig_term (int signum) {
+ (void)signum;
+
  ROAR_INFO("got SIGTERM (or called by SIGINT handler)", ROAR_DBG_INFO_NOTICE);
 
@@ -45,4 +47,6 @@
 
 void on_sig_chld (int signum) {
+ (void)signum;
+
  ROAR_INFO("got SIGCHLD", ROAR_DBG_INFO_NOTICE);
 
@@ -53,4 +57,6 @@
 
 void on_sig_usr1 (int signum) {
+ (void)signum;
+
  ROAR_INFO("got SIGUSR1", ROAR_DBG_INFO_NOTICE);
 
Index: roarfish/Makefile
===================================================================
--- roarfish/Makefile	(revision 4804)
+++ roarfish/Makefile	(revision 5270)
@@ -8,6 +8,6 @@
 #DEFINES        = -DDEBUG
 INCLUDE = -I../include -I./include
-CFLAGS += -g -Wall $(OPTI_O) $(DEFINES) $(INCLUDE) $(INCPATH)
-LDFLAGS+= -g -L../lib/ $(LDPATH)
+CFLAGS += -g -Wall $(Wextra) $(OPTI_O) $(DEFINES) $(INCLUDE) $(INCPATH)
+LDFLAGS+= -g -Wall $(Wextra) -L../lib/ $(LDPATH)
 LIBS    = $(LIBROAR) $(lib_fishsound) $(lib_oggz)
 
Index: roarfish/include/roarfish.h
===================================================================
--- roarfish/include/roarfish.h	(revision 4708)
+++ roarfish/include/roarfish.h	(revision 5270)
@@ -42,5 +42,5 @@
 #include <sndfile.h>
 
-int play (char * file, char ** opts);
+int play (const char * file, char ** opts);
 
 #ifdef __USE_SVID
Index: roarfish/play.c
===================================================================
--- roarfish/play.c	(revision 4908)
+++ roarfish/play.c	(revision 5270)
@@ -63,5 +63,7 @@
 
 
- roar_vs_write(inst->vss, (char*)data, frames * 2, NULL);
+ if ( roar_vs_write(inst->vss, (char*)data, frames * 2, NULL) != (ssize_t)(frames * 2) ) {
+  return -1;
+ }
 
 
@@ -74,13 +76,17 @@
  FishSound * fsound = (FishSound *)user_data;
 
- fish_sound_prepare_truncation (fsound, op->granulepos, op->e_o_s);
- fish_sound_decode (fsound, op->packet, op->bytes);
+ (void)oggz, (void)serialno;
+
+ fish_sound_prepare_truncation(fsound, op->granulepos, op->e_o_s);
+ fish_sound_decode(fsound, op->packet, op->bytes);
 
  return 0;
 }
 
-int play (char * file, char ** opts) {
+int play (const char * file, char ** opts) {
  OGGZ * oggz;
  struct roarfish_play_inst inst;
+
+ (void)opts;
 
  inst.vss    = NULL;
