Integer types changed for 16/32/64 bit environment.

Move to new API.
Fixed 24bit data Native-bigendian handling by using WORDS_BIGENDIAN.


git-svn-id: svn://svn.code.sf.net/p/bs2b/code/trunk/libbs2b@58 bc0edfbe-c936-4687-b64d-f70bc3985e72

7 files changed, 182 insertions, 128 deletions

diff --git a/ChangeLog b/ChangeLog
index 256d150..00c0224 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,9 @@
+2009-03-06 Boris Mikhaylov <http://www.tmn.ru/~bor>
+	* libsndfile v1.0.17 -> v1.0.19.
+	* Added more systems compatability (Integer types changed).
+	* Move to new API.
+	* Fixed 24bit data Native-bigendian handling.
+
 2009-02-18 Sebastian Pipping <sebastian@pipping.org>
 	* Shared lib (*nix) project started.
 
diff --git a/src/bs2b.c b/src/bs2b.c
index 4855370..6ea135c 100644
--- a/src/bs2b.c
+++ b/src/bs2b.c
@@ -30,37 +30,44 @@
 #define M_PI  3.14159265358979323846
 #endif
 
-/* Type for 24bit conversions */
-typedef union int_char
+static double int242double( int24_t *in )
 {
-	long i;
-	struct c { char byte[ 4 ]; } c;
-} t_int_char;
+	int32_t out =
+		( ( uint32_t )in->octet0 ) |
+		( ( uint32_t )in->octet1 << 8 ) |
+		( ( uint32_t )in->octet2 << 16 ) |
+		( ( in->octet2 < 0 ? ( uint32_t )-1 : 0 ) << 24 );
 
-/* Convert 24bit integer to double */
-static double tribyte2double( char *in_24 )
-{
-	t_int_char int_char;
+	return ( double )out;
+} /* int242double() */
 
-	int_char.c.byte[ 0 ] = in_24[ 0 ];
-	int_char.c.byte[ 1 ] = in_24[ 1 ];
-	int_char.c.byte[ 2 ] = in_24[ 2 ];
-	int_char.c.byte[ 3 ] = in_24[ 2 ] & 0x80 ? 0xFF : 0x00;
+static double uint242double( uint24_t *in )
+{
+	uint32_t out =
+		( ( uint32_t )in->octet0 ) |
+		( ( uint32_t )in->octet1 << 8 ) |
+		( ( uint32_t )in->octet2 << 16 );
 
-	return ( double )int_char.i;
-} /* tribyte2double() */
+	return ( double )out;
+} /* uint242double() */
 
-/* Convert double to 24bit integer */
-static void double2tribyte( double in_d, char *out_24 )
+static void double2int24( double in, int24_t *out )
 {
-	t_int_char int_char;
+	uint32_t i = ( uint32_t )in;
 
-	int_char.i = ( long )in_d;
+	out->octet0 = i & 0xff;
+	out->octet1 = ( i >> 8 ) & 0xff;
+	out->octet2 = ( i >> 16 ) & 0xff;
+} /* double2int24() */
 
-	out_24[ 0 ] = int_char.c.byte[ 0 ];
-	out_24[ 1 ] = int_char.c.byte[ 1 ];
-	out_24[ 2 ] = int_char.c.byte[ 2 ];
-} /* double2tribyte() */
+static void double2uint24( double in, uint24_t *out )
+{
+	uint32_t i = ( uint32_t )in;
+
+	out->octet0 = i & 0xff;
+	out->octet1 = ( i >> 8 ) & 0xff;
+	out->octet2 = ( i >> 16 ) & 0xff;
+} /* double2uint24() */
 
 /* Set up bs2b data. */
 static void init( t_bs2bdp bs2bdp )
@@ -158,7 +165,7 @@ void bs2b_close( t_bs2bdp bs2bdp )
 	free( bs2bdp );
 } /* bs2b_close() */
 
-void bs2b_set_level( t_bs2bdp bs2bdp, int level )
+void bs2b_set_level( t_bs2bdp bs2bdp, uint32_t level )
 {
 	if( ! bs2bdp ) return;
 
@@ -168,12 +175,12 @@ void bs2b_set_level( t_bs2bdp bs2bdp, int level )
 	init( bs2bdp );
 } /* bs2b_set_level() */
 
-int bs2b_get_level( t_bs2bdp bs2bdp )
+uint32_t bs2b_get_level( t_bs2bdp bs2bdp )
 {
 	return bs2bdp->level;
 } /* bs2b_get_level() */
 
