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