sigrid/sox · Ink

src/8svx.c+11−14

 /*                         8SVXSTARTREAD                                */
 /*======================================================================*/
-int st_svxstartread(ft_t ft)
+static int st_svxstartread(ft_t ft)
 {
         svx_t p = (svx_t ) ft->priv;
 /*======================================================================*/
 /*                         8SVXREAD                                     */
 /*======================================================================*/
-st_ssize_t st_svxread(ft_t ft, st_sample_t *buf, st_size_t nsamp)
+static st_size_t st_svxread(ft_t ft, st_sample_t *buf, st_size_t nsamp)
 {
         unsigned char datum;
-        int done = 0;
+        size_t done = 0, i;
-        int i;
         svx_t p = (svx_t ) ft->priv;
 /*======================================================================*/
 /*                         8SVXSTOPREAD                                 */
 /*======================================================================*/
-int st_svxstopread(ft_t ft)
+static int st_svxstopread(ft_t ft)
 {
-        int i;
+        size_t i;
         svx_t p = (svx_t ) ft->priv;
 /*======================================================================*/
 /*                         8SVXSTARTWRITE                               */
 /*======================================================================*/
-int st_svxstartwrite(ft_t ft)
+static int st_svxstartwrite(ft_t ft)
 {
         svx_t p = (svx_t ) ft->priv;
-        int i;
+        size_t i;
         /* 8svx is in big endian format.  Swaps wahst
          * read in on little endian machines.
 /*                         8SVXWRITE                                    */
 /*======================================================================*/
-st_ssize_t st_svxwrite(ft_t ft, const st_sample_t *buf, st_size_t len)
+static st_size_t st_svxwrite(ft_t ft, const st_sample_t *buf, st_size_t len)
 {
         svx_t p = (svx_t ) ft->priv;
         unsigned char datum;
-        int done = 0;
+        size_t done = 0, i;
-        int i;
         p->nsamples += len;
 /*                         8SVXSTOPWRITE                                */
 /*======================================================================*/
-int st_svxstopwrite(ft_t ft)
+static int st_svxstopwrite(ft_t ft)
 {
         svx_t p = (svx_t ) ft->priv;
-        int i;
+        size_t i, len;
-        int len;
         char svxbuf[512];
         /* append all channel pieces to channel 0 */

src/FFT.c+2−2

@@ -62,7 +62,7 @@ const int MaxFastBits = 16; · 61 unmodified lines
62	static int IsPowerOfTwo(int x);	62	static int IsPowerOfTwo(int x);
63	static int NumberOfBitsNeeded(int PowerOfTwo);	63	static int NumberOfBitsNeeded(int PowerOfTwo);
64	static int ReverseBits(int index, int NumBits);	64	static int ReverseBits(int index, int NumBits);
65	static void InitFFT();	65	static void InitFFT(void);
66		66
67	int IsPowerOfTwo(int x)	67	int IsPowerOfTwo(int x)
68	{	68	{
@@ -103,7 +103,7 @@ int ReverseBits(int index, int NumBits) · 34 unmodified lines
103	* freed, to use as a lookup table for bit-reversal. The good news is that	103	* freed, to use as a lookup table for bit-reversal. The good news is that
104	* we bascially need this until the very end, so the fact that it's not freed	104	* we bascially need this until the very end, so the fact that it's not freed
105	* is OK. */	105	* is OK. */
106	void InitFFT()	106	void InitFFT(void)
107	{	107	{
108	int len, b;	108	int len, b;
109		109

src/Makefile.in+10−5

 EXEEXT = @EXEEXT@
 GETOPT_LONG_FALSE = @GETOPT_LONG_FALSE@
 GETOPT_LONG_TRUE = @GETOPT_LONG_TRUE@
+GREP = @GREP@
 INSTALL_DATA = @INSTALL_DATA@
 INSTALL_PROGRAM = @INSTALL_PROGRAM@
 INSTALL_SCRIPT = @INSTALL_SCRIPT@
 STRIP = @STRIP@
 VERSION = @VERSION@
 ac_ct_CC = @ac_ct_CC@
-ac_ct_RANLIB = @ac_ct_RANLIB@
-ac_ct_STRIP = @ac_ct_STRIP@
-ac_pt_PKG_CONFIG = @ac_pt_PKG_CONFIG@
 am__fastdepCC_FALSE = @am__fastdepCC_FALSE@
 am__fastdepCC_TRUE = @am__fastdepCC_TRUE@
 am__include = @am__include@
 bindir = @bindir@
 build_alias = @build_alias@
 datadir = @datadir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+dvidir = @dvidir@
 exec_prefix = @exec_prefix@
 host_alias = @host_alias@
+htmldir = @htmldir@
 includedir = @includedir@
 infodir = @infodir@
 install_sh = @install_sh@
 libdir = @libdir@
 libexecdir = @libexecdir@
+localedir = @localedir@
 localstatedir = @localstatedir@
 mandir = @mandir@
 mkdir_p = @mkdir_p@
 oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
 prefix = @prefix@
 program_transform_name = @program_transform_name@
+psdir = @psdir@
 sbindir = @sbindir@
 sharedstatedir = @sharedstatedir@
 sysconfdir = @sysconfdir@
 	      exit 1;; \
 	  esac; \
 	done; \
-	echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign  src/Makefile'; \
+	echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu  src/Makefile'; \
 	cd $(top_srcdir) && \
-	  $(AUTOMAKE) --foreign  src/Makefile
+	  $(AUTOMAKE) --gnu  src/Makefile
 .PRECIOUS: Makefile
 Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
 	@case '$?' in \

src/adpcm.c+7−10

                         { 392,-232}
 };
-inline st_sample_t AdpcmDecode(st_sample_t c, MsState_t *state,
+static inline st_sample_t AdpcmDecode(st_sample_t c, MsState_t *state,
                                st_sample_t sample1, st_sample_t sample2)
 {
         st_sample_t vlin;
         return (int) sqrt(d2);
 }
-inline void AdpcmMashChannel(
+static inline void AdpcmMashChannel(
         int ch,             /* channel number to encode, REQUIRE 0 <= ch < chans  */
         int chans,          /* total channels */
         const SAMPL *ip,    /* ip[] is interleaved input samples */
         int n,              /* samples to encode PER channel, REQUIRE */
         int *st,            /* input/output steps, 16<=st[i] */
-        unsigned char *obuff,      /* output buffer[blockAlign] */
+        unsigned char *obuff /* output buffer[blockAlign] */
-        int opt             /* non-zero allows some cpu-intensive code to improve output */
 )
 {
         SAMPL v[2];
         int n,              /* samples to encode PER channel */
         int *st,            /* input/output steps, 16<=st[i] */
         unsigned char *obuff,      /* output buffer[blockAlign]     */
-        int blockAlign,     /* >= 7*chans + chans*(n-2)/2.0    */
+        int blockAlign      /* >= 7*chans + chans*(n-2)/2.0    */
-        int opt             /* non-zero allows some cpu-intensive code to improve output */
 )
 {
         int ch;
         for (p=obuff+7*chans; p<obuff+blockAlign; p++) *p=0;
         for (ch=0; ch<chans; ch++)
-                AdpcmMashChannel(ch, chans, ip, n, st+ch, obuff, opt);
+                AdpcmMashChannel(ch, chans, ip, n, st+ch, obuff);
 }
 /*
         unsigned short chans,
         unsigned short blockAlign,
         unsigned short samplesPerBlock
-)
+){
-{
         st_size_t m, n;
         if (samplesPerBlock) {
                 n = 0;
                 m = blockAlign;
         }
-        if (m >= 7*chans) {
+        if (m >= (size_t)(7*chans)) {
                 m -= 7*chans;          /* bytes beyond block-header */
                 m = (2*m)/chans + 2;   /* nibbles/chans + 2 in header */
                 if (samplesPerBlock && m > samplesPerBlock) m = samplesPerBlock;

src/adpcm.h+1−2

@@ -26,8 +26,7 @@ extern void AdpcmBlockMashI( · 25 unmodified lines
26	int n, /* samples to encode PER channel, REQUIRE */	26	int n, /* samples to encode PER channel, REQUIRE */
27	int st, / input/output steps, 16<=st[i] */	27	int st, / input/output steps, 16<=st[i] */
28	unsigned char obuff, / output buffer[blockAlign] */	28	unsigned char obuff, / output buffer[blockAlign] */
29	int blockAlign, /* >= 7chans + n/2 /	29	int blockAlign /* >= 7chans + n/2 /
30	int opt /* non-zero allows some cpu-intensive code to improve output */
31	);	30	);
32		31
33	/* Some helper functions for computing samples/block and blockalign */	32	/* Some helper functions for computing samples/block and blockalign */

src/aiff.c+16−18

 static int commentChunk(char **text, char *chunkDescription, ft_t ft);
 static void reportInstrument(ft_t ft);
-int st_aiffseek(ft_t ft, st_size_t offset)
+static int st_aiffseek(ft_t ft, st_size_t offset)
 {
     aiff_t aiff = (aiff_t ) ft->priv;
     st_size_t new_offset, channel_block, alignment;
     return(ft->st_errno);
 }
-int st_aiffstartread(ft_t ft)
+static int st_aiffstartread(ft_t ft)
 {
         aiff_t aiff = (aiff_t ) ft->priv;
         char buf[5];
         if (foundcomm) {
                 ft->info.channels = channels;
                 ft->info.rate = rate;
-                if (ft->info.encoding != -1 && ft->info.encoding != ST_ENCODING_SIGN2)
+                if (ft->info.encoding != ST_ENCODING_UNKNOWN && ft->info.encoding != ST_ENCODING_SIGN2)
                     st_report("AIFF only supports signed data.  Forcing to signed.");
                 ft->info.encoding = ST_ENCODING_SIGN2;
                 if (bits <= 8)
                     return(ST_EOF);
                 }
         } else  {
-                if ((ft->info.channels == -1)
+                if ((ft->info.channels == 0)
                         || (ft->info.rate == 0)
-                        || (ft->info.encoding == -1)
+                        || (ft->info.encoding == ST_ENCODING_UNKNOWN)
                         || (ft->info.size == -1)) {
                   st_report("You must specify # channels, sample rate, signed/unsigned,");
                   st_report("and 8/16 on the command line.");
   st_debug("%-10s   \"%s\"", chunkDescription, *text);
   /* make sure we read the whole chunk */
   if (totalReadLength < chunksize) {
-       int i;
+       size_t i;
        char c;
        for (i=0; i < chunksize - totalReadLength; i++ ) {
                st_readbuf(ft, &c, 1, 1);
   return(ST_SUCCESS);
 }
-st_ssize_t st_aiffread(ft_t ft, st_sample_t *buf, st_size_t len)
+static st_size_t st_aiffread(ft_t ft, st_sample_t *buf, st_size_t len)
 {
         aiff_t aiff = (aiff_t ) ft->priv;
         st_ssize_t done;
-        if (len < 0)
+        if ((st_size_t)len > aiff->nsamples)
-            return ST_EOF;
-        else if ((st_size_t)len > aiff->nsamples)
                 len = aiff->nsamples;
         done = st_rawread(ft, buf, len);
         if (done == 0 && aiff->nsamples != 0)
         return done;
 }
-int st_aiffstopread(ft_t ft)
+static int st_aiffstopread(ft_t ft)
 {
         char buf[5];
         uint32_t chunksize;
    Strictly spoken this is not legal, but the playaiff utility
    will still be able to play the resulting file. */
-int st_aiffstartwrite(ft_t ft)
+static int st_aiffstartwrite(ft_t ft)
 {
         aiff_t aiff = (aiff_t ) ft->priv;
         int rc;
                 ft->info.encoding = ST_ENCODING_SIGN2;
                 ft->info.size = ST_SIZE_WORD;
         }
-        if (ft->info.encoding != -1 && ft->info.encoding != ST_ENCODING_SIGN2)
+        if (ft->info.encoding != ST_ENCODING_UNKNOWN && ft->info.encoding != ST_ENCODING_SIGN2)
             st_report("AIFF only supports signed data.  Forcing to signed.");
         ft->info.encoding = ST_ENCODING_SIGN2; /* We have a fixed encoding */
         return(aiffwriteheader(ft, 0x7f000000L / (ft->info.size*ft->info.channels)));
 }
-st_ssize_t st_aiffwrite(ft_t ft, const st_sample_t *buf, st_size_t len)
+static st_size_t st_aiffwrite(ft_t ft, const st_sample_t *buf, st_size_t len)
 {
         aiff_t aiff = (aiff_t ) ft->priv;
         aiff->nsamples += len;
         return(len);
 }
-int st_aiffstopwrite(ft_t ft)
+static int st_aiffstopwrite(ft_t ft)
 {
         aiff_t aiff = (aiff_t ) ft->priv;
         int rc;
         return(ST_SUCCESS);
 }
-int st_aifcstartwrite(ft_t ft)
+static int st_aifcstartwrite(ft_t ft)
 {
         aiff_t aiff = (aiff_t ) ft->priv;
         int rc;
                 ft->info.encoding = ST_ENCODING_SIGN2;
                 ft->info.size = ST_SIZE_WORD;
         }
-        if (ft->info.encoding != -1 && ft->info.encoding != ST_ENCODING_SIGN2)
+        if (ft->info.encoding != ST_ENCODING_UNKNOWN && ft->info.encoding != ST_ENCODING_SIGN2)
             st_report("AIFC only supports signed data.  Forcing to signed.");
         ft->info.encoding = ST_ENCODING_SIGN2; /* We have a fixed encoding */
         return(aifcwriteheader(ft, 0x7f000000L / (ft->info.size*ft->info.channels)));
 }
-int st_aifcstopwrite(ft_t ft)
+static int st_aifcstopwrite(ft_t ft)
 {
         aiff_t aiff = (aiff_t ) ft->priv;
         int rc;

src/alsa.c+13−18

 typedef struct alsa_priv
 {
     snd_pcm_t *pcm_handle;
-    void *buf;
+    char *buf;
-    st_ssize_t buf_size;
+    st_size_t buf_size;
 } *alsa_priv_t;
 static int get_format(ft_t ft, snd_pcm_format_mask_t *fmask, int *fmt);
-int st_alsasetup(ft_t ft, snd_pcm_stream_t mode)
+static int st_alsasetup(ft_t ft, snd_pcm_stream_t mode)
 {
     int fmt = SND_PCM_FORMAT_S16;
     int err;
     snd_pcm_hw_params_get_channels_min(hw_params, &min_chan);
     snd_pcm_hw_params_get_channels_max(hw_params, &max_chan);
-    if (ft->info.channels == -1)
+    if (ft->info.channels == 0)
         ft->info.channels = min_chan;
     else
         if (ft->info.channels > max_chan)
     snd_pcm_hw_params_get_rate_min(hw_params, &min_rate, &dir);
     snd_pcm_hw_params_get_rate_max(hw_params, &max_rate, &dir);
-    if (min_rate != -1 && rate < min_rate)
+    rate = max(rate, min_rate);
-        rate = min_rate;
+    rate = min(rate, max_rate);
-    else
-        if (max_rate != -1 && rate > max_rate)
-            rate = max_rate;
     if (rate != ft->info.rate)
     {
         st_report("alsa: Hardware does not support %d.  Forcing sample rate to %d.", ft->info.rate, rate);
  *      size and encoding of samples,
  *      mono/stereo/quad.
  */
-int st_alsastartread(ft_t ft)
+static int st_alsastartread(ft_t ft)
 {
     return st_alsasetup(ft, SND_PCM_STREAM_CAPTURE);
 }
-st_ssize_t st_alsaread(ft_t ft, st_sample_t *buf, st_size_t nsamp)
+static st_size_t st_alsaread(ft_t ft, st_sample_t *buf, st_size_t nsamp)
 {
     st_size_t len;
     int err;
     return len;
 }
-int st_alsastopread(ft)
+static int st_alsastopread(ft_t ft)
-ft_t ft;
 {
     alsa_priv_t alsa = (alsa_priv_t)ft->priv;
     return ST_SUCCESS;
 }
-int st_alsastartwrite(ft_t ft)
+static int st_alsastartwrite(ft_t ft)
 {
     return st_alsasetup(ft, SND_PCM_STREAM_PLAYBACK);
 }
-st_ssize_t st_alsawrite(ft_t ft, const st_sample_t *buf, st_size_t nsamp)
+static st_size_t st_alsawrite(ft_t ft, const st_sample_t *buf, st_size_t nsamp)
 {
     st_size_t len;
     int err;
 }
-int st_alsastopwrite(ft)
+static int st_alsastopwrite(ft_t ft)
-ft_t ft;
 {
     alsa_priv_t alsa = (alsa_priv_t)ft->priv;
     if (ft->info.size == -1)
         ft->info.size = ST_SIZE_WORD;
-    if (ft->info.encoding == -1)
+    if (ft->info.encoding == ST_ENCODING_UNKNOWN)
     {
         if (ft->info.size == ST_SIZE_WORD)
             ft->info.encoding = ST_ENCODING_SIGN2;

src/au.c+9−9

@@ -107,7 +107,7 @@ static int st_auencodingandsize(int sun_encoding, st_encoding_t * encoding, sign · 106 unmodified lines
107	return(ST_SUCCESS);	107	return(ST_SUCCESS);
108	}	108	}
109		109
110	int st_auseek(ft_t ft, st_size_t offset)	110	static int st_auseek(ft_t ft, st_size_t offset)
111	{	111	{
112	au_t au = (au_t ) ft->priv;	112	au_t au = (au_t ) ft->priv;
113		113
@@ -137,7 +137,7 @@ int st_auseek(ft_t ft, st_size_t offset) · 23 unmodified lines
137	return(ft->st_errno);	137	return(ft->st_errno);
138	}	138	}
139		139
140	int st_austartread(ft_t ft)	140	static int st_austartread(ft_t ft)
141	{	141	{
142	/* The following 6 variables represent a Sun sound header on disk.	142	/* The following 6 variables represent a Sun sound header on disk.
143	The numbers are written as big-endians.	143	The numbers are written as big-endians.
@@ -245,8 +245,8 @@ int st_austartread(ft_t ft) · 101 unmodified lines
245		245
246	/* Read the number of channels */	246	/* Read the number of channels */
247	st_readdw(ft, &channels);	247	st_readdw(ft, &channels);
248	if (ft->info.channels == -1 \|\| ft->info.channels == (int) channels)	248	if (ft->info.channels == 0 \|\| ft->info.channels == channels)
249	ft->info.channels = (int) channels;	249	ft->info.channels = channels;
250	else	250	else
251	st_report("User options overriding channels read in .au header");	251	st_report("User options overriding channels read in .au header");
252		252
@@ -297,7 +297,7 @@ int st_austartread(ft_t ft) · 44 unmodified lines
297	if it is not, the unspecified size remains in the header	297	if it is not, the unspecified size remains in the header
298	(this is legal). */	298	(this is legal). */
299		299
300	int st_austartwrite(ft_t ft)	300	static int st_austartwrite(ft_t ft)
301	{	301	{
302	au_t p = (au_t ) ft->priv;	302	au_t p = (au_t ) ft->priv;
303	int rc;	303	int rc;
@@ -344,7 +344,7 @@ static int unpack_input(ft_t ft, unsigned char *code) · 40 unmodified lines
344	return (p->in_bits > 0);	344	return (p->in_bits > 0);
345	}	345	}
346		346
347	st_ssize_t st_auread(ft_t ft, st_sample_t *buf, st_size_t samp)	347	static st_size_t st_auread(ft_t ft, st_sample_t *buf, st_size_t samp)
348	{	348	{
349	au_t p = (au_t ) ft->priv;	349	au_t p = (au_t ) ft->priv;
350	unsigned char code;	350	unsigned char code;
@@ -362,14 +362,14 @@ st_ssize_t st_auread(ft_t ft, st_sample_t *buf, st_size_t samp) · 11 unmodified lines
362	return done;	362	return done;
363	}	363	}
364		364
365	st_ssize_t st_auwrite(ft_t ft, const st_sample_t *buf, st_size_t samp)	365	static st_size_t st_auwrite(ft_t ft, const st_sample_t *buf, st_size_t samp)
366	{	366	{
367	au_t p = (au_t ) ft->priv;	367	au_t p = (au_t ) ft->priv;
368	p->data_size += samp * ft->info.size;	368	p->data_size += samp * ft->info.size;
369	return(st_rawwrite(ft, buf, samp));	369	return(st_rawwrite(ft, buf, samp));
370	}	370	}
371		371
372	int st_austopwrite(ft_t ft)	372	static int st_austopwrite(ft_t ft)
373	{	373	{
374	au_t p = (au_t ) ft->priv;	374	au_t p = (au_t ) ft->priv;
375	int rc;	375	int rc;
@@ -411,7 +411,7 @@ static int st_ausunencoding(int size, int encoding) · 35 unmodified lines
411	else if (encoding == ST_ENCODING_FLOAT && size == ST_SIZE_32BIT)	411	else if (encoding == ST_ENCODING_FLOAT && size == ST_SIZE_32BIT)
412	sun_encoding = SUN_FLOAT;	412	sun_encoding = SUN_FLOAT;
413	else	413	else
414	sun_encoding = -1;	414	sun_encoding = ST_ENCODING_UNKNOWN;
415	return sun_encoding;	415	return sun_encoding;
416	}	416	}
417		417

src/auto.c+2−2

@@ -23,7 +23,7 @@ · 22 unmodified lines
23	#define LASTCHAR '/'	23	#define LASTCHAR '/'
24	#endif	24	#endif
25		25
26	int st_autostartread(ft_t ft)	26	static int st_autostartread(ft_t ft)
27	{	27	{
28	char *type = NULL;	28	char *type = NULL;
29	char header[20];	29	char header[20];
@@ -179,7 +179,7 @@ int st_autostartread(ft_t ft) · 149 unmodified lines
179	return ((* ft->h->startread)(ft));	179	return ((* ft->h->startread)(ft));
180	}	180	}
181		181
182	int st_autostartwrite(ft_t ft)	182	static int st_autostartwrite(ft_t ft)
183	{	183	{
184	st_fail_errno(ft,ST_EFMT,"Type AUTO can only be used for input!");	184	st_fail_errno(ft,ST_EFMT,"Type AUTO can only be used for input!");
185	return(ST_EOF);	185	return(ST_EOF);

src/avg.c+4−4

@@ -50,7 +50,7 @@ typedef struct avgstuff { · 49 unmodified lines
50	/*	50	/*
51	* Process options	51	* Process options
52	*/	52	*/
53	int st_avg_getopts(eff_t effp, int n, char **argv)	53	static int st_avg_getopts(eff_t effp, int n, char **argv)
54	{	54	{
55	avg_t avg = (avg_t) effp->priv;	55	avg_t avg = (avg_t) effp->priv;
56	double* pans = &avg->sources[0][0];	56	double* pans = &avg->sources[0][0];
@@ -118,7 +118,7 @@ int st_avg_getopts(eff_t effp, int n, char **argv) · 61 unmodified lines
118	/*	118	/*
119	* Start processing	119	* Start processing
120	*/	120	*/
121	int st_avg_start(eff_t effp)	121	static int st_avg_start(eff_t effp)
122	{	122	{
123	/*	123	/*
124	Hmmm, this is tricky. Lemme think:	124	Hmmm, this is tricky. Lemme think:
@@ -508,7 +508,7 @@ int st_avg_start(eff_t effp) · 383 unmodified lines
508	* Process either isamp or osamp samples, whichever is smaller.	508	* Process either isamp or osamp samples, whichever is smaller.
509	*/	509	*/
510		510
511	int st_avg_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf,	511	static int st_avg_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf,
512	st_size_t isamp, st_size_t osamp)	512	st_size_t isamp, st_size_t osamp)
513	{	513	{
514	avg_t avg = (avg_t) effp->priv;	514	avg_t avg = (avg_t) effp->priv;
@@ -542,7 +542,7 @@ int st_avg_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf, · 27 unmodified lines
542	*	542	*
543	* Should have statistics on right, left, and output amplitudes.	543	* Should have statistics on right, left, and output amplitudes.
544	*/	544	*/
545	int st_avg_stop(eff_t effp)	545	static int st_avg_stop(eff_t effp UNUSED)
546	{	546	{
547	return (ST_SUCCESS); /* nothing to do */	547	return (ST_SUCCESS); /* nothing to do */
548	}	548	}

src/avr.c+4−4

@@ -63,7 +63,7 @@ typedef struct avrstuff { · 62 unmodified lines
63	*/	63	*/
64		64
65		65
66	int st_avrstartread(ft_t ft)	66	static int st_avrstartread(ft_t ft)
67	{	67	{
68	avr_t avr = (avr_t)ft->priv;	68	avr_t avr = (avr_t)ft->priv;
69	int rc;	69	int rc;
@@ -148,7 +148,7 @@ int st_avrstartread(ft_t ft) · 78 unmodified lines
148	return(ST_SUCCESS);	148	return(ST_SUCCESS);
149	}	149	}
150		150
151	int st_avrstartwrite(ft_t ft)	151	static int st_avrstartwrite(ft_t ft)
152	{	152	{
153	avr_t avr = (avr_t)ft->priv;	153	avr_t avr = (avr_t)ft->priv;
154	int rc;	154	int rc;
@@ -260,7 +260,7 @@ int st_avrstartwrite(ft_t ft) · 105 unmodified lines
260	return(ST_SUCCESS);	260	return(ST_SUCCESS);
261	}	261	}
262		262
263	st_ssize_t st_avrwrite(ft_t ft, const st_sample_t *buf, st_size_t nsamp)	263	static st_size_t st_avrwrite(ft_t ft, const st_sample_t *buf, st_size_t nsamp)
264	{	264	{
265	avr_t avr = (avr_t)ft->priv;	265	avr_t avr = (avr_t)ft->priv;
266		266
@@ -269,7 +269,7 @@ st_ssize_t st_avrwrite(ft_t ft, const st_sample_t *buf, st_size_t nsamp) · 2 unmodified lines
269	return (st_rawwrite (ft, buf, nsamp));	269	return (st_rawwrite (ft, buf, nsamp));
270	}	270	}
271		271
272	int st_avrstopwrite(ft_t ft)	272	static int st_avrstopwrite(ft_t ft)
273	{	273	{
274	avr_t avr = (avr_t)ft->priv;	274	avr_t avr = (avr_t)ft->priv;
275	int rc;	275	int rc;

src/band.c+4−4

@@ -61,7 +61,7 @@ typedef struct bandstuff { · 60 unmodified lines
61	/*	61	/*
62	* Process options	62	* Process options
63	*/	63	*/
64	int st_band_getopts(eff_t effp, int n, char **argv)	64	static int st_band_getopts(eff_t effp, int n, char **argv)
65	{	65	{
66	band_t band = (band_t) effp->priv;	66	band_t band = (band_t) effp->priv;
67		67
@@ -88,7 +88,7 @@ int st_band_getopts(eff_t effp, int n, char **argv) · 20 unmodified lines
88	/*	88	/*
89	* Prepare processing.	89	* Prepare processing.
90	*/	90	*/
91	int st_band_start(eff_t effp)	91	static int st_band_start(eff_t effp)
92	{	92	{
93	band_t band = (band_t) effp->priv;	93	band_t band = (band_t) effp->priv;
94	if (band->center > effp->ininfo.rate/2)	94	if (band->center > effp->ininfo.rate/2)
@@ -135,7 +135,7 @@ int st_band_start(eff_t effp) · 40 unmodified lines
135	* Return number of samples processed.	135	* Return number of samples processed.
136	*/	136	*/
137		137
138	int st_band_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf,	138	static int st_band_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf,
139	st_size_t isamp, st_size_t osamp)	139	st_size_t isamp, st_size_t osamp)
140	{	140	{
141	band_t band = (band_t) effp->priv;	141	band_t band = (band_t) effp->priv;
@@ -162,7 +162,7 @@ int st_band_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf, · 20 unmodified lines
162	* Do anything required when you stop reading samples.	162	* Do anything required when you stop reading samples.
163	* Don't close input file!	163	* Don't close input file!
164	*/	164	*/
165	int st_band_stop(eff_t effp)	165	static int st_band_stop(eff_t effp UNUSED)
166	{	166	{
167	return (ST_SUCCESS); /* nothing to do */	167	return (ST_SUCCESS); /* nothing to do */
168	}	168	}

src/bandpass.c+2−2

@@ -38,7 +38,7 @@ · 37 unmodified lines
38		38
39	static st_effect_t st_bandpass_effect;	39	static st_effect_t st_bandpass_effect;
40		40
41	int st_bandpass_getopts (eff_t effp, int n, char **argv)	41	static int st_bandpass_getopts (eff_t effp, int n, char **argv)
42	{	42	{
43	butterworth_t butterworth = (butterworth_t)effp->priv;	43	butterworth_t butterworth = (butterworth_t)effp->priv;
44		44
@@ -61,7 +61,7 @@ int st_bandpass_getopts (eff_t effp, int n, char **argv) · 16 unmodified lines
61	return (ST_SUCCESS);	61	return (ST_SUCCESS);
62	}	62	}
63		63
64	int st_bandpass_start (eff_t effp)	64	static int st_bandpass_start(eff_t effp)
65	{	65	{
66	butterworth_t butterworth = (butterworth_t) effp->priv;	66	butterworth_t butterworth = (butterworth_t) effp->priv;
67	double c;	67	double c;

src/breject.c+2−2

@@ -38,7 +38,7 @@ · 37 unmodified lines
38		38
39	static st_effect_t st_bandreject_effect;	39	static st_effect_t st_bandreject_effect;
40		40
41	int st_bandreject_getopts(eff_t effp, int n, char **argv)	41	static int st_bandreject_getopts(eff_t effp, int n, char **argv)
42	{	42	{
43	butterworth_t butterworth = (butterworth_t)effp->priv;	43	butterworth_t butterworth = (butterworth_t)effp->priv;
44		44
@@ -61,7 +61,7 @@ int st_bandreject_getopts(eff_t effp, int n, char **argv) · 16 unmodified lines
61	return (ST_SUCCESS);	61	return (ST_SUCCESS);
62	}	62	}
63		63
64	int st_bandreject_start(eff_t effp)	64	static int st_bandreject_start(eff_t effp)
65	{	65	{
66	butterworth_t butterworth = (butterworth_t) effp->priv;	66	butterworth_t butterworth = (butterworth_t) effp->priv;
67	double c;	67	double c;

src/cdr.c+6−6

@@ -39,7 +39,7 @@ typedef struct cdrstuff { · 38 unmodified lines
39	* mono/stereo/quad.	39	* mono/stereo/quad.
40	*/	40	*/
41		41
42	int st_cdrstartread(ft_t ft)	42	static int st_cdrstartread(ft_t ft)
43	{	43	{
44	int rc;	44	int rc;
45		45
@@ -78,7 +78,7 @@ int st_cdrstartread(ft_t ft) · 32 unmodified lines
78	* Return number of samples read.	78	* Return number of samples read.
79	*/	79	*/
80		80
81	st_ssize_t st_cdrread(ft_t ft, st_sample_t *buf, st_size_t len)	81	static st_size_t st_cdrread(ft_t ft, st_sample_t *buf, st_size_t len)
82	{	82	{
83		83
84	return st_rawread(ft, buf, len);	84	return st_rawread(ft, buf, len);
@@ -88,13 +88,13 @@ st_ssize_t st_cdrread(ft_t ft, st_sample_t *buf, st_size_t len) · 3 unmodified lines
88	* Do anything required when you stop reading samples.	88	* Do anything required when you stop reading samples.
89	* Don't close input file!	89	* Don't close input file!
90	*/	90	*/
91	int st_cdrstopread(ft_t ft)	91	static int st_cdrstopread(ft_t ft)
92	{	92	{
93	/* Needed because of rawread() */	93	/* Needed because of rawread() */
94	return st_rawstopread(ft);	94	return st_rawstopread(ft);
95	}	95	}
96		96
97	int st_cdrstartwrite(ft_t ft)	97	static int st_cdrstartwrite(ft_t ft)
98	{	98	{
99	cdr_t cdr = (cdr_t) ft->priv;	99	cdr_t cdr = (cdr_t) ft->priv;
100	int rc;	100	int rc;
@@ -121,7 +121,7 @@ int st_cdrstartwrite(ft_t ft) · 20 unmodified lines
121	return(ST_SUCCESS);	121	return(ST_SUCCESS);
122	}	122	}
123		123
124	st_ssize_t st_cdrwrite(ft_t ft, const st_sample_t *buf, st_size_t len)	124	static st_size_t st_cdrwrite(ft_t ft, const st_sample_t *buf, st_size_t len)
125	{	125	{
126	cdr_t cdr = (cdr_t) ft->priv;	126	cdr_t cdr = (cdr_t) ft->priv;
127		127
@@ -135,7 +135,7 @@ st_ssize_t st_cdrwrite(ft_t ft, const st_sample_t *buf, st_size_t len) · 7 unmodified lines
135	* samples. We write -32768 for each sample to pad it out.	135	* samples. We write -32768 for each sample to pad it out.
136	*/	136	*/
137		137
138	int st_cdrstopwrite(ft_t ft)	138	static int st_cdrstopwrite(ft_t ft)
139	{	139	{
140	cdr_t cdr = (cdr_t) ft->priv;	140	cdr_t cdr = (cdr_t) ft->priv;
141	int padsamps = SECTORSIZE - (cdr->samples % SECTORSIZE);	141	int padsamps = SECTORSIZE - (cdr->samples % SECTORSIZE);

src/chorus.c+5−5

@@ -92,7 +92,7 @@ typedef struct chorusstuff { · 91 unmodified lines
92	/*	92	/*
93	* Process options	93	* Process options
94	*/	94	*/
95	int st_chorus_getopts(eff_t effp, int n, char **argv)	95	static int st_chorus_getopts(eff_t effp, int n, char **argv)
96	{	96	{
97	chorus_t chorus = (chorus_t) effp->priv;	97	chorus_t chorus = (chorus_t) effp->priv;
98	int i;	98	int i;
@@ -136,7 +136,7 @@ int st_chorus_getopts(eff_t effp, int n, char **argv) · 37 unmodified lines
136	/*	136	/*
137	* Prepare for processing.	137	* Prepare for processing.
138	*/	138	*/
139	int st_chorus_start(eff_t effp)	139	static int st_chorus_start(eff_t effp)
140	{	140	{
141	chorus_t chorus = (chorus_t) effp->priv;	141	chorus_t chorus = (chorus_t) effp->priv;
142	int i;	142	int i;
@@ -254,7 +254,7 @@ int st_chorus_start(eff_t effp) · 111 unmodified lines
254	* Processed signed long samples from ibuf to obuf.	254	* Processed signed long samples from ibuf to obuf.
255	* Return number of samples processed.	255	* Return number of samples processed.
256	*/	256	*/
257	int st_chorus_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf,	257	static int st_chorus_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf,
258	st_size_t isamp, st_size_t osamp)	258	st_size_t isamp, st_size_t osamp)
259	{	259	{
260	chorus_t chorus = (chorus_t) effp->priv;	260	chorus_t chorus = (chorus_t) effp->priv;
@@ -293,7 +293,7 @@ int st_chorus_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf, · 32 unmodified lines
293	/*	293	/*
294	* Drain out reverb lines.	294	* Drain out reverb lines.
295	*/	295	*/
296	int st_chorus_drain(eff_t effp, st_sample_t obuf, st_size_t osamp)	296	static int st_chorus_drain(eff_t effp, st_sample_t obuf, st_size_t osamp)
297	{	297	{
298	chorus_t chorus = (chorus_t) effp->priv;	298	chorus_t chorus = (chorus_t) effp->priv;
299	st_size_t done;	299	st_size_t done;
@@ -336,7 +336,7 @@ int st_chorus_drain(eff_t effp, st_sample_t obuf, st_size_t osamp) · 36 unmodified lines
336	/*	336	/*
337	* Clean up chorus effect.	337	* Clean up chorus effect.
338	*/	338	*/
339	int st_chorus_stop(eff_t effp)	339	static int st_chorus_stop(eff_t effp)
340	{	340	{
341	chorus_t chorus = (chorus_t) effp->priv;	341	chorus_t chorus = (chorus_t) effp->priv;
342	int i;	342	int i;

src/compand.c+8−8

@@ -70,7 +70,7 @@ typedef struct { · 69 unmodified lines
70	* Don't do initialization now.	70	* Don't do initialization now.
71	* The 'info' fields are not yet filled in.	71	* The 'info' fields are not yet filled in.
72	*/	72	*/
73	int st_compand_getopts(eff_t effp, int n, char **argv)	73	static int st_compand_getopts(eff_t effp, int n, char **argv)
74	{	74	{
75	compand_t l = (compand_t) effp->priv;	75	compand_t l = (compand_t) effp->priv;
76		76
@@ -191,7 +191,7 @@ int st_compand_getopts(eff_t effp, int n, char **argv) · 114 unmodified lines
191	* Prepare processing.	191	* Prepare processing.
192	* Do all initializations.	192	* Do all initializations.
193	*/	193	*/
194	int st_compand_start(eff_t effp)	194	static int st_compand_start(eff_t effp)
195	{	195	{
196	compand_t l = (compand_t) effp->priv;	196	compand_t l = (compand_t) effp->priv;
197	int i;	197	int i;
@@ -264,14 +264,14 @@ static void doVolume(double *v, double samp, compand_t l, int chan) · 66 unmodified lines
264	* Processed signed long samples from ibuf to obuf.	264	* Processed signed long samples from ibuf to obuf.
265	* Return number of samples processed.	265	* Return number of samples processed.
266	*/	266	*/
267	int st_compand_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf,	267	static int st_compand_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf,
268	st_size_t isamp, st_size_t osamp)	268	st_size_t isamp, st_size_t osamp)
269	{	269	{
270	compand_t l = (compand_t) effp->priv;	270	compand_t l = (compand_t) effp->priv;
271	int len = (isamp > osamp) ? osamp : isamp;	271	int len = (isamp > osamp) ? osamp : isamp;
272	int filechans = effp->outinfo.channels;	272	int filechans = effp->outinfo.channels;
273	int idone,odone;	273	int idone,odone;
274	int64_t checkbuf; //if st_sample_t of type int32_t	274	int64_t checkbuf; /* if st_sample_t of type int32_t */
275		275
276	for (idone = 0,odone = 0; idone < len; ibuf += filechans) {	276	for (idone = 0,odone = 0; idone < len; ibuf += filechans) {
277	int chan;	277	int chan;
@@ -326,7 +326,7 @@ int st_compand_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf, · 48 unmodified lines
326	{	326	{
327	if (l->delay_buf_cnt >= l->delay_buf_size)	327	if (l->delay_buf_cnt >= l->delay_buf_size)
328	{	328	{
329	l->delay_buf_full=1; //delay buffer is now definetly full	329	l->delay_buf_full=1; /* delay buffer is now definetly full */
330	checkbuf = l->delay_buf[l->delay_buf_ptr](outv/v)l->outgain;	330	checkbuf = l->delay_buf[l->delay_buf_ptr](outv/v)l->outgain;
331	ST_SAMPLE_CLIP_COUNT(checkbuf, effp->clippedCount);	331	ST_SAMPLE_CLIP_COUNT(checkbuf, effp->clippedCount);
332	obuf[odone] = checkbuf;	332	obuf[odone] = checkbuf;
@@ -337,7 +337,7 @@ int st_compand_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf, · 4 unmodified lines
337	else	337	else
338	{	338	{
339	l->delay_buf_cnt++;	339	l->delay_buf_cnt++;
340	idone++; //no "odone++" because we did not fill obuf[...]	340	idone++; /* no "odone++" because we did not fill obuf[...] */
341	}	341	}
342	l->delay_buf[l->delay_buf_ptr++] = ibuf[chan];	342	l->delay_buf[l->delay_buf_ptr++] = ibuf[chan];
343	l->delay_buf_ptr %= l->delay_buf_size;	343	l->delay_buf_ptr %= l->delay_buf_size;
@@ -352,7 +352,7 @@ int st_compand_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf, · 8 unmodified lines
352	/*	352	/*
353	* Drain out compander delay lines.	353	* Drain out compander delay lines.
354	*/	354	*/
355	int st_compand_drain(eff_t effp, st_sample_t obuf, st_size_t osamp)	355	static int st_compand_drain(eff_t effp, st_sample_t obuf, st_size_t osamp)
356	{	356	{
357	compand_t l = (compand_t) effp->priv;	357	compand_t l = (compand_t) effp->priv;
358	st_size_t done;	358	st_size_t done;
@@ -380,7 +380,7 @@ int st_compand_drain(eff_t effp, st_sample_t obuf, st_size_t osamp) · 21 unmodified lines
380	/*	380	/*
381	* Clean up compander effect.	381	* Clean up compander effect.
382	*/	382	*/
383	int st_compand_stop(eff_t effp)	383	static int st_compand_stop(eff_t effp)
384	{	384	{
385	compand_t l = (compand_t) effp->priv;	385	compand_t l = (compand_t) effp->priv;
386		386

src/copy.c+4−14

 /*
  * Process options
  */
-int st_copy_getopts(eff_t effp, int n, char **argv)
+static int st_copy_getopts(eff_t effp UNUSED, int n, char **argv UNUSED)
 {
         if (n)
         {
 /*
  * Start processing
  */
-int st_copy_start(eff_t effp)
+static int st_copy_start(eff_t effp UNUSED)
 {
         /* nothing to do */
         /* stuff data into delaying effects here */
-    return (ST_SUCCESS);
+        return (ST_SUCCESS);
 }
 /*
  * Place in buf[].
  * Return number of samples read.
  */
-int st_copy_flow(eff_t effp, const st_sample_t *ibuf, st_sample_t *obuf,
+static int st_copy_flow(eff_t effp UNUSED, const st_sample_t *ibuf, st_sample_t *obuf,
                  st_size_t *isamp, st_size_t *osamp)
 {
         int done;
         return (ST_SUCCESS);
 }
-/*
- * Do anything required when you stop reading samples.
- * Don't close input file!
- */
-int st_copy_stop(eff_t effp)
-{
-        /* nothing to do */
-    return (ST_SUCCESS);
-}
 static st_effect_t st_copy_effect = {
   "copy",
   "Usage: Copy effect takes no options",

src/cvsd.c+11−11

@@ -153,7 +153,7 @@ static void cvsdstartcommon(ft_t ft) · 152 unmodified lines
153		153
154	/* ---------------------------------------------------------------------- */	154	/* ---------------------------------------------------------------------- */
155		155
156	int st_cvsdstartread(ft_t ft)	156	static int st_cvsdstartread(ft_t ft)
157	{	157	{
158	struct cvsdpriv p = (struct cvsdpriv ) ft->priv;	158	struct cvsdpriv p = (struct cvsdpriv ) ft->priv;
159	float *fp1;	159	float *fp1;
@@ -179,7 +179,7 @@ int st_cvsdstartread(ft_t ft) · 19 unmodified lines
179		179
180	/* ---------------------------------------------------------------------- */	180	/* ---------------------------------------------------------------------- */
181		181
182	int st_cvsdstartwrite(ft_t ft)	182	static int st_cvsdstartwrite(ft_t ft)
183	{	183	{
184	struct cvsdpriv p = (struct cvsdpriv ) ft->priv;	184	struct cvsdpriv p = (struct cvsdpriv ) ft->priv;
185	float *fp1;	185	float *fp1;
@@ -201,7 +201,7 @@ int st_cvsdstartwrite(ft_t ft) · 15 unmodified lines
201		201
202	/* ---------------------------------------------------------------------- */	202	/* ---------------------------------------------------------------------- */
203		203
204	int st_cvsdstopwrite(ft_t ft)	204	static int st_cvsdstopwrite(ft_t ft)
205	{	205	{
206	struct cvsdpriv p = (struct cvsdpriv ) ft->priv;	206	struct cvsdpriv p = (struct cvsdpriv ) ft->priv;
207		207
@@ -217,7 +217,7 @@ int st_cvsdstopwrite(ft_t ft) · 9 unmodified lines
217		217
218	/* ---------------------------------------------------------------------- */	218	/* ---------------------------------------------------------------------- */
219		219
220	int st_cvsdstopread(ft_t ft)	220	static int st_cvsdstopread(ft_t ft)
221	{	221	{
222	struct cvsdpriv p = (struct cvsdpriv ) ft->priv;	222	struct cvsdpriv p = (struct cvsdpriv ) ft->priv;
223		223
@@ -229,10 +229,10 @@ int st_cvsdstopread(ft_t ft) · 5 unmodified lines
229		229
230	/* ---------------------------------------------------------------------- */	230	/* ---------------------------------------------------------------------- */
231		231
232	st_ssize_t st_cvsdread(ft_t ft, st_sample_t *buf, st_size_t nsamp)	232	static st_size_t st_cvsdread(ft_t ft, st_sample_t *buf, st_size_t nsamp)
233	{	233	{
234	struct cvsdpriv p = (struct cvsdpriv ) ft->priv;	234	struct cvsdpriv p = (struct cvsdpriv ) ft->priv;
235	int done = 0;	235	st_size_t done = 0;
236	float oval;	236	float oval;
237		237
238	while (done < nsamp) {	238	while (done < nsamp) {
@@ -288,10 +288,10 @@ st_ssize_t st_cvsdread(ft_t ft, st_sample_t *buf, st_size_t nsamp) · 49 unmodified lines
288		288
289	/* ---------------------------------------------------------------------- */	289	/* ---------------------------------------------------------------------- */
290		290
291	st_ssize_t st_cvsdwrite(ft_t ft, const st_sample_t *buf, st_size_t nsamp)	291	static st_size_t st_cvsdwrite(ft_t ft, const st_sample_t *buf, st_size_t nsamp)
292	{	292	{
293	struct cvsdpriv p = (struct cvsdpriv ) ft->priv;	293	struct cvsdpriv p = (struct cvsdpriv ) ft->priv;
294	int done = 0;	294	st_size_t done = 0;
295	float inval;	295	float inval;
296		296
297	for(;;) {	297	for(;;) {
@@ -519,7 +519,7 @@ static void make_dvms_hdr(ft_t ft, struct dvms_header *hdr) · 221 unmodified lines
519		519
520	/* ---------------------------------------------------------------------- */	520	/* ---------------------------------------------------------------------- */
521		521
522	int st_dvmsstartread(ft_t ft)	522	static int st_dvmsstartread(ft_t ft)
523	{	523	{
524	struct cvsdpriv p = (struct cvsdpriv ) ft->priv;	524	struct cvsdpriv p = (struct cvsdpriv ) ft->priv;
525	struct dvms_header hdr;	525	struct dvms_header hdr;
@@ -558,7 +558,7 @@ int st_dvmsstartread(ft_t ft) · 32 unmodified lines
558		558
559	/* ---------------------------------------------------------------------- */	559	/* ---------------------------------------------------------------------- */
560		560
561	int st_dvmsstartwrite(ft_t ft)	561	static int st_dvmsstartwrite(ft_t ft)
562	{	562	{
563	struct cvsdpriv p = (struct cvsdpriv ) ft->priv;	563	struct cvsdpriv p = (struct cvsdpriv ) ft->priv;
564	struct dvms_header hdr;	564	struct dvms_header hdr;
@@ -584,7 +584,7 @@ int st_dvmsstartwrite(ft_t ft) · 19 unmodified lines
584		584
585	/* ---------------------------------------------------------------------- */	585	/* ---------------------------------------------------------------------- */
586		586
587	int st_dvmsstopwrite(ft_t ft)	587	static int st_dvmsstopwrite(ft_t ft)
588	{	588	{
589	struct dvms_header hdr;	589	struct dvms_header hdr;
590	int rc;	590	int rc;

src/dat.c+14−26

 /*
- * July 5, 1991
+ * Sound Tools text format file.  Tom Littlejohn, March 93.
- * Copyright 1991 Lance Norskog And Sundry Contributors
+ *
+ * Reads/writes sound files as text for use with FFT and graph.
+ *
+ * Copyright 1998-2006 Chris Bagwell and SoX Contributors
  * This source code is freely redistributable and may be used for
  * any purpose.  This copyright notice must be maintained.
  * Lance Norskog And Sundry Contributors are not responsible for
  * the consequences of using this software.
  */
-/*
- * Sound Tools text format file.  Tom Littlejohn, March 93.
- *
- * Reads/writes sound files as text for use with fft and graph.
- *
- * June 28, 93: force output to mono.
- *
- * September 24, 1998: cbagwell - Set up extra output format info so that
- * reports are accurate.  Also warn user when forcing to mono.
- *
- * November 25, 2005: tomchristie - Work with multiple channels
- *
- */
 #include "st_i.h"
 #include <string.h>
     char prevline[LINEWIDTH];
 } *dat_t;
-int st_datstartread(ft_t ft)
+static int st_datstartread(ft_t ft)
 {
     char inpstr[LINEWIDTH];
     long rate;
     }
     /* Default channels to 1 if not found */
-    if (ft->info.channels == -1)
+    if (ft->info.channels == 0)
        ft->info.channels = 1;
     ft->info.size = ST_SIZE_64BIT;
     return (ST_SUCCESS);
 }
-int st_datstartwrite(ft_t ft)
+static int st_datstartwrite(ft_t ft)
 {
     dat_t dat = (dat_t) ft->priv;
     char s[LINEWIDTH];
     return (ST_SUCCESS);
 }
-st_ssize_t st_datread(ft_t ft, st_sample_t *buf, st_size_t nsamp)
+static st_size_t st_datread(ft_t ft, st_sample_t *buf, st_size_t nsamp)
 {
     char inpstr[LINEWIDTH];
     int  inpPtr = 0;
     double sampval = 0.0;
     int retc = 0;
     char sc = 0;
-    int done = 0;
+    st_size_t done = 0;
-    int i=0;
+    st_size_t i=0;
     /* Always read a complete set of channels */
     nsamp -= (nsamp % ft->info.channels);
     return (done);
 }
-st_ssize_t st_datwrite(ft_t ft, const st_sample_t *buf, st_size_t nsamp)
+static st_size_t st_datwrite(ft_t ft, const st_sample_t *buf, st_size_t nsamp)
 {
     dat_t dat = (dat_t) ft->priv;
-    int done = 0;
+    st_size_t done = 0;
     double sampval=0.0;
     char s[LINEWIDTH];
-    int i=0;
+    st_size_t i=0;
     /* Always write a complete set of channels */
     nsamp -= (nsamp % ft->info.channels);

src/dcshift.c+4−4

src/deemphas.c+4−40

@@ -112,22 +112,6 @@ typedef struct deemphstuff { · 111 unmodified lines
112	assert_static(sizeof(struct deemphstuff) <= ST_MAX_EFFECT_PRIVSIZE,	112	assert_static(sizeof(struct deemphstuff) <= ST_MAX_EFFECT_PRIVSIZE,
113	/* else */ deemph_PRIVSIZE_too_big);	113	/* else */ deemph_PRIVSIZE_too_big);
114		114
115	/*
116	* Process options
117	*
118	* Don't do initialization now.
119	* The 'info' fields are not yet filled in.
120	*/
121	int st_deemph_getopts(eff_t effp, int n, char **argv)
122	{
123	if (n)
124	{
125	st_fail(st_deemph_effect.usage);
126	return (ST_EOF);
127	}
128	return (ST_SUCCESS);
129	}
130
131	/* filter coefficients */	115	/* filter coefficients */
132	#define a1 -0.62786881719628784282	116	#define a1 -0.62786881719628784282
133	#define b0 0.45995451989513153057	117	#define b0 0.45995451989513153057
@@ -137,7 +121,7 @@ int st_deemph_getopts(eff_t effp, int n, char **argv) · 3 unmodified lines
137	* Prepare processing.	121	* Prepare processing.
138	* Do all initializations.	122	* Do all initializations.
139	*/	123	*/
140	int st_deemph_start(eff_t effp)	124	static int st_deemph_start(eff_t effp)
141	{	125	{
142	/* check the input format */	126	/* check the input format */
143		127
@@ -188,7 +172,7 @@ int st_deemph_start(eff_t effp) · 44 unmodified lines
188	* Return number of samples processed.	172	* Return number of samples processed.
189	*/	173	*/
190		174
191	int st_deemph_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf,	175	static int st_deemph_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf,
192	st_size_t isamp, st_size_t osamp)	176	st_size_t isamp, st_size_t osamp)
193	{	177	{
194	deemph_t deemph = (deemph_t) effp->priv;	178	deemph_t deemph = (deemph_t) effp->priv;
@@ -208,35 +192,15 @@ int st_deemph_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf, · 13 unmodified lines
208	return (ST_SUCCESS);	192	return (ST_SUCCESS);
209	}	193	}
210		194
211	/*
212	* Drain out remaining samples if the effect generates any.
213	*/
214
215	int st_deemph_drain(eff_t effp, st_sample_t obuf, st_size_t osamp)
216	{
217	/* nothing to do */
218	return (ST_EOF);
219	}
220
221	/*
222	* Do anything required when you stop reading samples.
223	* (free allocated memory, etc.)
224	*/
225	int st_deemph_stop(eff_t effp)
226	{
227	/* nothing to do */
228	return (ST_SUCCESS);
229	}
230
231	static st_effect_t st_deemph_effect = {	195	static st_effect_t st_deemph_effect = {
232	"deemph",	196	"deemph",
233	"Usage: Deemphasis filtering effect takes no options",	197	"Usage: Deemphasis filtering effect takes no options",
234	0,	198	0,
235	st_deemph_getopts,	199	st_effect_nothing_getopts,
236	st_deemph_start,	200	st_deemph_start,
237	st_deemph_flow,	201	st_deemph_flow,
238	st_effect_nothing_drain,	202	st_effect_nothing_drain,
239	st_deemph_stop	203	st_effect_nothing
240	};	204	};
241		205
242	const st_effect_t *st_deemph_effect_fn(void)	206	const st_effect_t *st_deemph_effect_fn(void)

src/earwax.c+12−28

-/*
- * November 9, 2000
- * Copyright (C) 2000 Edward Beingessner And Sundry Contributors
- * This source code is freely redistributable and may be used for
- * any purpose.  This copyright notice must be maintained.
- * Edward Beingessner And Sundry Contributors are not responsible for
- * the consequences of using this software.
- */
 /*
  * earwax - makes listening to headphones easier
  *
  * Note:
  *   This filter only works for 44.1 kHz stereo signals (cd format)
  *
-*/
+ * November 9, 2000
+ * Copyright (C) 2000 Edward Beingessner And Sundry Contributors
+ * This source code is freely redistributable and may be used for
+ * any purpose.  This copyright notice must be maintained.
+ * Edward Beingessner And Sundry Contributors are not responsible for
+ * the consequences of using this software.
+ */
 #include "st_i.h"
   st_sample_t *tap; /* taps are z^-1 delays for the FIR filter */
 } *earwax_t;
-/*
- * Process options
- */
-int st_earwax_getopts(eff_t effp, int n, char **argv)
-{
-  /* no options */
-  if (n){
-    st_fail(st_earwax_effect.usage);
-    return (ST_EOF);
-  }
-  return (ST_SUCCESS);
-}
 /*
  * Prepare for processing.
  */
-int st_earwax_start(eff_t effp)
+static int st_earwax_start(eff_t effp)
 {
   earwax_t earwax = (earwax_t) effp->priv;
   int i;
  * Return number of samples processed.
  */
-int st_earwax_flow(eff_t effp, const st_sample_t *ibuf, st_sample_t *obuf,
+static int st_earwax_flow(eff_t effp, const st_sample_t *ibuf, st_sample_t *obuf,
                    st_size_t *isamp, st_size_t *osamp)
 {
   earwax_t earwax = (earwax_t) effp->priv;
 /*
  * Drain out taps.
  */
-int st_earwax_drain(eff_t effp, st_sample_t *obuf, st_size_t *osamp)
+static int st_earwax_drain(eff_t effp, st_sample_t *obuf, st_size_t *osamp)
 {
   earwax_t earwax = (earwax_t) effp->priv;
   int i,j;
 /*
  * Clean up taps.
  */
-int st_earwax_stop(eff_t effp)
+static int st_earwax_stop(eff_t effp)
 {
   earwax_t earwax = (earwax_t) effp->priv;
   "earwax",
   "Usage: The earwax filtering effect takes no options",
   ST_EFF_MCHAN,
-  st_earwax_getopts,
+  st_effect_nothing_getopts,
   st_earwax_start,
   st_earwax_flow,
   st_earwax_drain,

src/echo.c+6−6

@@ -82,7 +82,7 @@ typedef struct echostuff { · 81 unmodified lines
82	/*	82	/*
83	* Process options	83	* Process options
84	*/	84	*/
85	int st_echo_getopts(eff_t effp, int n, char **argv)	85	static int st_echo_getopts(eff_t effp, int n, char **argv)
86	{	86	{
87	echo_t echo = (echo_t) effp->priv;	87	echo_t echo = (echo_t) effp->priv;
88	int i;	88	int i;
@@ -113,7 +113,7 @@ int st_echo_getopts(eff_t effp, int n, char **argv) · 24 unmodified lines
113	/*	113	/*
114	* Prepare for processing.	114	* Prepare for processing.
115	*/	115	*/
116	int st_echo_start(eff_t effp)	116	static int st_echo_start(eff_t effp)
117	{	117	{
118	echo_t echo = (echo_t) effp->priv;	118	echo_t echo = (echo_t) effp->priv;
119	int i;	119	int i;
@@ -143,7 +143,7 @@ int st_echo_start(eff_t effp) · 23 unmodified lines
143	st_fail("echo: delay must be positive!");	143	st_fail("echo: delay must be positive!");
144	return (ST_EOF);	144	return (ST_EOF);
145	}	145	}
146	if ( echo->samples[i] > DELAY_BUFSIZ )	146	if ( echo->samples[i] > (st_ssize_t)DELAY_BUFSIZ )
147	{	147	{
148	st_fail("echo: delay must be less than %g seconds!",	148	st_fail("echo: delay must be less than %g seconds!",
149	DELAY_BUFSIZ / (float) effp->ininfo.rate );	149	DELAY_BUFSIZ / (float) effp->ininfo.rate );
@@ -185,7 +185,7 @@ int st_echo_start(eff_t effp) · 35 unmodified lines
185	* Processed signed long samples from ibuf to obuf.	185	* Processed signed long samples from ibuf to obuf.
186	* Return number of samples processed.	186	* Return number of samples processed.
187	*/	187	*/
188	int st_echo_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf,	188	static int st_echo_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf,
189	st_size_t isamp, st_size_t osamp)	189	st_size_t isamp, st_size_t osamp)
190	{	190	{
191	echo_t echo = (echo_t) effp->priv;	191	echo_t echo = (echo_t) effp->priv;
@@ -222,7 +222,7 @@ int st_echo_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf, · 30 unmodified lines
222	/*	222	/*
223	* Drain out reverb lines.	223	* Drain out reverb lines.
224	*/	224	*/
225	int st_echo_drain(eff_t effp, st_sample_t obuf, st_size_t osamp)	225	static int st_echo_drain(eff_t effp, st_sample_t obuf, st_size_t osamp)
226	{	226	{
227	echo_t echo = (echo_t) effp->priv;	227	echo_t echo = (echo_t) effp->priv;
228	double d_in, d_out;	228	double d_in, d_out;
@@ -262,7 +262,7 @@ int st_echo_drain(eff_t effp, st_sample_t obuf, st_size_t osamp) · 33 unmodified lines
262	/*	262	/*
263	* Clean up reverb effect.	263	* Clean up reverb effect.
264	*/	264	*/
265	int st_echo_stop(eff_t effp)	265	static int st_echo_stop(eff_t effp)
266	{	266	{
267	echo_t echo = (echo_t) effp->priv;	267	echo_t echo = (echo_t) effp->priv;
268		268

src/echos.c+7−7

@@ -52,7 +52,7 @@ · 51 unmodified lines
52		52
53	static st_effect_t st_echos_effect;	53	static st_effect_t st_echos_effect;
54		54
55	#define DELAY_BUFSIZ ( 50L * ST_MAXRATE )	55	#define DELAY_BUFSIZ ( 50 * ST_MAXRATE )
56	#define MAX_ECHOS 7 /* 24 bit x ( 1 + MAX_ECHOS ) = */	56	#define MAX_ECHOS 7 /* 24 bit x ( 1 + MAX_ECHOS ) = */
57	/* 24 bit x 8 = 32 bit !!! */	57	/* 24 bit x 8 = 32 bit !!! */
58		58
@@ -72,7 +72,7 @@ typedef struct echosstuff { · 13 unmodified lines
72	/*	72	/*
73	* Process options	73	* Process options
74	*/	74	*/
75	int st_echos_getopts(eff_t effp, int n, char **argv)	75	static int st_echos_getopts(eff_t effp, int n, char **argv)
76	{	76	{
77	echos_t echos = (echos_t) effp->priv;	77	echos_t echos = (echos_t) effp->priv;
78	int i;	78	int i;
@@ -107,7 +107,7 @@ int st_echos_getopts(eff_t effp, int n, char **argv) · 28 unmodified lines
107	/*	107	/*
108	* Prepare for processing.	108	* Prepare for processing.
109	*/	109	*/
110	int st_echos_start(eff_t effp)	110	static int st_echos_start(eff_t effp)
111	{	111	{
112	echos_t echos = (echos_t) effp->priv;	112	echos_t echos = (echos_t) effp->priv;
113	int i;	113	int i;
@@ -136,7 +136,7 @@ int st_echos_start(eff_t effp) · 22 unmodified lines
136	st_fail("echos: delay must be positive!");	136	st_fail("echos: delay must be positive!");
137	return (ST_EOF);	137	return (ST_EOF);
138	}	138	}
139	if ( echos->samples[i] > DELAY_BUFSIZ )	139	if ( echos->samples[i] > (st_ssize_t)DELAY_BUFSIZ )
140	{	140	{
141	st_fail("echos: delay must be less than %g seconds!",	141	st_fail("echos: delay must be less than %g seconds!",
142	DELAY_BUFSIZ / (float) effp->ininfo.rate );	142	DELAY_BUFSIZ / (float) effp->ininfo.rate );
@@ -177,7 +177,7 @@ int st_echos_start(eff_t effp) · 34 unmodified lines
177	* Processed signed long samples from ibuf to obuf.	177	* Processed signed long samples from ibuf to obuf.
178	* Return number of samples processed.	178	* Return number of samples processed.
179	*/	179	*/
180	int st_echos_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf,	180	static int st_echos_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf,
181	st_size_t isamp, st_size_t osamp)	181	st_size_t isamp, st_size_t osamp)
182	{	182	{
183	echos_t echos = (echos_t) effp->priv;	183	echos_t echos = (echos_t) effp->priv;
@@ -220,7 +220,7 @@ int st_echos_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf, · 36 unmodified lines
220	/*	220	/*
221	* Drain out reverb lines.	221	* Drain out reverb lines.
222	*/	222	*/
223	int st_echos_drain(eff_t effp, st_sample_t obuf, st_size_t osamp)	223	static int st_echos_drain(eff_t effp, st_sample_t obuf, st_size_t osamp)
224	{	224	{
225	echos_t echos = (echos_t) effp->priv;	225	echos_t echos = (echos_t) effp->priv;
226	double d_in, d_out;	226	double d_in, d_out;
@@ -266,7 +266,7 @@ int st_echos_drain(eff_t effp, st_sample_t obuf, st_size_t osamp) · 39 unmodified lines
266	/*	266	/*
267	* Clean up echos effect.	267	* Clean up echos effect.
268	*/	268	*/
269	int st_echos_stop(eff_t effp)	269	static int st_echos_stop(eff_t effp)
270	{	270	{
271	echos_t echos = (echos_t) effp->priv;	271	echos_t echos = (echos_t) effp->priv;
272		272

src/equalizer.c+20−20

@@ -55,17 +55,17 @@ static st_effect_t st_equalizer_effect; · 54 unmodified lines
55		55
56	/* Filter parameters */	56	/* Filter parameters */
57	typedef struct filterparams {	57	typedef struct filterparams {
58	float rate; // Sample rate	58	float rate; /* Sample rate */
59	float Q; // Q-factor	59	float Q; /* Q-factor */
60	float cfreq; // Central frequency (Hz)	60	float cfreq; /* Central frequency (Hz) */
61	float gain; // Gain (dB)	61	float gain; /* Gain (dB) */
62	double x[3]; // In where x[2] <=> x[ n - 2 ]	62	double x[3]; /* In where x[2] <=> x[ n - 2 ] */
63	double y[3]; // Out	63	double y[3]; /* Out */
64	double b[3]; // From this point, equation constants...	64	double b[3]; /* From this point, equation constants... */
65	double a[3];	65	double a[3];
66	} *equalizer_t;	66	} *equalizer_t;
67		67
68	int st_equalizer_getopts(eff_t effp, int n, char **argv)	68	static int st_equalizer_getopts(eff_t effp, int n, char **argv)
69	{	69	{
70	equalizer_t eq = (equalizer_t) effp->priv;	70	equalizer_t eq = (equalizer_t) effp->priv;
71	int i;	71	int i;
@@ -81,20 +81,20 @@ int st_equalizer_getopts(eff_t effp, int n, char **argv) · 9 unmodified lines
81	sscanf(argv[i++], "%f", &eq->Q);	81	sscanf(argv[i++], "%f", &eq->Q);
82	sscanf(argv[i++], "%f", &eq->gain);	82	sscanf(argv[i++], "%f", &eq->gain);
83		83
84	// TODO: Would be nice to validate the params..	84	/* FIXME: Would be nice to validate the params.. */
85		85
86	return (ST_SUCCESS);	86	return (ST_SUCCESS);
87	}	87	}
88		88
89	// Set the filter constants	89	/* Set the filter constants */
90	int st_equalizer_start(eff_t effp)	90	static int st_equalizer_start(eff_t effp)
91	{	91	{
92	equalizer_t eq = (equalizer_t) effp->priv;	92	equalizer_t eq = (equalizer_t) effp->priv;
93	double w0;	93	double w0;
94	double amp;	94	double amp;
95	double alpha;	95	double alpha;
96		96
97	// Sample rate	97	/* Sample rate */
98	eq->rate = effp->ininfo.rate;	98	eq->rate = effp->ininfo.rate;
99		99
100	w0 = 2M_PIeq->cfreq/eq->rate;	100	w0 = 2M_PIeq->cfreq/eq->rate;
@@ -109,7 +109,7 @@ int st_equalizer_start(eff_t effp) · 8 unmodified lines
109	st_debug("amp: %f", amp);	109	st_debug("amp: %f", amp);
110	st_debug("alpha: %f", alpha);	110	st_debug("alpha: %f", alpha);
111		111
112	// Initialisation	112	/* Initialisation */
113	eq->b[0] = 1 + alpha*amp;	113	eq->b[0] = 1 + alpha*amp;
114	eq->b[1] = -2*cos(w0);	114	eq->b[1] = -2*cos(w0);
115	eq->b[2] = 1 - alpha*amp;	115	eq->b[2] = 1 - alpha*amp;
@@ -117,12 +117,12 @@ int st_equalizer_start(eff_t effp) · 1 unmodified line
117	eq->a[1] = -2*cos(w0);	117	eq->a[1] = -2*cos(w0);
118	eq->a[2] = 1 - alpha/amp;	118	eq->a[2] = 1 - alpha/amp;
119		119
120	eq->x[0] = 0; // x[n]	120	eq->x[0] = 0; /* x[n] */
121	eq->x[1] = 0; // x[n-1]	121	eq->x[1] = 0; /* x[n-1] */
122	eq->x[2] = 0; // x[n-2]	122	eq->x[2] = 0; /* x[n-2] */
123	eq->y[0] = 0; // y[n]	123	eq->y[0] = 0; /* y[n] */
124	eq->y[1] = 0; // y[n-1]	124	eq->y[1] = 0; /* y[n-1] */
125	eq->y[2] = 0; // y[n-2]	125	eq->y[2] = 0; /* y[n-2] */
126		126
127	if (effp->globalinfo.octave_plot_effect)	127	if (effp->globalinfo.octave_plot_effect)
128	{	128	{
@@ -147,7 +147,7 @@ int st_equalizer_start(eff_t effp) · 18 unmodified lines
147	return (ST_SUCCESS);	147	return (ST_SUCCESS);
148	}	148	}
149		149
150	int st_equalizer_flow(eff_t effp, const st_sample_t *ibuf,	150	static int st_equalizer_flow(eff_t effp, const st_sample_t *ibuf,
151	st_sample_t obuf, st_size_t isamp,	151	st_sample_t obuf, st_size_t isamp,
152	st_size_t *osamp)	152	st_size_t *osamp)
153	{	153	{

src/fade.c+15−20

 /* Private data for fade file */
 typedef struct fadestuff
 { /* These are measured as samples */
-    st_size_t in_start,  in_stop, out_start, out_stop, samplesdone;
+    st_size_t in_start, in_stop, out_start, out_stop, samplesdone;
     char *in_stop_str, *out_start_str, *out_stop_str;
     char in_fadetype, out_fadetype;
     char do_out;
  * The 'info' fields are not yet filled in.
  */
-int st_fade_getopts(eff_t effp, int n, char **argv)
+static int st_fade_getopts(eff_t effp, int n, char **argv)
 {
     fade_t fade = (fade_t) effp->priv;
  * Prepare processing.
  * Do all initializations.
  */
-int st_fade_start(eff_t effp)
+static int st_fade_start(eff_t effp)
 {
     fade_t fade = (fade_t) effp->priv;
         return(ST_EOF);
     } /* endif fade time sanity */
-    /* If lead-in is required it is handled as negative sample numbers */
+    fade->samplesdone = fade->in_start;
-    fade->samplesdone = (fade->in_start < 0 ? fade->in_start :0);
     fade->endpadwarned = 0;
-    /* st_debug("fade: in_start = %d in_stop = %d out_start = %d out_stop = %d", fade->in_start, fade->in_stop, fade->out_start, fade->out_stop); */
+    st_debug("fade: in_start = %d in_stop = %d out_start = %d out_stop = %d", fade->in_start, fade->in_stop, fade->out_start, fade->out_stop);
     return(ST_SUCCESS);
 }
  * Processed signed long samples from ibuf to obuf.
  * Return number of samples processed.
  */
-int st_fade_flow(eff_t effp, const st_sample_t *ibuf, st_sample_t *obuf,
+static int st_fade_flow(eff_t effp, const st_sample_t *ibuf, st_sample_t *obuf,
                  st_size_t *isamp, st_size_t *osamp)
 {
     fade_t fade = (fade_t) effp->priv;
     /* len is total samples, chcnt counts channels */
-    int len = 0, chcnt = 0, t_output = 1, more_output = 1;
+    int len = 0, t_output = 1, more_output = 1;
     st_sample_t t_ibuf;
+    st_size_t chcnt = 0;
     len = ((*isamp > *osamp) ? *osamp : *isamp);
     for(; len && more_output; len--)
     {
-        t_ibuf = (fade->samplesdone < 0 ? 0 : *ibuf);
+        t_ibuf = *ibuf;
         if ((fade->samplesdone >= fade->in_start) &&
             (!fade->do_out || fade->samplesdone < fade->out_stop))
             t_output = 0;
         } /* endif something to output */
-        /* samplesdone < 0 means we are inventing samples right now
+        *isamp += 1;
-         * and so not consuming (happens when in_start < 0).
+        ibuf++;
-         */
-        if (fade->samplesdone >= 0 )
-        { /* Something to input  */
-            *isamp += 1;
-            ibuf++;
-        } /* endif something accepted as input */
         if (t_output)
         { /* Output generated, update pointers and counters */
 /*
  * Drain out remaining samples if the effect generates any.
  */
-int st_fade_drain(eff_t effp, st_sample_t *obuf, st_size_t *osamp)
+static int st_fade_drain(eff_t effp, st_sample_t *obuf, st_size_t *osamp)
 {
     fade_t fade = (fade_t) effp->priv;
-    int len, t_chan = 0;
+    int len;
+    st_size_t t_chan = 0;
     len = *osamp;
     *osamp = 0;
  * Do anything required when you stop reading samples.
  *      (free allocated memory, etc.)
  */
-int st_fade_stop(eff_t effp)
+static int st_fade_stop(eff_t effp)
 {
     fade_t fade = (fade_t) effp->priv;

src/filter.c+9−9

@@ -54,7 +54,7 @@ static void FiltWin(filter_t f, long Nx); · 53 unmodified lines
54	/*	54	/*
55	* Process options	55	* Process options
56	*/	56	*/
57	int st_filter_getopts(eff_t effp, int n, char **argv)	57	static int st_filter_getopts(eff_t effp, int n, char **argv)
58	{	58	{
59	filter_t f = (filter_t) effp->priv;	59	filter_t f = (filter_t) effp->priv;
60		60
@@ -104,7 +104,7 @@ int st_filter_getopts(eff_t effp, int n, char **argv) · 43 unmodified lines
104	/*	104	/*
105	* Prepare processing.	105	* Prepare processing.
106	*/	106	*/
107	int st_filter_start(eff_t effp)	107	static int st_filter_start(eff_t effp)
108	{	108	{
109	filter_t f = (filter_t) effp->priv;	109	filter_t f = (filter_t) effp->priv;
110	double Fp0, Fp1;	110	double Fp0, Fp1;
@@ -114,7 +114,7 @@ int st_filter_start(eff_t effp) · 3 unmodified lines
114	f->rate = effp->ininfo.rate;	114	f->rate = effp->ininfo.rate;
115		115
116	/* adjust upper frequency to Nyquist if necessary */	116	/* adjust upper frequency to Nyquist if necessary */
117	if (f->freq1 > f->rate/2 \|\| f->freq1 <= 0)	117	if (f->freq1 > (st_sample_t)f->rate/2 \|\| f->freq1 <= 0)
118	f->freq1 = f->rate/2;	118	f->freq1 = f->rate/2;
119		119
120	if ((f->freq0 < 0) \|\| (f->freq0 > f->freq1))	120	if ((f->freq0 < 0) \|\| (f->freq0 > f->freq1))
@@ -126,7 +126,7 @@ int st_filter_start(eff_t effp) · 5 unmodified lines
126		126
127	Xh = f->Nwin/2;	127	Xh = f->Nwin/2;
128	Fp0 = (double ) malloc(sizeof(double) (Xh + 2)) + 1;	128	Fp0 = (double ) malloc(sizeof(double) (Xh + 2)) + 1;
129	if (f->freq0 > f->rate/200) {	129	if (f->freq0 > (st_sample_t)f->rate/200) {
130	Xh0 = makeFilter(Fp0, Xh, 2.0*(double)f->freq0/f->rate, f->beta, 1, 0);	130	Xh0 = makeFilter(Fp0, Xh, 2.0*(double)f->freq0/f->rate, f->beta, 1, 0);
131	if (Xh0 <= 1)	131	if (Xh0 <= 1)
132	{	132	{
@@ -138,7 +138,7 @@ int st_filter_start(eff_t effp) · 5 unmodified lines
138	}	138	}
139	Fp1 = (double ) malloc(sizeof(double) (Xh + 2)) + 1;	139	Fp1 = (double ) malloc(sizeof(double) (Xh + 2)) + 1;
140	/* need Fp[-1] and Fp[Xh] for makeFilter */	140	/* need Fp[-1] and Fp[Xh] for makeFilter */
141	if (f->freq1 < f->rate/2) {	141	if (f->freq1 < (st_sample_t)f->rate/2) {
142	Xh1 = makeFilter(Fp1, Xh, 2.0*(double)f->freq1/f->rate, f->beta, 1, 0);	142	Xh1 = makeFilter(Fp1, Xh, 2.0*(double)f->freq1/f->rate, f->beta, 1, 0);
143	if (Xh1 <= 1)	143	if (Xh1 <= 1)
144	{	144	{
@@ -182,11 +182,11 @@ int st_filter_start(eff_t effp) · 37 unmodified lines
182	* Processed signed long samples from ibuf to obuf.	182	* Processed signed long samples from ibuf to obuf.
183	* Return number of samples processed.	183	* Return number of samples processed.
184	*/	184	*/
185	int st_filter_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf,	185	static int st_filter_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf,
186	st_size_t isamp, st_size_t osamp)	186	st_size_t isamp, st_size_t osamp)
187	{	187	{
188	filter_t f = (filter_t) effp->priv;	188	filter_t f = (filter_t) effp->priv;
189	long i, Nx, Nproc;	189	st_size_t i, Nx, Nproc;
190		190
191	/* constrain amount we actually process */	191	/* constrain amount we actually process */
192	/* st_debug("Xh %d, Xt %d, isamp %d, ",f->Xh, f->Xt, isamp); /	192	/* st_debug("Xh %d, Xt %d, isamp %d, ",f->Xh, f->Xt, isamp); /
@@ -234,7 +234,7 @@ int st_filter_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf, · 41 unmodified lines
234	/*	234	/*
235	* Process tail of input samples.	235	* Process tail of input samples.
236	*/	236	*/
237	int st_filter_drain(eff_t effp, st_sample_t obuf, st_size_t osamp)	237	static int st_filter_drain(eff_t effp, st_sample_t obuf, st_size_t osamp)
238	{	238	{
239	filter_t f = (filter_t) effp->priv;	239	filter_t f = (filter_t) effp->priv;
240	long isamp_res, osamp_res;	240	long isamp_res, osamp_res;
@@ -271,7 +271,7 @@ int st_filter_drain(eff_t effp, st_sample_t obuf, st_size_t osamp) · 30 unmodified lines
271	* Do anything required when you stop reading samples.	271	* Do anything required when you stop reading samples.
272	* Don't close input file!	272	* Don't close input file!
273	*/	273	*/
274	int st_filter_stop(eff_t effp)	274	static int st_filter_stop(eff_t effp)
275	{	275	{
276	filter_t f = (filter_t) effp->priv;	276	filter_t f = (filter_t) effp->priv;
277		277

src/flac.c+9−10

   }
   else if (metadata->type == FLAC__METADATA_TYPE_VORBIS_COMMENT)
   {
-    int i;
+    size_t i, comment_size = 0;
-    int comment_size = 0;
     if (metadata->data.vorbis_comment.num_comments == 0)
     {
 }
-static st_ssize_t st_format_read(ft_t const format, st_sample_t * sampleBuffer, st_size_t const requested)
+static st_size_t st_format_read(ft_t const format, st_sample_t * sampleBuffer, st_size_t const requested)
 {
   Decoder * decoder = (Decoder *) format->priv;
-  int actual = 0;
+  size_t actual = 0;
   while (!decoder->eof && actual < requested)
   {
-FLAC__StreamEncoderWriteStatus flac_stream_encoder_write_callback(FLAC__StreamEncoder const * const flac, const FLAC__byte buffer[], unsigned const bytes, unsigned const samples, unsigned const current_frame, void * const client_data)
+static FLAC__StreamEncoderWriteStatus flac_stream_encoder_write_callback(FLAC__StreamEncoder const * const flac, const FLAC__byte buffer[], unsigned const bytes, unsigned const samples, unsigned const current_frame, void * const client_data)
 {
   ft_t const format = (ft_t) client_data;
   (void) flac, (void) samples, (void) current_frame;
-void flac_stream_encoder_metadata_callback(FLAC__StreamEncoder const * encoder, FLAC__StreamMetadata const * metadata, void * client_data)
+static void flac_stream_encoder_metadata_callback(FLAC__StreamEncoder const * encoder, FLAC__StreamMetadata const * metadata, void * client_data)
 {
   (void) encoder, (void) metadata, (void) client_data;
 }
   { /* Check if rate is streamable: */
     static const unsigned streamable_rates[] =
       {8000, 16000, 22050, 24000, 32000, 44100, 48000, 96000};
-    int i;
+    size_t i;
     bool streamable = false;
     for (i = 0; !streamable && i < array_length(streamable_rates); ++i)
     {
   if (format->length != 0)
   {
-    FLAC__stream_encoder_set_total_samples_estimate(encoder->flac, format->length);
+    FLAC__stream_encoder_set_total_samples_estimate(encoder->flac, (FLAC__uint64)format->length);
   }
   if (format->comment != NULL && * format->comment != '\0')
-static st_ssize_t st_format_write(ft_t const format, st_sample_t const * const sampleBuffer, st_size_t const len)
+static st_size_t st_format_write(ft_t const format, st_sample_t const * const sampleBuffer, st_size_t const len)
 {
   Encoder * encoder = (Encoder *) format->priv;
   unsigned i;
     }
   }
   FLAC__stream_encoder_process_interleaved(encoder->flac, encoder->decoded_samples, len / format->info.channels);
-  return FLAC__stream_encoder_get_state(encoder->flac) == FLAC__STREAM_ENCODER_OK ? len : -1;
+  return FLAC__stream_encoder_get_state(encoder->flac) == FLAC__STREAM_ENCODER_OK ? len : 0;
 }

src/flanger.c+34−34

@@ -5,38 +5,38 @@ · 4 unmodified lines
5	* See LICENSE file for further copyright information.	5	* See LICENSE file for further copyright information.
6	*/	6	*/
7		7
8	static char const st_flanger_usage[] =	8	#define st_flanger_usage \
9	"Usage: \n"	9	"Usage: \n" \
10	" .\n"	10	" .\n" \
11	" /\|regen\n"	11	" /\|regen\n" \
12	" / \|\n"	12	" / \|\n" \
13	" +--( \|------------+\n"	13	" +--( \|------------+\n" \
14	" \| \\ \| \| .\n"	14	" \| \\ \| \| .\n" \
15	" _V_ \\\| _______ \| \|\\ width ___\n"	15	" _V_ \\\| _______ \| \|\\ width ___\n" \
16	" \| \| ' \| \| \| \| \\ \| \|\n"	16	" \| \| ' \| \| \| \| \\ \| \|\n" \
17	" +-->\| + \|---->\| DELAY \|--+-->\| )----->\| \|\n"	17	" +-->\| + \|---->\| DELAY \|--+-->\| )----->\| \|\n" \
18	" \| \|___\| \|_______\| \| / \| \|\n"	18	" \| \|___\| \|_______\| \| / \| \|\n" \
19	" \| delay : depth \|/ \| \|\n"	19	" \| delay : depth \|/ \| \|\n" \
20	" In \| : interp ' \| \| Out\n"	20	" In \| : interp ' \| \| Out\n" \
21	" --->+ __:__ \| + \|--->\n"	21	" --->+ __:__ \| + \|--->\n" \
22	" \| \| \|speed \| \|\n"	22	" \| \| \|speed \| \|\n" \
23	" \| \| ~ \|shape \| \|\n"	23	" \| \| ~ \|shape \| \|\n" \
24	" \| \|_____\|phase \| \|\n"	24	" \| \|_____\|phase \| \|\n" \
25	" +------------------------------------->\| \|\n"	25	" +------------------------------------->\| \|\n" \
26	" \|___\|\n"	26	" \|___\|\n" \
27	"\n"	27	"\n" \
28	"Usage: flanger [delay depth regen width speed shape phase interp]\n"	28	"Usage: flanger [delay depth regen width speed shape phase interp]\n" \
29	"\n"	29	"\n" \
30	" RANGE DEFAULT DESCRIPTION\n"	30	" RANGE DEFAULT DESCRIPTION\n" \
31	"delay 0 10 0 base delay in milliseconds\n"	31	"delay 0 10 0 base delay in milliseconds\n" \
32	"depth 0 10 2 added swept delay in milliseconds\n"	32	"depth 0 10 2 added swept delay in milliseconds\n" \
33	"regen -95 +95 0 percentage regeneration (delayed signal feedback)\n"	33	"regen -95 +95 0 percentage regeneration (delayed signal feedback)\n" \
34	"width 0 100 71 percentage of delayed signal mixed with original\n"	34	"width 0 100 71 percentage of delayed signal mixed with original\n" \
35	"speed 0.1 10 0.5 sweeps per second (Hz) \n"	35	"speed 0.1 10 0.5 sweeps per second (Hz) \n" \
36	"shape -- sin swept wave shape: sine\|triangle\n"	36	"shape -- sin swept wave shape: sine\|triangle\n" \
37	"phase 0 100 25 swept wave percentage phase-shift for multi-channel\n"	37	"phase 0 100 25 swept wave percentage phase-shift for multi-channel\n" \
38	" (e.g. stereo) flange; 0 = 100 = same phase on each channel\n"	38	" (e.g. stereo) flange; 0 = 100 = same phase on each channel\n" \
39	"interp -- lin delay-line interpolation: linear\|quadratic";	39	"interp -- lin delay-line interpolation: linear\|quadratic"
40		40
41	/* TODO: Slide in the delay at the start? */	41	/* TODO: Slide in the delay at the start? */
42		42
@@ -88,7 +88,7 @@ assert_static(sizeof(struct flanger) <= ST_MAX_EFFECT_PRIVSIZE, · 45 unmodified lines
88	static enum_item const interp_enum[] = {	88	static enum_item const interp_enum[] = {
89	ENUM_ITEM(INTERP_,LINEAR)	89	ENUM_ITEM(INTERP_,LINEAR)
90	ENUM_ITEM(INTERP_,QUADRATIC)	90	ENUM_ITEM(INTERP_,QUADRATIC)
91	{0}};	91	{0, 0}};
92		92
93		93
94		94
@@ -121,7 +121,7 @@ static enum_item const interp_enum[] = { · 26 unmodified lines
121		121
122		122
123		123
124	static int st_flanger_getopts(eff_t effp, int argc, char const * const * argv)	124	static int st_flanger_getopts(eff_t effp, int argc, char *argv[])
125	{	125	{
126	flanger_t f = (flanger_t) effp->priv;	126	flanger_t f = (flanger_t) effp->priv;
127		127

src/g72x.c+2−2

@@ -373,7 +373,7 @@ void update(int code_size, int y, int wi, int fi, int dq, int sr, · 372 unmodified lines
373	state_ptr->dq[cnt] = state_ptr->dq[cnt-1];	373	state_ptr->dq[cnt] = state_ptr->dq[cnt-1];
374	/* FLOAT A : convert dq[0] to 4-bit exp, 6-bit mantissa f.p. */	374	/* FLOAT A : convert dq[0] to 4-bit exp, 6-bit mantissa f.p. */
375	if (mag == 0) {	375	if (mag == 0) {
376	state_ptr->dq[0] = (dq >= 0) ? 0x20 : 0xFC20;	376	state_ptr->dq[0] = (dq >= 0) ? 0x20 : (short)0xFC20;
377	} else {	377	} else {
378	exp = quan(mag, power2, 15);	378	exp = quan(mag, power2, 15);
379	state_ptr->dq[0] = (dq >= 0) ?	379	state_ptr->dq[0] = (dq >= 0) ?
@@ -393,7 +393,7 @@ void update(int code_size, int y, int wi, int fi, int dq, int sr, · 13 unmodified lines
393	exp = quan(mag, power2, 15);	393	exp = quan(mag, power2, 15);
394	state_ptr->sr[0] = (exp << 6) + ((mag << 6) >> exp) - 0x400;	394	state_ptr->sr[0] = (exp << 6) + ((mag << 6) >> exp) - 0x400;
395	} else	395	} else
396	state_ptr->sr[0] = 0xFC20;	396	state_ptr->sr[0] = (short)(0xFC20);
397		397
398	/* DELAY A */	398	/* DELAY A */
399	state_ptr->pk[1] = state_ptr->pk[0];	399	state_ptr->pk[1] = state_ptr->pk[0];

src/gsm.c+9−9

@@ -63,7 +63,7 @@ static int gsmstart_rw(ft_t ft, int w) · 62 unmodified lines
63	if (!ft->info.rate)	63	if (!ft->info.rate)
64	ft->info.rate = 8000;	64	ft->info.rate = 8000;
65		65
66	if (ft->info.channels == -1)	66	if (ft->info.channels == 0)
67	ft->info.channels = 1;	67	ft->info.channels = 1;
68		68
69	p->channels = ft->info.channels;	69	p->channels = ft->info.channels;
@@ -88,12 +88,12 @@ static int gsmstart_rw(ft_t ft, int w) · 18 unmodified lines
88	return (ST_SUCCESS);	88	return (ST_SUCCESS);
89	}	89	}
90		90
91	int st_gsmstartread(ft_t ft)	91	static int st_gsmstartread(ft_t ft)
92	{	92	{
93	return gsmstart_rw(ft,0);	93	return gsmstart_rw(ft,0);
94	}	94	}
95		95
96	int st_gsmstartwrite(ft_t ft)	96	static int st_gsmstartwrite(ft_t ft)
97	{	97	{
98	return gsmstart_rw(ft,1);	98	return gsmstart_rw(ft,1);
99	}	99	}
@@ -105,9 +105,9 @@ int st_gsmstartwrite(ft_t ft) · 5 unmodified lines
105	* Return number of samples read.	105	* Return number of samples read.
106	*/	106	*/
107		107
108	st_ssize_t st_gsmread(ft_t ft, st_sample_t *buf, st_size_t samp)	108	static st_size_t st_gsmread(ft_t ft, st_sample_t *buf, st_size_t samp)
109	{	109	{
110	int done = 0;	110	size_t done = 0;
111	int r, ch, chans;	111	int r, ch, chans;
112	gsm_signal *gbuff;	112	gsm_signal *gbuff;
113	struct gsmpriv p = (struct gsmpriv ) ft->priv;	113	struct gsmpriv p = (struct gsmpriv ) ft->priv;
@@ -183,9 +183,9 @@ static int gsmflush(ft_t ft) · 69 unmodified lines
183	return (ST_SUCCESS);	183	return (ST_SUCCESS);
184	}	184	}
185		185
186	st_ssize_t st_gsmwrite(ft_t ft, const st_sample_t *buf, st_size_t samp)	186	static st_size_t st_gsmwrite(ft_t ft, const st_sample_t *buf, st_size_t samp)
187	{	187	{
188	int done = 0;	188	size_t done = 0;
189	struct gsmpriv p = (struct gsmpriv ) ft->priv;	189	struct gsmpriv p = (struct gsmpriv ) ft->priv;
190		190
191	while (done < samp)	191	while (done < samp)
@@ -206,7 +206,7 @@ st_ssize_t st_gsmwrite(ft_t ft, const st_sample_t *buf, st_size_t samp) · 14 unmodified lines
206	return done;	206	return done;
207	}	207	}
208		208
209	int st_gsmstopread(ft_t ft)	209	static int st_gsmstopread(ft_t ft)
210	{	210	{
211	struct gsmpriv p = (struct gsmpriv ) ft->priv;	211	struct gsmpriv p = (struct gsmpriv ) ft->priv;
212	int ch;	212	int ch;
@@ -219,7 +219,7 @@ int st_gsmstopread(ft_t ft) · 6 unmodified lines
219	return (ST_SUCCESS);	219	return (ST_SUCCESS);
220	}	220	}
221		221
222	int st_gsmstopwrite(ft_t ft)	222	static int st_gsmstopwrite(ft_t ft)
223	{	223	{
224	int rc;	224	int rc;
225	struct gsmpriv p = (struct gsmpriv ) ft->priv;	225	struct gsmpriv p = (struct gsmpriv ) ft->priv;

src/handlers.c+1−1

@@ -37,7 +37,7 @@ st_format_fn_t st_format_fns[] = { · 36 unmodified lines
37	st_la_format_fn,	37	st_la_format_fn,
38	st_lu_format_fn,	38	st_lu_format_fn,
39	st_maud_format_fn,	39	st_maud_format_fn,
40	#if defined(HAVE_LIBMAD) \|\| defined(HAVE_LAME)	40	#if defined(HAVE_LIBMAD) \|\| defined(HAVE_LIBMP3LAME)
41	st_mp3_format_fn,	41	st_mp3_format_fn,
42	#endif	42	#endif
43	st_nul_format_fn,	43	st_nul_format_fn,

src/hcom.c+6−6

@@ -50,7 +50,7 @@ struct readpriv { · 49 unmodified lines
50		50
51	static int skipbytes(ft_t, int);	51	static int skipbytes(ft_t, int);
52		52
53	int st_hcomstartread(ft_t ft)	53	static int st_hcomstartread(ft_t ft)
54	{	54	{
55	struct readpriv p = (struct readpriv ) ft->priv;	55	struct readpriv p = (struct readpriv ) ft->priv;
56	int i;	56	int i;
@@ -174,7 +174,7 @@ static int skipbytes(ft_t ft, int n) · 117 unmodified lines
174	return(ST_SUCCESS);	174	return(ST_SUCCESS);
175	}	175	}
176		176
177	st_ssize_t st_hcomread(ft_t ft, st_sample_t *buf, st_size_t len)	177	static st_size_t st_hcomread(ft_t ft, st_sample_t *buf, st_size_t len)
178	{	178	{
179	register struct readpriv p = (struct readpriv ) ft->priv;	179	register struct readpriv p = (struct readpriv ) ft->priv;
180	int done = 0;	180	int done = 0;
@@ -238,7 +238,7 @@ st_ssize_t st_hcomread(ft_t ft, st_sample_t *buf, st_size_t len) · 57 unmodified lines
238	return done;	238	return done;
239	}	239	}
240		240
241	int st_hcomstopread(ft_t ft)	241	static int st_hcomstopread(ft_t ft)
242	{	242	{
243	register struct readpriv p = (struct readpriv ) ft->priv;	243	register struct readpriv p = (struct readpriv ) ft->priv;
244		244
@@ -265,7 +265,7 @@ struct writepriv { · 20 unmodified lines
265		265
266	#define BUFINCR (10*BUFSIZ)	266	#define BUFINCR (10*BUFSIZ)
267		267
268	int st_hcomstartwrite(ft_t ft)	268	static int st_hcomstartwrite(ft_t ft)
269	{	269	{
270	register struct writepriv p = (struct writepriv ) ft->priv;	270	register struct writepriv p = (struct writepriv ) ft->priv;
271		271
@@ -302,7 +302,7 @@ int st_hcomstartwrite(ft_t ft) · 30 unmodified lines
302	return (ST_SUCCESS);	302	return (ST_SUCCESS);
303	}	303	}
304		304
305	st_ssize_t st_hcomwrite(ft_t ft, const st_sample_t *buf, st_size_t len)	305	static st_size_t st_hcomwrite(ft_t ft, const st_sample_t *buf, st_size_t len)
306	{	306	{
307	register struct writepriv p = (struct writepriv ) ft->priv;	307	register struct writepriv p = (struct writepriv ) ft->priv;
308	st_sample_t datum;	308	st_sample_t datum;
@@ -514,7 +514,7 @@ static void padbytes(ft_t ft, int n) · 205 unmodified lines
514		514
515	/* End of hcom utility routines */	515	/* End of hcom utility routines */
516		516
517	int st_hcomstopwrite(ft_t ft)	517	static int st_hcomstopwrite(ft_t ft)
518	{	518	{
519	register struct writepriv p = (struct writepriv ) ft->priv;	519	register struct writepriv p = (struct writepriv ) ft->priv;
520	unsigned char *compressed_data = p->data;	520	unsigned char *compressed_data = p->data;

src/highp.c+4−14

 /*
  * Process options
  */
-int st_highp_getopts(eff_t effp, int n, char **argv)
+static int st_highp_getopts(eff_t effp, int n, char **argv)
 {
         highp_t highp = (highp_t) effp->priv;
 /*
  * Prepare processing.
  */
-int st_highp_start(eff_t effp)
+static int st_highp_start(eff_t effp)
 {
         highp_t highp = (highp_t) effp->priv;
         if (highp->cutoff > effp->ininfo.rate/2)
  * Processed signed long samples from ibuf to obuf.
  * Return number of samples processed.
  */
-int st_highp_flow(eff_t effp, const st_sample_t *ibuf, st_sample_t *obuf,
+static int st_highp_flow(eff_t effp, const st_sample_t *ibuf, st_sample_t *obuf,
                   st_size_t *isamp, st_size_t *osamp)
 {
         highp_t highp = (highp_t) effp->priv;
         return (ST_SUCCESS);
 }
-/*
- * Do anything required when you stop reading samples.
- * Don't close input file!
- */
-int st_highp_stop(eff_t effp)
-{
-        /* nothing to do */
-    return (ST_SUCCESS);
-}
 static st_effect_t st_highp_effect = {
   "highp",
   "Usage: highp cutoff",
   st_highp_start,
   st_highp_flow,
   st_effect_nothing_drain,
-  st_highp_stop
+  st_effect_nothing
 };
 const st_effect_t *st_highp_effect_fn(void)

src/highpass.c+2−5

@@ -1,5 +1,4 @@
1	/*	1	/*
2
3	High-pass effect file for SoX	2	High-pass effect file for SoX
4	Copyright (C) 1999 Jan Paul Schmidt <jps@fundament.org>	3	Copyright (C) 1999 Jan Paul Schmidt <jps@fundament.org>
5		4
@@ -38,7 +37,7 @@ · 32 unmodified lines
38		37
39	static st_effect_t st_highpass_effect;	38	static st_effect_t st_highpass_effect;
40		39
41	int st_highpass_getopts(eff_t effp, int n, char **argv)	40	static int st_highpass_getopts(eff_t effp, int n, char **argv)
42	{	41	{
43	butterworth_t butterworth = (butterworth_t)effp->priv;	42	butterworth_t butterworth = (butterworth_t)effp->priv;
44		43
@@ -56,9 +55,7 @@ int st_highpass_getopts(eff_t effp, int n, char **argv) · 11 unmodified lines
56	return (ST_SUCCESS);	55	return (ST_SUCCESS);
57	}	56	}
58		57
59		58	static int st_highpass_start(eff_t effp)
60
61	int st_highpass_start(eff_t effp)
62	{	59	{
63	butterworth_t butterworth = (butterworth_t) effp->priv;	60	butterworth_t butterworth = (butterworth_t) effp->priv;
64	double c;	61	double c;

src/ima_rw.c+5−7

         const SAMPL *ibuff, /* ibuff[] is interleaved input samples */
         int n,              /* samples to encode PER channel, REQUIRE n % 8 == 1 */
         int *st,            /* input/output state, REQUIRE 0 <= *st <= ISSTMAX */
-        unsigned char *obuff, /* output buffer[blockAlign], or NULL for no output  */
+        unsigned char *obuff /* output buffer[blockAlign], or NULL for no output  */
-        int sho             /* nonzero for debug printout */
 )
 {
         const SAMPL *ip, *itop;
         int snext,d;
         int s0,d0;
         int s32,d32;
-        int sho = 0;
         s32 = s0 = *st;
         if (opt>0) {
                 int low,hi,w;
                 int low0,hi0;
                 snext = s0;
-                d32 = d0 = ImaMashS(ch, chans, ip[0], ip,n,&snext, NULL, sho);
+                d32 = d0 = ImaMashS(ch, chans, ip[0], ip,n,&snext, NULL);
                 w = 0;
                 low=hi=s0;
                         if (!w && low>low0) {
                                 int d;
                                 snext = --low;
-                                d = ImaMashS(ch, chans, ip[0], ip,n,&snext, NULL, sho);
+                                d = ImaMashS(ch, chans, ip[0], ip,n,&snext, NULL);
                                 if (d<d0) {
                                         d0=d; s0=low;
                                         low0 = low-opt; if (low0<0) low0=0;
                         if (w && hi<hi0) {
                                 int d;
                                 snext = ++hi;
-                                d = ImaMashS(ch, chans, ip[0], ip,n,&snext, NULL, sho);
+                                d = ImaMashS(ch, chans, ip[0], ip,n,&snext, NULL);
                                 if (d<d0) {
                                         d0=d; s0=hi;
                                         low0 = hi-opt; if (low0<0) low0=0;
                 }
                 *st = s0;
         }
-        d = ImaMashS(ch, chans, ip[0], ip,n,st, obuff, 0);
+        d = ImaMashS(ch, chans, ip[0], ip,n,st, obuff);
 }
 /* mash one block.  if you want to use opt>0, 9 is a reasonable value */

src/libgsm/Makefile.in+10−5

 EXEEXT = @EXEEXT@
 GETOPT_LONG_FALSE = @GETOPT_LONG_FALSE@
 GETOPT_LONG_TRUE = @GETOPT_LONG_TRUE@
+GREP = @GREP@
 INSTALL_DATA = @INSTALL_DATA@
 INSTALL_PROGRAM = @INSTALL_PROGRAM@
 INSTALL_SCRIPT = @INSTALL_SCRIPT@
 STRIP = @STRIP@
 VERSION = @VERSION@
 ac_ct_CC = @ac_ct_CC@
-ac_ct_RANLIB = @ac_ct_RANLIB@
-ac_ct_STRIP = @ac_ct_STRIP@
-ac_pt_PKG_CONFIG = @ac_pt_PKG_CONFIG@
 am__fastdepCC_FALSE = @am__fastdepCC_FALSE@
 am__fastdepCC_TRUE = @am__fastdepCC_TRUE@
 am__include = @am__include@
 bindir = @bindir@
 build_alias = @build_alias@
 datadir = @datadir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+dvidir = @dvidir@
 exec_prefix = @exec_prefix@
 host_alias = @host_alias@
+htmldir = @htmldir@
 includedir = @includedir@
 infodir = @infodir@
 install_sh = @install_sh@
 libdir = @libdir@
 libexecdir = @libexecdir@
+localedir = @localedir@
 localstatedir = @localstatedir@
 mandir = @mandir@
 mkdir_p = @mkdir_p@
 oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
 prefix = @prefix@
 program_transform_name = @program_transform_name@
+psdir = @psdir@
 sbindir = @sbindir@
 sharedstatedir = @sharedstatedir@
 sysconfdir = @sysconfdir@
 	      exit 1;; \
 	  esac; \
 	done; \
-	echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign  src/libgsm/Makefile'; \
+	echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu  src/libgsm/Makefile'; \
 	cd $(top_srcdir) && \
-	  $(AUTOMAKE) --foreign  src/libgsm/Makefile
+	  $(AUTOMAKE) --gnu  src/libgsm/Makefile
 .PRECIOUS: Makefile
 Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
 	@case '$?' in \

src/libgsm/code.c+5−7

 	word	so[160];
 	Gsm_Preprocess			(S, s, so);
-	Gsm_LPC_Analysis		(S, so, LARc);
+	Gsm_LPC_Analysis		(so, LARc);
 	Gsm_Short_Term_Analysis_Filter	(S, LARc, so);
 	for (k = 0; k <= 3; k++, xMc += 13) {
-		Gsm_Long_Term_Predictor	( S,
+		Gsm_Long_Term_Predictor	(so+k*40, /* d      [0..39] IN	*/
-					 so+k*40, /* d      [0..39] IN	*/
 					 dp,	  /* dp  [-120..-1] IN	*/
-					e + 5,	  /* e      [0..39] OUT	*/
+					 e + 5,	  /* e      [0..39] OUT	*/
-					dpp,	  /* dpp    [0..39] OUT */
+					 dpp,	  /* dpp    [0..39] OUT */
 					 Nc++,
 					 bc++);
-		Gsm_RPE_Encoding	( S,
+		Gsm_RPE_Encoding	( e + 5,	/* e	  ][0..39][ IN/OUT */
-					e + 5,	/* e	  ][0..39][ IN/OUT */
 					  xmaxc++, Mc++, xMc );
 		/*
 		 * Gsm_Update_of_reconstructed_short_time_residual_signal

src/libgsm/decode.c+1−1

@@ -49,7 +49,7 @@ void Gsm_Decoder ( · 48 unmodified lines
49		49
50	for (j=0; j <= 3; j++, xmaxcr++, bcr++, Ncr++, Mcr++, xMcr += 13) {	50	for (j=0; j <= 3; j++, xmaxcr++, bcr++, Ncr++, Mcr++, xMcr += 13) {
51		51
52	Gsm_RPE_Decoding( S, xmaxcr, Mcr, xMcr, erp );	52	Gsm_RPE_Decoding( xmaxcr, Mcr, xMcr, erp );
53	Gsm_Long_Term_Synthesis_Filtering( S, Ncr, bcr, erp, drp );	53	Gsm_Long_Term_Synthesis_Filtering( S, Ncr, bcr, erp, drp );
54		54
55	for (k = 0; k <= 39; k++) wt[ j * 40 + k ] = drp[ k ];	55	for (k = 0; k <= 39; k++) wt[ j * 40 + k ] = drp[ k ];

src/libgsm/long_term.c+0−3

@@ -198,9 +198,6 @@ static void Long_term_analysis_filtering ( · 197 unmodified lines
198	}	198	}
199		199
200	void Gsm_Long_Term_Predictor ( /* 4x for 160 samples */	200	void Gsm_Long_Term_Predictor ( /* 4x for 160 samples */
201
202	struct gsm_state * S,
203
204	word * d, /* [0..39] residual signal IN */	201	word * d, /* [0..39] residual signal IN */
205	word * dp, /* [-120..-1] d' IN */	202	word * dp, /* [-120..-1] d' IN */
206		203

src/libgsm/lpc.c+0−1

@@ -269,7 +269,6 @@ static void Quantization_and_coding ( · 268 unmodified lines
269	}	269	}
270		270
271	void Gsm_LPC_Analysis (	271	void Gsm_LPC_Analysis (
272	struct gsm_state *S,
273	word * s, /* 0..159 signals IN/OUT */	272	word * s, /* 0..159 signals IN/OUT */
274	word * LARc) /* 0..7 LARc's OUT */	273	word * LARc) /* 0..7 LARc's OUT */
275	{	274	{

src/libgsm/preprocess.c+1−1

@@ -90,7 +90,7 @@ void Gsm_Preprocess ( · 89 unmodified lines
90		90
91	L_s2 += GSM_MULT_R( lsp, 32735 );	91	L_s2 += GSM_MULT_R( lsp, 32735 );
92	L_temp = (longword)msp * 32735; /* GSM_L_MULT(msp,32735) >> 1;*/	92	L_temp = (longword)msp * 32735; /* GSM_L_MULT(msp,32735) >> 1;*/
93	L_z2 = GSM_L_ADD( L_temp, L_s2 );	93	L_z2 = GSM_L_ADD( L_temp, L_s2 );
94		94
95	/* Compute sof[k] with rounding	95	/* Compute sof[k] with rounding
96	*/	96	*/

src/libgsm/private.h+1−5

 		   >= MAX_LONGWORD ? MIN_LONGWORD : -(longword)utmp-2 )   \
 	: ((b) <= 0 ? (a) + (b)   \
 	          : (utmp = (ulongword)(a) + (ulongword)(b)) >= MAX_LONGWORD \
-		    ? MAX_LONGWORD : utmp))
+		    ? MAX_LONGWORD : (longword)utmp))
 #define	GSM_ADD(a, b)	\
 	((ulongword)((ltmp = (longword)(a) + (longword)(b)) - MIN_WORD) > \
 		word	* xMc	/* [13*4] normalized RPE samples OUT	*/);
 extern void Gsm_Long_Term_Predictor (		/* 4x for 160 samples */
-		struct gsm_state * S,
 		word	* d,	/* [0..39]   residual signal	IN	*/
 		word	* dp,	/* [-120..-1] d'		IN	*/
 		word	* e,	/* [0..40] 			OUT	*/
 		word	* bc	/* gain factor			OUT	*/);
 extern void Gsm_LPC_Analysis (
-		struct gsm_state * S,
 		word * s,	 /* 0..159 signals	IN/OUT	*/
 	        word * LARc);   /* 0..7   LARc's	OUT	*/
 		word	* drp); 	/* [-120..-1] IN, [0..40] OUT 	*/
 void Gsm_RPE_Decoding (
-	struct gsm_state *S,
 		word xmaxcr,
 		word Mcr,
 		word * xMcr,  /* [0..12], 3 bits             IN      */
 		word * erp); /* [0..39]                     OUT     */
 void Gsm_RPE_Encoding (
-		struct gsm_state * S,
 		word    * e,            /* -5..-1][0..39][40..44     IN/OUT  */
 		word    * xmaxc,        /*                              OUT */
 		word    * Mc,           /*                              OUT */

src/libgsm/rpe.c+0−5

 #endif	/* Has been inlined in code.c */
 void Gsm_RPE_Encoding (
-	struct gsm_state * S,
 	word	* e,		/* -5..-1][0..39][40..44	IN/OUT  */
 	word	* xmaxc,	/* 				OUT */
 	word	* Mc,		/* 			  	OUT */
 }
 void Gsm_RPE_Decoding (
-	struct gsm_state	* S,
 	word 		xmaxcr,
 	word		Mcr,
 	word		* xMcr,  /* [0..12], 3 bits 		IN	*/

src/lowp.c+4−14

 /*
  * Process options
  */
-int st_lowp_getopts(eff_t effp, int n, char **argv)
+static int st_lowp_getopts(eff_t effp, int n, char **argv)
 {
         lowp_t lowp = (lowp_t) effp->priv;
 /*
  * Prepare processing.
  */
-int st_lowp_start(eff_t effp)
+static int st_lowp_start(eff_t effp)
 {
         lowp_t lowp = (lowp_t) effp->priv;
         if (lowp->cutoff > effp->ininfo.rate / 2)
  * Processed signed long samples from ibuf to obuf.
  * Return number of samples processed.
  */
-int st_lowp_flow(eff_t effp, const st_sample_t *ibuf, st_sample_t *obuf,
+static int st_lowp_flow(eff_t effp, const st_sample_t *ibuf, st_sample_t *obuf,
                  st_size_t *isamp, st_size_t *osamp)
 {
         lowp_t lowp = (lowp_t) effp->priv;
         return (ST_SUCCESS);
 }
-/*
- * Do anything required when you stop reading samples.
- * Don't close input file!
- */
-int st_lowp_stop(eff_t effp)
-{
-        /* nothing to do */
-    return (ST_SUCCESS);
-}
 static st_effect_t st_lowp_effect = {
   "lowp",
   "Usage: lowp cutoff",
   st_lowp_start,
   st_lowp_flow,
   st_effect_nothing_drain,
-  st_lowp_stop
+  st_effect_nothing
 };
 const st_effect_t *st_lowp_effect_fn(void)

src/lowpass.c+2−2

@@ -26,7 +26,7 @@ · 25 unmodified lines
26		26
27	static st_effect_t st_lowpass_effect;	27	static st_effect_t st_lowpass_effect;
28		28
29	int st_lowpass_getopts(eff_t effp, int n, char **argv)	29	static int st_lowpass_getopts(eff_t effp, int n, char **argv)
30	{	30	{
31	butterworth_t butterworth = (butterworth_t)effp->priv;	31	butterworth_t butterworth = (butterworth_t)effp->priv;
32		32
@@ -44,7 +44,7 @@ int st_lowpass_getopts(eff_t effp, int n, char **argv) · 11 unmodified lines
44	return (ST_SUCCESS);	44	return (ST_SUCCESS);
45	}	45	}
46		46
47	int st_lowpass_start(eff_t effp)	47	static int st_lowpass_start(eff_t effp)
48	{	48	{
49	butterworth_t butterworth = (butterworth_t) effp->priv;	49	butterworth_t butterworth = (butterworth_t) effp->priv;
50	double c;	50	double c;

src/mask.c+2−2

@@ -29,7 +29,7 @@ static st_effect_t st_mask_effect; · 28 unmodified lines
29	/*	29	/*
30	* Process options	30	* Process options
31	*/	31	*/
32	int st_mask_getopts(eff_t effp, int n, char **argv)	32	static int st_mask_getopts(eff_t effp UNUSED, int n, char **argv UNUSED)
33	{	33	{
34	if (n)	34	if (n)
35	{	35	{
@@ -46,7 +46,7 @@ int st_mask_getopts(eff_t effp, int n, char **argv) · 10 unmodified lines
46	* Processed signed long samples from ibuf to obuf.	46	* Processed signed long samples from ibuf to obuf.
47	* Return number of samples processed.	47	* Return number of samples processed.
48	*/	48	*/
49	int st_mask_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf,	49	static int st_mask_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf,
50	st_size_t isamp, st_size_t osamp)	50	st_size_t isamp, st_size_t osamp)
51	{	51	{
52	int len, done;	52	int len, done;

src/maud.c+11−40

-/*
- * July 5, 1991
- * Copyright 1991 Lance Norskog And Sundry Contributors
- * This source code is freely redistributable and may be used for
- * any purpose.  This copyright notice must be maintained.
- * Lance Norskog And Sundry Contributors are not responsible for
- * the consequences of using this software.
- */
 /*
  * Sound Tools MAUD file format driver, by Lutz Vieweg 1993
  *
  * supports: mono and stereo, linear, a-law and u-law reading and writing
  *
- * March 3, 1999 - cbagwell
+ * Copyright 1998-2006 Chris Bagwell and SoX Contributors
- *   Changed to use rawread for reading.
+ * This source code is freely redistributable and may be used for
- *
+ * any purpose.  This copyright notice must be maintained.
+ * Lance Norskog And Sundry Contributors are not responsible for
+ * the consequences of using this software.
  */
 #include "st_i.h"
  *      size and encoding of samples,
  *      mono/stereo/quad.
  */
-int st_maudstartread(ft_t ft)
+static int st_maudstartread(ft_t ft)
 {
         struct maudstuff * p = (struct maudstuff *) ft->priv;
         return(ST_SUCCESS);
 }
-/*
+static int st_maudstartwrite(ft_t ft)
- * Read up to len samples from file.
- * Convert to signed longs.
- * Place in buf[].
- * Return number of samples read.
- */
-st_ssize_t st_maudread(ft_t ft, st_sample_t *buf, st_size_t len)
-{
-        return (st_rawread(ft, buf, len));
-}
-/*
- * Do anything required when you stop reading samples.
- * Don't close input file!
- */
-int st_maudstopread(ft_t ft)
-{
-        /* Needed because of rawread() */
-        return st_rawstopread(ft);
-}
-int st_maudstartwrite(ft_t ft)
 {
         struct maudstuff * p = (struct maudstuff *) ft->priv;
         int rc;
         return (ST_SUCCESS);
 }
-st_ssize_t st_maudwrite(ft_t ft, const st_sample_t *buf, st_size_t len)
+static st_size_t st_maudwrite(ft_t ft, const st_sample_t *buf, st_size_t len)
 {
         struct maudstuff * p = (struct maudstuff *) ft->priv;
         return st_rawwrite(ft, buf, len);
 }
-int st_maudstopwrite(ft_t ft)
+static int st_maudstopwrite(ft_t ft)
 {
         int rc;
   NULL,
   ST_FILE_STEREO,
   st_maudstartread,
-  st_maudread,
+  st_rawread,
-  st_maudstopread,
+  st_rawstopread,
   st_maudstartwrite,
   st_maudwrite,
   st_maudstopwrite,

src/mcompand.c+13−12

 }
 typedef struct comp_band {
-  int expectedChannels; /* Also flags that channels aren't to be treated
+  st_size_t expectedChannels; /* Also flags that channels aren't to be treated
                            individually when = 1 and input not mono */
   int transferPoints;   /* Number of points specified on the transfer
                            function */
   double topfreq;       /* upper bound crossover frequency */
   struct butterworth_crossover filter;
   st_sample_t *delay_buf;   /* Old samples, used for delay processing */
-  st_ssize_t delay_size;    /* lookahead for this band (in samples) - function of delay, above */
+  st_size_t delay_size;    /* lookahead for this band (in samples) - function of delay, above */
   st_ssize_t delay_buf_ptr; /* Index into delay_buf */
-  st_ssize_t delay_buf_cnt; /* No. of active entries in delay_buf */
+  st_size_t delay_buf_cnt; /* No. of active entries in delay_buf */
 } *comp_band_t;
 typedef struct {
 static int st_mcompand_getopts_1(comp_band_t l, int n, char **argv)
 {
       char *s;
-      int rates, tfers, i, commas;
+      st_size_t rates, tfers, i, commas;
       /* Start by checking the attack and decay rates */
       return ST_SUCCESS;
 }
-int st_mcompand_getopts(eff_t effp, int n, char **argv)
+static int st_mcompand_getopts(eff_t effp, int n, char **argv)
 {
   char *subargv[6], *cp;
   int subargc, i, len;
  * Prepare processing.
  * Do all initializations.
  */
-int st_mcompand_start(eff_t effp)
+static int st_mcompand_start(eff_t effp)
 {
   compand_t c = (compand_t) effp->priv;
   comp_band_t l;
-  int band, i;
+  st_size_t i;
+  int band;
   for (band=0;band<c->nBands;++band) {
     l = &c->bands[band];
  * Processed signed long samples from ibuf to obuf.
  * Return number of samples processed.
  */
-int st_mcompand_flow(eff_t effp, const st_sample_t *ibuf, st_sample_t *obuf,
+static int st_mcompand_flow(eff_t effp, const st_sample_t *ibuf, st_sample_t *obuf,
                      st_size_t *isamp, st_size_t *osamp) {
   compand_t c = (compand_t) effp->priv;
   comp_band_t l;
   return ST_SUCCESS;
 }
-static int st_mcompand_drain_1(eff_t effp, compand_t c, comp_band_t l, st_sample_t *obuf, int maxdrain, int band)
+static int st_mcompand_drain_1(eff_t effp, compand_t c, comp_band_t l, st_sample_t *obuf, int maxdrain)
 {
   int done;
   double out;
 /*
  * Drain out compander delay lines.
  */
-int st_mcompand_drain(eff_t effp, st_sample_t *obuf, st_size_t *osamp)
+static int st_mcompand_drain(eff_t effp, st_sample_t *obuf, st_size_t *osamp)
 {
   int band, drained, mostdrained = 0;
   compand_t c = (compand_t)effp->priv;
   memset(obuf,0,*osamp * sizeof *obuf);
   for (band=0;band<c->nBands;++band) {
     l = &c->bands[band];
-    drained = st_mcompand_drain_1(effp, c,l,obuf,*osamp,0);
+    drained = st_mcompand_drain_1(effp, c,l,obuf,*osamp);
     if (drained > mostdrained)
       mostdrained = drained;
   }
 /*
  * Clean up compander effect.
  */
-int st_mcompand_stop(eff_t effp)
+static int st_mcompand_stop(eff_t effp)
 {
   compand_t c = (compand_t) effp->priv;
   comp_band_t l;

src/misc.c+58−21

 #include <math.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <stddef.h>
 #include <time.h>
 #include <string.h>
 #include <ctype.h>
  * Returns number of elements read, not bytes read.
  */
-st_ssize_t st_readbuf(ft_t ft, void *buf, size_t size, st_size_t len)
+size_t st_readbuf(ft_t ft, void *buf, size_t size, st_size_t len)
 {
     return fread(buf, size, len, ft->fp);
 }
 /* Write a buffer of data of length len and each element is size bytes.
- * Returns number of elements writen, not bytes writen.
+ * Returns number of elements writen, not bytes written.
  */
-st_ssize_t st_writebuf(ft_t ft, void const *buf, size_t size, st_size_t len)
+size_t st_writebuf(ft_t ft, void const *buf, size_t size, st_size_t len)
 {
     return fwrite(buf, size, len, ft->fp);
 }
             return (ST_EOF);
         }
         if (in == 0 || in == '\n')
-        {
             break;
-        }
         *sc = in;
         sc++;
-    } while (sc - c < len);
+    } while (sc - c < (ptrdiff_t)len);
     *sc = 0;
     return(ST_SUCCESS);
 }
 }
 /* generic swap routine. Swap l and place in to f (datatype length = n) */
-void st_swapb(char *l, char *f, int n)
+static void st_swapb(char *l, char *f, int n)
 {
     register int i;
 /* dummy format routines for do-nothing functions */
-int st_format_nothing(ft_t ft) { return(ST_SUCCESS); }
+int st_format_nothing(ft_t ft UNUSED) { return(ST_SUCCESS); }
-st_ssize_t st_format_nothing_read_io(ft_t ft, st_sample_t *buf, st_size_t len) { return(0); }
+st_size_t st_format_nothing_read_io(ft_t ft UNUSED, st_sample_t *buf UNUSED, st_size_t len UNUSED) { return(0); }
-st_ssize_t st_format_nothing_write_io(ft_t ft, const st_sample_t *buf, st_size_t len) { return(0); }
+st_size_t st_format_nothing_write_io(ft_t ft UNUSED, const st_sample_t *buf UNUSED, st_size_t len UNUSED) { return(0); }
-int st_format_nothing_seek(ft_t ft, st_size_t offset) { st_fail_errno(ft, ST_ENOTSUP, "operation not supported"); return(ST_EOF); }
+int st_format_nothing_seek(ft_t ft UNUSED, st_size_t offset UNUSED) { st_fail_errno(ft, ST_ENOTSUP, "operation not supported"); return(ST_EOF); }
 /* dummy effect routine for do-nothing functions */
-int st_effect_nothing(eff_t effp) { return(ST_SUCCESS); }
+int st_effect_nothing(eff_t effp UNUSED) { return(ST_SUCCESS); }
-int st_effect_nothing_drain(eff_t effp, st_sample_t *obuf, st_size_t *osamp)
+int st_effect_nothing_drain(eff_t effp UNUSED, st_sample_t *obuf UNUSED, st_size_t *osamp)
   { /* Inform no more samples to drain */ *osamp = 0; return(ST_EOF); }
+int st_effect_nothing_getopts(eff_t effp, int n, char **argv UNUSED)
+{
+     if (n) {
+          st_fail(effp->h->usage);
+          return (ST_EOF);
+     }
+     return (ST_SUCCESS);
+}
 /* here for linear interp.  might be useful for other things */
-st_sample_t st_gcd(st_sample_t a, st_sample_t b)
+REGPARM(2) st_sample_t st_gcd(st_sample_t a, st_sample_t b)
 {
         if (b == 0)
                 return a;
                 return st_gcd(b, a % b);
 }
-st_sample_t st_lcm(st_sample_t a, st_sample_t b)
+REGPARM(2) st_sample_t st_lcm(st_sample_t a, st_sample_t b)
 {
     /* parenthesize this way to avoid st_sample_t overflow in product term */
     return a * (b / st_gcd(a, b));
 void st_generate_wave_table(
     st_wave_t wave_type,
     st_data_t data_type,
-    void * table,
+    void *table,
     uint32_t table_size,
     double min,
     double max,
         case 3:         d = d - 1.5; break;
       }
       break;
+      default: /* Oops! FIXME */
+        d = 0.0; /* Make sure we have a value */
+      break;
     }
     d  = d * (max - min) + min;
     switch (data_type)
     {
-      case ST_FLOAT : *(float  *)table = d; table += sizeof(float ); continue;
+      case ST_FLOAT:
-      case ST_DOUBLE: *(double *)table = d; table += sizeof(double); continue;
+        {
+          float *fp = (float *)table;
+          *fp++ = (float)d;
+          table = fp;
+          continue;
+        }
+      case ST_DOUBLE:
+        {
+          double *dp = (double *)table;
+          *dp++ = d;
+          table = dp;
+          continue;
+        }
       default: break;
     }
     d += d < 0? -0.5 : +0.5;
     switch (data_type)
     {
-      case ST_SHORT : *(short  *)table = d; table += sizeof(short ); continue;
+      case ST_SHORT:
-      case ST_INT   : *(int    *)table = d; table += sizeof(int   ); continue;
+        {
+          short *sp = table;
+          *sp++ = (short)d;
+          table = sp;
+          continue;
+        }
+      case ST_INT:
+        {
+          int *ip = table;
+          *ip++ = (int)d;
+          table = ip;
+          continue;
+        }
       default: break;
     }
   }
 enum_item const st_wave_enum[] = {
   ENUM_ITEM(ST_WAVE_,SINE)
   ENUM_ITEM(ST_WAVE_,TRIANGLE)
-  {0}};
+  {0, 0}};

src/mp3.c+32−31

 #include <string.h>
-#if defined(HAVE_LIBMAD) || defined(HAVE_LAME)
+#if defined(HAVE_LIBMAD) || defined(HAVE_LIBMP3LAME)
 #ifdef HAVE_LIBMAD
 #include <mad.h>
 #endif
-#ifdef HAVE_LAME
+#ifdef HAVE_LIBMP3LAME
 #include <lame/lame.h>
 #include <math.h>
 #endif
         st_ssize_t              cursamp;
         st_size_t               FrameCount;
 #endif /*HAVE_LIBMAD*/
-#ifdef HAVE_LAME
+#ifdef HAVE_LIBMP3LAME
         lame_global_flags       *gfp;
-#endif /*HAVE_LAME*/
+#endif /*HAVE_LIBMP3LAME*/
 };
 #ifdef HAVE_LIBMAD
     return rc;
 }
-int st_mp3startread(ft_t ft)
+static int st_mp3startread(ft_t ft)
 {
     struct mp3priv *p = (struct mp3priv *) ft->priv;
     size_t ReadSize;
  * Place in buf[].
  * Return number of samples read.
  */
-st_ssize_t st_mp3read(ft_t ft, st_sample_t *buf, st_size_t len)
+static st_size_t st_mp3read(ft_t ft, st_sample_t *buf, st_size_t len)
 {
     struct mp3priv *p = (struct mp3priv *) ft->priv;
-    st_ssize_t donow,i,done=0;
+    st_size_t donow,i,done=0;
     mad_fixed_t sample;
-    int chan;
+    size_t chan;
     do {
         donow=min(len,(p->Synth->pcm.length - p->cursamp)*ft->info.channels);
     return done;
 }
-int st_mp3stopread(ft_t ft)
+static int st_mp3stopread(ft_t ft)
 {
   struct mp3priv *p=(struct mp3priv*) ft->priv;
   return ST_SUCCESS;
 }
 #else /*HAVE_LIBMAD*/
-int st_mp3startread(ft_t ft)
+static int st_mp3startread(ft_t ft)
 {
   st_fail_errno(ft,ST_EOF,"SoX was compiled without MP3 decoding support");
   return ST_EOF;
 }
 #endif /*HAVE_LIBMAD*/
-#ifdef HAVE_LAME
+#ifdef HAVE_LIBMP3LAME
-void null_error_func(const char* string, va_list va){
+static void null_error_func(const char* string UNUSED, va_list va UNUSED)
+{
   return;
 }
-int st_mp3startwrite(ft_t ft)
+static int st_mp3startwrite(ft_t ft)
 {
   struct mp3priv *p = (struct mp3priv *) ft->priv;
-  if (ft->info.encoding != ST_ENCODING_MP3){
+  if (ft->info.encoding != ST_ENCODING_MP3) {
-    if(ft->info.encoding != -1)
+    if(ft->info.encoding != ST_ENCODING_UNKNOWN)
       st_report("Encoding forced to MP3");
     ft->info.encoding = ST_ENCODING_MP3;
   }
     return(ST_EOF);
   }
-  if (ft->info.channels != -1){
+  if (ft->info.channels != ST_ENCODING_UNKNOWN) {
     if ( (lame_set_num_channels(p->gfp,ft->info.channels)) < 0) {
         st_fail_errno(ft,ST_EOF,"Unsupported number of channels");
         return(ST_EOF);
   return(ST_SUCCESS);
 }
-st_ssize_t st_mp3write(ft_t ft, const st_sample_t *buf, st_size_t samp)
+static st_size_t st_mp3write(ft_t ft, const st_sample_t *buf, st_size_t samp)
 {
     struct mp3priv *p = (struct mp3priv *)ft->priv;
     char *mp3buffer;
-    int mp3buffer_size;
+    st_size_t mp3buffer_size;
     short signed int *buffer_l, *buffer_r = NULL;
     int nsamples = samp/ft->info.channels;
     int i,j;
     st_ssize_t done = 0;
-    int written;
+    st_size_t written;
     /* NOTE: This logic assumes that "short int" is 16-bits
      * on all platforms.  It happens to be for all that I know
     if ((written = lame_encode_buffer(p->gfp,buffer_l, buffer_r,
                                       nsamples, (unsigned char *)mp3buffer,
-                                      mp3buffer_size)) < 0){
+                                      mp3buffer_size)) < mp3buffer_size){
         st_fail_errno(ft,ST_EOF,"Encoding failed");
         goto end;
     }
     return done;
 }
-int st_mp3stopwrite(ft_t ft)
+static int st_mp3stopwrite(ft_t ft)
 {
   struct mp3priv *p = (struct mp3priv *) ft->priv;
   char mp3buffer[7200];
   if ( (written=lame_encode_flush(p->gfp, (unsigned char *)mp3buffer, 7200)) <0){
     st_fail_errno(ft,ST_EOF,"Encoding failed");
   }
-  else if (st_writebuf(ft, mp3buffer, 1, written) < written){
+  else if ((int)st_writebuf(ft, mp3buffer, 1, written) < written){
     st_fail_errno(ft,ST_EOF,"File write failed");
   }
   return ST_SUCCESS;
 }
-#else /* HAVE_LAME */
+#else /* HAVE_LIBMP3LAME */
-int st_mp3startwrite(ft_t ft)
+static int st_mp3startwrite(ft_t ft UNUSED)
 {
-  st_fail_errno(ft,ST_EOF,"Sorry, no MP3 encoding support");
+  st_fail_errno(ft,ST_EOF,"SoX was compiled without MP3 encoding support");
   return ST_EOF;
 }
-st_ssize_t st_mp3write(ft_t ft, const st_sample_t *buf, st_size_t samp)
+static st_size_t st_mp3write(ft_t ft UNUSED, const st_sample_t *buf UNUSED, st_size_t samp UNUSED)
 {
-  st_fail_errno(ft,ST_EOF,"Sorry, no MP3 encoding support");
+  st_fail_errno(ft,ST_EOF,"SoX was compiled without MP3 encoding support");
-  return ST_EOF;
+  return 0;
 }
-int st_mp3stopwrite(ft_t ft)
+static int st_mp3stopwrite(ft_t ft)
 {
-  st_fail_errno(ft,ST_EOF,"Sorry, no MP3 encoding support");
+  st_fail_errno(ft,ST_EOF,"SoX was compiled without MP3 encoding support");
   return ST_EOF;
 }
-#endif /* HAVE_LAME */
+#endif /* HAVE_LIBMP3LAME */
 /* MP3 */
 static const char *mp3names[] = {

src/noiseprof.c+10−10

@@ -39,7 +39,7 @@ typedef struct profdata { · 38 unmodified lines
39	/*	39	/*
40	* Get the filename, if any. We don't open it until st_noiseprof_start.	40	* Get the filename, if any. We don't open it until st_noiseprof_start.
41	*/	41	*/
42	int st_noiseprof_getopts(eff_t effp, int n, char **argv)	42	static int st_noiseprof_getopts(eff_t effp, int n, char **argv)
43	{	43	{
44	profdata_t data = (profdata_t) effp->priv;	44	profdata_t data = (profdata_t) effp->priv;
45		45
@@ -57,7 +57,7 @@ int st_noiseprof_getopts(eff_t effp, int n, char **argv) · 11 unmodified lines
57	* Prepare processing.	57	* Prepare processing.
58	* Do all initializations.	58	* Do all initializations.
59	*/	59	*/
60	int st_noiseprof_start(eff_t effp)	60	static int st_noiseprof_start(eff_t effp)
61	{	61	{
62	profdata_t data = (profdata_t) effp->priv;	62	profdata_t data = (profdata_t) effp->priv;
63	int channels = effp->ininfo.channels;	63	int channels = effp->ininfo.channels;
@@ -88,7 +88,7 @@ int st_noiseprof_start(eff_t effp) · 24 unmodified lines
88	}	88	}
89		89
90	/* Collect statistics from the complete window on channel chan. */	90	/* Collect statistics from the complete window on channel chan. */
91	static void collect_data(profdata_t data, chandata_t* chan) {	91	static void collect_data(chandata_t* chan) {
92	float out = (float)calloc(FREQCOUNT, sizeof(float));	92	float out = (float)calloc(FREQCOUNT, sizeof(float));
93		93
94	int i;	94	int i;
@@ -109,13 +109,13 @@ static void collect_data(profdata_t data, chandata_t* chan) { · 14 unmodified lines
109	/*	109	/*
110	* Grab what we can from ibuf, and process if we have a whole window.	110	* Grab what we can from ibuf, and process if we have a whole window.
111	*/	111	*/
112	int st_noiseprof_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf,	112	static int st_noiseprof_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf,
113	st_size_t isamp, st_size_t osamp)	113	st_size_t isamp, st_size_t osamp)
114	{	114	{
115	profdata_t data = (profdata_t) effp->priv;	115	profdata_t data = (profdata_t) effp->priv;
116	int samp = min(isamp, osamp);	116	int samp = min(isamp, osamp);
117	int tracks = effp->ininfo.channels;	117	int tracks = effp->ininfo.channels;
118	int track_samples = samp / tracks;	118	st_size_t track_samples = samp / tracks;
119	int ncopy = 0;	119	int ncopy = 0;
120	int i;	120	int i;
121		121
@@ -133,7 +133,7 @@ int st_noiseprof_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf, · 11 unmodified lines
133	ST_SAMPLE_TO_FLOAT_DWORD(ibuf[i+j*tracks], effp->clippedCount);	133	ST_SAMPLE_TO_FLOAT_DWORD(ibuf[i+j*tracks], effp->clippedCount);
134	}	134	}
135	if (ncopy + data->bufdata == WINDOWSIZE) {	135	if (ncopy + data->bufdata == WINDOWSIZE) {
136	collect_data(data, chan);	136	collect_data(chan);
137	}	137	}
138	}	138	}
139		139
@@ -152,7 +152,7 @@ int st_noiseprof_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf, · 12 unmodified lines
152	* Finish off the last window.	152	* Finish off the last window.
153	*/	153	*/
154		154
155	int st_noiseprof_drain(eff_t effp, st_sample_t obuf, st_size_t osamp)	155	static int st_noiseprof_drain(eff_t effp, st_sample_t obuf UNUSED, st_size_t osamp)
156	{	156	{
157	profdata_t data = (profdata_t) effp->priv;	157	profdata_t data = (profdata_t) effp->priv;
158	int tracks = effp->ininfo.channels;	158	int tracks = effp->ininfo.channels;
@@ -169,7 +169,7 @@ int st_noiseprof_drain(eff_t effp, st_sample_t obuf, st_size_t osamp) · 10 unmodified lines
169	for (j = data->bufdata+1; j < WINDOWSIZE; j ++) {	169	for (j = data->bufdata+1; j < WINDOWSIZE; j ++) {
170	data->chandata[i].window[j] = 0;	170	data->chandata[i].window[j] = 0;
171	}	171	}
172	collect_data(data, &(data->chandata[i]));	172	collect_data(&(data->chandata[i]));
173	}	173	}
174		174
175	if (data->bufdata == WINDOWSIZE \|\| data->bufdata == 0)	175	if (data->bufdata == WINDOWSIZE \|\| data->bufdata == 0)
@@ -181,10 +181,10 @@ int st_noiseprof_drain(eff_t effp, st_sample_t obuf, st_size_t osamp) · 5 unmodified lines
181	/*	181	/*
182	* Print profile and clean up.	182	* Print profile and clean up.
183	*/	183	*/
184	int st_noiseprof_stop(eff_t effp)	184	static int st_noiseprof_stop(eff_t effp)
185	{	185	{
186	profdata_t data = (profdata_t) effp->priv;	186	profdata_t data = (profdata_t) effp->priv;
187	int i;	187	st_size_t i;
188		188
189	for (i = 0; i < effp->ininfo.channels; i ++) {	189	for (i = 0; i < effp->ininfo.channels; i ++) {
190	int j;	190	int j;

src/noisered.c+13−13

@@ -38,7 +38,7 @@ typedef struct reddata { · 37 unmodified lines
38	* Get the options. Filename is mandatory, though a reasonable default would	38	* Get the options. Filename is mandatory, though a reasonable default would
39	* be stdin (if the input file isn't coming from there, of course!)	39	* be stdin (if the input file isn't coming from there, of course!)
40	*/	40	*/
41	int st_noisered_getopts(eff_t effp, int n, char **argv)	41	static int st_noisered_getopts(eff_t effp, int n, char **argv)
42	{	42	{
43	reddata_t data = (reddata_t) effp->priv;	43	reddata_t data = (reddata_t) effp->priv;
44		44
@@ -67,7 +67,7 @@ int st_noisered_getopts(eff_t effp, int n, char **argv) · 22 unmodified lines
67	* Prepare processing.	67	* Prepare processing.
68	* Do all initializations.	68	* Do all initializations.
69	*/	69	*/
70	int st_noisered_start(eff_t effp)	70	static int st_noisered_start(eff_t effp)
71	{	71	{
72	reddata_t data = (reddata_t) effp->priv;	72	reddata_t data = (reddata_t) effp->priv;
73	int fchannels = 0;	73	int fchannels = 0;
@@ -245,17 +245,17 @@ static int process_window(eff_t effp, reddata_t data, int chan_num, int num_chan · 171 unmodified lines
245	/*	245	/*
246	* Read in windows, and call process_window once we get a whole one.	246	* Read in windows, and call process_window once we get a whole one.
247	*/	247	*/
248	int st_noisered_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf,	248	static int st_noisered_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf,
249	st_size_t isamp, st_size_t osamp)	249	st_size_t isamp, st_size_t osamp)
250	{	250	{
251	reddata_t data = (reddata_t) effp->priv;	251	reddata_t data = (reddata_t) effp->priv;
252	int samp = min(isamp, osamp);	252	st_size_t samp = min(isamp, osamp);
253	int tracks = effp->ininfo.channels;	253	st_size_t tracks = effp->ininfo.channels;
254	int track_samples = samp / tracks;	254	st_size_t track_samples = samp / tracks;
255	int ncopy = min(track_samples, WINDOWSIZE-data->bufdata);	255	st_size_t ncopy = min(track_samples, WINDOWSIZE-data->bufdata);
256	int whole_window = (ncopy + data->bufdata == WINDOWSIZE);	256	st_size_t whole_window = (ncopy + data->bufdata == WINDOWSIZE);
257	int oldbuf = data->bufdata;	257	int oldbuf = data->bufdata;
258	int i;	258	st_size_t i;
259	assert(effp->ininfo.channels == effp->outinfo.channels);	259	assert(effp->ininfo.channels == effp->outinfo.channels);
260		260
261	if (whole_window) {	261	if (whole_window) {
@@ -267,7 +267,7 @@ int st_noisered_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf, · 5 unmodified lines
267	/* Reduce noise on every channel. */	267	/* Reduce noise on every channel. */
268	for (i = 0; i < tracks; i ++) {	268	for (i = 0; i < tracks; i ++) {
269	chandata_t* chan = &(data->chandata[i]);	269	chandata_t* chan = &(data->chandata[i]);
270	int j;	270	st_size_t j;
271	if (chan->window == NULL) {	271	if (chan->window == NULL) {
272	chan->window = (float*)calloc(WINDOWSIZE, sizeof(float));	272	chan->window = (float*)calloc(WINDOWSIZE, sizeof(float));
273	}	273	}
@@ -298,7 +298,7 @@ int st_noisered_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf, · 24 unmodified lines
298	* We have up to half a window left to dump.	298	* We have up to half a window left to dump.
299	*/	299	*/
300		300
301	int st_noisered_drain(eff_t effp, st_sample_t obuf, st_size_t osamp)	301	static int st_noisered_drain(eff_t effp, st_sample_t obuf, st_size_t osamp)
302	{	302	{
303	reddata_t data = (reddata_t)effp->priv;	303	reddata_t data = (reddata_t)effp->priv;
304	int i;	304	int i;
@@ -315,10 +315,10 @@ int st_noisered_drain(eff_t effp, st_sample_t obuf, st_size_t osamp) · 10 unmodified lines
315	/*	315	/*
316	* Clean up.	316	* Clean up.
317	*/	317	*/
318	int st_noisered_stop(eff_t effp)	318	static int st_noisered_stop(eff_t effp)
319	{	319	{
320	reddata_t data = (reddata_t) effp->priv;	320	reddata_t data = (reddata_t) effp->priv;
321	int i;	321	st_size_t i;
322		322
323	for (i = 0; i < effp->ininfo.channels; i ++) {	323	for (i = 0; i < effp->ininfo.channels; i ++) {
324	chandata_t* chan = &(data->chandata[i]);	324	chandata_t* chan = &(data->chandata[i]);

src/nulfile.c+5−5

@@ -17,26 +17,26 @@ · 16 unmodified lines
17	#include "st_i.h"	17	#include "st_i.h"
18	#include <string.h>	18	#include <string.h>
19		19
20	int st_nulstartread(ft_t ft)	20	static int st_nulstartread(ft_t ft)
21	{	21	{
22	/* If format parameters are not given, set somewhat arbitrary	22	/* If format parameters are not given, set somewhat arbitrary
23	* (but commonly used) defaults: */	23	* (but commonly used) defaults: */
24	if (ft->info.rate == 0) ft->info.rate = 44100;	24	if (ft->info.rate == 0) ft->info.rate = 44100;
25	if (ft->info.channels == -1) ft->info.channels = 2;	25	if (ft->info.channels == 0) ft->info.channels = 2;
26	if (ft->info.size == -1) ft->info.size = ST_SIZE_WORD;	26	if (ft->info.size == -1) ft->info.size = ST_SIZE_WORD;
27	if (ft->info.encoding == -1) ft->info.encoding = ST_ENCODING_SIGN2;	27	if (ft->info.encoding == ST_ENCODING_UNKNOWN) ft->info.encoding = ST_ENCODING_SIGN2;
28		28
29	return ST_SUCCESS;	29	return ST_SUCCESS;
30	}	30	}
31		31
32	st_ssize_t st_nulread(ft_t ft, st_sample_t *buf, st_size_t len)	32	static st_size_t st_nulread(ft_t ft UNUSED, st_sample_t *buf, st_size_t len)
33	{	33	{
34	/* Reading from null generates silence i.e. (st_sample_t)0. */	34	/* Reading from null generates silence i.e. (st_sample_t)0. */
35	memset(buf, 0, sizeof(st_sample_t) * len);	35	memset(buf, 0, sizeof(st_sample_t) * len);
36	return len; /* Return number of samples "read". */	36	return len; /* Return number of samples "read". */
37	}	37	}
38		38
39	st_ssize_t st_nulwrite(ft_t ft, const st_sample_t *buf, st_size_t len)	39	static st_size_t st_nulwrite(ft_t ft UNUSED, const st_sample_t *buf UNUSED, st_size_t len)
40	{	40	{
41	/* Writing to null just discards the samples */	41	/* Writing to null just discards the samples */
42	return len; /* Return number of samples "written". */	42	return len; /* Return number of samples "written". */

src/oss.c+5−5

@@ -51,7 +51,7 @@ static int ossdspinit(ft_t ft) · 50 unmodified lines
51	if (ft->info.size == ST_SIZE_BYTE) {	51	if (ft->info.size == ST_SIZE_BYTE) {
52	sampletype = AFMT_U8;	52	sampletype = AFMT_U8;
53	samplesize = 8;	53	samplesize = 8;
54	if (ft->info.encoding == -1)	54	if (ft->info.encoding == ST_ENCODING_UNKNOWN)
55	ft->info.encoding = ST_ENCODING_UNSIGNED;	55	ft->info.encoding = ST_ENCODING_UNSIGNED;
56	if (ft->info.encoding != ST_ENCODING_UNSIGNED) {	56	if (ft->info.encoding != ST_ENCODING_UNSIGNED) {
57	st_report("OSS driver only supports unsigned with bytes");	57	st_report("OSS driver only supports unsigned with bytes");
@@ -62,7 +62,7 @@ static int ossdspinit(ft_t ft) · 4 unmodified lines
62	else if (ft->info.size == ST_SIZE_WORD) {	62	else if (ft->info.size == ST_SIZE_WORD) {
63	sampletype = (ST_IS_BIGENDIAN) ? AFMT_S16_BE : AFMT_S16_LE;	63	sampletype = (ST_IS_BIGENDIAN) ? AFMT_S16_BE : AFMT_S16_LE;
64	samplesize = 16;	64	samplesize = 16;
65	if (ft->info.encoding == -1)	65	if (ft->info.encoding == ST_ENCODING_UNKNOWN)
66	ft->info.encoding = ST_ENCODING_SIGN2;	66	ft->info.encoding = ST_ENCODING_SIGN2;
67	if (ft->info.encoding != ST_ENCODING_SIGN2) {	67	if (ft->info.encoding != ST_ENCODING_SIGN2) {
68	st_report("OSS driver only supports signed with words");	68	st_report("OSS driver only supports signed with words");
@@ -79,7 +79,7 @@ static int ossdspinit(ft_t ft) · 10 unmodified lines
79	st_report("Forcing to signed linear word");	79	st_report("Forcing to signed linear word");
80	}	80	}
81		81
82	if (ft->info.channels == -1) ft->info.channels = 1;	82	if (ft->info.channels == 0) ft->info.channels = 1;
83	else if (ft->info.channels > 2) ft->info.channels = 2;	83	else if (ft->info.channels > 2) ft->info.channels = 2;
84		84
85	if (ioctl(fileno(ft->fp), SNDCTL_DSP_RESET, 0) < 0)	85	if (ioctl(fileno(ft->fp), SNDCTL_DSP_RESET, 0) < 0)
@@ -204,14 +204,14 @@ static int ossdspinit(ft_t ft) · 118 unmodified lines
204	* size and encoding of samples,	204	* size and encoding of samples,
205	* mono/stereo/quad.	205	* mono/stereo/quad.
206	*/	206	*/
207	int st_ossdspstartread(ft_t ft)	207	static int st_ossdspstartread(ft_t ft)
208	{	208	{
209	int rc;	209	int rc;
210	rc = ossdspinit(ft);	210	rc = ossdspinit(ft);
211	return rc;	211	return rc;
212	}	212	}
213		213
214	int st_ossdspstartwrite(ft_t ft)	214	static int st_ossdspstartwrite(ft_t ft)
215	{	215	{
216	return ossdspinit(ft);	216	return ossdspinit(ft);
217	}	217	}

src/pan.c+5−12

 /*
  * Process options
  */
-int st_pan_getopts(eff_t effp, int n, char **argv)
+static int st_pan_getopts(eff_t effp, int n, char **argv)
 {
     pan_t pan = (pan_t) effp->priv;
 /*
  * Start processing
  */
-int st_pan_start(eff_t effp)
+static int st_pan_start(eff_t effp)
 {
     if (effp->outinfo.channels==1)
         st_warn("PAN onto a mono channel...");
 /*
  * Process either isamp or osamp samples, whichever is smaller.
  */
-int st_pan_flow(eff_t effp, const st_sample_t *ibuf, st_sample_t *obuf,
+static int st_pan_flow(eff_t effp, const st_sample_t *ibuf, st_sample_t *obuf,
                 st_size_t *isamp, st_size_t *osamp)
 {
     pan_t pan = (pan_t) effp->priv;
 }
 /*
- * Do anything required when you stop reading samples.
+ * FIXME: Add a stop function with statistics on right, left, and output amplitudes.
- * Don't close input file!
- *
- * Should have statistics on right, left, and output amplitudes.
  */
-int st_pan_stop(eff_t effp)
-{
-    return ST_SUCCESS;
-}
 static st_effect_t st_pan_effect = {
   "pan",
   st_pan_start,
   st_pan_flow,
   st_effect_nothing_drain,
-  st_pan_stop
+  st_effect_nothing
 };
 const st_effect_t *st_pan_effect_fn(void)

src/phaser.c+5−5

@@ -81,7 +81,7 @@ typedef struct phaserstuff { · 80 unmodified lines
81	/*	81	/*
82	* Process options	82	* Process options
83	*/	83	*/
84	int st_phaser_getopts(eff_t effp, int n, char **argv)	84	static int st_phaser_getopts(eff_t effp, int n, char **argv)
85	{	85	{
86	phaser_t phaser = (phaser_t) effp->priv;	86	phaser_t phaser = (phaser_t) effp->priv;
87		87
@@ -114,7 +114,7 @@ int st_phaser_getopts(eff_t effp, int n, char **argv) · 26 unmodified lines
114	/*	114	/*
115	* Prepare for processing.	115	* Prepare for processing.
116	*/	116	*/
117	int st_phaser_start(eff_t effp)	117	static int st_phaser_start(eff_t effp)
118	{	118	{
119	phaser_t phaser = (phaser_t) effp->priv;	119	phaser_t phaser = (phaser_t) effp->priv;
120	unsigned int i;	120	unsigned int i;
@@ -192,7 +192,7 @@ int st_phaser_start(eff_t effp) · 71 unmodified lines
192	* Processed signed long samples from ibuf to obuf.	192	* Processed signed long samples from ibuf to obuf.
193	* Return number of samples processed.	193	* Return number of samples processed.
194	*/	194	*/
195	int st_phaser_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf,	195	static int st_phaser_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf,
196	st_size_t isamp, st_size_t osamp)	196	st_size_t isamp, st_size_t osamp)
197	{	197	{
198	phaser_t phaser = (phaser_t) effp->priv;	198	phaser_t phaser = (phaser_t) effp->priv;
@@ -227,7 +227,7 @@ int st_phaser_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf, · 28 unmodified lines
227	/*	227	/*
228	* Drain out reverb lines.	228	* Drain out reverb lines.
229	*/	229	*/
230	int st_phaser_drain(eff_t effp, st_sample_t obuf, st_size_t osamp)	230	static int st_phaser_drain(eff_t effp, st_sample_t obuf, st_size_t osamp)
231	{	231	{
232	phaser_t phaser = (phaser_t) effp->priv;	232	phaser_t phaser = (phaser_t) effp->priv;
233	st_size_t done;	233	st_size_t done;
@@ -266,7 +266,7 @@ int st_phaser_drain(eff_t effp, st_sample_t obuf, st_size_t osamp) · 32 unmodified lines
266	/*	266	/*
267	* Clean up phaser effect.	267	* Clean up phaser effect.
268	*/	268	*/
269	int st_phaser_stop(eff_t effp)	269	static int st_phaser_stop(eff_t effp)
270	{	270	{
271	phaser_t phaser = (phaser_t) effp->priv;	271	phaser_t phaser = (phaser_t) effp->priv;
272		272

src/pitch.c+5−5

@@ -246,7 +246,7 @@ static void process_intput_buffer(pitch_t pitch) · 245 unmodified lines
246	/*	246	/*
247	* Process options	247	* Process options
248	*/	248	*/
249	int st_pitch_getopts(eff_t effp, int n, char **argv)	249	static int st_pitch_getopts(eff_t effp, int n, char **argv)
250	{	250	{
251	pitch_t pitch = (pitch_t) effp->priv;	251	pitch_t pitch = (pitch_t) effp->priv;
252		252
@@ -329,7 +329,7 @@ int st_pitch_getopts(eff_t effp, int n, char **argv) · 76 unmodified lines
329	/*	329	/*
330	* Start processing	330	* Start processing
331	*/	331	*/
332	int st_pitch_start(eff_t effp)	332	static int st_pitch_start(eff_t effp)
333	{	333	{
334	pitch_t pitch = (pitch_t) effp->priv;	334	pitch_t pitch = (pitch_t) effp->priv;
335	register int sample_rate = effp->outinfo.rate;	335	register int sample_rate = effp->outinfo.rate;
@@ -445,7 +445,7 @@ int st_pitch_start(eff_t effp) · 109 unmodified lines
445		445
446	/* Processes input.	446	/* Processes input.
447	*/	447	*/
448	int st_pitch_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf,	448	static int st_pitch_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf,
449	st_size_t isamp, st_size_t osamp)	449	st_size_t isamp, st_size_t osamp)
450	{	450	{
451	pitch_t pitch = (pitch_t) effp->priv;	451	pitch_t pitch = (pitch_t) effp->priv;
@@ -522,7 +522,7 @@ int st_pitch_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf, · 70 unmodified lines
522		522
523	/* at the end...	523	/* at the end...
524	*/	524	*/
525	int st_pitch_drain(eff_t effp, st_sample_t obuf, st_size_t osamp)	525	static int st_pitch_drain(eff_t effp, st_sample_t obuf, st_size_t osamp)
526	{	526	{
527	pitch_t pitch = (pitch_t) effp->priv;	527	pitch_t pitch = (pitch_t) effp->priv;
528	st_size_t i;	528	st_size_t i;
@@ -566,7 +566,7 @@ int st_pitch_drain(eff_t effp, st_sample_t obuf, st_size_t osamp) · 37 unmodified lines
566	* Do anything required when you stop reading samples.	566	* Do anything required when you stop reading samples.
567	* Don't close input file!	567	* Don't close input file!
568	*/	568	*/
569	int st_pitch_stop(eff_t effp)	569	static int st_pitch_stop(eff_t effp)
570	{	570	{
571	pitch_t pitch = (pitch_t) effp->priv;	571	pitch_t pitch = (pitch_t) effp->priv;
572		572

src/polyphas.c+13−13

@@ -80,7 +80,7 @@ static int win_type = 0; · 79 unmodified lines
80	static int win_width = 1024;	80	static int win_width = 1024;
81	static Float cutoff = 0.95;	81	static Float cutoff = 0.95;
82		82
83	int st_poly_getopts(eff_t effp, int n, char **argv)	83	static int st_poly_getopts(eff_t effp UNUSED, int n, char **argv)
84	{	84	{
85	/* 0: nuttall	85	/* 0: nuttall
86	1: hamming */	86	1: hamming */
@@ -179,9 +179,9 @@ static int prime(int n, int *q0) · 92 unmodified lines
179	return (q-q0);	179	return (q-q0);
180	}	180	}
181		181
182	static int permute(int m, int l, int ct, int ct1, int amalg)	182	static int permute(int m, int l, int ct, int ct1, size_t amalg)
183	{	183	{
184	int k, n;	184	size_t k, n;
185	int *p;	185	int *p;
186	int *q;	186	int *q;
187		187
@@ -221,7 +221,7 @@ static int permute(int m, int l, int ct, int ct1, int amalg) · 33 unmodified lines
221	static int optimize_factors(int numer, int denom, int l1, int l2)	221	static int optimize_factors(int numer, int denom, int l1, int l2)
222	{	222	{
223	int f_min,c_min,u_min,ct1,ct2;	223	int f_min,c_min,u_min,ct1,ct2;
224	int amalg;	224	size_t amalg;
225	int k;	225	int k;
226	static int m1[MF],m2[MF];	226	static int m1[MF],m2[MF];
227	static int b1[MF],b2[MF];	227	static int b1[MF],b2[MF];
@@ -239,7 +239,7 @@ static int optimize_factors(int numer, int denom, int l1, int l2) · 11 unmodified lines
239	ct1 = prime(numer,l1);	239	ct1 = prime(numer,l1);
240	ct2 = prime(denom,l2);	240	ct2 = prime(denom,l2);
241		241
242	for (amalg = max(9,l2[0]); amalg<= 9+l2[ct2-1]; amalg++) {	242	for (amalg = max(9,l2[0]); amalg <= (size_t)(9+l2[ct2-1]); amalg++) {
243	for (k = 0; k<100000; k++) {	243	for (k = 0; k<100000; k++) {
244	int u,u1,u2,j,f,cost;	244	int u,u1,u2,j,f,cost;
245	cost = 0;	245	cost = 0;
@@ -369,7 +369,7 @@ static void fir_design(Float *buffer, int length, Float cutoff) · 123 unmodified lines
369		369
370	#define RIBLEN 2048	370	#define RIBLEN 2048
371		371
372	int st_poly_start(eff_t effp)	372	static int st_poly_start(eff_t effp)
373	{	373	{
374	poly_t rate = (poly_t) effp->priv;	374	poly_t rate = (poly_t) effp->priv;
375	static int l1[MF], l2[MF];	375	static int l1[MF], l2[MF];
@@ -523,7 +523,7 @@ static void update_hist(Float *hist, int hist_size, int in_size) · 147 unmodified lines
523		523
524	}	524	}
525		525
526	int st_poly_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf,	526	static int st_poly_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf,
527	st_size_t isamp, st_size_t osamp)	527	st_size_t isamp, st_size_t osamp)
528	{	528	{
529	poly_t rate = (poly_t) effp->priv;	529	poly_t rate = (poly_t) effp->priv;
@@ -534,7 +534,7 @@ int st_poly_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf, · 4 unmodified lines
534	s0 = rate->stage[0]; /* the first stage */	534	s0 = rate->stage[0]; /* the first stage */
535	s1 = rate->stage[rate->total]; /* the 'last' stage is output buffer */	535	s1 = rate->stage[rate->total]; /* the 'last' stage is output buffer */
536	{	536	{
537	int in_size, gap, k;	537	st_size_t in_size, gap, k;
538		538
539	in_size = *isamp;	539	in_size = *isamp;
540	gap = s0->size - s0->held; /* space available in this 'input' buffer */	540	gap = s0->size - s0->held; /* space available in this 'input' buffer */
@@ -558,7 +558,7 @@ int st_poly_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf, · 17 unmodified lines
558	}	558	}
559		559
560	if (s0->held == s0->size && s1->held == 0) {	560	if (s0->held == s0->size && s1->held == 0) {
561	int k;	561	st_size_t k;
562	/* input buffer full, output buffer empty, so do process */	562	/* input buffer full, output buffer empty, so do process */
563		563
564	for(k=0; k<rate->total; k++) {	564	for(k=0; k<rate->total; k++) {
@@ -587,7 +587,7 @@ int st_poly_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf, · 22 unmodified lines
587	st_size_t out_size;	587	st_size_t out_size;
588	st_size_t oskip;	588	st_size_t oskip;
589	Float *out_buf;	589	Float *out_buf;
590	int k;	590	st_size_t k;
591		591
592	oskip = rate->oskip;	592	oskip = rate->oskip;
593	out_size = s1->held;	593	out_size = s1->held;
@@ -626,7 +626,7 @@ int st_poly_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf, · 32 unmodified lines
626	/*	626	/*
627	* Process tail of input samples.	627	* Process tail of input samples.
628	*/	628	*/
629	int st_poly_drain(eff_t effp, st_sample_t obuf, st_size_t osamp)	629	static int st_poly_drain(eff_t effp, st_sample_t obuf, st_size_t osamp)
630	{	630	{
631	st_size_t in_size;	631	st_size_t in_size;
632	/* Call "flow" with NULL input. */	632	/* Call "flow" with NULL input. */
@@ -638,11 +638,11 @@ int st_poly_drain(eff_t effp, st_sample_t obuf, st_size_t osamp) · 5 unmodified lines
638	* Do anything required when you stop reading samples.	638	* Do anything required when you stop reading samples.
639	* Don't close input file!	639	* Don't close input file!
640	*/	640	*/
641	int st_poly_stop(eff_t effp)	641	static int st_poly_stop(eff_t effp)
642	{	642	{
643	poly_t rate = (poly_t) effp->priv;	643	poly_t rate = (poly_t) effp->priv;
644	polystage *s;	644	polystage *s;
645	int k;	645	st_size_t k;
646		646
647	for(k = 0; k <= rate->total; k++) {	647	for(k = 0; k <= rate->total; k++) {
648	s = rate->stage[k];	648	s = rate->stage[k];

src/prc.c+10−15

 /* 16 bytes header = 3 UIDs plus checksum, standard Symbian/EPOC file
    header */
 static const char prc_header[]={
-  0x37,0x00,0x00,0x10,0x6d,0x00,0x00,0x10,
+  '\x37','\x00','\x00','\x10','\x6d','\x00','\x00','\x10',
-  0x7e,0x00,0x00,0x10,0xcf,0xac,0x08,0x55
+  '\x7e','\x00','\x00','\x10','\xcf','\xac','\x08','\x55'
 };
 int prc_checkheader(ft_t ft, char *head)
 static void prcwriteheader(ft_t ft);
-int st_prcseek(ft_t ft, st_size_t offset)
+static int st_prcseek(ft_t ft, st_size_t offset)
 {
     prc_t prc = (prc_t ) ft->priv;
     st_size_t new_offset, channel_block, alignment;
     return st_seeki(ft, new_offset, SEEK_SET);
 }
-int st_prcstartread(ft_t ft)
+static int st_prcstartread(ft_t ft)
 {
         prc_t p = (prc_t ) ft->priv;
         char head[sizeof(prc_header)];
             st_report("PRC must use 8000 sample rate.  Overriding");
         ft->info.rate = 8000;
-        if (ft->info.channels != -1 && ft->info.channels != 1)
+        if (ft->info.channels != ST_ENCODING_UNKNOWN && ft->info.channels != 0)
             st_report("PRC must only supports 1 channel.  Overriding");
         ft->info.channels = 1;
    if it is not, the unspecified size remains in the header
    (this is illegal). */
-int st_prcstartwrite(ft_t ft)
+static int st_prcstartwrite(ft_t ft)
 {
         prc_t p = (prc_t ) ft->priv;
         int rc;
         if (ft->info.rate != 0)
             st_report("PRC must use 8000 sample rate.  Overriding");
-        if (ft->info.channels != -1 && ft->info.channels != 1)
+        if (ft->info.channels != ST_ENCODING_UNKNOWN && ft->info.channels != 0)
             st_report("PRC must only supports 1 channel.  Overriding");
         ft->info.encoding = ST_ENCODING_ALAW;
         return ST_SUCCESS;
 }
-st_ssize_t st_prcread(ft_t ft, st_sample_t *buf, st_size_t samp)
+static st_size_t st_prcwrite(ft_t ft, const st_sample_t *buf, st_size_t samp)
-{
-        return st_rawread(ft, buf, samp);
-}
-st_ssize_t st_prcwrite(ft_t ft, const st_sample_t *buf, st_size_t samp)
 {
         prc_t p = (prc_t ) ft->priv;
         p->length += samp * ft->info.size;
         return st_rawwrite(ft, buf, samp);
 }
-int st_prcstopwrite(ft_t ft)
+static int st_prcstopwrite(ft_t ft)
 {
         /* Call before seeking to flush buffer */
         st_rawstopwrite(ft);
   NULL,
   ST_FILE_SEEK,
   st_prcstartread,
-  st_prcread,
+  st_rawread,
   st_rawstopread,
   st_prcstartwrite,
   st_prcwrite,

src/raw.c+36−42

     return ST_SUCCESS;
 }
-void st_ub_read_buf(st_sample_t *buf1, char const * buf2, st_size_t len, char swap, st_size_t * clippedCount)
+void st_ub_read_buf(st_sample_t *buf1, char const * buf2, st_size_t len, char swap UNUSED, st_size_t * clippedCount UNUSED)
 {
     while (len)
     {
     }
 }
-void st_sb_read_buf(st_sample_t *buf1, char const * buf2, st_size_t len, char swap, st_size_t * clippedCount)
+void st_sb_read_buf(st_sample_t *buf1, char const * buf2, st_size_t len, char swap UNUSED, st_size_t * clippedCount UNUSED)
 {
     while (len)
     {
     }
 }
-void st_ulaw_read_buf(st_sample_t *buf1, char const * buf2, st_size_t len, char swap, st_size_t * clippedCount)
+static void st_ulaw_read_buf(st_sample_t *buf1, char const * buf2, st_size_t len, char swap UNUSED, st_size_t * clippedCount UNUSED)
 {
     while (len)
     {
     }
 }
-void st_alaw_read_buf(st_sample_t *buf1, char const * buf2, st_size_t len, char swap, st_size_t * clippedCount)
+static void st_alaw_read_buf(st_sample_t *buf1, char const * buf2, st_size_t len, char swap UNUSED, st_size_t * clippedCount UNUSED)
 {
     while (len)
     {
     }
 }
-void st_inv_ulaw_read_buf(st_sample_t *buf1, char const * buf2, st_size_t len, char swap, st_size_t * clippedCount)
+static void st_inv_ulaw_read_buf(st_sample_t *buf1, char const * buf2, st_size_t len, char swap UNUSED, st_size_t * clippedCount UNUSED)
 {
     while (len)
     {
     }
 }
-void st_inv_alaw_read_buf(st_sample_t *buf1, char const * buf2, st_size_t len, char swap, st_size_t * clippedCount)
+static void st_inv_alaw_read_buf(st_sample_t *buf1, char const * buf2, st_size_t len, char swap UNUSED, st_size_t * clippedCount UNUSED)
 {
     while (len)
     {
 }
-void st_uw_read_buf(st_sample_t *buf1, char const * buf2, st_size_t len, char swap, st_size_t * clippedCount)
+void st_uw_read_buf(st_sample_t *buf1, char const * buf2, st_size_t len, char swap, st_size_t * clippedCount UNUSED)
 {
     while (len)
     {
     }
 }
-void st_sw_read_buf(st_sample_t *buf1, char const * buf2, st_size_t len, char swap, st_size_t * clippedCount)
+void st_sw_read_buf(st_sample_t *buf1, char const * buf2, st_size_t len, char swap, st_size_t * clippedCount UNUSED)
 {
     while (len)
     {
     datum >>= 8;
   }
-  return swap? st_swap24(datum) : datum;
+  return swap ? (int24_t)(st_swap24(datum)) : datum;
 }
-void st_u24_read_buf(st_sample_t * buf1, char const * buf2, st_size_t len, char const swap, st_size_t * clippedCount)
+static void st_u24_read_buf(st_sample_t * buf1, char const * buf2, st_size_t len, char const swap, st_size_t * clippedCount UNUSED)
 {
   while (len--)
   {
-void st_s24_read_buf(st_sample_t * buf1, char const * buf2, st_size_t len, char const swap, st_size_t * clippedCount)
+static void st_s24_read_buf(st_sample_t * buf1, char const * buf2, st_size_t len, char const swap, st_size_t * clippedCount UNUSED)
 {
   while (len--)
   {
-void st_udw_read_buf(st_sample_t *buf1, char const * buf2, st_size_t len, char swap, st_size_t * clippedCount)
+static void st_udw_read_buf(st_sample_t *buf1, char const * buf2, st_size_t len, char swap, st_size_t * clippedCount UNUSED)
 {
     while (len)
     {
     }
 }
-void st_dw_read_buf(st_sample_t *buf1, char const * buf2, st_size_t len, char swap, st_size_t * clippedCount)
+static void st_dw_read_buf(st_sample_t *buf1, char const * buf2, st_size_t len, char swap, st_size_t * clippedCount UNUSED)
 {
     while (len)
     {
     }
 }
-void st_f32_read_buf(st_sample_t *buf1, char const * buf2, st_size_t len, char swap, st_size_t * clippedCount)
+static void st_f32_read_buf(st_sample_t *buf1, char const * buf2, st_size_t len, char swap, st_size_t * clippedCount)
 {
     while (len)
     {
     }
 }
-void st_f64_read_buf(st_sample_t *buf1, char const * buf2, st_size_t len, char swap, st_size_t * clippedCount)
+static void st_f64_read_buf(st_sample_t *buf1, char const * buf2, st_size_t len, char swap, st_size_t * clippedCount)
 {
     while (len)
     {
  * functions will cause a loss of data!  Need to have sox implement
  * a consistent buffering protocol.
  */
-st_ssize_t st_rawread(ft_t ft, st_sample_t *buf, st_size_t nsamp)
+st_size_t st_rawread(ft_t ft, st_sample_t *buf, st_size_t nsamp)
 {
     st_size_t len, done = 0;
     void (*read_buf)(st_sample_t *, char const *, st_size_t, char, st_size_t *) = 0;
     size_t i;
-    if (nsamp < 0)
-    {
-        st_fail_errno(ft,ST_EINVAL,"st_rawread requires positive sizes");
-        return ST_EOF;
-    }
     switch(ft->info.size) {
         case ST_SIZE_BYTE:
             switch(ft->info.encoding)
         return ST_SUCCESS;
 }
-void st_ub_write_buf(char* buf1, st_sample_t const * buf2, st_size_t len, char swap, st_size_t * clippedCount)
+void st_ub_write_buf(char* buf1, st_sample_t const * buf2, st_size_t len, char swap UNUSED, st_size_t * clippedCount)
 {
     while (len)
     {
     }
 }
-void st_sb_write_buf(char *buf1, st_sample_t const * buf2, st_size_t len, char swap, st_size_t * clippedCount)
+void st_sb_write_buf(char *buf1, st_sample_t const * buf2, st_size_t len, char swap UNUSED, st_size_t * clippedCount)
 {
     while (len)
     {
     }
 }
-void st_ulaw_write_buf(char *buf1, st_sample_t const * buf2, st_size_t len,
+static void st_ulaw_write_buf(char *buf1, st_sample_t const * buf2, st_size_t len,
-                       char swap, st_size_t * clippedCount)
+                       char swap UNUSED, st_size_t * clippedCount)
 {
     while (len)
     {
     }
 }
-void st_alaw_write_buf(char *buf1, st_sample_t const * buf2, st_size_t len,
+static void st_alaw_write_buf(char *buf1, st_sample_t const * buf2, st_size_t len,
-                       char swap, st_size_t * clippedCount)
+                       char swap UNUSED, st_size_t * clippedCount)
 {
     while (len)
     {
     }
 }
-void st_inv_ulaw_write_buf(char *buf1, st_sample_t const * buf2, st_size_t len,
+static void st_inv_ulaw_write_buf(char *buf1, st_sample_t const * buf2, st_size_t len,
-                           char swap, st_size_t * clippedCount)
+                           char swap UNUSED, st_size_t * clippedCount)
 {
     while (len)
     {
     }
 }
-void st_inv_alaw_write_buf(char *buf1, st_sample_t const * buf2, st_size_t len,
+static void st_inv_alaw_write_buf(char *buf1, st_sample_t const * buf2, st_size_t len,
-                           char swap, st_size_t * clippedCount)
+                           char swap UNUSED, st_size_t * clippedCount)
 {
     while (len)
     {
-void st_u24_write_buf(char * buf1, st_sample_t const * buf2, st_size_t len, char const swap, st_size_t * clippedCount)
+static void st_u24_write_buf(char * buf1, st_sample_t const * buf2, st_size_t len, char const swap, st_size_t * clippedCount)
 {
   while (len--)
   {
-void st_s24_write_buf(char * buf1, st_sample_t const * buf2, st_size_t len, char const swap, st_size_t * clippedCount)
+static void st_s24_write_buf(char * buf1, st_sample_t const * buf2, st_size_t len, char const swap, st_size_t * clippedCount)
 {
   while (len--)
   {
-void st_udw_write_buf(char *buf1, st_sample_t const * buf2, st_size_t len, char swap, st_size_t * clippedCount)
+static void st_udw_write_buf(char *buf1, st_sample_t const * buf2, st_size_t len, char swap, st_size_t * clippedCount UNUSED)
 {
     while (len)
     {
     }
 }
-void st_dw_write_buf(char *buf1, st_sample_t const * buf2, st_size_t len, char swap, st_size_t * clippedCount)
+static void st_dw_write_buf(char *buf1, st_sample_t const * buf2, st_size_t len, char swap UNUSED, st_size_t * clippedCount UNUSED)
 {
     while (len)
     {
     }
 }
-void st_f32_write_buf(char *buf1, st_sample_t const * buf2, st_size_t len, char swap, st_size_t * clippedCount)
+static void st_f32_write_buf(char *buf1, st_sample_t const * buf2, st_size_t len, char swap, st_size_t * clippedCount)
 {
     while (len)
     {
     }
 }
-void st_f64_write_buf(char *buf1, st_sample_t const * buf2, st_size_t len, char swap, st_size_t * clippedCount)
+static void st_f64_write_buf(char *buf1, st_sample_t const * buf2, st_size_t len, char swap, st_size_t * clippedCount)
 {
     while (len)
     {
  * functions will cause a loss of data!  Need to have sox implement
  * a consistent buffering protocol.
  */
-st_ssize_t st_rawwrite(ft_t ft, const st_sample_t *buf, st_size_t nsamp)
+st_size_t st_rawwrite(ft_t ft, const st_sample_t *buf, st_size_t nsamp)
 {
     st_size_t len, done = 0;
     void (*write_buf)(char *, st_sample_t const *, st_size_t, char, st_size_t *) = 0;
 */
 #define STARTREAD(NAME,SIZE,STYLE) \
-int NAME(ft_t ft) \
+static int NAME(ft_t ft) \
 { \
         ft->info.size = SIZE; \
         ft->info.encoding = STYLE; \
 }
 #define STARTWRITE(NAME,SIZE,STYLE)\
-int NAME(ft_t ft) \
+static int NAME(ft_t ft) \
 { \
         ft->info.size = SIZE; \
         ft->info.encoding = STYLE; \
 {
         if (ft->info.rate == 0)
                 ft->info.rate = 8000;
-        if (ft->info.channels == -1)
+        if (ft->info.channels == 0)
                 ft->info.channels = 1;
 }

src/repeat.c+5−5

@@ -33,7 +33,7 @@ typedef struct repeatstuff { · 32 unmodified lines
33	int repeats;	33	int repeats;
34	} *repeat_t;	34	} *repeat_t;
35		35
36	int st_repeat_getopts(eff_t effp, int n, char **argv)	36	static int st_repeat_getopts(eff_t effp, int n, char **argv)
37	{	37	{
38	repeat_t repeat = (repeat_t)effp->priv;	38	repeat_t repeat = (repeat_t)effp->priv;
39		39
@@ -55,7 +55,7 @@ int st_repeat_getopts(eff_t effp, int n, char **argv) · 15 unmodified lines
55	return (ST_SUCCESS);	55	return (ST_SUCCESS);
56	}	56	}
57		57
58	int st_repeat_start(eff_t effp)	58	static int st_repeat_start(eff_t effp)
59	{	59	{
60	repeat_t repeat = (repeat_t)effp->priv;	60	repeat_t repeat = (repeat_t)effp->priv;
61		61
@@ -69,7 +69,7 @@ int st_repeat_start(eff_t effp) · 7 unmodified lines
69	return (ST_SUCCESS);	69	return (ST_SUCCESS);
70	}	70	}
71		71
72	int st_repeat_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf,	72	static int st_repeat_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf UNUSED,
73	st_size_t isamp, st_size_t osamp)	73	st_size_t isamp, st_size_t osamp)
74	{	74	{
75	repeat_t repeat = (repeat_t)effp->priv;	75	repeat_t repeat = (repeat_t)effp->priv;
@@ -85,7 +85,7 @@ int st_repeat_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf, · 9 unmodified lines
85	return (ST_SUCCESS);	85	return (ST_SUCCESS);
86	}	86	}
87		87
88	int st_repeat_drain(eff_t effp, st_sample_t obuf, st_size_t osamp)	88	static int st_repeat_drain(eff_t effp, st_sample_t obuf, st_size_t osamp)
89	{	89	{
90	size_t read = 0;	90	size_t read = 0;
91	st_sample_t *buf;	91	st_sample_t *buf;
@@ -187,7 +187,7 @@ int st_repeat_drain(eff_t effp, st_sample_t obuf, st_size_t osamp) · 95 unmodified lines
187	return ST_SUCCESS;	187	return ST_SUCCESS;
188	}	188	}
189		189
190	int st_repeat_stop(eff_t effp)	190	static int st_repeat_stop(eff_t effp)
191	{	191	{
192	repeat_t repeat = (repeat_t)effp->priv;	192	repeat_t repeat = (repeat_t)effp->priv;
193		193

src/resample.c+1−2

 /*
  * Process options
  */
 int st_resample_getopts(eff_t effp, int n, char **argv)
 {
         resample_t r = (resample_t) effp->priv;
         r->Xp = r->Xoff;
         for(i=0; i < Nout; i++) {
-                // orig: *obuf++ = r->Y[i] * ISCALE;
                 double ftemp = r->Y[i] * ISCALE;
                 ST_SAMPLE_CLIP_COUNT(ftemp, effp->clippedCount);

src/reverb.c+11−11

@@ -104,18 +104,18 @@ static st_effect_t st_reverb_effect; · 103 unmodified lines
104	/* Private data for SKEL file */	104	/* Private data for SKEL file */
105	typedef struct reverbstuff {	105	typedef struct reverbstuff {
106	int counter;	106	int counter;
107	int numdelays;	107	size_t numdelays;
108	float *reverbbuf;	108	float *reverbbuf;
109	float in_gain, out_gain, time;	109	float in_gain, out_gain, time;
110	float delay[MAXREVERBS], decay[MAXREVERBS];	110	float delay[MAXREVERBS], decay[MAXREVERBS];
111	long samples[MAXREVERBS], maxsamples;	111	size_t samples[MAXREVERBS], maxsamples;
112	st_sample_t pl, ppl, pppl;	112	st_sample_t pl, ppl, pppl;
113	} *reverb_t;	113	} *reverb_t;
114		114
115	/*	115	/*
116	* Process options	116	* Process options
117	*/	117	*/
118	int st_reverb_getopts(eff_t effp, int n, char **argv)	118	static int st_reverb_getopts(eff_t effp, int n, char **argv)
119	{	119	{
120	reverb_t reverb = (reverb_t) effp->priv;	120	reverb_t reverb = (reverb_t) effp->priv;
121	int i;	121	int i;
@@ -150,10 +150,10 @@ int st_reverb_getopts(eff_t effp, int n, char **argv) · 28 unmodified lines
150	/*	150	/*
151	* Prepare for processing.	151	* Prepare for processing.
152	*/	152	*/
153	int st_reverb_start(eff_t effp)	153	static int st_reverb_start(eff_t effp)
154	{	154	{
155	reverb_t reverb = (reverb_t) effp->priv;	155	reverb_t reverb = (reverb_t) effp->priv;
156	int i;	156	size_t i;
157		157
158	reverb->in_gain = 1.0;	158	reverb->in_gain = 1.0;
159		159
@@ -208,12 +208,12 @@ int st_reverb_start(eff_t effp) · 48 unmodified lines
208	* Processed signed long samples from ibuf to obuf.	208	* Processed signed long samples from ibuf to obuf.
209	* Return number of samples processed.	209	* Return number of samples processed.
210	*/	210	*/
211	int st_reverb_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf,	211	static int st_reverb_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf,
212	st_size_t isamp, st_size_t osamp)	212	st_size_t isamp, st_size_t osamp)
213	{	213	{
214	reverb_t reverb = (reverb_t) effp->priv;	214	reverb_t reverb = (reverb_t) effp->priv;
215	int len, done;	215	size_t len, done;
216	int i, j;	216	size_t i, j;
217		217
218	float d_in, d_out;	218	float d_in, d_out;
219	st_sample_t out;	219	st_sample_t out;
@@ -243,12 +243,12 @@ reverb->reverbbuf[(i + reverb->maxsamples - reverb->samples[j]) % reverb->maxsam · 23 unmodified lines
243	/*	243	/*
244	* Drain out reverb lines.	244	* Drain out reverb lines.
245	*/	245	*/
246	int st_reverb_drain(eff_t effp, st_sample_t obuf, st_size_t osamp)	246	static int st_reverb_drain(eff_t effp, st_sample_t obuf, st_size_t osamp)
247	{	247	{
248	reverb_t reverb = (reverb_t) effp->priv;	248	reverb_t reverb = (reverb_t) effp->priv;
249	float d_in, d_out;	249	float d_in, d_out;
250	st_sample_t out, l;	250	st_sample_t out, l;
251	int i, j;	251	size_t i, j;
252	st_size_t done;	252	st_size_t done;
253		253
254	i = reverb->counter;	254	i = reverb->counter;
@@ -280,7 +280,7 @@ reverb->reverbbuf[(i + reverb->maxsamples - reverb->samples[j]) % reverb->maxsam · 25 unmodified lines
280	/*	280	/*
281	* Clean up reverb effect.	281	* Clean up reverb effect.
282	*/	282	*/
283	int st_reverb_stop(eff_t effp)	283	static int st_reverb_stop(eff_t effp)
284	{	284	{
285	reverb_t reverb = (reverb_t) effp->priv;	285	reverb_t reverb = (reverb_t) effp->priv;
286		286

src/reverse.c+5−19

 #define WRITING 0
 #define READING 1
-/*
- * Process options: none in our case.
- */
-int st_reverse_getopts(eff_t effp, int n, char **argv)
-{
-        if (n)
-        {
-                st_fail(st_reverse_effect.usage);
-                return (ST_EOF);
-        }
-        return(ST_SUCCESS);
-}
 /*
  * Prepare processing: open temporary file.
  */
-int st_reverse_start(eff_t effp)
+static int st_reverse_start(eff_t effp)
 {
         reverse_t reverse = (reverse_t) effp->priv;
         reverse->fp = tmpfile();
  * Effect flow: a degenerate case: write input samples on temporary file,
  * don't generate any output samples.
  */
-int st_reverse_flow(eff_t effp, const st_sample_t *ibuf, st_sample_t *obuf,
+static int st_reverse_flow(eff_t effp, const st_sample_t *ibuf, st_sample_t *obuf UNUSED,
                     st_size_t *isamp, st_size_t *osamp)
 {
         reverse_t reverse = (reverse_t) effp->priv;
  * Effect drain: generate the actual samples in reverse order.
  */
-int st_reverse_drain(eff_t effp, st_sample_t *obuf, st_size_t *osamp)
+static int st_reverse_drain(eff_t effp, st_sample_t *obuf, st_size_t *osamp)
 {
         reverse_t reverse = (reverse_t) effp->priv;
         st_size_t len, nbytes;
 /*
  * Close and unlink the temporary file.
  */
-int st_reverse_stop(eff_t effp)
+static int st_reverse_stop(eff_t effp)
 {
         reverse_t reverse = (reverse_t) effp->priv;
   "reverse",
   "Usage: Reverse effect takes no options",
   0,
-  st_reverse_getopts,
+  st_effect_nothing_getopts,
   st_reverse_start,
   st_reverse_flow,
   st_reverse_drain,

src/sf.c+4−4

@@ -64,7 +64,7 @@ static void readcodes(ft_t ft, SFHEADER *sfhead) · 63 unmodified lines
64	ft->comment = commentbuf;	64	ft->comment = commentbuf;
65	}	65	}
66		66
67	int st_sfseek(ft_t ft, st_size_t offset)	67	static int st_sfseek(ft_t ft, st_size_t offset)
68	{	68	{
69	st_size_t new_offset, channel_block, alignment;	69	st_size_t new_offset, channel_block, alignment;
70		70
@@ -91,7 +91,7 @@ int st_sfseek(ft_t ft, st_size_t offset) · 20 unmodified lines
91	* size and encoding of samples,	91	* size and encoding of samples,
92	* mono/stereo/quad.	92	* mono/stereo/quad.
93	*/	93	*/
94	int st_sfstartread(ft_t ft)	94	static int st_sfstartread(ft_t ft)
95	{	95	{
96	sf_t sf = (sf_t) ft->priv;	96	sf_t sf = (sf_t) ft->priv;
97	SFHEADER sfhead;	97	SFHEADER sfhead;
@@ -139,7 +139,7 @@ int st_sfstartread(ft_t ft) · 41 unmodified lines
139	}	139	}
140	ft->info.channels = (int) sf->info.sf_chans;	140	ft->info.channels = (int) sf->info.sf_chans;
141		141
142	if (ft->info.channels == -1)	142	if (ft->info.channels == 0)
143	ft->info.channels = 1;	143	ft->info.channels = 1;
144		144
145	/* Read codes and print as comments. */	145	/* Read codes and print as comments. */
@@ -159,7 +159,7 @@ int st_sfstartread(ft_t ft) · 13 unmodified lines
159	return(rc);	159	return(rc);
160	}	160	}
161		161
162	int st_sfstartwrite(ft_t ft)	162	static int st_sfstartwrite(ft_t ft)
163	{	163	{
164	sf_t sf = (sf_t) ft->priv;	164	sf_t sf = (sf_t) ft->priv;
165	SFHEADER sfhead;	165	SFHEADER sfhead;

src/silence.c+8−8

@@ -78,7 +78,7 @@ static void clear_rms(eff_t effp) · 77 unmodified lines
78	silence->rms_sum = 0;	78	silence->rms_sum = 0;
79	}	79	}
80		80
81	int st_silence_getopts(eff_t effp, int n, char **argv)	81	static int st_silence_getopts(eff_t effp, int n, char **argv)
82	{	82	{
83	silence_t silence = (silence_t) effp->priv;	83	silence_t silence = (silence_t) effp->priv;
84	int parse_count;	84	int parse_count;
@@ -250,7 +250,7 @@ int st_silence_getopts(eff_t effp, int n, char **argv) · 165 unmodified lines
250	return(ST_SUCCESS);	250	return(ST_SUCCESS);
251	}	251	}
252		252
253	int st_silence_start(eff_t effp)	253	static int st_silence_start(eff_t effp)
254	{	254	{
255	silence_t silence = (silence_t) effp->priv;	255	silence_t silence = (silence_t) effp->priv;
256		256
@@ -321,7 +321,7 @@ int st_silence_start(eff_t effp) · 64 unmodified lines
321	return(ST_SUCCESS);	321	return(ST_SUCCESS);
322	}	322	}
323		323
324	int aboveThreshold(eff_t effp, st_sample_t value, double threshold, char unit)	324	static int aboveThreshold(eff_t effp, st_sample_t value, double threshold, char unit)
325	{	325	{
326	double ratio;	326	double ratio;
327	int rc;	327	int rc;
@@ -390,12 +390,12 @@ static void update_rms(eff_t effp, st_sample_t sample) · 62 unmodified lines
390		390
391	/* Process signed long samples from ibuf to obuf. */	391	/* Process signed long samples from ibuf to obuf. */
392	/* Return number of samples processed in isamp and osamp. */	392	/* Return number of samples processed in isamp and osamp. */
393	int st_silence_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf,	393	static int st_silence_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf,
394	st_size_t isamp, st_size_t osamp)	394	st_size_t isamp, st_size_t osamp)
395	{	395	{
396	silence_t silence = (silence_t) effp->priv;	396	silence_t silence = (silence_t) effp->priv;
397	int threshold, j;	397	int threshold;
398	st_size_t i;	398	st_size_t i, j;
399	st_size_t nrOfTicks, nrOfInSamplesRead, nrOfOutSamplesWritten;	399	st_size_t nrOfTicks, nrOfInSamplesRead, nrOfOutSamplesWritten;
400		400
401	nrOfInSamplesRead = 0;	401	nrOfInSamplesRead = 0;
@@ -640,7 +640,7 @@ silence_copy_flush: · 238 unmodified lines
640	return (ST_SUCCESS);	640	return (ST_SUCCESS);
641	}	641	}
642		642
643	int st_silence_drain(eff_t effp, st_sample_t obuf, st_size_t osamp)	643	static int st_silence_drain(eff_t effp, st_sample_t obuf, st_size_t osamp)
644	{	644	{
645	silence_t silence = (silence_t) effp->priv;	645	silence_t silence = (silence_t) effp->priv;
646	st_size_t i;	646	st_size_t i;
@@ -676,7 +676,7 @@ int st_silence_drain(eff_t effp, st_sample_t obuf, st_size_t osamp) · 29 unmodified lines
676	return ST_SUCCESS;	676	return ST_SUCCESS;
677	}	677	}
678		678
679	int st_silence_stop(eff_t effp)	679	static int st_silence_stop(eff_t effp)
680	{	680	{
681	silence_t silence = (silence_t) effp->priv;	681	silence_t silence = (silence_t) effp->priv;
682		682

src/smp.c+10−19

         return(ST_SUCCESS);
 }
-int st_smpseek(ft_t ft, st_size_t offset)
+static int st_smpseek(ft_t ft, st_size_t offset)
 {
     int new_offset, channel_block, alignment;
     smp_t smp = (smp_t) ft->priv;
  *      size and encoding of samples,
  *      mono/stereo/quad.
  */
-int st_smpstartread(ft_t ft)
+static int st_smpstartread(ft_t ft)
 {
         smp_t smp = (smp_t) ft->priv;
         int i;
  * Place in buf[].
  * Return number of samples read.
  */
-st_ssize_t st_smpread(ft_t ft, st_sample_t *buf, st_size_t len)
+static st_size_t st_smpread(ft_t ft, st_sample_t *buf, st_size_t len)
 {
         smp_t smp = (smp_t) ft->priv;
         unsigned short datum;
-        int done = 0;
+        st_size_t done = 0;
         for(; done < len && smp->NoOfSamps; done++, smp->NoOfSamps--) {
                 st_readw(ft, &datum);
         return done;
 }
-/*
+static int st_smpstartwrite(ft_t ft)
- * Do anything required when you stop reading samples.
- * Don't close input file!
- */
-int st_smpstopread(ft_t ft)
-{
-    return(ST_SUCCESS);
-}
-int st_smpstartwrite(ft_t ft)
 {
         smp_t smp = (smp_t) ft->priv;
         struct smpheader header;
         return(ST_SUCCESS);
 }
-st_ssize_t st_smpwrite(ft_t ft, const st_sample_t *buf, st_size_t len)
+static st_size_t st_smpwrite(ft_t ft, const st_sample_t *buf, st_size_t len)
 {
         smp_t smp = (smp_t) ft->priv;
-        register int datum;
+        int datum;
-        st_ssize_t done = 0;
+        st_size_t done = 0;
         while(done < len) {
                 datum = (int) ST_SAMPLE_TO_SIGNED_WORD(*buf++, ft->clippedCount);
         return(done);
 }
-int st_smpstopwrite(ft_t ft)
+static int st_smpstopwrite(ft_t ft)
 {
         smp_t smp = (smp_t) ft->priv;
         struct smptrailer trailer;
   ST_FILE_STEREO | ST_FILE_LOOPS | ST_FILE_SEEK,
   st_smpstartread,
   st_smpread,
-  st_smpstopread,
+  st_format_nothing,
   st_smpstartwrite,
   st_smpwrite,
   st_smpstopwrite,

src/sndrtool.c+31−84

         st_size_t dataStart;
 } *snd_t;
-static void  sndtwriteheader(ft_t ft, st_size_t nsamples);
+static void sndtwriteheader(ft_t ft, st_size_t nsamples)
+{
+    char name_buf[97];
-int st_sndseek(ft_t ft, st_size_t offset)
+    /* sndtool header */
+    st_writes(ft, "SOUND"); /* magic */
+    st_writeb(ft, 0x1a);
+    st_writew (ft,0);  /* hGSound */
+    st_writedw (ft,nsamples);
+    st_writedw (ft,0);
+    st_writedw (ft,nsamples);
+    st_writew (ft,(int) ft->info.rate);
+    st_writew (ft,0);
+    st_writew (ft,10);
+    st_writew (ft,4);
+    memset (name_buf, 0, 96);
+    sprintf (name_buf,"%.62s - File created by SoX",ft->filename);
+    st_writebuf(ft, name_buf, 1, 96);
+}
+static int st_sndseek(ft_t ft, st_size_t offset)
 {
     st_size_t new_offset, channel_block, alignment;
     snd_t snd = (snd_t ) ft->priv;
     return st_seeki(ft, new_offset, SEEK_SET);
 }
-/*======================================================================*/
-/*                         SNDSTARTREAD                                */
-/*======================================================================*/
-int st_sndtstartread(ft_t ft)
+static int st_sndtstartread(ft_t ft)
 {
         snd_t snd = (snd_t ) ft->priv;
         return (ST_SUCCESS);
 }
-/*======================================================================*/
+static int st_sndtstartwrite(ft_t ft)
-/*                         SNDTSTARTWRITE                               */
-/*======================================================================*/
-int st_sndtstartwrite(ft_t ft)
 {
         snd_t p = (snd_t ) ft->priv;
         int rc;
                 ft->swap = ft->swap ? 0 : 1;
         }
-/* write header */
+        /* write header */
-ft->info.channels = 1;
+        ft->info.channels = 1;
-ft->info.encoding = ST_ENCODING_UNSIGNED;
+        ft->info.encoding = ST_ENCODING_UNSIGNED;
-ft->info.size = ST_SIZE_BYTE;
+        ft->info.size = ST_SIZE_BYTE;
-p->nsamples = 0;
+        p->nsamples = 0;
-sndtwriteheader(ft, 0);
+        sndtwriteheader(ft, 0);
-return(ST_SUCCESS);
-}
-/*======================================================================*/
-/*                         SNDRSTARTWRITE                               */
-/*======================================================================*/
-int st_sndrstartwrite(ft_t ft)
-{
-        int rc;
-        /* Needed for rawread() */
-        rc = st_rawstartread(ft);
-        if (rc)
-            return rc;
-        /* sndr is in little endian format so
-         * swap bytes on big endian machines
-         */
-        if (ST_IS_BIGENDIAN)
-        {
-                ft->swap = ft->swap ? 0 : 1;
-        }
-/* write header */
-ft->info.channels = 1;
-ft->info.encoding = ST_ENCODING_UNSIGNED;
-ft->info.size = ST_SIZE_BYTE;
-/* sounder header */
-st_writew (ft,0); /* sample size code */
-st_writew (ft,(int) ft->info.rate);     /* sample rate */
-st_writew (ft,10);        /* volume */
-st_writew (ft,4); /* shift */
-return(ST_SUCCESS);
+        return(ST_SUCCESS);
 }
-/*======================================================================*/
+static st_size_t st_sndtwrite(ft_t ft, const st_sample_t *buf, st_size_t len)
-/*                         SNDTWRITE                                     */
-/*======================================================================*/
-st_ssize_t st_sndtwrite(ft_t ft, const st_sample_t *buf, st_size_t len)
 {
         snd_t p = (snd_t ) ft->priv;
         p->nsamples += len;
         return st_rawwrite(ft, buf, len);
 }
-/*======================================================================*/
+static int st_sndtstopwrite(ft_t ft)
-/*                         SNDTSTOPWRITE                                */
-/*======================================================================*/
-int st_sndtstopwrite(ft_t ft)
 {
         snd_t p = (snd_t ) ft->priv;
         int rc;
         return(ST_SUCCESS);
 }
-/*======================================================================*/
-/*                         SNDTWRITEHEADER                              */
-/*======================================================================*/
-static void sndtwriteheader(ft_t ft, st_size_t nsamples)
-{
-    char name_buf[97];
-    /* sndtool header */
-    st_writes(ft, "SOUND"); /* magic */
-    st_writeb(ft, 0x1a);
-    st_writew (ft,0);  /* hGSound */
-    st_writedw (ft,nsamples);
-    st_writedw (ft,0);
-    st_writedw (ft,nsamples);
-    st_writew (ft,(int) ft->info.rate);
-    st_writew (ft,0);
-    st_writew (ft,10);
-    st_writew (ft,4);
-    memset (name_buf, 0, 96);
-    sprintf (name_buf,"%.62s - File created by Sound Exchange",ft->filename);
-    st_writebuf(ft, name_buf, 1, 96);
-}
 /* Sndtool Sound File */
 static const char *sndtnames[] = {
   "sndt",

src/sox.c+15−15

@@ -128,8 +128,8 @@ static void sigint(int s); · 127 unmodified lines
128	/* Array's tracking input and output files */	128	/* Array's tracking input and output files */
129	static file_options_t *file_opts[MAX_FILES];	129	static file_options_t *file_opts[MAX_FILES];
130	static ft_t file_desc[MAX_FILES];	130	static ft_t file_desc[MAX_FILES];
131	static int file_count = 0;	131	static size_t file_count = 0;
132	static int input_count = 0;	132	static size_t input_count = 0;
133		133
134	/* We parse effects into a temporary effects table and then place into	134	/* We parse effects into a temporary effects table and then place into
135	* the real effects table. This makes it easier to reorder some effects	135	* the real effects table. This makes it easier to reorder some effects
@@ -179,7 +179,7 @@ static void sox_output_message(int level, st_output_message_t m) · 43 unmodified lines
179	int main(int argc, char **argv)	179	int main(int argc, char **argv)
180	{	180	{
181	file_options_t *fo;	181	file_options_t *fo;
182	int i;	182	size_t i;
183		183
184	myname = argv[0];	184	myname = argv[0];
185		185
@@ -202,8 +202,8 @@ int main(int argc, char **argv) · 16 unmodified lines
202		202
203	fo = (file_options_t *)calloc(sizeof(file_options_t), 1);	203	fo = (file_options_t *)calloc(sizeof(file_options_t), 1);
204	fo->info.size = -1;	204	fo->info.size = -1;
205	fo->info.encoding = -1;	205	fo->info.encoding = ST_ENCODING_UNKNOWN;
206	fo->info.channels = -1;	206	fo->info.channels = 0;
207	fo->info.compression = HUGE_VAL;	207	fo->info.compression = HUGE_VAL;
208	fo->volume = 1.0;	208	fo->volume = 1.0;
209	file_opts[file_count++] = fo;	209	file_opts[file_count++] = fo;
@@ -551,7 +551,7 @@ static int compare_input(ft_t ft1, ft_t ft2) · 341 unmodified lines
551	return ST_SUCCESS;	551	return ST_SUCCESS;
552	}	552	}
553		553
554	void optimize_trim(void)	554	static void optimize_trim(void)
555	{	555	{
556	/* Speed hack. If the "trim" effect is the first effect then	556	/* Speed hack. If the "trim" effect is the first effect then
557	* peak inside its "effect descriptor" and see what the	557	* peak inside its "effect descriptor" and see what the
@@ -585,9 +585,9 @@ void optimize_trim(void) · 27 unmodified lines
585	*/	585	*/
586		586
587	static void process(void) {	587	static void process(void) {
588	int e, f, flowstatus = ST_SUCCESS;	588	int e, flowstatus = ST_SUCCESS;
589	int current_input;	589	size_t current_input;
590	st_size_t s;	590	st_size_t s, f;
591	st_ssize_t ilen[MAX_INPUT_FILES];	591	st_ssize_t ilen[MAX_INPUT_FILES];
592	st_sample_t *ibuf[MAX_INPUT_FILES];	592	st_sample_t *ibuf[MAX_INPUT_FILES];
593		593
@@ -626,9 +626,9 @@ static void process(void) { · 32 unmodified lines
626	options->info.rate = file_desc[0]->info.rate;	626	options->info.rate = file_desc[0]->info.rate;
627	if (options->info.size == -1)	627	if (options->info.size == -1)
628	options->info.size = file_desc[0]->info.size;	628	options->info.size = file_desc[0]->info.size;
629	if (options->info.encoding == -1)	629	if (options->info.encoding == ST_ENCODING_UNKNOWN)
630	options->info.encoding = file_desc[0]->info.encoding;	630	options->info.encoding = file_desc[0]->info.encoding;
631	if (options->info.channels == -1)	631	if (options->info.channels == 0)
632	options->info.channels = file_desc[0]->info.channels;	632	options->info.channels = file_desc[0]->info.channels;
633		633
634	if (options->comment != NULL)	634	if (options->comment != NULL)
@@ -1263,7 +1263,7 @@ static void reserve_effect_buf(void) · 628 unmodified lines
1263	static int flow_effect_out(void)	1263	static int flow_effect_out(void)
1264	{	1264	{
1265	int e, havedata, flowstatus = 0;	1265	int e, havedata, flowstatus = 0;
1266	int len, total;	1266	size_t len, total;
1267		1267
1268	do {	1268	do {
1269	/* run entire chain BACKWARDS: pull, don't push.*/	1269	/* run entire chain BACKWARDS: pull, don't push.*/
@@ -1330,9 +1330,9 @@ static int flow_effect_out(void) · 60 unmodified lines
1330		1330
1331	len = st_write(file_desc[file_count-1],	1331	len = st_write(file_desc[file_count-1],
1332	&efftab[neffects-1].obuf[total],	1332	&efftab[neffects-1].obuf[total],
1333	(st_ssize_t)efftab[neffects-1].olen-total);	1333	efftab[neffects-1].olen-total);
1334		1334
1335	if (len < 0 \|\| file_desc[file_count-1]->file.eof)	1335	if (len != efftab[neffects-1].olen-total \|\| file_desc[file_count-1]->file.eof)
1336	{	1336	{
1337	st_warn("Error writing: %s",	1337	st_warn("Error writing: %s",
1338	file_desc[file_count-1]->st_errstr);	1338	file_desc[file_count-1]->st_errstr);
@@ -1877,7 +1877,7 @@ static void usage_effect(char *effect) · 538 unmodified lines
1877		1877
1878	void cleanup(void)	1878	void cleanup(void)
1879	{	1879	{
1880	int i;	1880	size_t i;
1881	struct stat st;	1881	struct stat st;
1882	char *fn;	1882	char *fn;
1883		1883

src/speed.c+5−5

@@ -76,7 +76,7 @@ static double cub( · 75 unmodified lines
76	}	76	}
77		77
78	/* get options. */	78	/* get options. */
79	int st_speed_getopts(eff_t effp, int n, char **argv)	79	static int st_speed_getopts(eff_t effp, int n, char **argv)
80	{	80	{
81	speed_t speed = (speed_t) effp->priv;	81	speed_t speed = (speed_t) effp->priv;
82	int cent = 0;	82	int cent = 0;
@@ -106,7 +106,7 @@ int st_speed_getopts(eff_t effp, int n, char **argv) · 23 unmodified lines
106	}	106	}
107		107
108	/* start processing. */	108	/* start processing. */
109	int st_speed_start(eff_t effp)	109	static int st_speed_start(eff_t effp)
110	{	110	{
111	speed_t speed = (speed_t) effp->priv;	111	speed_t speed = (speed_t) effp->priv;
112		112
@@ -192,7 +192,7 @@ static st_size_t compute(eff_t effp, speed_t speed, st_sample_t *obuf, st_size_t · 79 unmodified lines
192		192
193	/* handle a flow.	193	/* handle a flow.
194	*/	194	*/
195	int st_speed_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf,	195	static int st_speed_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf,
196	st_size_t isamp, st_size_t osamp)	196	st_size_t isamp, st_size_t osamp)
197	{	197	{
198	speed_t speed;	198	speed_t speed;
@@ -237,7 +237,7 @@ int st_speed_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf, · 38 unmodified lines
237		237
238	/* end of stuff.	238	/* end of stuff.
239	*/	239	*/
240	int st_speed_drain(eff_t effp, st_sample_t obuf, st_size_t osamp)	240	static int st_speed_drain(eff_t effp, st_sample_t obuf, st_size_t osamp)
241	{	241	{
242	speed_t speed = (speed_t) effp->priv;	242	speed_t speed = (speed_t) effp->priv;
243	st_size_t i, oindex;	243	st_size_t i, oindex;
@@ -274,7 +274,7 @@ int st_speed_drain(eff_t effp, st_sample_t obuf, st_size_t osamp) · 30 unmodified lines
274		274
275	/* stop processing. report overflows.	275	/* stop processing. report overflows.
276	*/	276	*/
277	int st_speed_stop(eff_t effp)	277	static int st_speed_stop(eff_t effp)
278	{	278	{
279	speed_t speed = (speed_t) effp->priv;	279	speed_t speed = (speed_t) effp->priv;
280		280

src/sphere.c+9−11

 /*
  * NIST Sphere file format handler.
- */
+ *
-/*
  * August 7, 2000
  *
  * Copyright (C) 2000 Chris Bagwell (cbagwell@sprynet.com)
  *      size and encoding of samples,
  *      mono/stereo/quad.
  */
-int st_spherestartread(ft_t ft)
+static int st_spherestartread(ft_t ft)
 {
         sphere_t sphere = (sphere_t) ft->priv;
         int rc;
                 ft->info.size = i;
             }
             if (strncmp(buf, "channel_count", 13) == 0 &&
-                ft->info.channels == -1)
+                ft->info.channels == 0)
             {
                 sscanf(buf, "%63s %15s %d", fldname, fldtype, &i);
                 ft->info.channels = i;
                 /* Only bother looking for ulaw flag.  All others
                  * should be caught below by default PCM check
                  */
-                if (ft->info.encoding == -1 &&
+                if (ft->info.encoding == ST_ENCODING_UNKNOWN &&
                     strncmp(fldsval,"ulaw",4) == 0)
                 {
                     ft->info.encoding = ST_ENCODING_ULAW;
          * This means encoding is signed if size = word or
          * unsigned if size = byte.
          */
-        if (ft->info.encoding == -1)
+        if (ft->info.encoding == ST_ENCODING_UNKNOWN)
         {
             if (ft->info.size == 1)
                 ft->info.encoding = ST_ENCODING_UNSIGNED;
  * Return number of samples read.
  */
-st_ssize_t st_sphereread(ft_t ft, st_sample_t *buf, st_size_t len)
+static st_size_t st_sphereread(ft_t ft, st_sample_t *buf, st_size_t len)
 {
     sphere_t sphere = (sphere_t) ft->priv;
     return st_rawread(ft, buf, len);
 }
-int st_spherestartwrite(ft_t ft)
+static int st_spherestartwrite(ft_t ft)
 {
     int rc;
     int x;
 }
-st_ssize_t st_spherewrite(ft_t ft, const st_sample_t *buf, st_size_t len)
+static st_size_t st_spherewrite(ft_t ft, const st_sample_t *buf, st_size_t len)
 {
     sphere_t sphere = (sphere_t) ft->priv;
     return st_rawwrite(ft, buf, len);
 }
-int st_spherestopwrite(ft_t ft)
+static int st_spherestopwrite(ft_t ft)
 {
     int rc;
     char buf[128];

src/st.h+13−10

 #  define  __attribute__(x)  /*NOTHING*/
 #endif
+/* Avoid warnings about unused parameters. */
+#define UNUSED __attribute__ ((unused))
 /* C language enhancements: */
 /* Boolean type, compatible with C++ */
  */
 /* Temporary variables to prevent multiple evaluation of macro arguments: */
-static st_sample_t st_macro_temp_sample __attribute__((unused));
+static st_sample_t st_macro_temp_sample UNUSED;
-static double st_macro_temp_double __attribute__((unused));
+static double st_macro_temp_double UNUSED;
 #define ST_SAMPLE_NEG ST_INT_MIN(32)
 #define ST_SAMPLE_TO_UNSIGNED(bits,d,clips) \
     st_rate_t rate;       /* sampling rate */
     signed char size;     /* word length of data */
     st_encoding_t encoding; /* format of sample numbers */
-    signed char channels; /* number of sound channels */
+    unsigned channels;    /* number of sound channels */
     char swap;            /* do byte- or word-swap */
     double compression;   /* compression factor (where applicable) */
 } st_signalinfo_t;
 typedef struct st_format {
     const char   * const *names;
-    char         *usage;
+    const char   *usage;
     unsigned int flags;
     int          (*startread)(ft_t ft);
-    st_ssize_t   (*read)(ft_t ft, st_sample_t *buf, st_size_t len);
+    st_size_t    (*read)(ft_t ft, st_sample_t *buf, st_size_t len);
     int          (*stopread)(ft_t ft);
     int          (*startwrite)(ft_t ft);
-    st_ssize_t   (*write)(ft_t ft, const st_sample_t *buf, st_size_t len);
+    st_size_t    (*write)(ft_t ft, const st_sample_t *buf, st_size_t len);
     int          (*stopwrite)(ft_t ft);
     int          (*seek)(ft_t ft, st_size_t offset);
 } st_format_t;
     char    *usage;
     unsigned int flags;
-    int (*getopts)(eff_t effp, int argc, char **argv);
+    int (*getopts)(eff_t effp, int argc, char *argv[]);
     int (*start)(eff_t effp);
     int (*flow)(eff_t effp, const st_sample_t *ibuf, st_sample_t *obuf,
                 st_size_t *isamp, st_size_t *osamp);
     st_size_t       odone, olen;    /* consumed, total length */
     st_size_t       clippedCount;   /* increment if clipping occurs */
     /* The following is a portable trick to align this variable on
-     * an 8-byte bounder.  Once this is done, the buffer alloced
+     * an 8-byte boundary.  Once this is done, the buffer alloced
      * after it should be align on an 8-byte boundery as well.
      * This lets you cast any structure over the private area
      * without concerns of alignment.
                                 const char *filetype, const char *comment,
                                 const st_instrinfo_t *instr,
                                 const st_loopinfo_t *loops);
-extern st_ssize_t st_read(ft_t ft, st_sample_t *buf, st_size_t len);
+extern st_size_t st_read(ft_t ft, st_sample_t *buf, st_size_t len);
-extern st_ssize_t st_write(ft_t ft, const st_sample_t *buf, st_size_t len);
+extern st_size_t st_write(ft_t ft, const st_sample_t *buf, st_size_t len);
 extern int st_close(ft_t ft);
 #define ST_SEEK_SET 0

src/st_i.h+18−20

 #endif
 /* various gcc optimizations and portablity defines */
-#ifdef __GNUC__
 #define NORET __attribute__((noreturn))
-#else
-#define NORET
-#endif
-#ifdef USE_REGPARM
 #define REGPARM(n) __attribute__((regparm(n)))
-#else
-#define REGPARM(n)
-#endif
 /* declared in misc.c */
 typedef struct {char const *text; int value;} enum_item;
 void st_generate_wave_table(
     st_wave_t wave_type,
     st_data_t data_type,
-    void * table,
+    void *table,
     uint32_t table_size,
     double min,
     double max,
     double phase);
-st_sample_t st_gcd(st_sample_t a, st_sample_t b) REGPARM(2);
+REGPARM(2) st_sample_t st_gcd(st_sample_t a, st_sample_t b);
-st_sample_t st_lcm(st_sample_t a, st_sample_t b) REGPARM(2);
+REGPARM(2) st_sample_t st_lcm(st_sample_t a, st_sample_t b);
 #ifndef HAVE_STRCASECMP
 int strcasecmp(const char *s1, const char *s2);
  * possible byte swapping.
  */
 /* declared in misc.c */
-st_ssize_t st_readbuf(ft_t ft, void *buf, size_t size, st_size_t len);
+size_t st_readbuf(ft_t ft, void *buf, size_t size, st_size_t len);
-st_ssize_t st_writebuf(ft_t ft, void const *buf, size_t size, st_size_t len);
+size_t st_writebuf(ft_t ft, void const *buf, size_t size, st_size_t len);
 int st_reads(ft_t ft, char *c, st_size_t len);
 int st_writes(ft_t ft, char *c);
 int st_readb(ft_t ft, uint8_t *ub);
 /* Raw I/O
  */
 int st_rawstartread(ft_t ft);
-st_ssize_t st_rawread(ft_t ft, st_sample_t *buf, st_size_t nsamp);
+st_size_t st_rawread(ft_t ft, st_sample_t *buf, st_size_t nsamp);
 int st_rawstopread(ft_t ft);
 int st_rawstartwrite(ft_t ft);
-st_ssize_t st_rawwrite(ft_t ft, const st_sample_t *buf, st_size_t nsamp);
+st_size_t st_rawwrite(ft_t ft, const st_sample_t *buf, st_size_t nsamp);
 int st_rawstopwrite(ft_t ft);
 int st_rawseek(ft_t ft, st_size_t offset);
  * a file handler or effect doesn't need to do anything special
  */
 int st_format_nothing(ft_t ft);
-st_ssize_t st_format_nothing_read_io(ft_t ft, st_sample_t *buf, st_size_t len);
+st_size_t st_format_nothing_read_io(ft_t ft, st_sample_t *buf, st_size_t len);
-st_ssize_t st_format_nothing_write_io(ft_t ft, const st_sample_t *buf, st_size_t len);
+st_size_t st_format_nothing_write_io(ft_t ft, const st_sample_t *buf, st_size_t len);
 int st_format_nothing_seek(ft_t ft, st_size_t offset);
 int st_effect_nothing(eff_t effp);
 int st_effect_nothing_drain(eff_t effp, st_sample_t *obuf, st_size_t *osamp);
+int st_effect_nothing_getopts(eff_t effp, int n, char **argv UNUSED);
 /*=============================================================================
  * Effects
 extern const st_effect_t *st_vibro_effect_fn(void);
 extern const st_effect_t *st_vol_effect_fn(void);
-/* Needed in sox.c
+/* Needed in sox.c */
- */
 st_size_t st_trim_get_start(eff_t effp);
 void st_trim_clear_start(eff_t effp);
+/* Needed in rate.c */
+int st_resample_start(eff_t effp);
+int st_resample_getopts(eff_t effp, int n, char **argv);
+int st_resample_flow(eff_t effp, const st_sample_t *ibuf, st_sample_t *obuf, st_size_t *isamp, st_size_t *osamp);
+int st_resample_drain(eff_t effp, st_sample_t *obuf, st_size_t *osamp);
+int st_resample_stop(eff_t effp);
 #endif

src/stat.c+5−5

@@ -45,7 +45,7 @@ typedef struct statstuff { · 44 unmodified lines
45	/*	45	/*
46	* Process options	46	* Process options
47	*/	47	*/
48	int st_stat_getopts(eff_t effp, int n, char **argv)	48	static int st_stat_getopts(eff_t effp, int n, char **argv)
49	{	49	{
50	stat_t stat = (stat_t) effp->priv;	50	stat_t stat = (stat_t) effp->priv;
51		51
@@ -96,7 +96,7 @@ int st_stat_getopts(eff_t effp, int n, char **argv) · 44 unmodified lines
96	/*	96	/*
97	* Prepare processing.	97	* Prepare processing.
98	*/	98	*/
99	int st_stat_start(eff_t effp)	99	static int st_stat_start(eff_t effp)
100	{	100	{
101	stat_t stat = (stat_t) effp->priv;	101	stat_t stat = (stat_t) effp->priv;
102	int i;	102	int i;
@@ -152,7 +152,7 @@ static void print_power_spectrum(unsigned samples, float rate, float *re_in, flo · 49 unmodified lines
152	* Return number of samples processed.	152	* Return number of samples processed.
153	*/	153	*/
154		154
155	int st_stat_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf,	155	static int st_stat_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf,
156	st_size_t isamp, st_size_t osamp)	156	st_size_t isamp, st_size_t osamp)
157	{	157	{
158	stat_t stat = (stat_t) effp->priv;	158	stat_t stat = (stat_t) effp->priv;
@@ -231,7 +231,7 @@ int st_stat_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf, · 72 unmodified lines
231	/*	231	/*
232	* Process tail of input samples.	232	* Process tail of input samples.
233	*/	233	*/
234	int st_stat_drain(eff_t effp, st_sample_t obuf, st_size_t osamp)	234	static int st_stat_drain(eff_t effp, st_sample_t obuf UNUSED, st_size_t osamp)
235	{	235	{
236	stat_t stat = (stat_t) effp->priv;	236	stat_t stat = (stat_t) effp->priv;
237		237
@@ -256,7 +256,7 @@ int st_stat_drain(eff_t effp, st_sample_t obuf, st_size_t osamp) · 18 unmodified lines
256	* Do anything required when you stop reading samples.	256	* Do anything required when you stop reading samples.
257	* Don't close input file!	257	* Don't close input file!
258	*/	258	*/
259	int st_stat_stop(eff_t effp)	259	static int st_stat_stop(eff_t effp)
260	{	260	{
261	stat_t stat = (stat_t) effp->priv;	261	stat_t stat = (stat_t) effp->priv;
262	double amp, scale, rms = 0, freq;	262	double amp, scale, rms = 0, freq;

src/stconfig.h.in+5−5

@@ -111,19 +111,19 @@ · 110 unmodified lines
111	/* Define to the version of this package. */	111	/* Define to the version of this package. */
112	#undef PACKAGE_VERSION	112	#undef PACKAGE_VERSION
113		113
114	/* The size of a `char', as computed by sizeof. */	114	/* The size of `char', as computed by sizeof. */
115	#undef SIZEOF_CHAR	115	#undef SIZEOF_CHAR
116		116
117	/* The size of a `int', as computed by sizeof. */	117	/* The size of `int', as computed by sizeof. */
118	#undef SIZEOF_INT	118	#undef SIZEOF_INT
119		119
120	/* The size of a `long', as computed by sizeof. */	120	/* The size of `long', as computed by sizeof. */
121	#undef SIZEOF_LONG	121	#undef SIZEOF_LONG
122		122
123	/* The size of a `short', as computed by sizeof. */	123	/* The size of `short', as computed by sizeof. */
124	#undef SIZEOF_SHORT	124	#undef SIZEOF_SHORT
125		125
126	/* The size of a `void', as computed by sizeof. /	126	/* The size of `void', as computed by sizeof. /
127	#undef SIZEOF_VOIDP	127	#undef SIZEOF_VOIDP
128		128
129	/* Define to 1 if you have the ANSI C header files. */	129	/* Define to 1 if you have the ANSI C header files. */

src/stio.c+8−8

@@ -54,7 +54,7 @@ static int st_checkformat(ft_t ft) · 53 unmodified lines
54	return ST_EOF;	54	return ST_EOF;
55	}	55	}
56		56
57	if (ft->info.encoding == -1)	57	if (ft->info.encoding == ST_ENCODING_UNKNOWN)
58	{	58	{
59	st_fail_errno(ft,ST_EFMT,"data encoding was not specified");	59	st_fail_errno(ft,ST_EFMT,"data encoding was not specified");
60	return ST_EOF;	60	return ST_EOF;
@@ -105,8 +105,8 @@ ft_t st_open_read(const char path, const st_signalinfo_t info, · 44 unmodified lines
105	}	105	}
106		106
107	ft->info.size = -1;	107	ft->info.size = -1;
108	ft->info.encoding = -1;	108	ft->info.encoding = ST_ENCODING_UNKNOWN;
109	ft->info.channels = -1;	109	ft->info.channels = 0;
110	if (info)	110	if (info)
111	ft->info = *info;	111	ft->info = *info;
112	/* FIXME: Remove ft->swap from code */	112	/* FIXME: Remove ft->swap from code */
@@ -145,7 +145,7 @@ ft_t st_open_read(const char path, const st_signalinfo_t info, · 32 unmodified lines
145	* This is because libst usually doesn't set this for mono file	145	* This is because libst usually doesn't set this for mono file
146	* formats (for historical reasons).	146	* formats (for historical reasons).
147	*/	147	*/
148	if (ft->info.channels == -1)	148	if (ft->info.channels == 0)
149	ft->info.channels = 1;	149	ft->info.channels = 1;
150		150
151	if (st_checkformat(ft) )	151	if (st_checkformat(ft) )
@@ -229,8 +229,8 @@ ft_t st_open_write_instr(const char path, const st_signalinfo_t info, · 77 unmodified lines
229	}	229	}
230		230
231	ft->info.size = -1;	231	ft->info.size = -1;
232	ft->info.encoding = -1;	232	ft->info.encoding = ST_ENCODING_UNKNOWN;
233	ft->info.channels = -1;	233	ft->info.channels = 0;
234	if (info)	234	if (info)
235	ft->info = *info;	235	ft->info = *info;
236	ft->mode = 'w';	236	ft->mode = 'w';
@@ -314,12 +314,12 @@ ft_t st_open_write(const char path, const st_signalinfo_t info, · 77 unmodified lines
314	return st_open_write_instr(path, info, filetype, comment, NULL, NULL);	314	return st_open_write_instr(path, info, filetype, comment, NULL, NULL);
315	}	315	}
316		316
317	st_ssize_t st_read(ft_t ft, st_sample_t *buf, st_size_t len)	317	st_size_t st_read(ft_t ft, st_sample_t *buf, st_size_t len)
318	{	318	{
319	return (*ft->h->read)(ft, buf, len);	319	return (*ft->h->read)(ft, buf, len);
320	}	320	}
321		321
322	st_ssize_t st_write(ft_t ft, const st_sample_t *buf, st_size_t len)	322	st_size_t st_write(ft_t ft, const st_sample_t *buf, st_size_t len)
323	{	323	{
324	return (*ft->h->write)(ft, buf, len);	324	return (*ft->h->write)(ft, buf, len);
325	}	325	}

src/stretch.c+19−27

      */
     stretch_status_t state; /* automaton status */
-    int size;               /* buffer size */
+    st_size_t size;         /* buffer size */
-    int index;              /* next available element */
+    st_size_t index;        /* next available element */
     st_sample_t *ibuf;      /* input buffer */
     int ishift;             /* input shift */
-    int oindex;             /* next evailable element */
+    st_size_t oindex;       /* next evailable element */
     double * obuf;   /* output buffer */
-    int oshift;             /* output shift */
+    st_size_t oshift;       /* output shift */
-    int fsize;              /* fading size */
+    st_size_t fsize;        /* fading size */
     double * fbuf;   /* fading, 1.0 -> 0.0 */
 } * stretch_t;
-/*
-static void debug(stretch_t s, char * where)
-{
-    st_debug(
-            "%s: (f=%.2f w=%.2f r=%.2f f=%.2f)"
-            " st=%d s=%d ii=%d is=%d oi=%d os=%d fs=%d\n",
-            where, s->factor, s->window, s->shift, s->fading,
-            s->state, s->size, s->index, s->ishift,
-            s->oindex, s->oshift, s->fsize);
-}
-*/
 /*
  * Process options
  */
-int st_stretch_getopts(eff_t effp, int n, char **argv)
+static int st_stretch_getopts(eff_t effp, int n, char **argv)
 {
     char usage[1024];
     stretch_t stretch = (stretch_t) effp->priv;
 /*
  * Start processing
  */
-int st_stretch_start(eff_t effp)
+static int st_stretch_start(eff_t effp)
 {
     stretch_t stretch = (stretch_t) effp->priv;
-    register int i;
+    st_size_t i;
     /* not necessary. taken care by effect processing? */
     if (effp->outinfo.channels != effp->ininfo.channels)
                                             sizeof(st_sample_t));
     /* the shift ratio deal with the longest of ishift/oshift
-       hence ishift<=size and oshift<=size. should be asserted.
+       hence ishift<=size and oshift<=size. FIXME: should be asserted.
      */
     if (stretch->factor < 1.0)
     {
     } else if (stretch->fsize==1)
         stretch->fbuf[0] = 1.0;
-    /* debug(stretch, "start"); */
+    st_debug("start: (f=%.2f w=%.2f r=%.2f f=%.2f)"
+             " st=%d s=%d ii=%d is=%d oi=%d os=%d fs=%d\n",
+             stretch->factor, stretch->window, stretch->shift, stretch->fading,
+             stretch->state, stretch->size, stretch->index, stretch->ishift,
+             stretch->oindex, stretch->oshift, stretch->fsize);
     return ST_SUCCESS;
 }
 /*
  * Processes flow.
  */
-int st_stretch_flow(eff_t effp, const st_sample_t *ibuf, st_sample_t *obuf,
+static int st_stretch_flow(eff_t effp, const st_sample_t *ibuf, st_sample_t *obuf,
                     st_size_t *isamp, st_size_t *osamp)
 {
     stretch_t stretch = (stretch_t) effp->priv;
     st_size_t iindex, oindex;
-    int i;
+    st_size_t i;
     iindex = 0;
     oindex = 0;
  * Drain buffer at the end
  * maybe not correct ? end might be artificially faded?
  */
-int st_stretch_drain(eff_t effp, st_sample_t *obuf, st_size_t *osamp)
+static int st_stretch_drain(eff_t effp, st_sample_t *obuf, st_size_t *osamp)
 {
     stretch_t stretch = (stretch_t) effp->priv;
-    register int i;
+    st_size_t i;
     st_size_t oindex;
     oindex = 0;
  * Do anything required when you stop reading samples.
  * Don't close input file!
  */
-int st_stretch_stop(eff_t effp)
+static int st_stretch_stop(eff_t effp)
 {
     stretch_t stretch = (stretch_t) effp->priv;

src/sunaudio.c+5−5

@@ -63,7 +63,7 @@ int st_sunstartread(ft_t ft) · 62 unmodified lines
63		63
64	if (ft->info.rate == 0.0) ft->info.rate = 8000;	64	if (ft->info.rate == 0.0) ft->info.rate = 8000;
65	if (ft->info.size == -1) ft->info.size = ST_SIZE_BYTE;	65	if (ft->info.size == -1) ft->info.size = ST_SIZE_BYTE;
66	if (ft->info.encoding == -1) ft->info.encoding = ST_ENCODING_ULAW;	66	if (ft->info.encoding == ST_ENCODING_UNKNOWN) ft->info.encoding = ST_ENCODING_ULAW;
67		67
68	#ifdef __SVR4	68	#ifdef __SVR4
69	/* Read in old values, change to what we need and then send back */	69	/* Read in old values, change to what we need and then send back */
@@ -78,7 +78,7 @@ int st_sunstartread(ft_t ft) · 8 unmodified lines
78	}	78	}
79	#endif	79	#endif
80		80
81	// If simple hardware detected in force data to ulaw.	81	/* If simple hardware detected in force data to ulaw. */
82	if (simple_hw)	82	if (simple_hw)
83	{	83	{
84	if (ft->info.size == ST_SIZE_BYTE)	84	if (ft->info.size == ST_SIZE_BYTE)
@@ -125,7 +125,7 @@ int st_sunstartread(ft_t ft) · 40 unmodified lines
125	return(ST_EOF);	125	return(ST_EOF);
126	}	126	}
127		127
128	if (ft->info.channels == -1) ft->info.channels = 1;	128	if (ft->info.channels == 0) ft->info.channels = 1;
129	else if (ft->info.channels > 1) {	129	else if (ft->info.channels > 1) {
130	st_report("Warning: some Sun audio devices can not play stereo");	130	st_report("Warning: some Sun audio devices can not play stereo");
131	st_report("at all or sometimes only with signed words. If the");	131	st_report("at all or sometimes only with signed words. If the");
@@ -233,7 +233,7 @@ int st_sunstartwrite(ft_t ft) · 101 unmodified lines
233		233
234	if (ft->info.rate == 0.0) ft->info.rate = 8000;	234	if (ft->info.rate == 0.0) ft->info.rate = 8000;
235	if (ft->info.size == -1) ft->info.size = ST_SIZE_BYTE;	235	if (ft->info.size == -1) ft->info.size = ST_SIZE_BYTE;
236	if (ft->info.encoding == -1) ft->info.encoding = ST_ENCODING_ULAW;	236	if (ft->info.encoding == ST_ENCODING_UNKNOWN) ft->info.encoding = ST_ENCODING_ULAW;
237		237
238	if (ft->info.size == ST_SIZE_BYTE) {	238	if (ft->info.size == ST_SIZE_BYTE) {
239	samplesize = 8;	239	samplesize = 8;
@@ -266,7 +266,7 @@ int st_sunstartwrite(ft_t ft) · 26 unmodified lines
266	samplesize = 16;	266	samplesize = 16;
267	}	267	}
268		268
269	if (ft->info.channels == -1) ft->info.channels = 1;	269	if (ft->info.channels == 0) ft->info.channels = 1;
270	else if (ft->info.channels > 1) ft->info.channels = 2;	270	else if (ft->info.channels > 1) ft->info.channels = 2;
271		271
272	/* Read in old values, change to what we need and then send back */	272	/* Read in old values, change to what we need and then send back */

src/swap.c+5−25

  * Don't do initialization now.
  * The 'info' fields are not yet filled in.
  */
-int st_swap_getopts(eff_t effp, int n, char **argv)
+static int st_swap_getopts(eff_t effp, int n, char **argv)
 {
     swap_t swap = (swap_t) effp->priv;
  * Prepare processing.
  * Do all initializations.
  */
-int st_swap_start(eff_t effp)
+static int st_swap_start(eff_t effp)
 {
     swap_t swap = (swap_t) effp->priv;
  * Processed signed long samples from ibuf to obuf.
  * Return number of samples processed.
  */
-int st_swap_flow(eff_t effp, const st_sample_t *ibuf, st_sample_t *obuf,
+static int st_swap_flow(eff_t effp, const st_sample_t *ibuf, st_sample_t *obuf,
                  st_size_t *isamp, st_size_t *osamp)
 {
     swap_t swap = (swap_t) effp->priv;
     return (ST_SUCCESS);
 }
-/*
- * Drain out remaining samples if the effect generates any.
- */
-int st_swap_drain(eff_t effp, st_sample_t *obuf, st_size_t *osamp)
-{
-    *osamp = 0;
-    return ST_EOF;
-}
-/*
- * Do anything required when you stop reading samples.
- *      (free allocated memory, etc.)
- */
-int st_swap_stop(eff_t effp)
-{
-        /* nothing to do */
-    return (ST_SUCCESS);
-}
 static st_effect_t st_swap_effect = {
   "swap",
   "Usage: swap [1 2 | 1 2 3 4]",
   st_swap_getopts,
   st_swap_start,
   st_swap_flow,
-  st_swap_drain,
+  st_effect_nothing_drain,
-  st_swap_stop
+  st_effect_nothing
 };
 const st_effect_t *st_swap_effect_fn(void)

src/synth.c+9−29

   ENUM_ITEM(SYNTH_,PINKNOISE )
   ENUM_ITEM(SYNTH_,BROWNNOISE)
   ENUM_ITEM(SYNTH_,EXP       )
-  {0}};
+  {0, 0}};
 enum_item const combine_type[] = {
   ENUM_ITEM(SYNTH_,CREATE)
   ENUM_ITEM(SYNTH_,MIX   )
   ENUM_ITEM(SYNTH_,AMOD  )
   ENUM_ITEM(SYNTH_,FMOD  )
-  {0}};
+  {0, 0}};
 /* do not ask me for the colored noise, i copied the
  * algorithm somewhere...
 } PinkNoise;
 /* Setup PinkNoise structure for N rows of generators. */
-void InitializePinkNoise( PinkNoise *pink, int numRows )
+static void InitializePinkNoise( PinkNoise *pink, int numRows )
 {
         int i;
         long pmax;
 }
 /* Generate Pink noise values between -1.0 and +1.0 */
-float GeneratePinkNoise( PinkNoise *pink )
+static float GeneratePinkNoise( PinkNoise *pink )
 {
         long newRandom;
         long sum;
  * Don't do initialization now.
  * The 'info' fields are not yet filled in.
  */
-int st_synth_getopts(eff_t effp, int n, char **argv)
+static int st_synth_getopts(eff_t effp, int n, char **argv)
 {
     int argn;
     char *hlp;
  * Prepare processing.
  * Do all initializations.
  */
-int st_synth_start(eff_t effp)
+static int st_synth_start(eff_t effp)
 {
     int i;
     int c;
 /*
  * Processed signed long samples from ibuf to obuf.
  */
-int st_synth_flow(eff_t effp, const st_sample_t *ibuf, st_sample_t *obuf,
+static int st_synth_flow(eff_t effp, const st_sample_t *ibuf, st_sample_t *obuf,
                   st_size_t *isamp, st_size_t *osamp)
 {
     synth_t synth = (synth_t) effp->priv;
     return result;
 }
-/*
- * Drain out remaining samples if the effect generates any.
- */
-int st_synth_drain(eff_t effp, st_sample_t *obuf, st_size_t *osamp)
-{
-    *osamp = 0;
-    return ST_EOF;
-}
-/*
- * Do anything required when you stop reading samples.
- *      (free allocated memory, etc.)
- */
-int st_synth_stop(eff_t effp)
-{
-    /* nothing to do */
-    return (ST_SUCCESS);
-}
 static st_effect_t st_synth_effect = {
   "synth",
   "Usage: synth [len] {[type] [combine] [freq[-freq2]] [off] [ph] [p1] [p2] [p3]}\n"
   st_synth_getopts,
   st_synth_start,
   st_synth_flow,
-  st_synth_drain,
+  st_effect_nothing_drain,
-  st_synth_stop
+  st_effect_nothing
 };
 const st_effect_t *st_synth_effect_fn(void)

src/trim.c+5−5

@@ -37,7 +37,7 @@ typedef struct · 36 unmodified lines
37	/*	37	/*
38	* Process options	38	* Process options
39	*/	39	*/
40	int st_trim_getopts(eff_t effp, int n, char **argv)	40	static int st_trim_getopts(eff_t effp, int n, char **argv)
41	{	41	{
42	trim_t trim = (trim_t) effp->priv;	42	trim_t trim = (trim_t) effp->priv;
43		43
@@ -88,7 +88,7 @@ int st_trim_getopts(eff_t effp, int n, char **argv) · 44 unmodified lines
88	/*	88	/*
89	* Start processing	89	* Start processing
90	*/	90	*/
91	int st_trim_start(eff_t effp)	91	static int st_trim_start(eff_t effp)
92	{	92	{
93	trim_t trim = (trim_t) effp->priv;	93	trim_t trim = (trim_t) effp->priv;
94		94
@@ -128,7 +128,7 @@ int st_trim_start(eff_t effp) · 33 unmodified lines
128	* Place in buf[].	128	* Place in buf[].
129	* Return number of samples read.	129	* Return number of samples read.
130	*/	130	*/
131	int st_trim_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf,	131	static int st_trim_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf,
132	st_size_t isamp, st_size_t osamp)	132	st_size_t isamp, st_size_t osamp)
133	{	133	{
134	int finished = 0;	134	int finished = 0;
@@ -195,7 +195,7 @@ int st_trim_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf, · 60 unmodified lines
195	* Do anything required when you stop reading samples.	195	* Do anything required when you stop reading samples.
196	* Don't close input file!	196	* Don't close input file!
197	*/	197	*/
198	int st_trim_stop(eff_t effp)	198	static int st_trim_stop(eff_t effp)
199	{	199	{
200	trim_t trim = (trim_t) effp->priv;	200	trim_t trim = (trim_t) effp->priv;
201		201
@@ -227,7 +227,7 @@ static st_effect_t st_trim_effect = { · 25 unmodified lines
227	st_trim_start,	227	st_trim_start,
228	st_trim_flow,	228	st_trim_flow,
229	st_effect_nothing_drain,	229	st_effect_nothing_drain,
230	st_effect_nothing	230	st_trim_stop
231	};	231	};
232		232
233	const st_effect_t *st_trim_effect_fn(void)	233	const st_effect_t *st_trim_effect_fn(void)

src/tx16w.c+8−17

  *      size and encoding of samples,
  *      mono/stereo/quad.
  */
-int st_txwstartread(ft_t ft)
+static int st_txwstartread(ft_t ft)
 {
     int c;
     char filetype[7];
  * Return number of samples read.
  */
-st_ssize_t st_txwread(ft_t ft, st_sample_t *buf, st_size_t len)
+static st_size_t st_txwread(ft_t ft, st_sample_t *buf, st_size_t len)
 {
     txw_t sk = (txw_t) ft->priv;
-    int done = 0;
+    st_size_t done = 0;
     unsigned char uc1,uc2,uc3;
     unsigned short s1,s2;
     return done;
 }
-/*
+static int st_txwstartwrite(ft_t ft)
- * Do anything required when you stop reading samples.
- * Don't close input file!
- */
-int st_txwstopread(ft_t ft)
-{
-    return(ST_SUCCESS);
-}
-int st_txwstartwrite(ft_t ft)
 {
     struct WaveHeader_ WH;
     return(ST_SUCCESS);
 }
-st_ssize_t st_txwwrite(ft_t ft, const st_sample_t *buf, st_size_t len)
+static st_size_t st_txwwrite(ft_t ft, const st_sample_t *buf, st_size_t len)
 {
-    int i;
+    st_size_t i;
     unsigned int w1,w2;
     tx16w_len += len;
     return(len);
 }
-int st_txwstopwrite(ft_t ft)
+static int st_txwstopwrite(ft_t ft)
 {
     struct WaveHeader_ WH;
     int AttackLength, LoopLength, i;
    0,
    st_txwstartread,
    st_txwread,
-   st_txwstopread,
+   st_format_nothing,
    st_txwstartwrite,
    st_txwwrite,
    st_txwstopwrite,

src/util.c+3−3

  */
 #include "st_i.h"
+#include <stddef.h>
 #include <string.h>
 #include <ctype.h>
 #include <stdarg.h>
 struct st_output_message_s
   }
   dot_pos = strrchr(drivername, '.');
-  if (dot_pos != NULL && dot_pos - drivername <= sizeof(buffer) - 1) {
+  if (dot_pos != NULL && dot_pos - drivername <= (ptrdiff_t)(sizeof(buffer) - 1)) {
-    strncpy(buffer, drivername, dot_pos - drivername);
+    strncpy(buffer, drivername, (size_t)(dot_pos - drivername));
     buffer[dot_pos - drivername] = '\0';
     drivername = buffer;
   }

src/vibro.c+3−13

 /*
  * Process options
  */
-int st_vibro_getopts(eff_t effp, int n, char **argv)
+static int st_vibro_getopts(eff_t effp, int n, char **argv)
 {
         vibro_t vibro = (vibro_t) effp->priv;
 /*
  * Prepare processing.
  */
-int st_vibro_start(eff_t effp)
+static int st_vibro_start(eff_t effp)
 {
         vibro_t vibro = (vibro_t) effp->priv;
  * Return number of samples processed.
  */
-int st_vibro_flow(eff_t effp, const st_sample_t *ibuf, st_sample_t *obuf,
+static int st_vibro_flow(eff_t effp, const st_sample_t *ibuf, st_sample_t *obuf,
                   st_size_t *isamp, st_size_t *osamp)
 {
         vibro_t vibro = (vibro_t) effp->priv;
         return (ST_SUCCESS);
 }
-/*
- * Do anything required when you stop reading samples.
- * Don't close input file!
- */
-int st_vibro_stop(eff_t effp)
-{
-        /* nothing to do */
-    return (ST_SUCCESS);
-}
 static st_effect_t st_vibro_effect = {
   "vibro",
   "Usage: vibro speed [ depth ]",

src/voc.c+41−51

 /* Prototypes for internal functions */
 static int getblock(ft_t);
 static void blockstart(ft_t);
-static void blockstop(ft_t);
 /* Conversion macros (from raw.c) */
 #define ST_ALAW_BYTE_TO_SAMPLE(d) ((st_sample_t)(st_alaw2linear16(d)) << 16)
 /*-----------------------------------------------------------------
  * st_vocstartread() -- start reading a VOC file
  *-----------------------------------------------------------------*/
-int st_vocstartread(ft_t ft)
+static int st_vocstartread(ft_t ft)
 {
         int rtn = ST_SUCCESS;
         char header[20];
         }
         /* setup number of channels */
-        if (ft->info.channels == -1)
+        if (ft->info.channels == 0)
                 ft->info.channels = v->channels;
         return(ST_SUCCESS);
  * ANN:  Major changes here to support multi-part files and files
  *       that do not have audio in block 9's.
  *-----------------------------------------------------------------*/
-st_ssize_t st_vocread(ft_t ft, st_sample_t *buf, st_size_t len)
+static st_size_t st_vocread(ft_t ft, st_sample_t *buf, st_size_t len)
 {
         vs_t v = (vs_t) ft->priv;
-        int done = 0;
+        st_size_t done = 0;
         int rc = 0;
         int16_t sw;
         unsigned char  uc;
         return done;
 }
-/*-----------------------------------------------------------------
- * st_vocstartread() -- start reading a VOC file
- * nothing to do
- *-----------------------------------------------------------------*/
-int st_vocstopread(ft_t ft)
-{
-    return(ST_SUCCESS);
-}
 /* When saving samples in VOC format the following outline is followed:
  * If an 8-bit mono sample then use a VOC_DATA header.
  * If an 8-bit stereo sample then use a VOC_EXTENDED header followed
  * which will work with the oldest software (eg. an 8-bit mono sample
  * will be able to be played with a really old SB VOC player.)
  */
-int st_vocstartwrite(ft_t ft)
+static int st_vocstartwrite(ft_t ft)
 {
         vs_t v = (vs_t) ft->priv;
           ft->info.encoding = ST_ENCODING_UNSIGNED;
         else
           ft->info.encoding = ST_ENCODING_SIGN2;
-        if (ft->info.channels == -1)
+        if (ft->info.channels == 0)
                 ft->info.channels = 1;
         return(ST_SUCCESS);
 }
 /*-----------------------------------------------------------------
- * st_vocstartread() -- start reading a VOC file
+ * st_vocwrite() -- write a VOC file
  *-----------------------------------------------------------------*/
-st_ssize_t st_vocwrite(ft_t ft, const st_sample_t *buf, st_size_t len)
+static st_size_t st_vocwrite(ft_t ft, const st_sample_t *buf, st_size_t len)
 {
         vs_t v = (vs_t) ft->priv;
         unsigned char uc;
         int16_t sw;
-        st_ssize_t done = 0;
+        st_size_t done = 0;
         if (v->samples == 0) {
           /* No silence packing yet. */
         return done;
 }
+/*-----------------------------------------------------------------
+ * blockstop() -- stop an output block
+ * End the current data or silence block.
+ *-----------------------------------------------------------------*/
+static void blockstop(ft_t ft)
+{
+        vs_t v = (vs_t) ft->priv;
+        st_sample_t datum;
+        st_writeb(ft, 0);                     /* End of file block code */
+        st_seeki(ft, v->blockseek, 0);         /* seek back to block length */
+        st_seeki(ft, 1, 1);                    /* seek forward one */
+        if (v->silent) {
+                st_writew(ft, v->samples);
+        } else {
+          if (ft->info.size == ST_SIZE_BYTE) {
+            if (ft->info.channels > 1) {
+              st_seeki(ft, 8, 1); /* forward 7 + 1 for new block header */
+            }
+          }
+                v->samples += 2;                /* adjustment: SBDK pp. 3-5 */
+                datum = (v->samples * ft->info.size) & 0xff;
+                st_writeb(ft, (int)datum);       /* low byte of length */
+                datum = ((v->samples * ft->info.size) >> 8) & 0xff;
+                st_writeb(ft, (int)datum);  /* middle byte of length */
+                datum = ((v->samples  * ft->info.size)>> 16) & 0xff;
+                st_writeb(ft, (int)datum); /* high byte of length */
+        }
+}
 /*-----------------------------------------------------------------
  * st_vocstopwrite() -- stop writing a VOC file
  *-----------------------------------------------------------------*/
-int st_vocstopwrite(ft_t ft)
+static int st_vocstopwrite(ft_t ft)
 {
         blockstop(ft);
         return(ST_SUCCESS);
         }
 }
-/*-----------------------------------------------------------------
- * blockstop() -- stop an output block
- * End the current data or silence block.
- *-----------------------------------------------------------------*/
-static void blockstop(ft_t ft)
-{
-        vs_t v = (vs_t) ft->priv;
-        st_sample_t datum;
-        st_writeb(ft, 0);                     /* End of file block code */
-        st_seeki(ft, v->blockseek, 0);         /* seek back to block length */
-        st_seeki(ft, 1, 1);                    /* seek forward one */
-        if (v->silent) {
-                st_writew(ft, v->samples);
-        } else {
-          if (ft->info.size == ST_SIZE_BYTE) {
-            if (ft->info.channels > 1) {
-              st_seeki(ft, 8, 1); /* forward 7 + 1 for new block header */
-            }
-          }
-                v->samples += 2;                /* adjustment: SBDK pp. 3-5 */
-                datum = (v->samples * ft->info.size) & 0xff;
-                st_writeb(ft, (int)datum);       /* low byte of length */
-                datum = ((v->samples * ft->info.size) >> 8) & 0xff;
-                st_writeb(ft, (int)datum);  /* middle byte of length */
-                datum = ((v->samples  * ft->info.size)>> 16) & 0xff;
-                st_writeb(ft, (int)datum); /* high byte of length */
-        }
-}
 /* Sound Blaster .VOC */
 static const char *vocnames[] = {
   "voc",
   ST_FILE_STEREO,
   st_vocstartread,
   st_vocread,
-  st_vocstopread,
+  st_format_nothing,
   st_vocstartwrite,
   st_vocwrite,
   st_vocstopwrite,

src/vol.c+4−4

@@ -29,7 +29,7 @@ typedef struct { · 28 unmodified lines
29	/*	29	/*
30	* Process options: gain (float) type (amplitude, power, dB)	30	* Process options: gain (float) type (amplitude, power, dB)
31	*/	31	*/
32	int st_vol_getopts(eff_t effp, int n, char **argv)	32	static int st_vol_getopts(eff_t effp, int n, char **argv)
33	{	33	{
34	vol_t vol = (vol_t) effp->priv;	34	vol_t vol = (vol_t) effp->priv;
35	vol->gain = 1.0; /* default is no change */	35	vol->gain = 1.0; /* default is no change */
@@ -90,7 +90,7 @@ int st_vol_getopts(eff_t effp, int n, char **argv) · 54 unmodified lines
90	/*	90	/*
91	* Start processing	91	* Start processing
92	*/	92	*/
93	int st_vol_start(eff_t effp)	93	static int st_vol_start(eff_t effp)
94	{	94	{
95	vol_t vol = (vol_t) effp->priv;	95	vol_t vol = (vol_t) effp->priv;
96		96
@@ -116,7 +116,7 @@ int st_vol_start(eff_t effp) · 19 unmodified lines
116	/*	116	/*
117	* Process data.	117	* Process data.
118	*/	118	*/
119	int st_vol_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf,	119	static int st_vol_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf,
120	st_size_t isamp, st_size_t osamp)	120	st_size_t isamp, st_size_t osamp)
121	{	121	{
122	vol_t vol = (vol_t) effp->priv;	122	vol_t vol = (vol_t) effp->priv;
@@ -180,7 +180,7 @@ int st_vol_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf, · 57 unmodified lines
180	* Do anything required when you stop reading samples.	180	* Do anything required when you stop reading samples.
181	* Don't close input file!	181	* Don't close input file!
182	*/	182	*/
183	int st_vol_stop(eff_t effp)	183	static int st_vol_stop(eff_t effp)
184	{	184	{
185	vol_t vol = (vol_t) effp->priv;	185	vol_t vol = (vol_t) effp->priv;
186	if (vol->limited)	186	if (vol->limited)

src/vorbis.c+13−13

@@ -66,7 +66,7 @@ typedef struct vorbisstuff { · 65 unmodified lines
66	} *vorbis_t;	66	} *vorbis_t;
67		67
68	/****** Callback functions used in ov_open_callbacks **********/	68	/****** Callback functions used in ov_open_callbacks **********/
69	int myclose (void *datasource)	69	static int myclose (void *datasource UNUSED)
70	{	70	{
71	/* Do nothing so sox can close the file for us */	71	/* Do nothing so sox can close the file for us */
72	return 0;	72	return 0;
@@ -89,7 +89,7 @@ static int _fseeko64_wrap(FILE *f, ogg_int64_t off, int whence) { · 16 unmodified lines
89	* size and encoding of samples,	89	* size and encoding of samples,
90	* mono/stereo/quad.	90	* mono/stereo/quad.
91	*/	91	*/
92	int st_vorbisstartread(ft_t ft)	92	static int st_vorbisstartread(ft_t ft)
93	{	93	{
94	vorbis_t vb = (vorbis_t) ft->priv;	94	vorbis_t vb = (vorbis_t) ft->priv;
95	vorbis_info *vi;	95	vorbis_info *vi;
@@ -195,7 +195,7 @@ int st_vorbisstartread(ft_t ft) · 99 unmodified lines
195	/* Refill the buffer with samples. Returns BUF_EOF if the end of the	195	/* Refill the buffer with samples. Returns BUF_EOF if the end of the
196	vorbis data was reached while the buffer was being filled,	196	vorbis data was reached while the buffer was being filled,
197	BUF_ERROR is something bad happens, and BUF_DATA otherwise */	197	BUF_ERROR is something bad happens, and BUF_DATA otherwise */
198	int refill_buffer (vorbis_t vb)	198	static int refill_buffer (vorbis_t vb)
199	{	199	{
200	int num_read;	200	int num_read;
201		201
@@ -230,10 +230,10 @@ int refill_buffer (vorbis_t vb) · 28 unmodified lines
230	* Return number of samples read.	230	* Return number of samples read.
231	*/	231	*/
232		232
233	st_ssize_t st_vorbisread(ft_t ft, st_sample_t *buf, st_size_t len)	233	static st_size_t st_vorbisread(ft_t ft, st_sample_t *buf, st_size_t len)
234	{	234	{
235	vorbis_t vb = (vorbis_t) ft->priv;	235	vorbis_t vb = (vorbis_t) ft->priv;
236	int i;	236	st_size_t i;
237	int ret;	237	int ret;
238	st_sample_t l;	238	st_sample_t l;
239		239
@@ -265,7 +265,7 @@ st_ssize_t st_vorbisread(ft_t ft, st_sample_t *buf, st_size_t len) · 25 unmodified lines
265	* Do anything required when you stop reading samples.	265	* Do anything required when you stop reading samples.
266	* Don't close input file!	266	* Don't close input file!
267	*/	267	*/
268	int st_vorbisstopread(ft_t ft)	268	static int st_vorbisstopread(ft_t ft)
269	{	269	{
270	vorbis_t vb = (vorbis_t) ft->priv;	270	vorbis_t vb = (vorbis_t) ft->priv;
271		271
@@ -277,7 +277,7 @@ int st_vorbisstopread(ft_t ft) · 5 unmodified lines
277		277
278	/* Write a page of ogg data to a file. Taken directly from encode.c in	278	/* Write a page of ogg data to a file. Taken directly from encode.c in
279	oggenc. Returns the number of bytes written. */	279	oggenc. Returns the number of bytes written. */
280	int oe_write_page(ogg_page *page, ft_t ft)	280	static int oe_write_page(ogg_page *page, ft_t ft)
281	{	281	{
282	int written;	282	int written;
283	written = st_writebuf(ft, page->header,1,page->header_len);	283	written = st_writebuf(ft, page->header,1,page->header_len);
@@ -289,7 +289,7 @@ int oe_write_page(ogg_page *page, ft_t ft) · 5 unmodified lines
289	/* Write out the header packets. Derived mostly from encode.c in	289	/* Write out the header packets. Derived mostly from encode.c in
290	oggenc. Returns HEADER_ERROR if the header cannot be written and	290	oggenc. Returns HEADER_ERROR if the header cannot be written and
291	HEADER_OK otherwise. */	291	HEADER_OK otherwise. */
292	int write_vorbis_header(ft_t ft, vorbis_enc_t *ve)	292	static int write_vorbis_header(ft_t ft, vorbis_enc_t *ve)
293	{	293	{
294	ogg_packet header_main;	294	ogg_packet header_main;
295	ogg_packet header_comments;	295	ogg_packet header_comments;
@@ -345,7 +345,7 @@ int write_vorbis_header(ft_t ft, vorbis_enc_t *ve) · 49 unmodified lines
345	return HEADER_OK;	345	return HEADER_OK;
346	}	346	}
347		347
348	int st_vorbisstartwrite(ft_t ft)	348	static int st_vorbisstartwrite(ft_t ft)
349	{	349	{
350	vorbis_t vb = (vorbis_t) ft->priv;	350	vorbis_t vb = (vorbis_t) ft->priv;
351	vorbis_enc_t *ve;	351	vorbis_enc_t *ve;
@@ -399,13 +399,13 @@ int st_vorbisstartwrite(ft_t ft) · 47 unmodified lines
399	return(ST_SUCCESS);	399	return(ST_SUCCESS);
400	}	400	}
401		401
402	st_ssize_t st_vorbiswrite(ft_t ft, const st_sample_t *buf, st_size_t len)	402	static st_size_t st_vorbiswrite(ft_t ft, const st_sample_t *buf, st_size_t len)
403	{	403	{
404	vorbis_t vb = (vorbis_t) ft->priv;	404	vorbis_t vb = (vorbis_t) ft->priv;
405	vorbis_enc_t *ve = vb->vorbis_enc_data;	405	vorbis_enc_t *ve = vb->vorbis_enc_data;
406	st_ssize_t samples = len / ft->info.channels;	406	st_size_t samples = len / ft->info.channels;
407	float **buffer = vorbis_analysis_buffer(&ve->vd, samples);	407	float **buffer = vorbis_analysis_buffer(&ve->vd, samples);
408	st_ssize_t i, j;	408	st_size_t i, j;
409	int ret;	409	int ret;
410	int eos = 0;	410	int eos = 0;
411		411
@@ -450,7 +450,7 @@ st_ssize_t st_vorbiswrite(ft_t ft, const st_sample_t *buf, st_size_t len) · 38 unmodified lines
450	return (len);	450	return (len);
451	}	451	}
452		452
453	int st_vorbisstopwrite(ft_t ft)	453	static int st_vorbisstopwrite(ft_t ft)
454	{	454	{
455	vorbis_t vb = (vorbis_t) ft->priv;	455	vorbis_t vb = (vorbis_t) ft->priv;
456	vorbis_enc_t *ve = vb->vorbis_enc_data;	456	vorbis_enc_t *ve = vb->vorbis_enc_data;

src/vox.c+26−50

  *                                                                      *
  ************************************************************************/
-  ///////////////////////////////////////////
- // ORIGINAL SOX COPYRIGHT AND DISCLAIMER //
-///////////////////////////////////////////
 /************************************************************************
  * July 5, 1991                                                         *
  *                                                                      *
  *                                                                      *
  ************************************************************************/
-  ///////////////////
- // INCLUDE FILES //
-///////////////////
 #include "st_i.h"
-  //////////////
- // TYPEDEFS //
-//////////////
-typedef struct voxstuff { struct { short    last;                       // ADPCM codec state
+typedef struct voxstuff { struct { short    last;                       /* ADPCM codec state */
                                    short    index;
                                  } state;
-                          struct { uint8_t  byte;                       // write store
+                          struct { uint8_t  byte;                       /* write store */
                                    uint8_t  flag;
                                  } store;
                         } *vox_t;
-  ///////////////
- // CONSTANTS //
-///////////////
 static short STEPSIZE[49] = { 16,  17,  19,  21,  23,  25,  28,
                               31,  34,  37,  41,  45,  50,  55,
                               60,  66,  73,  80,  88,  97,  107,
 static short STEPADJUST[8] = { -1,-1,-1,-1,2,4,6,8 };
-  /////////////////////////
- // FUNCTION PROTOTYPES //
-/////////////////////////
 static uint8_t envox       (short,  vox_t);
 static short   devox       (uint8_t,vox_t);
-  ////////////////////
- // IMPLEMENTATION //
-////////////////////
 /******************************************************************************
  * Function   : st_voxstartread
  * Description: Initialises the file parameters and ADPCM codec state.
  *                 rates but the codecs allows any user specified rate.
  ******************************************************************************/
-int  st_voxstartread (ft_t ft)
+static int  st_voxstartread (ft_t ft)
      { vox_t state = (vox_t) ft->priv;
-           // ... setup file info
+       /* ... setup file info */
        ft->file.buf = (char *)malloc(ST_BUFSIZ);
        ft->file.pos      = 0;
        ft->file.eof      = 0;
-           ft->info.size     = ST_SIZE_WORD;
+       ft->info.size     = ST_SIZE_WORD;
        ft->info.encoding = ST_ENCODING_OKI_ADPCM;
        ft->info.channels = 1;
-       // ... initialise CODEC state
+       /* ... initialise CODEC state */
        state->state.last  = 0;
        state->state.index = 0;
  * Notes      :
  ******************************************************************************/
-st_ssize_t st_voxread (ft_t ft,st_sample_t *buffer,st_size_t length)
+static st_size_t st_voxread (ft_t ft,st_sample_t *buffer,st_size_t length)
            { vox_t    state = (vox_t) ft->priv;
-                 int      count = 0;
+             int      count = 0;
              int      N;
              uint8_t  byte;
              short    word;
-             // ... round length down to nearest even number
+             /* ... round length down to nearest even number */
              N  = length/2;
              N *=2;
-             // ... loop until buffer full or EOF
+             /* ... loop until buffer full or EOF */
              while (count < N)
-                   { // ... refill buffer
+               {     /* ... refill buffer */
                      if (ft->file.pos >= ft->file.count)
                         { ft->file.count = st_readbuf (ft,ft->file.buf,1,ft->file.size);
                              break;
                         }
-                     // ... decode two nibbles stored as a byte
+                     /* ... decode two nybbles stored as a byte */
                      byte      = ft->file.buf[ft->file.pos++];
  * Notes      :
  ******************************************************************************/
-int  st_voxstopread (ft_t ft)
+static int  st_voxstopread (ft_t ft)
      { free (ft->file.buf);
        return (ST_SUCCESS);
  *                 rates but the codecs allows any user specified rate.
  ******************************************************************************/
-int  st_voxstartwrite (ft_t ft)
+static int  st_voxstartwrite (ft_t ft)
      { vox_t state = (vox_t) ft->priv;
-           // ... setup file info
+       /* ... setup file info */
        ft->file.buf = (char *)malloc(ST_BUFSIZ);
        ft->info.encoding = ST_ENCODING_OKI_ADPCM;
        ft->info.channels = 1;
-       // ... initialise CODEC state
+       /* ... initialise CODEC state */
        state->state.last  = 0;
        state->state.index = 0;
  * Notes      :
  ******************************************************************************/
-st_ssize_t st_voxwrite (ft_t ft,const st_sample_t *buffer,st_size_t length)
+static st_size_t st_voxwrite (ft_t ft,const st_sample_t *buffer,st_size_t length)
            { vox_t    state = (vox_t) ft->priv;
-             int      count = 0;
+             st_size_t count = 0;
              uint8_t  byte  = state->store.byte;
              uint8_t  flag  = state->store.flag;
              short    word;
                      count++;
                    }
-             // ... keep last byte across calls
+             /* ... keep last byte across calls */
              state->store.byte = byte;
              state->store.flag = flag;
  * Notes      :
  ******************************************************************************/
-int  st_voxstopwrite (ft_t ft)
+static int  st_voxstopwrite (ft_t ft)
      { vox_t    state = (vox_t) ft->priv;
        uint8_t  byte  = state->store.byte;
        uint8_t  flag  = state->store.flag;
-       // ... flush remaining samples
+       /* ... flush remaining samples */
        if (flag != 0)
           { byte <<= 4;
        if (ft->file.count > 0)
           st_writebuf (ft,ft->file.buf,1,ft->file.count);
-       // ... free buffer
        free (ft->file.buf);
        return (ST_SUCCESS);
              { code = code | 0x01;
              }
-          // ... use decoder to set the estimate of last sample and adjust the step index
+          /* ... use decoder to set the estimate of last sample and
+             adjust the step index */
           state->state.last = devox (code,state);
         sample = state->state.last + dn;
-        // ... clip to 12 bits
+        /* ... clip to 12 bits */
         if (sample > 2047)
            sample = 2047;
         if (sample < -2048)
            sample = -2048;
-        // ... adjust step size
+        /* ... adjust step size */
         state->state.last   = sample;
         state->state.index += STEPADJUST[code & 0x07];
         if (state->state.index > 48)
            state->state.index = 48;
-        // ... done
+        /* ... done */
         return (sample);
       }

src/wav.c+39−87

 /*
  * Microsoft's WAVE sound format driver
  *
- * This source code is freely redistributable and may be used for
+ * Copyright 1998-2006 Chris Bagwell and SoX Contributors
- * any purpose.  This copyright notice must be maintained.
- * Lance Norskog And Sundry Contributors are not responsible for
- * the consequences of using this software.
- *
- * Change History:
- *
- * November  23, 1999 - Stan Brooks (stabro@megsinet.com)
- *   Merged in gsm support patches from Stuart Daines...
- *   Since we had simultaneously made similar changes in
- *   wavwritehdr() and wavstartread(), this was some
- *   work.  Hopefully the result is cleaner than either
- *   version, and nothing broke.
- *
- * November  20, 1999 - Stan Brooks (stabro@megsinet.com)
- *   Mods for faster adpcm decoding and addition of IMA_ADPCM
- *   and ADPCM  writing... low-level codex functions moved to
- *   external modules ima_rw.c and adpcm.c. Some general cleanup,
- *   consistent with writing adpcm and other output formats.
- *   Headers written for adpcm include the 'fact' subchunk.
- *
- * September 11, 1998 - Chris Bagwell (cbagwell@sprynet.com)
- *   Fixed length bug for IMA and MS ADPCM files.
- *
- * June 1, 1998 - Chris Bagwell (cbagwell@sprynet.com)
- *   Fixed some compiler warnings as reported by Kjetil Torgrim Homme
- *   <kjetilho@ifi.uio.no>.
- *   Fixed bug that caused crashes when reading mono MS ADPCM files. Patch
- *   was sent from Michael Brown (mjb@pootle.demon.co.uk).
- *
- * March 15, 1998 - Chris Bagwell (cbagwell@sprynet.com)
- *   Added support for Microsoft's ADPCM and IMA (or better known as
- *   DVI) ADPCM format for wav files.  Thanks goes to Mark Podlipec's
- *   XAnim code.  It gave some real life understanding of how the ADPCM
- *   format is processed.  Actual code was implemented based off of
- *   various sources from the net.
- *
- * NOTE: Previous maintainers weren't very good at providing contact
- * information.
- *
- * Copyright 1992 Rick Richardson
  * Copyright 1991 Lance Norskog And Sundry Contributors
- *
+ * Copyright 1992 Rick Richardson
- * Fixed by various contributors previous to 1998:
+ * Copyright 1997 Graeme W. Gill, 93/5/17
- * 1) Little-endian handling
- * 2) Skip other kinds of file data
- * 3) Handle 16-bit formats correctly
- * 4) Not go into infinite loop
- *
- * User options should override file header - we assumed user knows what
- * they are doing if they specify options.
- * Enhancements and clean up by Graeme W. Gill, 93/5/17
  *
  * Info for format tags can be found at:
  *   http://www.microsoft.com/asf/resources/draft-ietf-fleischman-codec-subtree-01.txt
  * ImaAdpcmReadBlock - Grab and decode complete block of samples
  *
  */
-unsigned short  ImaAdpcmReadBlock(ft_t ft)
+static unsigned short  ImaAdpcmReadBlock(ft_t ft)
 {
     wav_t       wav = (wav_t) ft->priv;
     int bytesRead;
  * AdpcmReadBlock - Grab and decode complete block of samples
  *
  */
-unsigned short  AdpcmReadBlock(ft_t ft)
+static unsigned short  AdpcmReadBlock(ft_t ft)
 {
     wav_t       wav = (wav_t) ft->priv;
     int bytesRead;
         for (p = wav->samplePtr; p < wav->sampleTop; p++) *p=0;
         /* compress the samples to wav->packet */
         if (wav->formatTag == WAVE_FORMAT_ADPCM) {
-            AdpcmBlockMashI(chans, wav->samples, wav->samplesPerBlock, wav->state, wav->packet, wav->blockAlign,9);
+            AdpcmBlockMashI(chans, wav->samples, wav->samplesPerBlock, wav->state, wav->packet, wav->blockAlign);
         }else{ /* WAVE_FORMAT_IMA_ADPCM */
             ImaBlockMashI(chans, wav->samples, wav->samplesPerBlock, wav->state, wav->packet, 9);
         }
 /* WAV GSM6.10 support functions                                            */
 /****************************************************************************/
 /* create the gsm object, malloc buffer for 160*2 samples */
-int wavgsminit(ft_t ft)
+static int wavgsminit(ft_t ft)
 {
     int valueP=1;
     wav_t       wav = (wav_t) ft->priv;
 }
 /*destroy the gsm object and free the buffer */
-void wavgsmdestroy(ft_t ft)
+static void wavgsmdestroy(ft_t ft)
 {
     wav_t       wav = (wav_t) ft->priv;
     gsm_destroy(wav->gsmhandle);
     free(wav->gsmsample);
 }
-st_ssize_t wavgsmread(ft_t ft, st_sample_t *buf, st_size_t len)
+static st_size_t wavgsmread(ft_t ft, st_sample_t *buf, st_size_t len)
 {
     wav_t       wav = (wav_t) ft->priv;
-    int done=0;
+    size_t done=0;
     int bytes;
     gsm_byte    frame[65];
-        ft->st_errno = ST_SUCCESS;
+    ft->st_errno = ST_SUCCESS;
   /* copy out any samples left from the last call */
     while(wav->gsmindex && (wav->gsmindex<160*2) && (done < len))
     return (ST_SUCCESS);
 }
-st_ssize_t wavgsmwrite(ft_t ft, const st_sample_t *buf, st_size_t len)
+static st_size_t wavgsmwrite(ft_t ft, const st_sample_t *buf, st_size_t len)
 {
-    wav_t       wav = (wav_t) ft->priv;
+    wav_t wav = (wav_t) ft->priv;
-    int done = 0;
+    size_t done = 0;
     int rc;
-        ft->st_errno = ST_SUCCESS;
+    ft->st_errno = ST_SUCCESS;
     while (done < len) {
         while ((wav->gsmindex < 160*2) && (done < len))
 }
-void wavgsmstopwrite(ft_t ft)
+static void wavgsmstopwrite(ft_t ft)
 {
     wav_t       wav = (wav_t) ft->priv;
  *      size and encoding of samples,
  *      mono/stereo/quad.
  */
-int st_wavstartread(ft_t ft)
+static int st_wavstartread(ft_t ft)
 {
     wav_t       wav = (wav_t) ft->priv;
     char        magic[5];
     case WAVE_FORMAT_PCM:
         /* Default (-1) depends on sample size.  Set that later on. */
-        if (ft->info.encoding != -1 && ft->info.encoding != ST_ENCODING_UNSIGNED &&
+        if (ft->info.encoding != ST_ENCODING_UNKNOWN && ft->info.encoding != ST_ENCODING_UNSIGNED &&
             ft->info.encoding != ST_ENCODING_SIGN2)
             st_report("User options overriding encoding read in .wav header");
         break;
     case WAVE_FORMAT_IMA_ADPCM:
-        if (ft->info.encoding == -1 || ft->info.encoding == ST_ENCODING_IMA_ADPCM)
+        if (ft->info.encoding == ST_ENCODING_UNKNOWN || ft->info.encoding == ST_ENCODING_IMA_ADPCM)
             ft->info.encoding = ST_ENCODING_IMA_ADPCM;
         else
             st_report("User options overriding encoding read in .wav header");
         break;
     case WAVE_FORMAT_ADPCM:
-        if (ft->info.encoding == -1 || ft->info.encoding == ST_ENCODING_ADPCM)
+        if (ft->info.encoding == ST_ENCODING_UNKNOWN || ft->info.encoding == ST_ENCODING_ADPCM)
             ft->info.encoding = ST_ENCODING_ADPCM;
         else
             st_report("User options overriding encoding read in .wav header");
         break;
     case WAVE_FORMAT_IEEE_FLOAT:
-        if (ft->info.encoding == -1 || ft->info.encoding == ST_ENCODING_FLOAT)
+        if (ft->info.encoding == ST_ENCODING_UNKNOWN || ft->info.encoding == ST_ENCODING_FLOAT)
             ft->info.encoding = ST_ENCODING_FLOAT;
         else
             st_report("User options overriding encoding read in .wav header");
         break;
     case WAVE_FORMAT_ALAW:
-        if (ft->info.encoding == -1 || ft->info.encoding == ST_ENCODING_ALAW)
+        if (ft->info.encoding == ST_ENCODING_UNKNOWN || ft->info.encoding == ST_ENCODING_ALAW)
             ft->info.encoding = ST_ENCODING_ALAW;
         else
             st_report("User options overriding encoding read in .wav header");
         break;
     case WAVE_FORMAT_MULAW:
-        if (ft->info.encoding == -1 || ft->info.encoding == ST_ENCODING_ULAW)
+        if (ft->info.encoding == ST_ENCODING_UNKNOWN || ft->info.encoding == ST_ENCODING_ULAW)
             ft->info.encoding = ST_ENCODING_ULAW;
         else
             st_report("User options overriding encoding read in .wav header");
         st_fail_errno(ft,ST_EHDR,"Sorry, this WAV file is in Dolby AC2 format.");
         return ST_EOF;
     case WAVE_FORMAT_GSM610:
-        if (ft->info.encoding == -1 || ft->info.encoding == ST_ENCODING_GSM )
+        if (ft->info.encoding == ST_ENCODING_UNKNOWN || ft->info.encoding == ST_ENCODING_GSM )
             ft->info.encoding = ST_ENCODING_GSM;
         else
             st_report("User options overriding encoding read in .wav header");
     }
     /* User options take precedence */
-    if (ft->info.channels == -1 || ft->info.channels == wChannels)
+    if (ft->info.channels == 0 || ft->info.channels == wChannels)
         ft->info.channels = wChannels;
     else
         st_report("User options overriding channels read in .wav header");
             st_warn("User options overriding size read in .wav header");
         /* Now we have enough information to set default encodings. */
-        if (ft->info.encoding == -1)
+        if (ft->info.encoding == ST_ENCODING_UNKNOWN)
             ft->info.encoding = ST_ENCODING_UNSIGNED;
         break;
             st_warn("User options overriding size read in .wav header");
         /* Now we have enough information to set default encodings. */
-        if (ft->info.encoding == -1)
+        if (ft->info.encoding == ST_ENCODING_UNKNOWN)
             ft->info.encoding = ST_ENCODING_SIGN2;
         break;
             st_warn("User options overriding size read in .wav header");
         /* Now we have enough information to set default encodings. */
-        if (ft->info.encoding == -1)
+        if (ft->info.encoding == ST_ENCODING_UNKNOWN)
             ft->info.encoding = ST_ENCODING_SIGN2;
         break;
             st_warn("User options overriding size read in .wav header");
         /* Now we have enough information to set default encodings. */
-        if (ft->info.encoding == -1)
+        if (ft->info.encoding == ST_ENCODING_UNKNOWN)
             ft->info.encoding = ST_ENCODING_SIGN2;
         break;
  * Return number of samples read.
  */
-st_ssize_t st_wavread(ft_t ft, st_sample_t *buf, st_size_t len)
+static st_size_t st_wavread(ft_t ft, st_sample_t *buf, st_size_t len)
 {
         wav_t   wav = (wav_t) ft->priv;
-        st_ssize_t done;
+        st_size_t done;
         ft->st_errno = ST_SUCCESS;
                 /* Copy interleaved data into buf, converting to st_sample_t */
                 {
                     short *p, *top;
-                    int ct;
+                    size_t ct;
                     ct = len-done;
                     if (ct > (wav->blockSamplesRemaining*ft->info.channels))
                         ct = (wav->blockSamplesRemaining*ft->info.channels);
  * Do anything required when you stop reading samples.
  * Don't close input file!
  */
-int st_wavstopread(ft_t ft)
+static int st_wavstopread(ft_t ft)
 {
     wav_t       wav = (wav_t) ft->priv;
     int         rc = ST_SUCCESS;
     return rc;
 }
-int st_wavstartwrite(ft_t ft)
+static int st_wavstartwrite(ft_t ft)
 {
     wav_t wav = (wav_t) ft->priv;
     int rc;
     wav->iCoefs = NULL;
     switch (wav->formatTag)
     {
-        int ch, sbsize;
+        size_t ch, sbsize;
         case WAVE_FORMAT_IMA_ADPCM:
             initImaTable();
     if (isExtensible)
     {
-      int i;
+      size_t i;
       static const char guid[14] = "\x00\x00\x00\x00\x10\x00\x80\x00\x00\xAA\x00\x38\x9B\x71";
       st_writew(ft, 22);
       st_writew(ft, wBitsPerSample); /* No padding in container */
     return ST_SUCCESS;
 }
-st_ssize_t st_wavwrite(ft_t ft, const st_sample_t *buf, st_size_t len)
+static st_size_t st_wavwrite(ft_t ft, const st_sample_t *buf, st_size_t len)
 {
         wav_t   wav = (wav_t) ft->priv;
         st_ssize_t total_len = len;
         }
 }
-int st_wavstopwrite(ft_t ft)
+static int st_wavstopwrite(ft_t ft)
 {
         wav_t   wav = (wav_t) ft->priv;
         }
 }
-int st_wavseek(ft_t ft, st_size_t offset)
+static int st_wavseek(ft_t ft, st_size_t offset)
 {
     wav_t   wav = (wav_t) ft->priv;
     int new_offset, channel_block, alignment;

src/wve.c+7−7

@@ -25,7 +25,7 @@ typedef struct wvepriv · 24 unmodified lines
25		25
26	static void wvewriteheader(ft_t ft);	26	static void wvewriteheader(ft_t ft);
27		27
28	int st_wveseek(ft_t ft, st_size_t offset)	28	static int st_wveseek(ft_t ft, st_size_t offset)
29	{	29	{
30	int new_offset, channel_block, alignment;	30	int new_offset, channel_block, alignment;
31	wve_t wve = (wve_t ) ft->priv;	31	wve_t wve = (wve_t ) ft->priv;
@@ -45,7 +45,7 @@ int st_wveseek(ft_t ft, st_size_t offset) · 13 unmodified lines
45	return st_seeki(ft, offset, SEEK_SET);	45	return st_seeki(ft, offset, SEEK_SET);
46	}	46	}
47		47
48	int st_wvestartread(ft_t ft)	48	static int st_wvestartread(ft_t ft)
49	{	49	{
50	wve_t p = (wve_t ) ft->priv;	50	wve_t p = (wve_t ) ft->priv;
51	char magic[16];	51	char magic[16];
@@ -117,7 +117,7 @@ int st_wvestartread(ft_t ft) · 65 unmodified lines
117	st_report("WVE must use 8000 sample rate. Overriding");	117	st_report("WVE must use 8000 sample rate. Overriding");
118	ft->info.rate = 8000;	118	ft->info.rate = 8000;
119		119
120	if (ft->info.channels != -1 && ft->info.channels != 1)	120	if (ft->info.channels != ST_ENCODING_UNKNOWN && ft->info.channels != 1)
121	st_report("WVE must only supports 1 channel. Overriding");	121	st_report("WVE must only supports 1 channel. Overriding");
122	ft->info.channels = 1;	122	ft->info.channels = 1;
123		123
@@ -136,7 +136,7 @@ int st_wvestartread(ft_t ft) · 12 unmodified lines
136	if it is not, the unspecified size remains in the header	136	if it is not, the unspecified size remains in the header
137	(this is illegal). */	137	(this is illegal). */
138		138
139	int st_wvestartwrite(ft_t ft)	139	static int st_wvestartwrite(ft_t ft)
140	{	140	{
141	wve_t p = (wve_t ) ft->priv;	141	wve_t p = (wve_t ) ft->priv;
142	int rc;	142	int rc;
@@ -161,7 +161,7 @@ int st_wvestartwrite(ft_t ft) · 18 unmodified lines
161	if (ft->info.rate != 0)	161	if (ft->info.rate != 0)
162	st_report("WVE must use 8000 sample rate. Overriding");	162	st_report("WVE must use 8000 sample rate. Overriding");
163		163
164	if (ft->info.channels != -1 && ft->info.channels != 1)	164	if (ft->info.channels != 0 && ft->info.channels != 1)
165	st_report("WVE must only supports 1 channel. Overriding");	165	st_report("WVE must only supports 1 channel. Overriding");
166		166
167	ft->info.encoding = ST_ENCODING_ALAW;	167	ft->info.encoding = ST_ENCODING_ALAW;
@@ -172,14 +172,14 @@ int st_wvestartwrite(ft_t ft) · 4 unmodified lines
172	return ST_SUCCESS;	172	return ST_SUCCESS;
173	}	173	}
174		174
175	st_ssize_t st_wvewrite(ft_t ft, const st_sample_t *buf, st_size_t samp)	175	static st_size_t st_wvewrite(ft_t ft, const st_sample_t *buf, st_size_t samp)
176	{	176	{
177	wve_t p = (wve_t ) ft->priv;	177	wve_t p = (wve_t ) ft->priv;
178	p->length += samp * ft->info.size;	178	p->length += samp * ft->info.size;
179	return st_rawwrite(ft, buf, samp);	179	return st_rawwrite(ft, buf, samp);
180	}	180	}
181		181
182	int st_wvestopwrite(ft_t ft)	182	static int st_wvestopwrite(ft_t ft)
183	{	183	{
184		184
185	/* Call before seeking to flush buffer */	185	/* Call before seeking to flush buffer */

src/xa.c+4−6

         st_report("User options overriding size read in .xa header");
     }
-    if (ft->info.channels == -1 || ft->info.channels == xa->header.channels) {
+    if (ft->info.channels == 0 || ft->info.channels == xa->header.channels) {
         ft->info.channels = xa->header.channels;
     } else {
         st_report("User options overriding channels read in .xa header");
  * Read up to len samples from a file, converted to signed longs.
  * Return the number of samples read.
  */
-static st_ssize_t st_xaread(ft_t ft, st_sample_t *buf, st_size_t len)
+static st_size_t st_xaread(ft_t ft, st_sample_t *buf, st_size_t len)
 {
     xa_t xa = (xa_t) ft->priv;
-    st_ssize_t done;
-    st_ssize_t bytes;
     int32_t sample;
     unsigned char inByte;
-    unsigned int i;
+    size_t i, done, bytes;
     ft->st_errno = ST_SUCCESS;
     done = 0;
     return ST_EOF;
 }
-static st_ssize_t st_xawrite(ft_t ft, const st_sample_t *buf, st_size_t len)
+static st_size_t st_xawrite(ft_t ft, const st_sample_t *buf UNUSED, st_size_t len UNUSED)
 {
     st_fail_errno(ft, ST_ENOTSUP, ".XA writing not supported");
     return ST_EOF;

Fix read and write return types: now st_size_t, like the size inputs.

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code

@@ -30,7 +30,7 @@ typedef struct { · 29 unmodified lines
30	/*	30	/*
31	* Process options: dcshift (double) type (amplitude, power, dB)	31	* Process options: dcshift (double) type (amplitude, power, dB)
32	*/	32	*/
33	int st_dcshift_getopts(eff_t effp, int n, char **argv)	33	static int st_dcshift_getopts(eff_t effp, int n, char **argv)
34	{	34	{
35	dcs_t dcs = (dcs_t) effp->priv;	35	dcs_t dcs = (dcs_t) effp->priv;
36	dcs->dcshift = 1.0; /* default is no change */	36	dcs->dcshift = 1.0; /* default is no change */
@@ -72,7 +72,7 @@ int st_dcshift_getopts(eff_t effp, int n, char **argv) · 35 unmodified lines
72	/*	72	/*
73	* Start processing	73	* Start processing
74	*/	74	*/
75	int st_dcshift_start(eff_t effp)	75	static int st_dcshift_start(eff_t effp)
76	{	76	{
77	dcs_t dcs = (dcs_t) effp->priv;	77	dcs_t dcs = (dcs_t) effp->priv;
78		78
@@ -99,7 +99,7 @@ int st_dcshift_start(eff_t effp) · 20 unmodified lines
99	/*	99	/*
100	* Process data.	100	* Process data.
101	*/	101	*/
102	int st_dcshift_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf,	102	static int st_dcshift_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf,
103	st_size_t isamp, st_size_t osamp)	103	st_size_t isamp, st_size_t osamp)
104	{	104	{
105	dcs_t dcs = (dcs_t) effp->priv;	105	dcs_t dcs = (dcs_t) effp->priv;
@@ -166,7 +166,7 @@ int st_dcshift_flow(eff_t effp, const st_sample_t ibuf, st_sample_t obuf, · 60 unmodified lines
166	* Do anything required when you stop reading samples.	166	* Do anything required when you stop reading samples.
167	* Don't close input file!	167	* Don't close input file!
168	*/	168	*/
169	int st_dcshift_stop(eff_t effp)	169	static int st_dcshift_stop(eff_t effp)
170	{	170	{
171	dcs_t dcs = (dcs_t) effp->priv;	171	dcs_t dcs = (dcs_t) effp->priv;
172		172