-void bs2b_set_srate( t_bs2bdp bs2bdp, long srate )
+void bs2b_set_srate( t_bs2bdp bs2bdp, uint32_t srate )
 {
 	if( ! bs2bdp ) return;
 
@@ -184,7 +191,7 @@ void bs2b_set_srate( t_bs2bdp bs2bdp, long srate )
 	bs2b_clear( bs2bdp );
 } /* bs2b_set_srate() */
 
-long bs2b_get_srate( t_bs2bdp bs2bdp )
+uint32_t bs2b_get_srate( t_bs2bdp bs2bdp )
 {
 	return bs2bdp->srate;
 } /* bs2b_get_srate() */
@@ -223,7 +230,7 @@ int bs2b_is_clear( t_bs2bdp bs2bdp )
 #define hi_filter( in, in_1, out_1 ) \
 	( bs2bdp->a0_hi * in + bs2bdp->a1_hi * in_1 + bs2bdp->b1_hi * out_1 )
 
-void bs2b_cross_feed( t_bs2bdp bs2bdp, double *sample )
+void bs2b_cross_feed_dne( t_bs2bdp bs2bdp, double *sample )
 {
 	/* Single pole IIR filter.
 	 * O[n] = a0*I[n] + a1*I[n-1] + b1*O[n-1]
@@ -254,95 +261,90 @@ void bs2b_cross_feed( t_bs2bdp bs2bdp, double *sample )
 	if( sample[ 0 ] < -1.0 ) sample[ 0 ] = -1.0;
 	if( sample[ 1 ] >  1.0 ) sample[ 1 ] =  1.0;
 	if( sample[ 1 ] < -1.0 ) sample[ 1 ] = -1.0;
-} /* bs2b_cross_feed() */
+} /* bs2b_cross_feed_dne() */
 
-void bs2b_cross_feed_f32( t_bs2bdp bs2bdp, float *sample )
+void bs2b_cross_feed_fne( t_bs2bdp bs2bdp, float *sample )
 {
 	double sample_d[ 2 ];
 
 	sample_d[ 0 ] = ( double )sample[ 0 ];
 	sample_d[ 1 ] = ( double )sample[ 1 ];
 
-	bs2b_cross_feed( bs2bdp, sample_d );
+	bs2b_cross_feed_dne( bs2bdp, sample_d );
 
 	sample[ 0 ] = ( float )sample_d[ 0 ];
 	sample[ 1 ] = ( float )sample_d[ 1 ];
-} /* bs2b_cross_feed_f32() */
+} /* bs2b_cross_feed_fne() */
 
-#define MAX_LONG_VALUE   2147483647.0
-#define MAX_SHORT_VALUE       32767.0
-#define MAX_CHAR_VALUE          127.0
-#define MAX_24BIT_VALUE     8388607.0
+#define MAX_INT32_VALUE  2147483647.0
+#define MAX_INT16_VALUE       32767.0
+#define MAX_INT8_VALUE          127.0
+#define MAX_INT24_VALUE     8388607.0
 
-void bs2b_cross_feed_32( t_bs2bdp bs2bdp, long *sample )
+void bs2b_cross_feed_s32ne( t_bs2bdp bs2bdp, int32_t *sample )
 {
 	double sample_d[ 2 ];
 
-	sample_d[ 0 ] = ( double )sample[ 0 ] / MAX_LONG_VALUE;
-	sample_d[ 1 ] = ( double )sample[ 1 ] / MAX_LONG_VALUE;
+	sample_d[ 0 ] = ( double )sample[ 0 ] / MAX_INT32_VALUE;
+	sample_d[ 1 ] = ( double )sample[ 1 ] / MAX_INT32_VALUE;
 
-	bs2b_cross_feed( bs2bdp, sample_d );
+	bs2b_cross_feed_dne( bs2bdp, sample_d );
 
-	sample[ 0 ] = ( long )( sample_d[ 0 ] * MAX_LONG_VALUE );
-	sample[ 1 ] = ( long )( sample_d[ 1 ] * MAX_LONG_VALUE );
-} /* bs2b_cross_feed_32 */
+	sample[ 0 ] = ( int32_t )( sample_d[ 0 ] * MAX_INT32_VALUE );
+	sample[ 1 ] = ( int32_t )( sample_d[ 1 ] * MAX_INT32_VALUE );
+} /* bs2b_cross_feed_s32ne() */
 
-void bs2b_cross_feed_16( t_bs2bdp bs2bdp, short *sample )
+void bs2b_cross_feed_s16ne( t_bs2bdp bs2bdp, int16_t *sample )
 {
 	double sample_d[ 2 ];
 
-	sample_d[ 0 ] = ( double )sample[ 0 ] / MAX_SHORT_VALUE;
-	sample_d[ 1 ] = ( double )sample[ 1 ] / MAX_SHORT_VALUE;
+	sample_d[ 0 ] = ( double )sample[ 0 ] / MAX_INT16_VALUE;
+	sample_d[ 1 ] = ( double )sample[ 1 ] / MAX_INT16_VALUE;
 
-	bs2b_cross_feed( bs2bdp, sample_d );
+	bs2b_cross_feed_dne( bs2bdp, sample_d );
 
-	sample[ 0 ] = ( short )( sample_d[ 0 ] * MAX_SHORT_VALUE );
-	sample[ 1 ] = ( short )( sample_d[ 1 ] * MAX_SHORT_VALUE );
-} /* bs2b_cross_feed_16() */
+	sample[ 0 ] = ( int16_t )( sample_d[ 0 ] * MAX_INT16_VALUE );
+	sample[ 1 ] = ( int16_t )( sample_d[ 1 ] * MAX_INT16_VALUE );
+} /* bs2b_cross_feed_s16ne() */
 
-void bs2b_cross_feed_s8( t_bs2bdp bs2bdp, char *sample )
+void bs2b_cross_feed_s8( t_bs2bdp bs2bdp, int8_t *sample )
 {
 	double sample_d[ 2 ];
 
-	sample_d[ 0 ] = ( double )sample[ 0 ] / MAX_CHAR_VALUE;
-	sample_d[ 1 ] = ( double )sample[ 1 ] / MAX_CHAR_VALUE;
+	sample_d[ 0 ] = ( double )sample[ 0 ] / MAX_INT8_VALUE;
+	sample_d[ 1 ] = ( double )sample[ 1 ] / MAX_INT8_VALUE;
 
-	bs2b_cross_feed( bs2bdp, sample_d );
+	bs2b_cross_feed_dne( bs2bdp, sample_d );
 
-	sample[ 0 ] = ( char )( sample_d[ 0 ] * MAX_CHAR_VALUE );
-	sample[ 1 ] = ( char )( sample_d[ 1 ] * MAX_CHAR_VALUE );
+	sample[ 0 ] = ( int8_t )( sample_d[ 0 ] * MAX_INT8_VALUE );
+	sample[ 1 ] = ( int8_t )( sample_d[ 1 ] * MAX_INT8_VALUE );
 } /* bs2b_cross_feed_s8() */
 
-void bs2b_cross_feed_u8( t_bs2bdp bs2bdp, unsigned char *sample )
+void bs2b_cross_feed_u8( t_bs2bdp bs2bdp, uint8_t *sample )
 {
 	double sample_d[ 2 ];
 
-	sample_d[ 0 ] = ( ( double )( ( char )( sample[ 0 ] ^ 0x80 ) ) ) / MAX_CHAR_VALUE;
-	sample_d[ 1 ] = ( ( double )( ( char )( sample[ 1 ] ^ 0x80 ) ) ) / MAX_CHAR_VALUE;
+	sample_d[ 0 ] = ( ( double )( ( int8_t )( sample[ 0 ] ^ 0x80 ) ) ) / MAX_INT8_VALUE;
+	sample_d[ 1 ] = ( ( double )( ( int8_t )( sample[ 1 ] ^ 0x80 ) ) ) / MAX_INT8_VALUE;
 
-	bs2b_cross_feed( bs2bdp, sample_d );
+	bs2b_cross_feed_dne( bs2bdp, sample_d );
 
-	sample[ 0 ] = ( ( unsigned char )( sample_d[ 0 ] * MAX_CHAR_VALUE ) ) ^ 0x80;
-	sample[ 1 ] = ( ( unsigned char )( sample_d[ 1 ] * MAX_CHAR_VALUE ) ) ^ 0x80;
+	sample[ 0 ] = ( ( uint8_t )( sample_d[ 0 ] * MAX_INT8_VALUE ) ) ^ 0x80;
+	sample[ 1 ] = ( ( uint8_t )( sample_d[ 1 ] * MAX_INT8_VALUE ) ) ^ 0x80;
 } /* bs2b_cross_feed_u8() */
 
-void bs2b_cross_feed_24( t_bs2bdp bs2bdp, void *sample )
+void bs2b_cross_feed_s24ne( t_bs2bdp bs2bdp, int24_t *sample )
 {
 	double sample_d[ 2 ];
-	char  *sample_1 = sample;
-	char  *sample_2 = sample_1 + 3;
-
-	sample_d[ 0 ] = tribyte2double( sample_1 );
-	sample_d[ 1 ] = tribyte2double( sample_2 );
 
-	sample_d[ 0 ] /= MAX_24BIT_VALUE;
-	sample_d[ 1 ] /= MAX_24BIT_VALUE;
+	sample_d[ 0 ] = int242double( sample )     / MAX_INT24_VALUE;
+	sample_d[ 1 ] = int242double( sample + 1 ) / MAX_INT24_VALUE;
 
-	bs2b_cross_feed( bs2bdp, sample_d );
+	bs2b_cross_feed_dne( bs2bdp, sample_d );
 
-	double2tribyte( sample_d[ 0 ] * MAX_24BIT_VALUE, sample_1 );
-	double2tribyte( sample_d[ 1 ] * MAX_24BIT_VALUE, sample_2 );
-} /* bs2b_cross_feed_24() */
+	double2int24( sample_d[ 0 ] * MAX_INT24_VALUE, sample );
+	double2int24( sample_d[ 1 ] * MAX_INT24_VALUE, sample + 1 );
+} /* bs2b_cross_feed_s24ne() */
 
 char const *bs2b_runtime_version( void )
 {
diff --git a/src/bs2b.h b/src/bs2b.h
index 0200bd7..0ce9860 100644
--- a/src/bs2b.h
+++ b/src/bs2b.h
@@ -21,11 +21,57 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#ifndef BS2B_H
-#define BS2B_H
+#ifndef _BS2B_H_
+#define _BS2B_H_
+
+#include <limits.h>
 
 #include "bs2bversion.h"
 
+#if HAVE_STDINT_H
+#include <stdint.h>
+#elif UINT_MAX == 0xffff /* 16 bit compiler */
+typedef signed   char    int8_t;
+typedef signed   short   int16_t;
+typedef signed   long    int32_t;
+typedef unsigned char    uint8_t;
+typedef unsigned short   uint16_t;
+typedef unsigned long    uint32_t;
+#else /* UINT_MAX != 0xffff */ /* 32/64 bit compiler */
+typedef signed   char    int8_t;
+typedef signed   short   int16_t;
+typedef signed   int     int32_t;
+typedef unsigned char    uint8_t;
+typedef unsigned short   uint16_t;
+typedef unsigned int     uint32_t;
+#endif /* HAVE_STDINT_H */
+
+typedef struct
+{
+#ifdef WORDS_BIGENDIAN
+	int8_t  octet2;
+	uint8_t octet1;
+	uint8_t octet0;
+#else
+	uint8_t octet0;
+	uint8_t octet1;
+	int8_t  octet2;
+#endif /* WORDS_BIGENDIAN */
+} int24_t;
+
+typedef struct
+{
+#ifdef WORDS_BIGENDIAN
+	uint8_t octet2;
+	uint8_t octet1;
+	uint8_t octet0;
+#else
+	uint8_t octet0;
+	uint8_t octet1;
+	uint8_t octet2;
+#endif /* WORDS_BIGENDIAN */
+} uint24_t;
+
 /* Number of crossfeed levels */
 #define BS2B_CLEVELS           3
 
@@ -46,8 +92,8 @@
 
 typedef struct
 {
-	long level;                  /* Crossfeed level */
-	long srate;                  /* Sample rate (Hz) */
+	uint32_t level;              /* Crossfeed level */
+	uint32_t srate;              /* Sample rate (Hz) */
 	double a0_lo, b1_lo;         /* Lowpass IIR filter coefficients */
 	double a0_hi, a1_hi, b1_hi;  /* Highboost IIR filter coefficients */
 	double gain;                 /* Global gain against overloading */
@@ -73,18 +119,18 @@ void bs2b_close( t_bs2bdp bs2bdp );
 /* Sets a new coefficients with new crossfeed level value.
  * level - crossfeed level of *LEVEL values.
  */
-void bs2b_set_level( t_bs2bdp bs2bdp, int level );
+void bs2b_set_level( t_bs2bdp bs2bdp, uint32_t level );
 
 /* Return current crossfeed level value */
-int bs2b_get_level( t_bs2bdp bs2bdp );
+uint32_t bs2b_get_level( t_bs2bdp bs2bdp );
 
 /* Clear buffers and sets a new coefficients with new sample rate value.
  * srate - sample rate by Hz.
  */
-void bs2b_set_srate( t_bs2bdp bs2bdp, long srate );
+void bs2b_set_srate( t_bs2bdp bs2bdp, uint32_t srate );
 
 /* Return current sample rate value */
-long bs2b_get_srate( t_bs2bdp bs2bdp );
+uint32_t bs2b_get_srate( t_bs2bdp bs2bdp );
 
 /* Clear buffer */
 void bs2b_clear( t_bs2bdp bs2bdp );
@@ -97,26 +143,26 @@ int bs2b_is_clear( t_bs2bdp bs2bdp );
  * Returns crossfided samle by sample pointer.
  */
 
-/* sample poits to double floats */
-void bs2b_cross_feed( t_bs2bdp bs2bdp, double *sample );
+/* sample poits to double floats native endians */
+void bs2b_cross_feed_dne( t_bs2bdp bs2bdp, double *sample );
 
-/* sample poits to floats */
-void bs2b_cross_feed_f32( t_bs2bdp bs2bdp, float *sample );
+/* sample poits to floats native endians */
+void bs2b_cross_feed_fne( t_bs2bdp bs2bdp, float *sample );
 
-/* sample poits to 32bit integers */
-void bs2b_cross_feed_32( t_bs2bdp bs2bdp, long *sample );
+/* sample poits to 32bit signed integers native endians */
+void bs2b_cross_feed_s32ne( t_bs2bdp bs2bdp, int32_t *sample );
 
-/* sample poits to 16bit integers */
-void bs2b_cross_feed_16( t_bs2bdp bs2bdp, short *sample );
+/* sample poits to 16bit signed integers native endians */
+void bs2b_cross_feed_s16ne( t_bs2bdp bs2bdp, int16_t *sample );
 
-/* sample poits to 8bit integers */
-void bs2b_cross_feed_s8( t_bs2bdp bs2bdp, char *sample );
+/* sample poits to 8bit signed integers */
+void bs2b_cross_feed_s8( t_bs2bdp bs2bdp, int8_t *sample );
 
 /* sample poits to 8bit unsigned integers */
-void bs2b_cross_feed_u8( t_bs2bdp bs2bdp, unsigned char *sample );
+void bs2b_cross_feed_u8( t_bs2bdp bs2bdp, uint8_t *sample );
 
-/* sample poits to 24bit integers */
-void bs2b_cross_feed_24( t_bs2bdp bs2bdp, void *sample );
+/* sample poits to 24bit signed integers native endians */
+void bs2b_cross_feed_s24ne( t_bs2bdp bs2bdp, int24_t *sample );
 
 /* Return bs2b version string */
 char const *bs2b_runtime_version( void );
@@ -125,4 +171,4 @@ char const *bs2b_runtime_version( void );
 }	/* extern "C" */
 #endif /* __cplusplus */
 
-#endif	/* BS2B_H */
+#endif	/* _BS2B_H_ */
diff --git a/src/bs2bclass.cpp b/src/bs2bclass.cpp
index c2b631a..bedeb40 100644
--- a/src/bs2bclass.cpp
+++ b/src/bs2bclass.cpp
@@ -33,22 +33,22 @@ bs2b_base::~bs2b_base()
 	bs2b_close( bs2bdp );
 }
 
-void bs2b_base::set_level( int level )
+void bs2b_base::set_level( uint32_t level )
 {
 	bs2b_set_level( bs2bdp, level );
 }
 
-int bs2b_base::get_level()
+uint32_t bs2b_base::get_level()
 {
 	return bs2b_get_level( bs2bdp );
 }
 
-void bs2b_base::set_srate( long srate )
+void bs2b_base::set_srate( uint32_t srate )
 {
 	bs2b_set_srate( bs2bdp, srate );
 }
 
-long bs2b_base::get_srate()
+uint32_t bs2b_base::get_srate()
 {
 	return bs2b_get_srate( bs2bdp );
 }
@@ -65,35 +65,35 @@ bool bs2b_base::is_clear()
 
 void bs2b_base::cross_feed( double *sample )
 {
-	bs2b_cross_feed( bs2bdp, sample );
+	bs2b_cross_feed_dne( bs2bdp, sample );
 }
 
 void bs2b_base::cross_feed( float *sample )
 {
-	bs2b_cross_feed_f32( bs2bdp, sample );
+	bs2b_cross_feed_fne( bs2bdp, sample );
 }
 
-void bs2b_base::cross_feed( long *sample )
+void bs2b_base::cross_feed( int32_t *sample )
 {
-	bs2b_cross_feed_32( bs2bdp, sample );
+	bs2b_cross_feed_s32ne( bs2bdp, sample );
 }
 
-void bs2b_base::cross_feed( short *sample )
+void bs2b_base::cross_feed( int16_t *sample )
 {
-	bs2b_cross_feed_16( bs2bdp, sample );
+	bs2b_cross_feed_s16ne( bs2bdp, sample );
 }
 
-void bs2b_base::cross_feed( char *sample )
+void bs2b_base::cross_feed( int8_t *sample )
 {
 	bs2b_cross_feed_s8( bs2bdp, sample );
 }
 
-void bs2b_base::cross_feed( unsigned char *sample )
+void bs2b_base::cross_feed( uint8_t *sample )
 {
 	bs2b_cross_feed_u8( bs2bdp, sample );
 }
 
-void bs2b_base::cross_feed( void *sample )
+void bs2b_base::cross_feed( int24_t *sample )
 {
-	bs2b_cross_feed_24( bs2bdp, sample );
+	bs2b_cross_feed_s24ne( bs2bdp, sample );
 }
diff --git a/src/bs2bclass.h b/src/bs2bclass.h
index c36b812..d2ddbd9 100644
--- a/src/bs2bclass.h
+++ b/src/bs2bclass.h
@@ -21,8 +21,8 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#ifndef BS2BCLASS_H
-#define BS2BCLASS_H
+#ifndef _BS2BCLASS_H_
+#define _BS2BCLASS_H_
 
 #include "bs2b.h"
 
@@ -35,20 +35,20 @@ public:
 	bs2b_base();
 	~bs2b_base();
 
-	void set_level( int level );
-	int  get_level();
-	void set_srate( long srate );
-	long get_srate();
-	void clear();
-	bool is_clear();
+	void      set_level( uint32_t level );
+	uint32_t  get_level();
+	void      set_srate( uint32_t srate );
+	uint32_t  get_srate();
+	void      clear();
+	bool      is_clear();
 
-	void cross_feed( double *sample );
-	void cross_feed( float *sample );
-	void cross_feed( long *sample );
-	void cross_feed( short *sample );
-	void cross_feed( char *sample );
-	void cross_feed( unsigned char *sample );
-	void cross_feed( void *sample );
+	void cross_feed( double   *sample );
+	void cross_feed( float    *sample );
+	void cross_feed( int32_t  *sample );
+	void cross_feed( int16_t  *sample );
+	void cross_feed( int8_t   *sample );
+	void cross_feed( uint8_t  *sample );
+	void cross_feed( int24_t  *sample );
 }; // class bs2b_base
 
-#endif // BS2BCLASS_H
+#endif // _BS2BCLASS_H_
diff --git a/src/bs2bconvert.c b/src/bs2bconvert.c
index 1938b0e..2c1c4dd 100644
--- a/src/bs2bconvert.c
+++ b/src/bs2bconvert.c
@@ -198,7 +198,7 @@ static void copy_data( SNDFILE *outfile, SNDFILE *infile, t_bs2bdp bs2bdp )
 		readcount = (int)sf_read_double( infile, data, items );
 
 		for( k = 0; k < readcount; k += 2 )
-			bs2b_cross_feed( bs2bdp, data + k );
+			bs2b_cross_feed_dne( bs2bdp, data + k );
 
 		sf_write_double( outfile, data, readcount );
 	}
diff --git a/src/bs2bstream.c b/src/bs2bstream.c
index 372b3da..2817d68 100644
--- a/src/bs2bstream.c
+++ b/src/bs2bstream.c
@@ -113,7 +113,7 @@ int main( int argc, char *argv[] )
 
 	while( 2 == fread( sample, sizeof( short ), 2, stdin ) )
 	{
-		bs2b_cross_feed_16( bs2bdp, sample );
+		bs2b_cross_feed_s16ne( bs2bdp, sample );
 		fwrite( sample, sizeof( short ), 2, stdout );
 	}