sigrid/sox · Ink

ChangeLog+12−5

   Deprec-  Feature    [O(ption)]                           Removal
   ated in  [F(ormat)] [E(ffect)]   Replacement             due after
   -------  ----------------------  ----------------------  -------
+  14.3.0   E norm -b, norm -i      gain -B, gain -en       14.3.0 + 1 year
   14.3.0   F flac: libFLAC 1.1.2,3 libFLAC > 1.1.3         14.3.0 + 6 months
 Previously deprecated features (to be removed in future):
   o Fix [2404566] segfault when converting from MS ADPCM wav file.  (robs)
   o Fix slight FLAC seek inaccuracy e.g. when using `trim' effect.  (robs)
+Audio device drivers:
+  o New native OpenBSD audio handler for play/recording.  (Alexandre Ratchov)
+  o 24-bit support for ALSA handler.  (robs)
+  o Warn if ALSA under/overrun.  (robs)
 Effects:
   o New `overdrive' effect.  (robs)
   o New `pluck' and `tpdf' types for `synth'.  (robs)
   o Can now set common parameters for multiple `synth' channels.  (robs)
+  o Richer gain/normalise options.  (robs)
   o Fix [2487589] `dither' clipping detection & handling.  (robs)
   o Fix `repeat' sometimes stopping repeating too soon.  (robs)
   o Fix `repeat' sometimes repeating wrong audio segments.  (robs)
 Other new features:
-  o New native OpenBSD audio handler for play/recording.  (Alexandre Ratchov)
+  o Added ability to create shared DLL's on cygwin (cbagwell)
-  o 24-bit support for ALSA handler.  (robs)
+  o New `--guard' & `--norm' options; use temporary files to guard against
-  o Warn if ALSA under/overrun.  (robs)
+    clipping for many, but not currently all, effects.  (robs)
   o New `--ignore-length' option to ignore length in input file
     header (for simple encodings); instead, read to end of file.  (robs)
-  o Added ability to create shared DLL's on cygwin (cbagwell)
-  o Grouped files, e.g. play -r 6k "*.vox" plays all at 6k.  (robs)
   o New `--temp DIRECTORY' option.  (robs)
+  o Grouped files, e.g. play -r 6k "*.vox" plays all at 6k.  (robs)
   o New bitrate, time in seconds, & total options for soxi.  (robs)
 Other bug fixes:

src/.cvsignore+0−1

@@ -1,5 +1,4 @@
1	Makefile Makefile.in	1	Makefile Makefile.in
2	sox_sample_test
3	example0 example1 example2	2	example0 example1 example2
4	soxconfig.h.in soxconfig.h soxstdint.h	3	soxconfig.h.in soxconfig.h soxstdint.h
5	.deps	4	.deps

src/8svx.c+1−2

 static size_t write_samples(sox_format_t * ft, const sox_sample_t *buf, size_t len)
 {
         priv_t * p = (priv_t * ) ft->priv;
-        SOX_SAMPLE_LOCALS;
         unsigned char datum;
         size_t done = 0, i;
         while(done < len) {
                 for (i = 0; i < ft->signal.channels; i++) {
-                        datum = SOX_SAMPLE_TO_SIGNED_8BIT(*buf++, ft->clips);
+                        datum = SOX_SAMPLE_TO_SIGNED_8BIT(*buf++);
                         /* FIXME: Needs to pass ft struct and not FILE */
                         putc(datum, p->ch[i]);
                 }

src/CMakeLists.txt+8−9

 # Format with: !xargs echo|tr ' ' '\n'|sort|column|expand|sed 's/^/  /'
 set(effects_srcs
-  bend            dither          lowfir          phaser          stat
+  bend            dither          loudness        phaser          stat
-  biquad          earwax          mcompand        rate            stretch
+  biquad          earwax          lowfir          rate            stretch
-  biquads         echo            mixer           remix           swap
+  biquads         echo            mcompand        remix           swap
-  chorus          echos           noiseprof       repeat          synth
+  chorus          echos           mixer           repeat          synth
-  compand         fade            noisered        reverb          tempo
+  compand         fade            noiseprof       reverb          tempo
-  compandt        fft4g           normalise       reverse         tremolo
+  compandt        fft4g           noisered        reverse         tremolo
   contrast        filter          output          silence         trim
   dcshift         flanger         overdrive       skeleff         vol
-  delay           input           pad             speed
+  delay           gain            pad             speed
-  dft_filter      loudness        pan             splice
+  dft_filter      input           pan             splice
 )
 set(formats_srcs
   8svx            dat             ima-fmt         s3-fmt          u3-fmt
 )
 add_executable(${PROJECT_NAME} ${PROJECT_NAME}.c)
 target_link_libraries(${PROJECT_NAME} lib${PROJECT_NAME} lpc10 ${optional_libs})
-add_executable(sox_sample_test sox_sample_test.c)
 add_executable(example0 example0.c)
 target_link_libraries(example0 lib${PROJECT_NAME} lpc10 ${optional_libs})
 add_executable(example1 example1.c)

src/Makefile.am+3−5

 #########################
 bin_PROGRAMS = sox
-EXTRA_PROGRAMS = example0 example1 example2 sox_sample_test
+EXTRA_PROGRAMS = example0 example1 example2
 lib_LTLIBRARIES = libsox.la
 include_HEADERS = sox.h
 nodist_include_HEADERS = soxstdint.h
 example0_SOURCES = example0.c
 example1_SOURCES = example1.c
 example2_SOURCES = example2.c
-sox_sample_test_SOURCES = sox_sample_test.c sox_sample_test.h
 ###############################################
 # libsox - Dynamic Libraries for File Formats #
 	dither_fir.h dither_iir.h earwax.c echo.c echos.c effects.c effects.h \
 	effects_i.c fade.c fft4g.c fft4g.h fifo.h filter.c flanger.c input.c \
 	ladspa.c loudness.c mcompand.c mcompand_xover.h mixer.c noiseprof.c \
-	noisered.c noisered.h normalise.c output.c pad.c pan.c phaser.c \
+	noisered.c noisered.h gain.c output.c pad.c pan.c phaser.c \
 	rate.c rate_filters.h rate_half_fir.h \
 	rate_poly_fir0.h rate_poly_fir.h remix.c repeat.c reverb.c \
 	reverse.c silence.c skeleff.c speed.c splice.c stat.c swap.c stretch.c \
 	     CMakeLists.txt soxstdint.h.cmake soxconfig.h.cmake \
 	     tests.sh testall.sh tests.bat testall.bat test-comments
-all: sox$(EXEEXT) play rec soxi sox_sample_test$(EXEEXT) example0$(EXEEXT) example1$(EXEEXT) example2$(EXEEXT)
+all: sox$(EXEEXT) play rec soxi example0$(EXEEXT) example1$(EXEEXT) example2$(EXEEXT)
 play rec: sox$(EXEEXT)
 	if test "$(PLAYRECLINKS)" = "yes"; then	\
 clean-local:
 	$(RM) play rec soxi
-	$(RM) sox_sample_test$(EXEEXT)
 	$(RM) example0$(EXEEXT) example1$(EXEEXT) example2$(EXEEXT)
 distclean-local:

src/adpcms.c+1−2

@@ -251,8 +251,7 @@ size_t lsx_adpcm_write(sox_format_t * ft, adpcm_io_t * state, const sox_sample_t · 250 unmodified lines
251	short word;	251	short word;
252		252
253	while (count < length) {	253	while (count < length) {
254	SOX_SAMPLE_LOCALS;	254	word = SOX_SAMPLE_TO_SIGNED_16BIT(*buffer++);
255	word = SOX_SAMPLE_TO_SIGNED_16BIT(*buffer++, ft->clips);
256		255
257	byte <<= 4;	256	byte <<= 4;
258	byte \|= lsx_adpcm_encode(word, &state->encoder) & 0x0F;	257	byte \|= lsx_adpcm_encode(word, &state->encoder) & 0x0F;

src/alsa.c+8−9

   priv_t             * p = (priv_t *)ft->priv;
   size_t             done, i, n;
   snd_pcm_sframes_t  actual;
-  SOX_SAMPLE_LOCALS;
   for (done = 0; done < len; done += n) {
     i = n = min(len - done, p->buf_len);
     switch (p->format) {
       case SND_PCM_FORMAT_S8: {
         int8_t * buf1 = (int8_t *)p->buf;
-        while (i--) *buf1++ = SOX_SAMPLE_TO_SIGNED_8BIT(*buf++, ft->clips);
+        while (i--) *buf1++ = SOX_SAMPLE_TO_SIGNED_8BIT(*buf++);
         break;
       }
       case SND_PCM_FORMAT_U8: {
         uint8_t * buf1 = (uint8_t *)p->buf;
-        while (i--) *buf1++ = SOX_SAMPLE_TO_UNSIGNED_8BIT(*buf++, ft->clips);
+        while (i--) *buf1++ = SOX_SAMPLE_TO_UNSIGNED_8BIT(*buf++);
         break;
       }
       case SND_PCM_FORMAT_S16: {
         int16_t * buf1 = (int16_t *)p->buf;
         if (ft->encoding.reverse_bytes) while (i--)
-          *buf1++ = lsx_swapw(SOX_SAMPLE_TO_SIGNED_16BIT(*buf++, ft->clips));
+          *buf1++ = lsx_swapw(SOX_SAMPLE_TO_SIGNED_16BIT(*buf++));
         else
-          while (i--) *buf1++ = SOX_SAMPLE_TO_SIGNED_16BIT(*buf++, ft->clips);
+          while (i--) *buf1++ = SOX_SAMPLE_TO_SIGNED_16BIT(*buf++);
         break;
       }
       case SND_PCM_FORMAT_U16: {
         uint16_t * buf1 = (uint16_t *)p->buf;
         if (ft->encoding.reverse_bytes) while (i--)
-          *buf1++ = lsx_swapw(SOX_SAMPLE_TO_UNSIGNED_16BIT(*buf++, ft->clips));
+          *buf1++ = lsx_swapw(SOX_SAMPLE_TO_UNSIGNED_16BIT(*buf++));
         else
-          while (i--) *buf1++ = SOX_SAMPLE_TO_UNSIGNED_16BIT(*buf++, ft->clips);
+          while (i--) *buf1++ = SOX_SAMPLE_TO_UNSIGNED_16BIT(*buf++);
         break;
       }
       case SND_PCM_FORMAT_S24: {
         int24_t * buf1 = (int24_t *)p->buf;
-        while (i--) *buf1++ = SOX_SAMPLE_TO_SIGNED_24BIT(*buf++, ft->clips);
+        while (i--) *buf1++ = SOX_SAMPLE_TO_SIGNED_24BIT(*buf++);
         break;
       }
       case SND_PCM_FORMAT_U24: {
         uint24_t * buf1 = (uint24_t *)p->buf;
-        while (i--) *buf1++ = SOX_SAMPLE_TO_UNSIGNED_24BIT(*buf++, ft->clips);
+        while (i--) *buf1++ = SOX_SAMPLE_TO_UNSIGNED_24BIT(*buf++);
         break;
       }
     }

src/amr.h+1−2

@@ -117,8 +117,7 @@ static size_t write_samples(sox_format_t * ft, const sox_sample_t * buf, size_t · 116 unmodified lines
117	size_t done;	117	size_t done;
118		118
119	for (done = 0; done < len; ++done) {	119	for (done = 0; done < len; ++done) {
120	SOX_SAMPLE_LOCALS;	120	p->pcm[p->pcm_index++] = SOX_SAMPLE_TO_SIGNED_16BIT(*buf++);
121	p->pcm[p->pcm_index++] = SOX_SAMPLE_TO_SIGNED_16BIT(*buf++, ft->clips);
122	if (p->pcm_index == AMR_FRAME) {	121	if (p->pcm_index == AMR_FRAME) {
123	p->pcm_index = 0;	122	p->pcm_index = 0;
124	if (!encode_1_frame(ft))	123	if (!encode_1_frame(ft))

src/ao.c+3−5

   return SOX_SUCCESS;
 }
-static void sox_sw_write_buf(char *buf1, sox_sample_t const * buf2, size_t len, sox_bool swap, size_t * clips)
+static void sox_sw_write_buf(char *buf1, sox_sample_t const * buf2, size_t len, sox_bool swap)
 {
     while (len--)
     {
-        SOX_SAMPLE_LOCALS;
+        uint16_t datum = SOX_SAMPLE_TO_SIGNED_16BIT(*buf2++);
-        uint16_t datum = SOX_SAMPLE_TO_SIGNED_16BIT(*buf2++, *clips);
         if (swap)
             datum = lsx_swapw(datum);
         *(uint16_t *)buf1 = datum;
   aobuf_size = (ft->encoding.bits_per_sample >> 3) * len;
-  sox_sw_write_buf(ao->buf, buf, len, ft->encoding.reverse_bytes,
+  sox_sw_write_buf(ao->buf, buf, len, ft->encoding.reverse_bytes);
-                   &(ft->clips));
   if (ao_play(ao->device, (void *)ao->buf, aobuf_size) == 0)
     return 0;

src/band.h+5−4

@@ -40,7 +40,8 @@ · 39 unmodified lines
40		40
41	p->a2 = exp(-2 * M_PI * bw_Hz / effp->in_signal.rate);	41	p->a2 = exp(-2 * M_PI * bw_Hz / effp->in_signal.rate);
42	p->a1 = -4 * p->a2 / (1 + p->a2) * cos(2 * M_PI * p->fc / effp->in_signal.rate);	42	p->a1 = -4 * p->a2 / (1 + p->a2) * cos(2 * M_PI * p->fc / effp->in_signal.rate);
43	if (p->filter_type == filter_BPF_SPK_N)	43	p->b0 = sqrt(1 - p->a1 * p->a1 / (4 * p->a2)) * (1 - p->a2);
44	p->b0 = sqrt(((1+p->a2) * (1+p->a2) - p->a1p->a1) (1-p->a2) / (1+p->a2));	44	if (p->filter_type == filter_BPF_SPK_N) {
45	else	45	mult = sqrt(((1+p->a2) * (1+p->a2) - p->a1p->a1) (1-p->a2) / (1+p->a2)) / p->b0;
46	p->b0 = sqrt(1 - p->a1 * p->a1 / (4 * p->a2)) * (1 - p->a2);	46	p->b0 *= mult;
		47	}

src/bend.c+1−1

@@ -154,7 +154,7 @@ static int flow(sox_effect_t * effp, const sox_sample_t * ibuf, · 153 unmodified lines
154	++p->in_pos;	154	++p->in_pos;
155		155
156	/* As long as we have not yet collected enough data just read in */	156	/* As long as we have not yet collected enough data just read in */
157	p->gInFIFO[p->gRover] = SOX_SAMPLE_TO_FLOAT_32BIT(ibuf[i], effp->clips);	157	p->gInFIFO[p->gRover] = SOX_SAMPLE_TO_FLOAT_32BIT(ibuf[i]);
158	obuf[i] = SOX_FLOAT_32BIT_TO_SAMPLE(	158	obuf[i] = SOX_FLOAT_32BIT_TO_SAMPLE(
159	p->gOutFIFO[p->gRover - inFifoLatency], effp->clips);	159	p->gOutFIFO[p->gRover - inFifoLatency], effp->clips);
160	p->gRover++;	160	p->gRover++;

src/biquad.h+1−3

 #ifndef biquad_included
 #define biquad_included
+#define LSX_EFF_ALIAS
 #include "sox_i.h"
 typedef enum {
 int lsx_biquad_flow(sox_effect_t * effp, const sox_sample_t *ibuf, sox_sample_t *obuf,
                         size_t *isamp, size_t *osamp);
-#undef lsx_fail
-#define lsx_fail sox_globals.subsystem=effp->handler.name,lsx_fail
 #endif

src/biquads.c+4−1

   priv_t * p = (priv_t *)effp->priv;
   double w0 = 2 * M_PI * p->fc / effp->in_signal.rate;
   double A  = exp(p->gain / 40 * log(10.));
-  double alpha = 0;
+  double alpha = 0, mult = dB_to_linear(max(p->gain, 0));
   if (w0 > M_PI) {
     lsx_fail("frequency must be less than half the sample-rate (Nyquist rate)");
       {double g = dB_to_linear(19.9 - linear_to_dB(
             (p->b0 + p->b1 + p->b2) / (p->a0 + p->a1 + p->a2)));
       p->b0 *= g; p->b1 *= g; p->b2 *= g;}
+      mult = dB_to_linear(19.9);
       break;
   }
+  if (effp->in_signal.mult)
+    *effp->in_signal.mult /= mult;
   return lsx_biquad_start(effp);
 }

src/chorus.c+1−1

@@ -333,7 +333,7 @@ static int sox_chorus_stop(sox_effect_t * effp) · 332 unmodified lines
333	static sox_effect_handler_t sox_chorus_effect = {	333	static sox_effect_handler_t sox_chorus_effect = {
334	"chorus",	334	"chorus",
335	"gain-in gain-out delay decay speed depth [ -s \| -t ]",	335	"gain-in gain-out delay decay speed depth [ -s \| -t ]",
336	SOX_EFF_LENGTH,	336	SOX_EFF_LENGTH \| SOX_EFF_GAIN,
337	sox_chorus_getopts,	337	sox_chorus_getopts,
338	sox_chorus_start,	338	sox_chorus_start,
339	sox_chorus_flow,	339	sox_chorus_flow,

src/compand.c+1−1

@@ -275,7 +275,7 @@ static int kill(sox_effect_t * effp) · 274 unmodified lines
275	sox_effect_handler_t const * sox_compand_effect_fn(void)	275	sox_effect_handler_t const * sox_compand_effect_fn(void)
276	{	276	{
277	static sox_effect_handler_t handler = {	277	static sox_effect_handler_t handler = {
278	"compand", compand_usage, SOX_EFF_MCHAN,	278	"compand", compand_usage, SOX_EFF_MCHAN \| SOX_EFF_GAIN,
279	getopts, start, flow, drain, stop, kill, sizeof(priv_t)	279	getopts, start, flow, drain, stop, kill, sizeof(priv_t)
280	};	280	};
281	return &handler;	281	return &handler;

src/coreaudio.c+1−1

@@ -285,7 +285,7 @@ static size_t write_samples(sox_format_t ft, const sox_sample_t buf, size_t ns · 284 unmodified lines
285	p = &ac->buffer[ac->buf_offset];	285	p = &ac->buffer[ac->buf_offset];
286		286
287	while (samp_left--)	287	while (samp_left--)
288	p++ = SOX_SAMPLE_TO_FLOAT_32BIT(buf++, ft->clips);	288	p++ = SOX_SAMPLE_TO_FLOAT_32BIT(buf++);
289		289
290	ac->buf_offset += len;	290	ac->buf_offset += len;
291		291

src/dat.c+3−4

       /* Read a complete set of channels */
       sscanf(inpstr," %*s%n", &inpPtr);
       for (i=0; i<ft->signal.channels; i++) {
+        SOX_SAMPLE_LOCALS;
         retc = sscanf(&inpstr[inpPtr]," %lg%n", &sampval, &inpPtrInc);
         inpPtr += inpPtrInc;
         if (retc != 1) {
           lsx_fail_errno(ft,SOX_EOF,"Unable to read sample.");
           return 0;
         }
-        sampval *= SOX_SAMPLE_MAX;
+        *buf++ = SOX_FLOAT_64BIT_TO_SAMPLE(sampval, ft->clips);
-        *buf++ = SOX_ROUND_CLIP_COUNT(sampval, ft->clips);
         done++;
       }
     }
       sprintf(s," %15.8g ",dat->timevalue);
       lsx_writes(ft, s);
       for (i=0; i<ft->signal.channels; i++) {
-        SOX_SAMPLE_LOCALS;
+        sampval = SOX_SAMPLE_TO_FLOAT_64BIT(*buf++);
-        sampval = SOX_SAMPLE_TO_FLOAT_64BIT(*buf++, ft->clips);
         sprintf(s," %15.8g", sampval);
         lsx_writes(ft, s);
         done++;

src/dcshift.c+1−1

@@ -173,7 +173,7 @@ static sox_effect_handler_t sox_dcshift_effect = { · 172 unmodified lines
173	"shift [ limitergain ]\n"	173	"shift [ limitergain ]\n"
174	" The peak limiter has a gain much less than 1.0 (ie 0.05 or 0.02) which is only\n"	174	" The peak limiter has a gain much less than 1.0 (ie 0.05 or 0.02) which is only\n"
175	" used on peaks to prevent clipping. (default is no limiter)",	175	" used on peaks to prevent clipping. (default is no limiter)",
176	SOX_EFF_MCHAN,	176	SOX_EFF_MCHAN \| SOX_EFF_GAIN,
177	sox_dcshift_getopts,	177	sox_dcshift_getopts,
178	sox_dcshift_start,	178	sox_dcshift_start,
179	sox_dcshift_flow,	179	sox_dcshift_flow,

src/dft_filter.c+2−2

@@ -79,7 +79,7 @@ static int flow(sox_effect_t * effp, const sox_sample_t * ibuf, · 78 unmodified lines
79	p->samples_in += (int)*isamp;	79	p->samples_in += (int)*isamp;
80		80
81	for (i = *isamp; i; --i)	81	for (i = *isamp; i; --i)
82	t++ = SOX_SAMPLE_TO_FLOAT_64BIT(ibuf++, effp->clips);	82	t++ = SOX_SAMPLE_TO_FLOAT_64BIT(ibuf++);
83	filter(p);	83	filter(p);
84	}	84	}
85	else *isamp = 0;	85	else *isamp = 0;
@@ -122,7 +122,7 @@ static int stop(sox_effect_t * effp) · 36 unmodified lines
122	sox_effect_handler_t const * sox_dft_filter_effect_fn(void)	122	sox_effect_handler_t const * sox_dft_filter_effect_fn(void)
123	{	123	{
124	static sox_effect_handler_t handler = {	124	static sox_effect_handler_t handler = {
125	NULL, NULL, 0, NULL, start, flow, drain, stop, NULL, 0	125	NULL, NULL, SOX_EFF_GAIN, NULL, start, flow, drain, stop, NULL, 0
126	};	126	};
127	return &handler;	127	return &handler;
128	}	128	}

src/dither.c+26−26

 #include <assert.h>
 #define PREC effp->out_signal.precision
-#define SOX_ROUND_PREC_CLIP_COUNT(d, clips) \
-  ((d) < 0? (d) <= SOX_SAMPLE_MIN - 0.5? ++(clips), SOX_SAMPLE_MIN: (d) - 0.5 \
-  : (d) >= SOX_SAMPLE_MAX - (1 << (31-PREC)) + 0.5? \
-  ++(clips), SOX_SAMPLE_MAX - (1 << (31-PREC)): (d) + 0.5)
 typedef enum {Pdf_rectangular, Pdf_triangular, Pdf_gaussian} pdf_type_t;
 static lsx_enum_item const pdf_types[] = {
   {48000, iir,  4, 21.0, ges48, Shape_gesemann},
   {44100, iir,  4, 21.2, ges44, Shape_gesemann},
   {48000, fir, 16, 28.8, shi48, Shape_shibata},
-  {44100, fir, 20, 32.5, shi44, Shape_shibata},
+  {44100, fir, 20, 32.6, shi44, Shape_shibata},
   {37800, fir, 16, 22.7, shi38, Shape_shibata},
   {32000, fir, 16, 15.7, shi32, Shape_shibata},
   {22050, fir, 15,  9.0, shi22, Shape_shibata},
   {48000, fir, 16, 23.5, shl48, Shape_low_shibata},
-  {44100, fir, 15, 23.0, shl44, Shape_low_shibata},
+  {44100, fir, 15, 23.1, shl44, Shape_low_shibata},
   {44100, fir, 20, 37.5, shh44, Shape_high_shibata},
   {    0, fir,  0,  0.0,  NULL, Shape_none},
 };
   double        previous_outputs[MAX_N * 2];
   size_t        pos;
   double const * coefs;
+  sox_sample_t  offset;
   int           (*flow)(sox_effect_t *, const sox_sample_t *, sox_sample_t *, size_t *, size_t *);
 } priv_t;
   size_t len = *isamp = *osamp = min(*isamp, *osamp);
   while (len--) {
-    double d = *ibuf++ + floor(p->am0 * RANQD1) + floor(p->am1 * RANQD1);
+    double d = *ibuf++ + p->offset + floor(p->am0 * RANQD1) + floor(p->am1 * RANQD1);
     SOX_SAMPLE_CLIP_COUNT(d, effp->clips);
     *obuf++ = d;
   }
   if (PREC > 24)
     return SOX_EFF_NULL;   /* Dithering not needed at this resolution */
-  if (!p->filter_name)
+  p->flow = flow_no_shape;
-    p->flow = flow_no_shape;
+  if (p->filter_name) {
-  else {
     filter_t const * f;
     for (f = filters; f->len && (f->name != p->filter_name || fabs(effp->in_signal.rate - f->rate) / f->rate > .05); ++f);
     if (!f->len) {
-      lsx_fail("no `%s' filter is available for rate %g", lsx_find_enum_value(p->filter_name, filter_names)->text, effp->in_signal.rate);
+      lsx_warn("no `%s' filter is available for rate %g", lsx_find_enum_value(p->filter_name, filter_names)->text, effp->in_signal.rate);
-      return SOX_EOF;
     }
-    assert(f->len <= MAX_N);
+    else {
-    if (f->type == fir) switch(f->len) {
+      assert(f->len <= MAX_N);
-      case  5: p->flow = flow_fir_5 ; break;
+      if (f->type == fir) switch(f->len) {
-      case  9: p->flow = flow_fir_9 ; break;
+        case  5: p->flow = flow_fir_5 ; break;
-      case 15: p->flow = flow_fir_15; break;
+        case  9: p->flow = flow_fir_9 ; break;
-      case 16: p->flow = flow_fir_16; break;
+        case 15: p->flow = flow_fir_15; break;
-      case 20: p->flow = flow_fir_20; break;
+        case 16: p->flow = flow_fir_16; break;
-      default: assert(sox_false);
+        case 20: p->flow = flow_fir_20; break;
-    } else switch(f->len) {
+        default: assert(sox_false);
-      case  4: p->flow = flow_iir_4 ; break;
+      } else switch(f->len) {
-      default: assert(sox_false);
+        case  4: p->flow = flow_iir_4 ; break;
+        default: assert(sox_false);
+      }
+      p->coefs = f->coefs;
+      mult = dB_to_linear(f->gain);
     }
-    p->coefs = f->coefs;
-    mult = dB_to_linear(f->gain);
   }
   p->am1 = p->depth / (1 << PREC);
   p->am0 = (p->pdf == Pdf_triangular) * p->am1;
+  if (effp->out_encoding->half_bit && PREC < 32)
+    p->offset = 1 << (31 - PREC);
   if (effp->flow == 0 && effp->in_signal.mult)
-    *effp->in_signal.mult *= 1 - (p->am0 + p->am1) * mult;
+    *effp->in_signal.mult *=
+      1 - (p->offset * (1./SOX_SAMPLE_MAX) + p->am0 + p->am1) * mult;
   lsx_debug("pdf=%s filter=%s depth=%g", lsx_find_enum_value(p->pdf, pdf_types)->text, lsx_find_enum_value(p->filter_name, filter_names)->text, p->depth);
   return SOX_SUCCESS;

src/dither_fir.h+3−3

@@ -7,12 +7,12 @@ static int NAME(sox_effect_t * effp, const sox_sample_t * ibuf, · 6 unmodified lines
7		7
8	while (len--) {	8	while (len--) {
9	double r = floor(p->am0 * RANQD1) + floor(p->am1 * RANQD1);	9	double r = floor(p->am0 * RANQD1) + floor(p->am1 * RANQD1);
10	double error, d = *ibuf++;	10	double error, d = *ibuf++ + p->offset;
11	int j = 0;	11	int j = 0;
12	CONVOLVE	12	CONVOLVE
13	assert(j == N);	13	assert(j == N);
14	*obuf = SOX_ROUND_PREC_CLIP_COUNT(d + r, effp->clips);	14	*obuf = SOX_ROUND_CLIP_COUNT(d + r, effp->clips);
15	error = ((*obuf++ + (1 << (31-PREC))) & (-1 << (32-PREC))) - d;	15	error = (*obuf++ & (-1 << (32-PREC))) + (1 << (31-PREC)) - d;
16	p->pos = p->pos? p->pos - 1 : p->pos - 1 + N;	16	p->pos = p->pos? p->pos - 1 : p->pos - 1 + N;
17	p->previous_errors[p->pos + N] = p->previous_errors[p->pos] = error;	17	p->previous_errors[p->pos + N] = p->previous_errors[p->pos] = error;
18	}	18	}

src/dither_iir.h+3−3

@@ -12,9 +12,9 @@ static int NAME(sox_effect_t * effp, const sox_sample_t * ibuf, · 11 unmodified lines
12	int j = 0;	12	int j = 0;
13	CONVOLVE	13	CONVOLVE
14	assert(j == N);	14	assert(j == N);
15	d = *ibuf++ - output;	15	d = *ibuf++ + p->offset - output;
16	*obuf = SOX_ROUND_PREC_CLIP_COUNT(d + r, effp->clips);	16	*obuf = SOX_ROUND_CLIP_COUNT(d + r, effp->clips);
17	error = ((*obuf++ + (1 << (31-PREC))) & (-1 << (32-PREC))) - d;	17	error = (*obuf++ & (-1 << (32-PREC))) + (1 << (31-PREC)) - d;
18	p->pos = p->pos? p->pos - 1 : p->pos - 1 + N;	18	p->pos = p->pos? p->pos - 1 : p->pos - 1 + N;
19	p->previous_errors[p->pos + N] = p->previous_errors[p->pos] = error;	19	p->previous_errors[p->pos + N] = p->previous_errors[p->pos] = error;
20	p->previous_outputs[p->pos + N] = p->previous_outputs[p->pos] = output;	20	p->previous_outputs[p->pos + N] = p->previous_outputs[p->pos] = output;

src/earwax.c+2−0

@@ -62,6 +62,8 @@ static int start(sox_effect_t * effp) · 61 unmodified lines
62	return SOX_EOF;	62	return SOX_EOF;
63	}	63	}
64	memset(p->tap, 0, NUMTAPS * sizeof(p->tap)); / zero tap memory */	64	memset(p->tap, 0, NUMTAPS * sizeof(p->tap)); / zero tap memory */
		65	if (effp->in_signal.mult)
		66	effp->in_signal.mult = dB_to_linear(-4.4);
65	return SOX_SUCCESS;	67	return SOX_SUCCESS;
66	}	68	}
67		69

src/echo.c+1−1

@@ -248,7 +248,7 @@ static int sox_echo_stop(sox_effect_t * effp) · 247 unmodified lines
248	static sox_effect_handler_t sox_echo_effect = {	248	static sox_effect_handler_t sox_echo_effect = {
249	"echo",	249	"echo",
250	"gain-in gain-out delay decay [ delay decay ... ]",	250	"gain-in gain-out delay decay [ delay decay ... ]",
251	SOX_EFF_LENGTH,	251	SOX_EFF_LENGTH \| SOX_EFF_GAIN,
252	sox_echo_getopts,	252	sox_echo_getopts,
253	sox_echo_start,	253	sox_echo_start,
254	sox_echo_flow,	254	sox_echo_flow,

src/echos.c+1−1

@@ -260,7 +260,7 @@ static int sox_echos_stop(sox_effect_t * effp) · 259 unmodified lines
260	static sox_effect_handler_t sox_echos_effect = {	260	static sox_effect_handler_t sox_echos_effect = {
261	"echos",	261	"echos",
262	"gain-in gain-out delay decay [ delay decay ... ]",	262	"gain-in gain-out delay decay [ delay decay ... ]",
263	SOX_EFF_LENGTH,	263	SOX_EFF_LENGTH \| SOX_EFF_GAIN,
264	sox_echos_getopts,	264	sox_echos_getopts,
265	sox_echos_start,	265	sox_echos_start,
266	sox_echos_flow,	266	sox_echos_flow,

src/effects.c+6−7

  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  */
+#define LSX_EFF_ALIAS
 #include "sox_i.h"
 #include "getopt.h"
 #include <assert.h>
   #include <strings.h>
 #endif
-#undef lsx_fail
-#undef lsx_report
-#define lsx_fail sox_globals.subsystem=effp->handler.name,lsx_fail
-#define lsx_report sox_globals.subsystem=effp->handler.name,lsx_report
 #define DEBUG_EFFECTS_CHAIN 0
 /* FIXME: Not thread safe using globals */
 /* Effects chain: */
 sox_effects_chain_t * sox_create_effects_chain(
-    sox_encodinginfo_t const * in_enc, sox_encodinginfo_t const * out_enc)
+    sox_encodinginfo_t const * in_enc, sox_encodinginfo_t * out_enc)
 {
   sox_effects_chain_t * result = lsx_calloc(1, sizeof(sox_effects_chain_t));
   result->global_info = sox_effects_globals;
     effp->out_signal.rate = in->rate;
   if (!(effp->handler.flags & SOX_EFF_PREC))
     effp->out_signal.precision = in->precision;
+  if (!(effp->handler.flags & SOX_EFF_GAIN))
+    effp->out_signal.mult = in->mult;
   effp->flows =
     (effp->handler.flags & SOX_EFF_MCHAN)? 1 : effp->in_signal.channels;
     free(eff0.priv);
     return SOX_EOF;
   }
+  if (in->mult)
+    lsx_debug("mult=%g", *in->mult);
   *in = effp->out_signal;

src/effects_i.c+1−3

  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  */
+#define LSX_EFF_ALIAS
 #include "sox_i.h"
 #include <string.h>
-#undef lsx_fail
-#define lsx_fail sox_globals.subsystem=effp->handler.name,lsx_fail
 int lsx_usage(sox_effect_t * effp)
 {
   if (effp->handler.usage)

src/example2.c+2−3

   /* Read in and process blocks of audio for the selected period or until EOF: */
   for (blocks = 0; sox_read(in, buf, block_size) == block_size && blocks * block_period < period; ++blocks) {
     double left = 0, right = 0;
-    size_t i, clips = 0;
+    size_t i;
     static const char line[] = "===================================";
     int l, r;
     for (i = 0; i < block_size; ++i) {
-      SOX_SAMPLE_LOCALS;
       /* convert the sample from SoX's internal format to a `double' for
        * processing in this application: */
-      double sample = SOX_SAMPLE_TO_FLOAT_64BIT(buf[i], clips);
+      double sample = SOX_SAMPLE_TO_FLOAT_64BIT(buf[i]);
       /* The samples for each channel are interleaved; in this example
        * we allow only stereo audio, so the left channel audio can be found in

src/ffmpeg.c+1−2

   do {
     /* If output frame is not full, copy data into it */
     if (ffmpeg->samples_index < ffmpeg->audio_input_frame_size) {
-      SOX_SAMPLE_LOCALS;
       for (; nread < len && ffmpeg->samples_index < ffmpeg->audio_input_frame_size; nread++)
-        ffmpeg->samples[ffmpeg->samples_index++] = SOX_SAMPLE_TO_SIGNED_16BIT(buf[nread], ft->clips);
+        ffmpeg->samples[ffmpeg->samples_index++] = SOX_SAMPLE_TO_SIGNED_16BIT(buf[nread]);
     }
     /* If output frame full or no more data to read, write it out */

src/flac.c+5−6

   unsigned i;
   for (i = 0; i < len; ++i) {
-    SOX_SAMPLE_LOCALS;
+    long pcm = SOX_SAMPLE_TO_SIGNED_32BIT(sampleBuffer[i]);
-    long pcm = SOX_SAMPLE_TO_SIGNED_32BIT(sampleBuffer[i], ft->clips);
     p->decoded_samples[i] = pcm >> (32 - p->bits_per_sample);
     switch (p->bits_per_sample) {
       case  8: p->decoded_samples[i] =
-          SOX_SAMPLE_TO_SIGNED_8BIT(sampleBuffer[i], ft->clips);
+          SOX_SAMPLE_TO_SIGNED_8BIT(sampleBuffer[i]);
         break;
       case 16: p->decoded_samples[i] =
-          SOX_SAMPLE_TO_SIGNED_16BIT(sampleBuffer[i], ft->clips);
+          SOX_SAMPLE_TO_SIGNED_16BIT(sampleBuffer[i]);
         break;
       case 24: p->decoded_samples[i] = /* sign extension: */
-          SOX_SAMPLE_TO_SIGNED_24BIT(sampleBuffer[i],ft->clips) << 8;
+          SOX_SAMPLE_TO_SIGNED_24BIT(sampleBuffer[i]) << 8;
         p->decoded_samples[i] >>= 8;
         break;
       case 32: p->decoded_samples[i] =
-          SOX_SAMPLE_TO_SIGNED_32BIT(sampleBuffer[i],ft->clips);
+          SOX_SAMPLE_TO_SIGNED_32BIT(sampleBuffer[i]);
         break;
     }
   }

src/formats.c+1−0

@@ -428,6 +428,7 @@ sox_format_t * sox_open_read( · 427 unmodified lines
428	if (magic)	428	if (magic)
429	filetype = magic_file(magic, path);	429	filetype = magic_file(magic, path);
430	if (filetype && (	430	if (filetype && (
		431	lsx_strends(filetype, "/unknown") \|\|
431	!strcmp(filetype, "application/octet-stream") \|\|	432	!strcmp(filetype, "application/octet-stream") \|\|
432	!strncmp(filetype, "text/plain", (size_t)10) ))	433	!strncmp(filetype, "text/plain", (size_t)10) ))
433	filetype = NULL;	434	filetype = NULL;

src/formats_i.c+0−8

@@ -90,14 +90,6 @@ int lsx_check_read_params(sox_format_t * ft, unsigned channels, · 89 unmodified lines
90	return SOX_EOF;	90	return SOX_EOF;
91	}	91	}
92		92
93	sox_sample_t lsx_sample_max(sox_encodinginfo_t const * encoding)
94	{
95	unsigned precision = encoding->encoding == SOX_ENCODING_FLOAT?
96	SOX_SAMPLE_PRECISION : sox_precision(encoding->encoding, encoding->bits_per_sample);
97	unsigned shift = SOX_SAMPLE_PRECISION - min(precision, SOX_SAMPLE_PRECISION);
98	return (SOX_SAMPLE_MAX >> shift) << shift;
99	}
100
101	/* Read in a buffer of data of length len bytes.	93	/* Read in a buffer of data of length len bytes.
102	* Returns number of bytes read.	94	* Returns number of bytes read.
103	*/	95	*/

src/gain.c+248−0

@@ -0,0 +1,248 @@
	1	/* libSoX effect: gain/norm/etc. (c) 2008-9 robs@users.sourceforge.net
	2	*
	3	* This library is free software; you can redistribute it and/or modify it
	4	* under the terms of the GNU Lesser General Public License as published by
	5	* the Free Software Foundation; either version 2.1 of the License, or (at
	6	* your option) any later version.
	7	*
	8	* This library is distributed in the hope that it will be useful, but
	9	* WITHOUT ANY WARRANTY; without even the implied warranty of
	10	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser
	11	* General Public License for more details.
	12	*
	13	* You should have received a copy of the GNU Lesser General Public License
	14	* along with this library; if not, write to the Free Software Foundation,
	15	* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	16	*/
	17
	18	#define LSX_EFF_ALIAS
	19	#include "sox_i.h"
	20	#include <ctype.h>
	21	#include <string.h>
	22
	23	typedef struct {
	24	sox_bool do_equalise, do_balance, do_balance_no_clip;
	25	sox_bool do_restore, make_headroom, do_normalise, do_scan;
	26	double fixed_gain; /* Valid only in channel 0 */
	27
	28	double mult;
	29	double restore;
	30	double rms;
	31	off_t num_samples;
	32	sox_sample_t min, max;
	33	FILE * tmp_file;
	34	} priv_t;
	35
	36	static int create(sox_effect_t * effp, int argc, char * * argv)
	37	{
	38	priv_t * p = (priv_t *)effp->priv;
	39	char const * q;
	40	for (--argc, ++argv; argc && **argv == '-' && !isdigit(argv[0][1]) &&
	41	argv[0][1] != '.'; --argc, ++argv)
	42	for (q = &argv[0][1]; q; ++q) switch (q) {
	43	case 'n': p->do_scan = p->do_normalise = sox_true; break;
	44	case 'e': p->do_scan = p->do_equalise = sox_true; break;
	45	case 'B': p->do_scan = p->do_balance = sox_true; break;
	46	case 'b': p->do_scan = p->do_balance_no_clip = sox_true; break;
	47	case 'r': p->do_scan = p->do_restore = sox_true; break;
	48	case 'h': p->make_headroom = sox_true; break;
	49	default: lsx_fail("invalid option `-%c'", *q); return lsx_usage(effp);
	50	}
	51	if ((p->do_equalise + p->do_balance + p->do_balance_no_clip + p->do_restore)/ sox_true > 1) {
	52	lsx_fail("Only one of -e, -B, -b, -r may be given");
	53	return SOX_EOF;
	54	}
	55	if (p->do_normalise && p->do_restore) {
	56	lsx_fail("Only one of -n, -r may be given");
	57	return SOX_EOF;
	58	}
	59	do {NUMERIC_PARAMETER(fixed_gain, -HUGE_VAL, HUGE_VAL)} while (0);
	60	p->fixed_gain = dB_to_linear(p->fixed_gain);
	61	return argc? lsx_usage(effp) : SOX_SUCCESS;
	62	}
	63
	64	static int start(sox_effect_t * effp)
	65	{
	66	priv_t * p = (priv_t *)effp->priv;
	67
	68	if (effp->flow == 0) {
	69	if (p->do_restore) {
	70	if (!effp->in_signal.mult \|\| *effp->in_signal.mult >= 1) {
	71	lsx_fail("can't restore level");
	72	return SOX_EOF;
	73	}
	74	p->restore = 1 / *effp->in_signal.mult;
	75	}
	76	effp->out_signal.mult = p->make_headroom? &p->fixed_gain : NULL;
	77	if (!p->do_equalise && !p->do_balance && !p->do_balance_no_clip)
	78	effp->flows = 1;
	79	}
	80	p->mult = p->max = p->min = 0;
	81	if (p->do_scan) {
	82	p->tmp_file = lsx_tmpfile();
	83	if (p->tmp_file == NULL) {
	84	lsx_fail("can't create temporary file: %s", strerror(errno));
	85	return SOX_EOF;
	86	}
	87	}
	88	return SOX_SUCCESS;
	89	}
	90
	91	static int flow(sox_effect_t * effp, const sox_sample_t * ibuf,
	92	sox_sample_t * obuf, size_t * isamp, size_t * osamp)
	93	{
	94	priv_t * p = (priv_t *)effp->priv;
	95	size_t len;
	96
	97	if (p->do_scan) {
	98	if (fwrite(ibuf, sizeof(ibuf), isamp, p->tmp_file) != *isamp) {
	99	lsx_fail("error writing temporary file: %s", strerror(errno));
	100	return SOX_EOF;
	101	}
	102	if (p->do_balance && !p->do_normalise)
	103	for (len = *isamp; len; --len, ++ibuf) {
	104	double d = SOX_SAMPLE_TO_FLOAT_64BIT(*ibuf);
	105	p->rms += sqr(d);
	106	++p->num_samples;
	107	}
	108	else if (p->do_balance \|\| p->do_balance_no_clip)
	109	for (len = *isamp; len; --len, ++ibuf) {
	110	double d = SOX_SAMPLE_TO_FLOAT_64BIT(*ibuf);
	111	p->rms += sqr(d);
	112	++p->num_samples;
	113	p->max = max(p->max, *ibuf);
	114	p->min = min(p->min, *ibuf);
	115	}
	116	else for (len = *isamp; len; --len, ++ibuf) {
	117	p->max = max(p->max, *ibuf);
	118	p->min = min(p->min, *ibuf);
	119	}
	120	osamp = 0; / samples not output until drain */
	121	}
	122	else {
	123	double mult = ((priv_t *)(effp - effp->flow)->priv)->fixed_gain;
	124	len = isamp = osamp = min(isamp, osamp);
	125	for (; len; --len, ++ibuf)
	126	obuf++ = SOX_ROUND_CLIP_COUNT(ibuf * mult, effp->clips);
	127	}
	128	return SOX_SUCCESS;
	129	}
	130
	131	static void start_drain(sox_effect_t * effp)
	132	{
	133	priv_t * p = (priv_t *)effp->priv;
	134	double max = SOX_SAMPLE_MAX, max_peak = 0, max_rms = 0;
	135	size_t i;
	136
	137	if (p->do_balance \|\| p->do_balance_no_clip) {
	138	for (i = 0; i < effp->flows; ++i) {
	139	priv_t * q = (priv_t *)(effp - effp->flow + i)->priv;
	140	max_rms = max(max_rms, sqrt(q->rms / q->num_samples));
	141	rewind(q->tmp_file);
	142	}
	143	for (i = 0; i < effp->flows; ++i) {
	144	priv_t * q = (priv_t *)(effp - effp->flow + i)->priv;
	145	double this_rms = sqrt(q->rms / q->num_samples);
	146	double this_peak = max(q->max / max, q->min / (double)SOX_SAMPLE_MIN);
	147	q->mult = this_rms != 0? max_rms / this_rms : 1;
	148	max_peak = max(max_peak, q->mult * this_peak);
	149	q->mult *= p->fixed_gain;
	150	}
	151	if (p->do_normalise \|\| (p->do_balance_no_clip && max_peak > 1))
	152	for (i = 0; i < effp->flows; ++i) {
	153	priv_t * q = (priv_t *)(effp - effp->flow + i)->priv;
	154	q->mult /= max_peak;
	155	}
	156	} else if (p->do_equalise && !p->do_normalise) {
	157	for (i = 0; i < effp->flows; ++i) {
	158	priv_t * q = (priv_t *)(effp - effp->flow + i)->priv;
	159	double this_peak = max(q->max / max, q->min / (double)SOX_SAMPLE_MIN);
	160	max_peak = max(max_peak, this_peak);
	161	q->mult = p->fixed_gain / this_peak;
	162	rewind(q->tmp_file);
	163	}
	164	for (i = 0; i < effp->flows; ++i) {
	165	priv_t * q = (priv_t *)(effp - effp->flow + i)->priv;
	166	q->mult *= max_peak;
	167	}
	168	} else {
	169	p->mult = min(max / p->max, (double)SOX_SAMPLE_MIN / p->min);
	170	if (p->do_restore) {
	171	if (p->restore > p->mult)
	172	lsx_debug("%.3gdB not restored", linear_to_dB(p->restore / p->mult));
	173	else p->mult = p->restore;
	174	}
	175	p->mult *= p->fixed_gain;
	176	rewind(p->tmp_file);
	177	}
	178	}
	179
	180	static int drain(sox_effect_t * effp, sox_sample_t * obuf, size_t * osamp)
	181	{
	182	priv_t * p = (priv_t *)effp->priv;
	183	size_t len;
	184	int result = SOX_SUCCESS;
	185
	186	if (p->do_scan) {
	187	if (!p->mult)
	188	start_drain(effp);
	189	len = fread(obuf, sizeof(obuf), osamp, p->tmp_file);
	190	if (len != *osamp && !feof(p->tmp_file)) {
	191	lsx_fail("error reading temporary file: %s", strerror(errno));
	192	result = SOX_EOF;
	193	}
	194	if (p->mult > 1) for (*osamp = len; len; --len, ++obuf)
	195	obuf = SOX_ROUND_CLIP_COUNT(obuf * p->mult, effp->clips);
	196	else for (*osamp = len; len; --len, ++obuf)
	197	obuf = floor(obuf * p->mult + .5);
	198	}
	199	else *osamp = 0;
	200	return result;
	201	}
	202
	203	static int stop(sox_effect_t * effp)
	204	{
	205	priv_t * p = (priv_t *)effp->priv;
	206	if (p->do_scan)
	207	fclose(p->tmp_file); /* auto-deleted by lsx_tmpfile */
	208	return SOX_SUCCESS;
	209	}
	210
	211	sox_effect_handler_t const * sox_gain_effect_fn(void)
	212	{
	213	static sox_effect_handler_t handler = {
	214	"gain", "[-e\|-b\|-B\|-r] [-n] [-h] [gain-dB]", SOX_EFF_GAIN,
	215	create, start, flow, drain, stop, NULL, sizeof(priv_t)};
	216	return &handler;
	217	}
	218
	219	/------------------ emulation of the old `normalise' effect -----------------/
	220
	221	static int norm_getopts(sox_effect_t * effp, int argc, char * * argv)
	222	{
	223	char * argv2[3];
	224	int argc2 = 0;
	225
	226	argv2[argc2++] = argv[0], --argc, ++argv;
	227	if (argc && !strcmp(*argv, "-i"))
	228	argv2[argc2++] = "-en", --argc, ++argv;
	229	else if (argc && !strcmp(*argv, "-b"))
	230	argv2[argc2++] = "-B", --argc, ++argv;
	231	if (argc2 > 1)
	232	lsx_warn("this use is deprecated; use `gain %s' instead", argv2[1]);
	233	else argv2[argc2++] = "-n";
	234	if (argc)
	235	argv2[argc2++] = *argv, --argc, ++argv;
	236	return argc? lsx_usage(effp) :
	237	sox_gain_effect_fn()->getopts(effp, argc2, argv2);
	238	}
	239
	240	sox_effect_handler_t const * sox_norm_effect_fn(void)
	241	{
	242	static sox_effect_handler_t handler;
	243	handler = *sox_gain_effect_fn();
	244	handler.name = "norm";
	245	handler.usage = "[level]";
	246	handler.getopts = norm_getopts;
	247	return &handler;
	248	}

src/gsm.c+1−2

         while (done < samp)
         {
-                SOX_SAMPLE_LOCALS;
                 while ((p->samplePtr < p->sampleTop) && (done < samp))
                         *(p->samplePtr)++ =
-                            SOX_SAMPLE_TO_SIGNED_16BIT(buf[done++], ft->clips);
+                            SOX_SAMPLE_TO_SIGNED_16BIT(buf[done++]);
                 if (p->samplePtr == p->sampleTop)
                 {

src/hcom.c+1−2

@@ -277,9 +277,8 @@ static size_t write_samples(sox_format_t * ft, const sox_sample_t *buf, size_t l · 276 unmodified lines
277	}	277	}
278		278
279	for (i = 0; i < len; i++) {	279	for (i = 0; i < len; i++) {
280	SOX_SAMPLE_LOCALS;
281	datum = *buf++;	280	datum = *buf++;
282	p->data[p->pos++] = SOX_SAMPLE_TO_UNSIGNED_8BIT(datum, ft->clips);	281	p->data[p->pos++] = SOX_SAMPLE_TO_UNSIGNED_8BIT(datum);
283	}	282	}
284		283
285	return len;	284	return len;

src/ladspa.c+2−2

@@ -237,7 +237,7 @@ static int sox_ladspa_flow(sox_effect_t * effp, const sox_sample_t *ibuf, sox_sa · 236 unmodified lines
237	if (l_st->input_port != ULONG_MAX) {	237	if (l_st->input_port != ULONG_MAX) {
238	/* Copy the input; FIXME: Assume LADSPA_Data == float! */	238	/* Copy the input; FIXME: Assume LADSPA_Data == float! */
239	for (i = 0; i < len; i++)	239	for (i = 0; i < len; i++)
240	buf[i] = SOX_SAMPLE_TO_FLOAT_32BIT(ibuf[i], effp->clips);	240	buf[i] = SOX_SAMPLE_TO_FLOAT_32BIT(ibuf[i]);
241		241
242	/* Connect the input port */	242	/* Connect the input port */
243	l_st->desc->connect_port(l_st->handle, l_st->input_port, buf);	243	l_st->desc->connect_port(l_st->handle, l_st->input_port, buf);
@@ -291,7 +291,7 @@ static int sox_ladspa_stop(sox_effect_t * effp) · 47 unmodified lines
291	static sox_effect_handler_t sox_ladspa_effect = {	291	static sox_effect_handler_t sox_ladspa_effect = {
292	"ladspa",	292	"ladspa",
293	"MODULE [PLUGIN] [ARGUMENT...]",	293	"MODULE [PLUGIN] [ARGUMENT...]",
294	0,	294	SOX_EFF_GAIN,
295	sox_ladspa_getopts,	295	sox_ladspa_getopts,
296	sox_ladspa_start,	296	sox_ladspa_start,
297	sox_ladspa_flow,	297	sox_ladspa_flow,

src/lpc10.c+1−2

@@ -179,8 +179,7 @@ static size_t write_samples(sox_format_t * ft, const sox_sample_t *buf, size_t l · 178 unmodified lines
179		179
180	while (len > 0) {	180	while (len > 0) {
181	while (len > 0 && lpc->samples < LPC10_SAMPLES_PER_FRAME) {	181	while (len > 0 && lpc->samples < LPC10_SAMPLES_PER_FRAME) {
182	SOX_SAMPLE_LOCALS;	182	lpc->speech[lpc->samples++] = SOX_SAMPLE_TO_FLOAT_32BIT(buf[nwritten++]);
183	lpc->speech[lpc->samples++] = SOX_SAMPLE_TO_FLOAT_32BIT(buf[nwritten++], ft->clips);
184	len--;	183	len--;
185	}	184	}
186		185

src/mcompand.c+1−1

@@ -492,7 +492,7 @@ const sox_effect_handler_t *sox_mcompand_effect_fn(void) · 491 unmodified lines
492	" attack1,decay1[,attack2,decay2...]\n"	492	" attack1,decay1[,attack2,decay2...]\n"
493	" in-dB1,out-dB1[,in-dB2,out-dB2...]\n"	493	" in-dB1,out-dB1[,in-dB2,out-dB2...]\n"
494	" [ gain [ initial-volume [ delay ] ] ]",	494	" [ gain [ initial-volume [ delay ] ] ]",
495	SOX_EFF_MCHAN,	495	SOX_EFF_MCHAN \| SOX_EFF_GAIN,
496	getopts, start, flow, drain, stop, kill, sizeof(priv_t)	496	getopts, start, flow, drain, stop, kill, sizeof(priv_t)
497	};	497	};
498		498

src/mixer.c+13−0

@@ -485,6 +485,19 @@ static int start(sox_effect_t * effp) · 484 unmodified lines
485	}	485	}
486	}	486	}
487		487
		488	if (effp->in_signal.mult) {
		489	double max_sum = 0;
		490
		491	for (j = 0; j < (int)effp->out_signal.channels; ++j) {
		492	double sum = 0;
		493	for (i = 0; i < (int)effp->in_signal.channels; ++i)
		494	sum += fabs(mixer->sources[mixer->mix == MIX_CENTER? 0 : i][j]);
		495	max_sum = max(max_sum, sum);
		496	}
		497	if (max_sum > 1)
		498	*effp->in_signal.mult /= max_sum;
		499	}
		500
488	if (effp->in_signal.channels != effp->out_signal.channels)	501	if (effp->in_signal.channels != effp->out_signal.channels)
489	return SOX_SUCCESS;	502	return SOX_SUCCESS;
490		503

src/mp3.c+3−4

     int i,j;
     ptrdiff_t done = 0;
     size_t written;
-    SOX_SAMPLE_LOCALS;
     /* NOTE: This logic assumes that "short int" is 16-bits
      * on all platforms.  It happens to be for all that I know
         j=0;
         for (i=0; i<nsamples; i++)
         {
-            buffer_l[i]=SOX_SAMPLE_TO_SIGNED_16BIT(buf[j++], ft->clips);
+            buffer_l[i]=SOX_SAMPLE_TO_SIGNED_16BIT(buf[j++]);
-            buffer_r[i]=SOX_SAMPLE_TO_SIGNED_16BIT(buf[j++], ft->clips);
+            buffer_r[i]=SOX_SAMPLE_TO_SIGNED_16BIT(buf[j++]);
         }
     }
     else
     {
         j=0;
         for (i=0; i<nsamples; i++)
-            buffer_l[i]=SOX_SAMPLE_TO_SIGNED_16BIT(buf[j++], ft->clips);
+            buffer_l[i]=SOX_SAMPLE_TO_SIGNED_16BIT(buf[j++]);
     }
     mp3buffer_size = 1.25 * nsamples + 7200;

src/noiseprof.c+3−4

                     size_t *isamp, size_t *osamp)
 {
   priv_t * p = (priv_t *) effp->priv;
-  size_t samp = min(*isamp, *osamp), dummy = 0; /* No need to clip count */
+  size_t samp = min(*isamp, *osamp);
   size_t chans = effp->in_signal.channels;
   size_t i, j, n = min(samp / chans, WINDOWSIZE - p->bufdata);
   /* Collect data for every channel. */
   for (i = 0; i < chans; i ++) {
-    SOX_SAMPLE_LOCALS;
     chandata_t * chan = &(p->chandata[i]);
     for (j = 0; j < n; j ++)
       chan->window[j + p->bufdata] =
-        SOX_SAMPLE_TO_FLOAT_32BIT(ibuf[i + j * chans], dummy);
+        SOX_SAMPLE_TO_FLOAT_32BIT(ibuf[i + j * chans]);
     if (n + p->bufdata == WINDOWSIZE)
       collect_data(chan);
   }
 static sox_effect_handler_t sox_noiseprof_effect = {
   "noiseprof",
   "[profile-file]",
-  SOX_EFF_MCHAN,
+  SOX_EFF_MCHAN | SOX_EFF_MODIFY,
   sox_noiseprof_getopts,
   sox_noiseprof_start,
   sox_noiseprof_flow,

src/noisered.c+1−2

     /* Reduce noise on every channel. */
     for (i = 0; i < tracks; i ++) {
-        SOX_SAMPLE_LOCALS;
         chandata_t* chan = &(data->chandata[i]);
         size_t j;
         for (j = 0; j < ncopy; j ++)
             chan->window[oldbuf + j] =
-                SOX_SAMPLE_TO_FLOAT_32BIT(ibuf[i + tracks * j], effp->clips);
+                SOX_SAMPLE_TO_FLOAT_32BIT(ibuf[i + tracks * j]);
         if (!whole_window)
             continue;

src/normalise.c+0−127

@@ -1,127 +0,0 @@
1	/* libSoX effect: Normalise (c) 2008 robs@users.sourceforge.net
2	*
3	* This library is free software; you can redistribute it and/or modify it
4	* under the terms of the GNU Lesser General Public License as published by
5	* the Free Software Foundation; either version 2.1 of the License, or (at
6	* your option) any later version.
7	*
8	* This library is distributed in the hope that it will be useful, but
9	* WITHOUT ANY WARRANTY; without even the implied warranty of
10	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser
11	* General Public License for more details.
12	*
13	* You should have received a copy of the GNU Lesser General Public License
14	* along with this library; if not, write to the Free Software Foundation,
15	* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16	*/
17
18	#include "sox_i.h"
19	#include <string.h>
20
21	typedef struct {
22	sox_bool individual, balance;
23	double norm0; /* Multiplier to take to 0dB FSD */
24	double level; /* Multiplier to take to 'level' */
25	double rms;
26	off_t num_samples;
27	sox_sample_t min, max;
28	FILE * tmp_file;
29	} priv_t;
30
31	static int create(sox_effect_t * effp, int argc, char * * argv)
32	{
33	priv_t * p = (priv_t *)effp->priv;
34	--argc, ++argv;
35	if (argc && !strcmp(*argv, "-i")) p->individual = sox_true, ++argv, --argc;
36	if (argc && !strcmp(*argv, "-b")) p->balance = sox_true, ++argv, --argc;
37	do {NUMERIC_PARAMETER(level, -100, 0)} while (0);
38	p->level = dB_to_linear(p->level);
39	return argc? lsx_usage(effp) : SOX_SUCCESS;
40	}
41
42	static int start(sox_effect_t * effp)
43	{
44	priv_t * p = (priv_t *)effp->priv;
45	if (!(p->individual \|\| p->balance))
46	effp->flows = 1;
47	p->norm0 = p->max = p->min = 0;
48	p->tmp_file = lsx_tmpfile();
49	if (p->tmp_file == NULL) {
50	lsx_fail("can't create temporary file: %s", strerror(errno));
51	return SOX_EOF;
52	}
53	return SOX_SUCCESS;
54	}
55
56	static int flow(sox_effect_t * effp, const sox_sample_t * ibuf,
57	sox_sample_t * obuf, size_t * isamp, size_t * osamp)
58	{
59	priv_t * p = (priv_t *)effp->priv;
60	size_t len;
61
62	if (fwrite(ibuf, sizeof(ibuf), isamp, p->tmp_file) != *isamp) {
63	lsx_fail("error writing temporary file: %s", strerror(errno));
64	return SOX_EOF;
65	}
66	if (p->balance) for (len = *isamp; len; --len, ++ibuf) {
67	SOX_SAMPLE_LOCALS;
68	size_t dummy = 0;
69	double d = SOX_SAMPLE_TO_FLOAT_64BIT(*ibuf, dummy);
70	p->rms += sqr(d);
71	++p->num_samples;
72	}
73	else for (len = *isamp; len; --len, ++ibuf) {
74	p->max = max(p->max, *ibuf);
75	p->min = min(p->min, *ibuf);
76	}
77	(void)obuf, osamp = 0; / samples not output until drain */
78	return SOX_SUCCESS;
79	}
80
81	static int drain(sox_effect_t * effp, sox_sample_t * obuf, size_t * osamp)
82	{
83	priv_t * p = (priv_t *)effp->priv;
84	size_t len, i;
85	int result = SOX_SUCCESS;
86
87	if (!p->norm0) {
88	if (p->balance) {
89	double max_rms = 0, this_rms = sqrt(p->rms / p->num_samples);
90	sox_effect_t * effects = effp - effp->flow;
91	for (i = 0; i < effp->flows; ++i) {
92	priv_t * q = (priv_t *)(effects + i)->priv;
93	max_rms = max(max_rms, sqrt(q->rms / q->num_samples));
94	}
95	p->norm0 = p->level * (this_rms != 0? max_rms / this_rms : 1);
96	}
97	else {
98	double max = lsx_sample_max(effp->out_encoding);
99	p->norm0 = p->level * min(max / p->max, (double)SOX_SAMPLE_MIN / p->min);
100	}
101	rewind(p->tmp_file);
102	}
103	len = fread(obuf, sizeof(obuf), osamp, p->tmp_file);
104	if (len != *osamp && !feof(p->tmp_file)) {
105	lsx_fail("error reading temporary file: %s", strerror(errno));
106	result = SOX_EOF;
107	}
108	if (p->balance) for (*osamp = len; len; --len, ++obuf)
109	obuf = SOX_ROUND_CLIP_COUNT(obuf * p->norm0, effp->clips);
110	else for (*osamp = len; len; --len, ++obuf)
111	obuf = floor(obuf * p->norm0 + .5);
112	return result;
113	}
114
115	static int stop(sox_effect_t * effp)
116	{
117	priv_t * p = (priv_t *)effp->priv;
118	fclose(p->tmp_file); /* auto-deleted by lsx_tmpfile */
119	return SOX_SUCCESS;
120	}
121
122	sox_effect_handler_t const * sox_norm_effect_fn(void)
123	{
124	static sox_effect_handler_t handler = {"norm", "[-i\|-b] [level]", 0,
125	create, start, flow, drain, stop, NULL, sizeof(priv_t)};
126	return &handler;
127	}

src/overdrive.c+2−2

@@ -52,7 +52,7 @@ static int flow(sox_effect_t * effp, const sox_sample_t * ibuf, · 51 unmodified lines
52	size_t dummy = 0, len = isamp = osamp = min(isamp, osamp);	52	size_t dummy = 0, len = isamp = osamp = min(isamp, osamp);
53	while (len--) {	53	while (len--) {
54	SOX_SAMPLE_LOCALS;	54	SOX_SAMPLE_LOCALS;
55	double d = SOX_SAMPLE_TO_FLOAT_64BIT(*ibuf++, dummy), d0 = d;	55	double d = SOX_SAMPLE_TO_FLOAT_64BIT(*ibuf++), d0 = d;
56	d *= p->gain;	56	d *= p->gain;
57	d += p->colour;	57	d += p->colour;
58	d = d < -1? -2./3 : d > 1? 2./3 : d - d * d * d * (1./3);	58	d = d < -1? -2./3 : d > 1? 2./3 : d - d * d * d * (1./3);
@@ -66,6 +66,6 @@ static int flow(sox_effect_t * effp, const sox_sample_t * ibuf, · 7 unmodified lines
66	sox_effect_handler_t const * sox_overdrive_effect_fn(void)	66	sox_effect_handler_t const * sox_overdrive_effect_fn(void)
67	{	67	{
68	static sox_effect_handler_t handler = {"overdrive", "[gain [colour]]",	68	static sox_effect_handler_t handler = {"overdrive", "[gain [colour]]",
69	0, create, start, flow, NULL, NULL, NULL, sizeof(priv_t)};	69	SOX_EFF_GAIN, create, start, flow, NULL, NULL, NULL, sizeof(priv_t)};
70	return &handler;	70	return &handler;
71	}	71	}

src/phaser.c+1−1

@@ -139,7 +139,7 @@ sox_effect_handler_t const * sox_phaser_effect_fn(void) · 138 unmodified lines
139	{	139	{
140	static sox_effect_handler_t handler = {	140	static sox_effect_handler_t handler = {
141	"phaser", "gain-in gain-out delay decay speed [ -s \| -t ]",	141	"phaser", "gain-in gain-out delay decay speed [ -s \| -t ]",
142	SOX_EFF_LENGTH, getopts, start, flow, NULL, stop, NULL, sizeof(priv_t)	142	SOX_EFF_LENGTH \| SOX_EFF_GAIN, getopts, start, flow, NULL, stop, NULL, sizeof(priv_t)
143	};	143	};
144	return &handler;	144	return &handler;
145	}	145	}

src/rate.c+2−2

@@ -494,7 +494,7 @@ static int start(sox_effect_t * effp) · 493 unmodified lines
494	if (effp->in_signal.rate == out_rate)	494	if (effp->in_signal.rate == out_rate)
495	return SOX_EFF_NULL;	495	return SOX_EFF_NULL;
496		496
497	if (effp->flow == 0 && effp->in_signal.mult)	497	if (effp->in_signal.mult)
498	effp->in_signal.mult = .705; /* 1/(2/sinc(pi/3)-1); see De Soras 4.1.2 */	498	effp->in_signal.mult = .705; /* 1/(2/sinc(pi/3)-1); see De Soras 4.1.2 */
499		499
500	effp->out_signal.channels = effp->in_signal.channels;	500	effp->out_signal.channels = effp->in_signal.channels;
@@ -516,7 +516,7 @@ static int flow(sox_effect_t * effp, const sox_sample_t * ibuf, · 15 unmodified lines
516		516
517	if (isamp && odone < osamp) {	517	if (isamp && odone < osamp) {
518	sample_t * t = rate_input(&p->rate, NULL, *isamp);	518	sample_t * t = rate_input(&p->rate, NULL, *isamp);
519	for (i = isamp; i; --i) t++ = FROM_SOX(*ibuf++, effp->clips);	519	for (i = isamp; i; --i) t++ = FROM_SOX(*ibuf++);
520	rate_process(&p->rate);	520	rate_process(&p->rate);
521	}	521	}
522	else *isamp = 0;	522	else *isamp = 0;

src/raw.c+3−4

 typedef uint16_t uint13_t;
 #define SOX_ULAW_BYTE_TO_SAMPLE(d,clips)   SOX_SIGNED_16BIT_TO_SAMPLE(sox_ulaw2linear16(d),clips)
 #define SOX_ALAW_BYTE_TO_SAMPLE(d,clips)   SOX_SIGNED_16BIT_TO_SAMPLE(sox_alaw2linear16(d),clips)
-#define SOX_SAMPLE_TO_ULAW_BYTE(d,c) sox_14linear2ulaw(SOX_SAMPLE_TO_UNSIGNED(14,d,c) - 0x2000)
+#define SOX_SAMPLE_TO_ULAW_BYTE(d) sox_14linear2ulaw(SOX_SAMPLE_TO_UNSIGNED(14,d) - 0x2000)
-#define SOX_SAMPLE_TO_ALAW_BYTE(d,c) sox_13linear2alaw(SOX_SAMPLE_TO_UNSIGNED(13,d,c) - 0x1000)
+#define SOX_SAMPLE_TO_ALAW_BYTE(d) sox_13linear2alaw(SOX_SAMPLE_TO_UNSIGNED(13,d) - 0x1000)
 int lsx_rawseek(sox_format_t * ft, uint64_t offset)
 {
   static size_t sox_write_ ## sign ## type ## _samples( \
       sox_format_t * ft, sox_sample_t const * buf, size_t len) \
   { \
-    SOX_SAMPLE_LOCALS; \
     size_t n, nwritten; \
     ctype *data = lsx_malloc(sizeof(ctype) * len); \
     for (n = 0; n < len; n++) \
-      data[n] = cast(buf[n], ft->clips); \
+      data[n] = cast(buf[n]); \
     nwritten = lsx_write_ ## type ## _buf(ft, (uctype *)data, len); \
     free(data); \
     return nwritten; \

src/remix.c+13−0

@@ -95,6 +95,19 @@ static int parse(sox_effect_t * effp, char * * argv, unsigned channels) · 94 unmodified lines
95	p->out_specs[i].in_specs[j].multiplier = (p->mode == automatic \|\| (p->mode == semi && !mul_spec)) ? mult : 1;	95	p->out_specs[i].in_specs[j].multiplier = (p->mode == automatic \|\| (p->mode == semi && !mul_spec)) ? mult : 1;
96	}	96	}
97	effp->out_signal.channels = p->num_out_channels;	97	effp->out_signal.channels = p->num_out_channels;
		98
		99	if (effp->in_signal.mult) {
		100	double max_sum = 0;
		101
		102	for (j = 0; j < effp->out_signal.channels; j++) {
		103	double sum = 0;
		104	for (i = 0; i < p->out_specs[j].num_in_channels; i++)
		105	sum += fabs(p->out_specs[j].in_specs[i].multiplier);
		106	max_sum = max(max_sum, sum);
		107	}
		108	if (max_sum > 1)
		109	*effp->in_signal.mult /= max_sum;
		110	}
98	return SOX_SUCCESS;	111	return SOX_SUCCESS;
99	}	112	}
100		113

src/reverb.c+4−1

     &p->chan[i].reverb, effp->in_signal.rate, p->wet_gain_dB, p->room_scale,
     p->reverberance, p->hf_damping, p->pre_delay_ms, p->stereo_depth,
     effp->global_info->global_info->bufsiz / p->ochannels, p->chan[i].wet);
+  if (effp->in_signal.mult)
+    *effp->in_signal.mult /= !p->wet_only + 2 * dB_to_linear(max(0,p->wet_gain_dB));
   return SOX_SUCCESS;
 }
   for (c = 0; c < p->ichannels; ++c)
     p->chan[c].dry = fifo_write(&p->chan[c].reverb.input_fifo, len, 0);
   for (i = 0; i < len; ++i) for (c = 0; c < p->ichannels; ++c)
-    p->chan[c].dry[i] = SOX_SAMPLE_TO_FLOAT_32BIT(*ibuf++, effp->clips);
+    p->chan[c].dry[i] = SOX_SAMPLE_TO_FLOAT_32BIT(*ibuf++);
   for (c = 0; c < p->ichannels; ++c)
     reverb_process(&p->chan[c].reverb, len);
   if (p->ichannels == 2) for (i = 0; i < len; ++i) for (w = 0; w < 2; ++w) {

src/silence.c+4−6

 {
     double ratio;
     int rc;
-    sox_sample_t dummy_clipped_count = 0;
     /* When scaling low bit data, noise values got scaled way up */
     /* Only consider the original bits when looking for silence */
     switch(effp->in_signal.precision)
     {
-        SOX_SAMPLE_LOCALS;
         case 8:
-            value = SOX_SAMPLE_TO_SIGNED_8BIT(value, dummy_clipped_count);
+            value = SOX_SAMPLE_TO_SIGNED_8BIT(value);
             ratio = (double)abs(value) / (double)SOX_INT8_MAX;
             break;
         case 16:
-            value = SOX_SAMPLE_TO_SIGNED_16BIT(value, dummy_clipped_count);
+            value = SOX_SAMPLE_TO_SIGNED_16BIT(value);
             ratio = (double)abs(value) / (double)SOX_INT16_MAX;
             break;
         case 24:
-            value = SOX_SAMPLE_TO_SIGNED_24BIT(value, dummy_clipped_count);
+            value = SOX_SAMPLE_TO_SIGNED_24BIT(value);
             ratio = (double)abs(value) / (double)SOX_INT24_MAX;
             break;
         case 32:
-            value = SOX_SAMPLE_TO_SIGNED_32BIT(value,);
+            value = SOX_SAMPLE_TO_SIGNED_32BIT(value);
             ratio = (double)abs(value) / (double)SOX_INT32_MAX;
             break;
         default:

src/skelform.c+1−2

   switch (ft->encoding.bits_per_sample) {
   case 8:
     switch (ft->encoding.encoding) {
-    SOX_SAMPLE_LOCALS;
     case SOX_ENCODING_UNSIGNED:
-      while (done < len && lsx_writeb(ft, SOX_SAMPLE_TO_UNSIGNED_8BIT(*buf++, ft->clips)) == SOX_SUCCESS)
+      while (done < len && lsx_writeb(ft, SOX_SAMPLE_TO_UNSIGNED_8BIT(*buf++)) == SOX_SUCCESS)
         ++done;
       break;
     default:

src/smp.c+1−2

@@ -368,8 +368,7 @@ static size_t sox_smpwrite(sox_format_t * ft, const sox_sample_t *buf, size_t le · 367 unmodified lines
368	size_t done = 0;	368	size_t done = 0;
369		369
370	while(done < len) {	370	while(done < len) {
371	SOX_SAMPLE_LOCALS;	371	datum = (int) SOX_SAMPLE_TO_SIGNED_16BIT(*buf++);
372	datum = (int) SOX_SAMPLE_TO_SIGNED_16BIT(*buf++, ft->clips);
373	lsx_writew(ft, (uint16_t)datum);	372	lsx_writew(ft, (uint16_t)datum);
374	smp->NoOfSamps++;	373	smp->NoOfSamps++;
375	done++;	374	done++;

src/sox.c+133−115

@@ -1,9 +1,9 @@
1	/* SoX - The Swiss Army Knife of Audio Manipulation.	1	/* SoX - The Swiss Army Knife of Audio Manipulation.
2	*	2	*
3	* This is the main function for the command line sox program.	3	* This is the main function for the SoX command line programs.
4	*	4	*
		5	* Copyright 1998-2009 Chris Bagwell and SoX contributors
5	* Copyright 1991 Lance Norskog And Sundry Contributors	6	* Copyright 1991 Lance Norskog And Sundry Contributors
6	* Copyright 1998-2008 Chris Bagwell and SoX contributors
7	*	7	*
8	* This program is free software; you can redistribute it and/or modify it	8	* This program is free software; you can redistribute it and/or modify it
9	* under the terms of the GNU General Public License as published by the	9	* under the terms of the GNU General Public License as published by the
@@ -133,6 +133,7 @@ typedef struct { · 123 unmodified lines
133	sox_signalinfo_t signal;	133	sox_signalinfo_t signal;
134	sox_encodinginfo_t encoding;	134	sox_encodinginfo_t encoding;
135	double volume;	135	double volume;
		136	sox_sample_t offset;
136	double replay_gain;	137	double replay_gain;
137	sox_oob_t oob;	138	sox_oob_t oob;
138	sox_bool no_glob;	139	sox_bool no_glob;
@@ -197,8 +198,7 @@ static sox_bool single_threaded = sox_false; · 58 unmodified lines
197	static struct termios original_termios;	198	static struct termios original_termios;
198	#endif	199	#endif
199		200
200	static sox_bool stdin_is_a_tty, is_player;	201	static sox_bool stdin_is_a_tty, is_player, is_guarded, do_guarded_norm;
201
202		202
203	/* Cleanup atexit() function, hence always called. */	203	/* Cleanup atexit() function, hence always called. */
204	static void cleanup(void)	204	static void cleanup(void)
@@ -214,7 +214,7 @@ static void cleanup(void) · 9 unmodified lines
214	}	214	}
215		215
216	if (file_count) {	216	if (file_count) {
217	if (ofile->ft) {	217	if (ofile->ft) {
218	if (!success && ofile->ft->fp) { /* If we failed part way through */	218	if (!success && ofile->ft->fp) { /* If we failed part way through */
219	struct stat st; /* writing a normal file, remove it. */	219	struct stat st; /* writing a normal file, remove it. */
220	fstat(fileno(ofile->ft->fp), &st);	220	fstat(fileno(ofile->ft->fp), &st);
@@ -405,13 +405,14 @@ static void progress_to_next_input_file(file_t * f) · 184 unmodified lines
405	display_file_info(f->ft, f, sox_false);	405	display_file_info(f->ft, f, sox_false);
406	if (f->volume == HUGE_VAL)	406	if (f->volume == HUGE_VAL)
407	f->volume = 1;	407	f->volume = 1;
		408	if (f->encoding.half_bit && f->ft->signal.precision < 32)
		409	f->offset = 1 << (31 - f->ft->signal.precision);
408	if (f->replay_gain != HUGE_VAL)	410	if (f->replay_gain != HUGE_VAL)
409	f->volume *= pow(10.0, f->replay_gain / 20);	411	f->volume *= pow(10.0, f->replay_gain / 20);
410	f->ft->sox_errno = errno = 0;	412	f->ft->sox_errno = errno = 0;
411	}	413	}
412		414
413	/* Read up to max `wide' samples. A wide sample contains one sample per channel	415	/* Read up to max `wide' samples. A wide sample contains one sample per channel
414	printf("effect %d obeg = %d oend = %d\n", e, effects_chain->effects[e]->obeg, effects_chain->effects[e]->oend);
415	* from the input audio. */	416	* from the input audio. */
416	static size_t sox_read_wide(sox_format_t * ft, sox_sample_t * buf, size_t max)	417	static size_t sox_read_wide(sox_format_t * ft, sox_sample_t * buf, size_t max)
417	{	418	{
@@ -427,11 +428,12 @@ static void balance_input(sox_sample_t * buf, size_t ws, file_t * f) · 9 unmodified lines
427	{	428	{
428	size_t s = ws * f->ft->signal.channels;	429	size_t s = ws * f->ft->signal.channels;
429		430
430	if (f->volume != 1)	431	if (f->volume == 1 && f->offset !=0 ) while (s--)
431	while (s--) {	432	*buf++ -= f->offset;
432	double d = f->volume * *buf;	433	else if (f->volume != 1 \|\| f->offset !=0 ) while (s--) {
433	*buf++ = SOX_ROUND_CLIP_COUNT(d, f->volume_clips);	434	double d = f->volume * (*buf - f->offset);
434	}	435	*buf++ = SOX_ROUND_CLIP_COUNT(d, f->volume_clips);
		436	}
435	}	437	}
436		438
437	/* The input combiner: contains one sample buffer per input file, but only	439	/* The input combiner: contains one sample buffer per input file, but only
@@ -557,12 +559,24 @@ static sox_effect_handler_t const * input_combiner_effect_fn(void) · 119 unmodified lines
557	return &handler;	559	return &handler;
558	}	560	}
559		561
		562	static int ostart(sox_effect_t *effp)
		563	{
		564	(void)effp;
		565	if (effp->out_encoding->half_bit && effp->out_signal.precision < 32)
		566	ofile->offset = 1 << (31 - ofile->ft->signal.precision);
		567	return SOX_SUCCESS;
		568	}
		569
560	static int output_flow(sox_effect_t effp, sox_sample_t const ibuf,	570	static int output_flow(sox_effect_t effp, sox_sample_t const ibuf,
561	sox_sample_t * obuf, size_t * isamp, size_t * osamp)	571	sox_sample_t * obuf, size_t * isamp, size_t * osamp)
562	{	572	{
		573	sox_sample_t const * buf;
563	size_t len;	574	size_t len;
564		575
565	(void)effp, (void)obuf;	576	(void)effp, (void)obuf;
		577	if (ofile->offset != 0 ) for (buf = ibuf, len = *isamp; len; --len, ++buf)
		578	(sox_sample_t )buf = *buf >= SOX_SAMPLE_MAX - ofile->offset?
		579	SOX_SAMPLE_MAX : *buf + ofile->offset;
566	if (show_progress) for (len = 0; len < *isamp; len += effp->in_signal.channels) {	580	if (show_progress) for (len = 0; len < *isamp; len += effp->in_signal.channels) {
567	omax[0] = max(omax[0], ibuf[len]);	581	omax[0] = max(omax[0], ibuf[len]);
568	omin[0] = min(omin[0], ibuf[len]);	582	omin[0] = min(omin[0], ibuf[len]);
@@ -591,26 +605,49 @@ static int output_flow(sox_effect_t effp, sox_sample_t const ibuf, · 22 unmodified lines
591	static sox_effect_handler_t const * output_effect_fn(void)	605	static sox_effect_handler_t const * output_effect_fn(void)
592	{	606	{
593	static sox_effect_handler_t handler = {	607	static sox_effect_handler_t handler = {
594	"output", 0, SOX_EFF_MCHAN, NULL, NULL, output_flow, NULL, NULL, NULL, 0	608	"output", 0, SOX_EFF_MCHAN, NULL, ostart, output_flow, NULL, NULL, NULL, 0
595	};	609	};
596	return &handler;	610	return &handler;
597	}	611	}
598		612
599	static void add_effect(sox_effects_chain_t chain, char const name,	613	static void auto_effect(sox_effects_chain_t , char const , int, char **,
600	int argc, char argv[], sox_signalinfo_t signal)	614	sox_signalinfo_t , int );
		615
		616	static int add_effect(sox_effects_chain_t * chain, sox_effect_t * effp,
		617	sox_signalinfo_t * in, sox_signalinfo_t const * out, int * guard) {
		618	int no_guard = -1;
		619	switch (*guard) {
		620	case 0: if (!(effp->handler.flags & SOX_EFF_GAIN)) {
		621	char * arg = "-h";
		622	auto_effect(chain, "gain", 1, &arg, in, &no_guard);
		623	++*guard;
		624	}
		625	break;
		626	case 1: if (effp->handler.flags & SOX_EFF_GAIN) {
		627	char * arg = "-r";
		628	auto_effect(chain, "gain", 1, &arg, in, &no_guard);
		629	--*guard;
		630	}
		631	break;
		632	case 2: if (!(effp->handler.flags & SOX_EFF_MODIFY)) {
		633	lsx_fail("effects that modify audio must not follow dither");
		634	exit(1);
		635	}
		636	}
		637	return sox_add_effect(chain, effp, in, out);
		638	}
		639
		640	static void auto_effect(sox_effects_chain_t chain, char const name, int argc,
		641	char argv[], sox_signalinfo_t signal, int * guard)
601	{	642	{
602	sox_effect_t * effp;	643	sox_effect_t * effp;
603		644
604	effp = sox_create_effect(sox_find_effect(name)); /* Should always succeed. */	645	effp = sox_create_effect(sox_find_effect(name)); /* Should always succeed. */
605		646
606	if (effp->handler.flags & SOX_EFF_DEPRECATED)
607	lsx_warn("effect `%s' is deprecated; see sox(1) for an alternative",
608	effp->handler.name);
609
610	if (sox_effect_options(effp, argc, argv) == SOX_EOF)	647	if (sox_effect_options(effp, argc, argv) == SOX_EOF)
611	exit(1); /* The failing effect should have displayed an error message */	648	exit(1); /* The failing effect should have displayed an error message */
612		649
613	if (sox_add_effect(chain, effp, signal, &ofile->ft->signal) != SOX_SUCCESS)	650	if (add_effect(chain, effp, signal, &ofile->ft->signal, guard) != SOX_SUCCESS)
614	exit(2); /* The effects chain should have displayed an error message */	651	exit(2); /* The effects chain should have displayed an error message */
615	}	652	}
616		653
@@ -621,7 +658,7 @@ static void init_eff_chains(void) · 4 unmodified lines
621	nuser_effects[0] = 0;	658	nuser_effects[0] = 0;
622	} /* init_eff_chains */	659	} /* init_eff_chains */
623		660
624	/* add_eff_chain() - NOTE: this only adds memory for one	661	/* add_eff_chain() - NOTE: this only adds memory for one
625	* additional effects chain beyond value of eff_chain_count. It	662	* additional effects chain beyond value of eff_chain_count. It
626	* does not unconditionally increase size of effects chain.	663	* does not unconditionally increase size of effects chain.
627	*/	664	*/
@@ -639,9 +676,9 @@ static void delete_eff_chains(void) · 11 unmodified lines
639	unsigned j;	676	unsigned j;
640	int i, k;	677	int i, k;
641		678
642	for (i = 0; i < eff_chain_count; i++)	679	for (i = 0; i < eff_chain_count; i++)
643	{	680	{
644	for (j = 0; j < nuser_effects[i]; j++)	681	for (j = 0; j < nuser_effects[i]; j++)
645	{	682	{
646	if (user_effargs[i][j].name)	683	if (user_effargs[i][j].name)
647	free(user_effargs[i][j].name);	684	free(user_effargs[i][j].name);
@@ -665,7 +702,7 @@ static void delete_eff_chains(void) · 17 unmodified lines
665		702
666	static sox_bool is_pseudo_effect(char *s)	703	static sox_bool is_pseudo_effect(char *s)
667	{	704	{
668	if (strcmp("newfile", s) == 0 \|\|	705	if (strcmp("newfile", s) == 0 \|\|
669	strcmp("restart", s) == 0 \|\|	706	strcmp("restart", s) == 0 \|\|
670	strcmp(":", s) == 0)	707	strcmp(":", s) == 0)
671	return sox_true;	708	return sox_true;
@@ -700,7 +737,7 @@ static void parse_effects(int argc, char **argv) · 28 unmodified lines
700	optind++;	737	optind++;
701	continue;	738	continue;
702	}	739	}
703		740
704	if (strcmp(argv[optind], "newfile") == 0)	741	if (strcmp(argv[optind], "newfile") == 0)
705	{	742	{
706	/* Start a new effect chain for newfile if user doesn't	743	/* Start a new effect chain for newfile if user doesn't
@@ -739,7 +776,7 @@ static void parse_effects(int argc, char **argv) · 32 unmodified lines
739		776
740	optind += j; /* Skip past the effect arguments */	777	optind += j; /* Skip past the effect arguments */
741	nuser_effects[eff_chain_count]++;	778	nuser_effects[eff_chain_count]++;
742	if (newline_mode)	779	if (newline_mode)
743	{	780	{
744	output_method = sox_multiple;	781	output_method = sox_multiple;
745	eff_chain_count++;	782	eff_chain_count++;
@@ -865,9 +902,9 @@ static void read_user_effects(char *filename) · 119 unmodified lines
865	/* Creates users effects and passes in user specified options.	902	/* Creates users effects and passes in user specified options.
866	* This is done without putting anything into the effects chain	903	* This is done without putting anything into the effects chain
867	* because an effect may set the effp->in_format and we may want	904	* because an effect may set the effp->in_format and we may want
868	* to copy that back into the input/combiner before opening and	905	* to copy that back into the input/combiner before opening and
869	* inserting it.	906	* inserting it.
870	* Similarly, we may want to use effp->out_format to override the	907	* Similarly, we may want to use effp->out_format to override the
871	* default values of output file before we open it.	908	* default values of output file before we open it.
872	* To keep things simple, we create all user effects. Later, when	909	* To keep things simple, we create all user effects. Later, when
873	* we add them, some may already be in the chain and we will need to free	910	* we add them, some may already be in the chain and we will need to free
@@ -882,11 +919,11 @@ static void create_user_effects(void) · 8 unmodified lines
882	effp = sox_create_effect(sox_find_effect(user_effargs[current_eff_chain][i].name));	919	effp = sox_create_effect(sox_find_effect(user_effargs[current_eff_chain][i].name));
883		920
884	if (effp->handler.flags & SOX_EFF_DEPRECATED)	921	if (effp->handler.flags & SOX_EFF_DEPRECATED)
885	lsx_warn("effect `%s' is deprecated; see sox(1) for an alternative",	922	lsx_warn("effect `%s' is deprecated; see sox(1) for an alternative",
886	effp->handler.name);	923	effp->handler.name);
887		924
888	/* The failing effect should have displayed an error message */	925	/* The failing effect should have displayed an error message */
889	if (sox_effect_options(effp, user_effargs[current_eff_chain][i].argc,	926	if (sox_effect_options(effp, user_effargs[current_eff_chain][i].argc,
890	user_effargs[current_eff_chain][i].argv) == SOX_EOF)	927	user_effargs[current_eff_chain][i].argv) == SOX_EOF)
891	exit(1);	928	exit(1);
892		929
@@ -905,38 +942,50 @@ static void create_user_effects(void) · 12 unmodified lines
905	static void add_effects(sox_effects_chain_t *chain)	942	static void add_effects(sox_effects_chain_t *chain)
906	{	943	{
907	sox_signalinfo_t signal = combiner_signal;	944	sox_signalinfo_t signal = combiner_signal;
		945	int guard = is_guarded - 1;
908	unsigned i;	946	unsigned i;
909	sox_effect_t * effp;	947	sox_effect_t * effp;
910	char * rate_arg =	948	char * rate_arg =
911	is_player ? (rate_arg = getenv("PLAY_RATE_ARG")) ? rate_arg : "-l" : NULL;	949	is_player ? (rate_arg = getenv("PLAY_RATE_ARG")) ? rate_arg : "-l" : NULL;
912		950
913	/* 1st `effect' in the chain is the input combiner_signal.	951	/* 1st `effect' in the chain is the input combiner_signal.
914	* add it only if its not there from a previous run.	952	* add it only if its not there from a previous run. */
915	*/	953	if (chain->length == 0) {
916	if (chain->length == 0)
917	{
918	effp = sox_create_effect(input_combiner_effect_fn());	954	effp = sox_create_effect(input_combiner_effect_fn());
919	sox_add_effect(chain, effp, &signal, &ofile->ft->signal);	955	sox_add_effect(chain, effp, &signal, &ofile->ft->signal);
920	}	956	}
921		957
922	/* Add auto effects if appropriate; add user specified effects */	958	/* Add user specified effects; stop before `dither' */
923	for (i = 0; i < nuser_effects[current_eff_chain]; i++) {	959	for (i = 0; i < nuser_effects[current_eff_chain] &&
924	/* Effects chain should have displayed an error message */	960	strcmp(user_efftab[i]->handler.name, "dither"); i++)
925	if (sox_add_effect(chain, user_efftab[i],	961	if (add_effect(chain, user_efftab[i], &signal, &ofile->ft->signal,
926	&signal, &ofile->ft->signal) != SOX_SUCCESS)	962	&guard) != SOX_SUCCESS)
927	exit(2);	963	exit(2); /* Effects chain should have displayed an error message */
928	}
929		964
930	/* Add auto effects if still needed at this point */	965	/* Add auto effects if still needed at this point */
		966	if (signal.channels < ofile->ft->signal.channels &&
		967	signal.rate != ofile->ft->signal.rate)
		968	auto_effect(chain, "rate", rate_arg != NULL, &rate_arg, &signal, &guard);
		969	if (signal.channels != ofile->ft->signal.channels)
		970	auto_effect(chain, "mixer", 0, NULL, &signal, &guard);
931	if (signal.rate != ofile->ft->signal.rate)	971	if (signal.rate != ofile->ft->signal.rate)
932	{	972	auto_effect(chain, "rate", rate_arg != NULL, &rate_arg, &signal, &guard);
933	add_effect(chain, "rate", rate_arg != NULL, &rate_arg, &signal); /* Must be up-sampling */	973
		974	if (is_guarded && (do_guarded_norm \|\| !(signal.mult && *signal.mult == 1))) {
		975	char * arg = do_guarded_norm? "-nh" : guard? "-rh" : "-h";
		976	int no_guard = -1;
		977	auto_effect(chain, "gain", 1, &arg, &signal, &no_guard);
		978	guard = 1;
934	}	979	}
935	if (signal.channels != ofile->ft->signal.channels)	980
936	{	981	/* Add user specified effects from `dither' onwards */
937	add_effect(chain, "mixer", 0, NULL, &signal); /* Must be increasing channels */	982	for (; i < nuser_effects[current_eff_chain]; i++, guard = 2) {
		983	if (add_effect(chain, user_efftab[i], &signal, &ofile->ft->signal,
		984	&guard) != SOX_SUCCESS)
		985	exit(2); /* Effects chain should have displayed an error message */
		986	chain->out_enc->half_bit = sox_false;
938	}	987	}
939		988
940	if (!save_output_eff)	989	if (!save_output_eff)
941	{	990	{
942	/* Last `effect' in the chain is the output file */	991	/* Last `effect' in the chain is the output file */
@@ -981,15 +1030,15 @@ static int advance_eff_chain(void) · 38 unmodified lines
981	/* Effect chain stopped so advance to next effect chain but	1030	/* Effect chain stopped so advance to next effect chain but
982	* quite if no more chains exist.	1031	* quite if no more chains exist.
983	*/	1032	*/
984	else if (++current_eff_chain >= eff_chain_count)	1033	else if (++current_eff_chain >= eff_chain_count)
985	return SOX_EOF;	1034	return SOX_EOF;
986		1035
987	while (nuser_effects[current_eff_chain] == 1 &&	1036	while (nuser_effects[current_eff_chain] == 1 &&
988	is_pseudo_effect(user_effargs[current_eff_chain][0].name))	1037	is_pseudo_effect(user_effargs[current_eff_chain][0].name))
989	{	1038	{
990	if (strcmp("newfile", user_effargs[current_eff_chain][0].name) == 0)	1039	if (strcmp("newfile", user_effargs[current_eff_chain][0].name) == 0)
991	{	1040	{
992	if (++current_eff_chain >= eff_chain_count)	1041	if (++current_eff_chain >= eff_chain_count)
993	return SOX_EOF;	1042	return SOX_EOF;
994	reuse_output = sox_false;	1043	reuse_output = sox_false;
995	}	1044	}
@@ -1167,7 +1216,7 @@ static int update_status(sox_bool all_done) · 171 unmodified lines
1167	int ch = getchar();	1216	int ch = getchar();
1168		1217
1169	#ifdef INTERACTIVE	1218	#ifdef INTERACTIVE
1170	if (files[current_input]->ft->handler.seek &&	1219	if (files[current_input]->ft->handler.seek &&
1171	files[current_input]->ft->seekable)	1220	files[current_input]->ft->seekable)
1172	{	1221	{
1173	if (ch == '>')	1222	if (ch == '>')
@@ -1408,7 +1457,7 @@ static void calculate_combiner_signal_parameters(void) · 234 unmodified lines
1408	*/	1457	*/
1409	for (i = 0; i < input_count; i++) {	1458	for (i = 0; i < input_count; i++) {
1410	unsigned j;	1459	unsigned j;
1411	for (j =0; j < nuser_effects[current_eff_chain] &&	1460	for (j =0; j < nuser_effects[current_eff_chain] &&
1412	!files[i]->ft->signal.channels; ++j)	1461	!files[i]->ft->signal.channels; ++j)
1413	files[i]->ft->signal.channels = user_efftab[j]->in_signal.channels;	1462	files[i]->ft->signal.channels = user_efftab[j]->in_signal.channels;
1414	/* For historical reasons, default to one channel if not specified. */	1463	/* For historical reasons, default to one channel if not specified. */
@@ -1520,7 +1569,7 @@ static void set_combiner_and_output_encoding_parameters(void) · 105 unmodified lines
1520	/* Determine the output file encoding attributes; set from user options	1569	/* Determine the output file encoding attributes; set from user options
1521	* if given: */	1570	* if given: */
1522	ofile->encoding = ofile_encoding_options;	1571	ofile->encoding = ofile_encoding_options;
1523		1572
1524	/* Get unspecified output file encoding attributes from the input file and	1573	/* Get unspecified output file encoding attributes from the input file and
1525	* set the output file to the resultant encoding if this is supported by the	1574	* set the output file to the resultant encoding if this is supported by the
1526	* output file type; if not, the output file handler should select an	1575	* output file type; if not, the output file handler should select an
@@ -1548,7 +1597,7 @@ static int process(void) · 21 unmodified lines
1548	open_output_file();	1597	open_output_file();
1549		1598
1550	if (!effects_chain)	1599	if (!effects_chain)
1551	effects_chain = sox_create_effects_chain(&combiner_encoding,	1600	effects_chain = sox_create_effects_chain(&combiner_encoding,
1552	&ofile->ft->encoding);	1601	&ofile->ft->encoding);
1553	add_effects(effects_chain);	1602	add_effects(effects_chain);
1554		1603
@@ -1564,7 +1613,7 @@ static int process(void) · 9 unmodified lines
1564	* effect chains.	1613	* effect chains.
1565	* For case #2, something else must decide when to stop processing.	1614	* For case #2, something else must decide when to stop processing.
1566	*/	1615	*/
1567	if ((input_eof && current_input < input_count) \|\|	1616	if ((input_eof && current_input < input_count) \|\|
1568	(!output_eof && current_eff_chain < eff_chain_count))	1617	(!output_eof && current_eff_chain < eff_chain_count))
1569	flow_status = SOX_SUCCESS;	1618	flow_status = SOX_SUCCESS;
1570		1619
@@ -1691,6 +1740,7 @@ static void usage(char const * message) · 120 unmodified lines
1691	"--combine concatenate Concatenate multiple input files (default for sox, rec)",	1740	"--combine concatenate Concatenate multiple input files (default for sox, rec)",
1692	"--combine sequence Sequence multiple input files (default for play)",	1741	"--combine sequence Sequence multiple input files (default for play)",
1693	"--effects-file FILENAME File containing effects and options",	1742	"--effects-file FILENAME File containing effects and options",
		1743	"-G, --guard Use temporary files to guard against clipping",
1694	"-h, --help Display version number and usage information",	1744	"-h, --help Display version number and usage information",
1695	"--help-effect NAME Show usage of effect NAME, or NAME=all for all",	1745	"--help-effect NAME Show usage of effect NAME, or NAME=all for all",
1696	"--help-format NAME Show info on format NAME, or NAME=all for all",	1746	"--help-format NAME Show info on format NAME, or NAME=all for all",
@@ -1698,6 +1748,7 @@ static void usage(char const * message) · 1 unmodified line
1698	"--interactive Prompt to overwrite output file",	1748	"--interactive Prompt to overwrite output file",
1699	"-m, --combine mix Mix multiple input files (instead of concatenating)",	1749	"-m, --combine mix Mix multiple input files (instead of concatenating)",
1700	"-M, --combine merge Merge multiple input files (instead of concatenating)",	1750	"-M, --combine merge Merge multiple input files (instead of concatenating)",
		1751	"--norm Guard (see --guard) & normalise",
1701	"--plot gnuplot\|octave Generate script to plot response of filter effect",	1752	"--plot gnuplot\|octave Generate script to plot response of filter effect",
1702	"-q, --no-show-progress Run in quiet mode; opposite of -S",	1753	"-q, --no-show-progress Run in quiet mode; opposite of -S",
1703	"--replay-gain track\|album\|off Default: off (sox, rec), track (play)",	1754	"--replay-gain track\|album\|off Default: off (sox, rec), track (play)",
@@ -1728,6 +1779,7 @@ static void usage(char const * message) · 24 unmodified lines
1728	"-X\|--reverse-bits Encoded bit-order",	1779	"-X\|--reverse-bits Encoded bit-order",
1729	"--endian little\|big\|swap Encoded byte-order; swap means opposite to default",	1780	"--endian little\|big\|swap Encoded byte-order; swap means opposite to default",
1730	"-L/-B/-x Short options for the above",	1781	"-L/-B/-x Short options for the above",
		1782	"-0 PCM encoding is 0 biased (offset by half a bit)",
1731	"-c\|--channels CHANNELS Number of channels of audio data; e.g. 2 = stereo",	1783	"-c\|--channels CHANNELS Number of channels of audio data; e.g. 2 = stereo",
1732	"-r\|--rate RATE Sample rate of audio",	1784	"-r\|--rate RATE Sample rate of audio",
1733	"-C\|--compression FACTOR Compression factor for output format",	1785	"-C\|--compression FACTOR Compression factor for output format",
@@ -1885,7 +1937,7 @@ static void read_comment_file(sox_comments_t * comments, char const * const file · 151 unmodified lines
1885	free(text);	1937	free(text);
1886	}	1938	}
1887		1939
1888	static char *getoptstr = "+ab:c:de:fghimnopqr:st:uv:xABC:LMNRSTUV::X12348";	1940	static char *getoptstr = "+ab:c:de:fghimnopqr:st:uv:xABC:GLMNRSTUV::X012348";
1889		1941
1890	static struct option long_options[] =	1942	static struct option long_options[] =
1891	{	1943	{
@@ -1908,6 +1960,7 @@ static struct option long_options[] = · 16 unmodified lines
1908	{"temp" , required_argument, NULL, 0},	1960	{"temp" , required_argument, NULL, 0},
1909	{"single-threaded" , no_argument, NULL, 0},	1961	{"single-threaded" , no_argument, NULL, 0},
1910	{"ignore-length" , no_argument, NULL, 0},	1962	{"ignore-length" , no_argument, NULL, 0},
		1963	{"norm" , no_argument, NULL, 0},
1911		1964
1912	{"bits" , required_argument, NULL, 'b'},	1965	{"bits" , required_argument, NULL, 'b'},
1913	{"channels" , required_argument, NULL, 'c'},	1966	{"channels" , required_argument, NULL, 'c'},
@@ -1924,6 +1977,7 @@ static struct option long_options[] = · 10 unmodified lines
1924	{"show-progress" , no_argument, NULL, 'S'},	1977	{"show-progress" , no_argument, NULL, 'S'},
1925	{"type" , required_argument, NULL, 't'},	1978	{"type" , required_argument, NULL, 't'},
1926	{"volume" , required_argument, NULL, 'v'},	1979	{"volume" , required_argument, NULL, 'v'},
		1980	{"guard" , no_argument, NULL, 'G'},
1927		1981
1928	{NULL, 0, NULL, 0}	1982	{NULL, 0, NULL, 0}
1929	};	1983	};
@@ -2056,57 +2110,25 @@ static char parse_gopts_and_fopts(file_t * f, int argc, char **argv) · 126 unmodified lines
2056	sox_globals.input_bufsiz = i;	2110	sox_globals.input_bufsiz = i;
2057	break;	2111	break;
2058		2112
2059	case 7:	2113	case 7: interactive = sox_true; break;
2060	interactive = sox_true;	2114	case 8: usage_effect(optarg); break;
2061	break;	2115	case 9: usage_format(optarg); break;
2062		2116	case 10: f->no_glob = sox_true; break;
2063	case 8:
2064	usage_effect(optarg);
2065	break;
2066
2067	case 9:
2068	usage_format(optarg);
2069	break;
2070
2071	case 10:
2072	f->no_glob = sox_true;
2073	break;
2074
2075	case 11:	2117	case 11:
2076	sox_effects_globals.plot = enum_option(option_index, plot_methods);	2118	sox_effects_globals.plot = enum_option(option_index, plot_methods);
2077	break;	2119	break;
2078		2120	case 12: replay_gain_mode = enum_option(option_index, rg_modes); break;
2079	case 12:	2121	case 13: display_SoX_version(stdout); exit(0); break;
2080	replay_gain_mode = enum_option(option_index, rg_modes);	2122	case 14: break;
2081	break;	2123	case 15: effects_filename = strdup(optarg); break;
2082		2124	case 16: sox_globals.tmp_path = strdup(optarg); break;
2083	case 13:	2125	case 17: single_threaded = sox_true; break;
2084	display_SoX_version(stdout);	2126	case 18: f->signal.length = SOX_IGNORE_LENGTH; break;
2085	exit(0);	2127	case 19: do_guarded_norm = is_guarded = sox_true; break;
2086	break;
2087
2088	case 14:
2089	break;
2090
2091	case 15:
2092	effects_filename = strdup(optarg);
2093	break;
2094
2095	case 16:
2096	sox_globals.tmp_path = strdup(optarg);
2097	break;
2098
2099	case 17:
2100	single_threaded = sox_true;
2101	break;
2102
2103	case 18:
2104	f->signal.length = SOX_IGNORE_LENGTH;
2105	break;
2106
2107	}	2128	}
2108	break;	2129	break;
2109		2130
		2131	case 'G': is_guarded = sox_true; break;
2110	case 'm': combine_method = sox_mix; break;	2132	case 'm': combine_method = sox_mix; break;
2111	case 'M': combine_method = sox_merge; break;	2133	case 'M': combine_method = sox_merge; break;
2112	case 'T': combine_method = sox_multiply; break;	2134	case 'T': combine_method = sox_multiply; break;
@@ -2119,7 +2141,7 @@ static char parse_gopts_and_fopts(file_t * f, int argc, char **argv) · 6 unmodified lines
2119	return c;	2141	return c;
2120	break;	2142	break;
2121		2143
2122	case 'h':	2144	case 'h':
2123	usage(NULL);	2145	usage(NULL);
2124	break;	2146	break;
2125		2147
@@ -2144,6 +2166,8 @@ static char parse_gopts_and_fopts(file_t * f, int argc, char **argv) · 18 unmodified lines
2144	break;	2166	break;
2145	}	2167	}
2146		2168
		2169	case '0': f->encoding.half_bit = sox_true; break;
		2170
2147	case 'v':	2171	case 'v':
2148	if (sscanf(optarg, "%lf %c", &f->volume, &dummy) != 1) {	2172	if (sscanf(optarg, "%lf %c", &f->volume, &dummy) != 1) {
2149	lsx_fail("Volume value `%s' is not a number", optarg);	2173	lsx_fail("Volume value `%s' is not a number", optarg);
@@ -2444,7 +2468,7 @@ static int soxi(int argc, char * const * argv) · 294 unmodified lines
2444	}	2468	}
2445	sox_globals.verbosity = (unsigned)i;	2469	sox_globals.verbosity = (unsigned)i;
2446	}	2470	}
2447	}	2471	}
2448	else if (opt == 'T')	2472	else if (opt == 'T')
2449	do_total = sox_true;	2473	do_total = sox_true;
2450	else type = 1 + (strchr(opts, opt) - opts);	2474	else type = 1 + (strchr(opts, opt) - opts);
@@ -2512,12 +2536,6 @@ static sox_bool cmp_comment_text(char const * c1, char const * c2) · 61 unmodified lines
2512	return c1 && c2 && !strcasecmp(c1, c2);	2536	return c1 && c2 && !strcasecmp(c1, c2);
2513	}	2537	}
2514		2538
2515	static int strends(char const * str, char const * end)
2516	{
2517	size_t str_len = strlen(str), end_len = strlen(end);
2518	return str_len >= end_len && !strcmp(str + str_len - end_len, end);
2519	}
2520
2521	#ifdef __CYGWIN__	2539	#ifdef __CYGWIN__
2522	static char * check_dir(char * name)	2540	static char * check_dir(char * name)
2523	{	2541	{
@@ -2534,11 +2552,11 @@ int main(int argc, char **argv) · 10 unmodified lines
2534	myname = argv[0];	2552	myname = argv[0];
2535	sox_globals.output_message_handler = output_message;	2553	sox_globals.output_message_handler = output_message;
2536		2554
2537	if (strends(myname, "play"))	2555	if (lsx_strends(myname, "play"))
2538	sox_mode = sox_play;	2556	sox_mode = sox_play;
2539	else if (strends(myname, "rec"))	2557	else if (lsx_strends(myname, "rec"))
2540	sox_mode = sox_rec;	2558	sox_mode = sox_rec;
2541	else if (strends(myname, "soxi"))	2559	else if (lsx_strends(myname, "soxi"))
2542	sox_mode = sox_soxi;	2560	sox_mode = sox_soxi;
2543		2561
2544	if (sox_init() != SOX_SUCCESS)	2562	if (sox_init() != SOX_SUCCESS)
@@ -2686,7 +2704,7 @@ int main(int argc, char **argv) · 141 unmodified lines
2686	}	2704	}
2687		2705
2688	/* Not the best way for users to do this; now deprecated in favour of soxi. */	2706	/* Not the best way for users to do this; now deprecated in favour of soxi. */
2689	if (!show_progress && !nuser_effects[current_eff_chain] &&	2707	if (!show_progress && !nuser_effects[current_eff_chain] &&
2690	ofile->filetype && !strcmp(ofile->filetype, "null")) {	2708	ofile->filetype && !strcmp(ofile->filetype, "null")) {
2691	for (i = 0; i < input_count; i++)	2709	for (i = 0; i < input_count; i++)
2692	report_file_info(files[i]);	2710	report_file_info(files[i]);
@@ -2703,7 +2721,7 @@ int main(int argc, char **argv) · 10 unmodified lines
2703		2721
2704	/* If user specified an effects filename then use that file	2722	/* If user specified an effects filename then use that file
2705	* to load user effects. Free any previously specified options	2723	* to load user effects. Free any previously specified options
2706	* from the command line.	2724	* from the command line.
2707	*/	2725	*/
2708	if (effects_filename)	2726	if (effects_filename)
2709	{	2727	{

src/sox.h+32−35

 /* libSoX Library Public Interface
  *
- * Copyright 1999-2008 Chris Bagwell and SoX Contributors.
+ * Copyright 1999-2009 Chris Bagwell and SoX Contributors.
  *
  * This source code is freely redistributable and may be used for
  * any purpose.  This copyright notice must be maintained.
 #define SOX_H
 #include <limits.h>
+#include <math.h>
 #include <stdarg.h>
 #include <stddef.h> /* Ensure NULL etc. are available throughout SoX */
 #include <stdio.h>
 /*                Conversions: Linear PCM <--> sox_sample_t
  *
- *   I/O       I/O     sox_sample_t Clips?    I/O     sox_sample_t Clips?
+ *   I/O       I/O     sox_sample_t    I/O     sox_sample_t
- *  Format   Minimum     Minimum     I O    Maximum     Maximum     I O
+ *  Format   Minimum     Minimum     Maximum     Maximum
- *  ------  ---------  ------------ -- --   --------  ------------ -- --
+ *  ------  ---------  ------------  --------  ------------
- *  Float      -1     -1.00000000047 y y       1           1        y n
+ *  Float      -1          -1           1       1 - 5e-10
- *  Int8      -128        -128       n n      127     127.9999999   n y
+ *  Int8      -128        -127.5       127     127.4999999
- *  Int16    -32768      -32768      n n     32767    32767.99998   n y
+ *  Int16    -32768      -32767.5     32767    32767.49998
- *  Int24   -8388608    -8388608     n n    8388607   8388607.996   n y
+ *  Int24   -8388608    -8388607.5   8388607   8388607.496
- *  Int32  -2147483648 -2147483648   n n   2147483647 2147483647    n n
+ *  Int32  -2147483648 -2147483648  2147483647 2147483647
  *
  * Conversions are as accurate as possible (with rounding).
  *
  * Rounding: halves toward +inf, all others to nearest integer.
  *
- * Clips? shows whether on not there is the possibility of a conversion
+ * The only possibility of clipping on conversion is when inputting Float.
- * clipping to the minimum or maximum value when inputing from or outputing
- * to a given type.
  *
  * Unsigned integers are converted to and from signed integers by flipping
  * the upper-most bit then treating them as signed integers.
  */
-#define SOX_SAMPLE_LOCALS sox_sample_t sox_macro_temp_sample UNUSED; \
+#define SOX_SAMPLE_LOCALS double sox_macro_temp_double UNUSED
-  double sox_macro_temp_double UNUSED
 #define SOX_SAMPLE_NEG SOX_INT_MIN(32)
-#define SOX_SAMPLE_TO_UNSIGNED(bits,d,clips) \
+#define SOX_SAMPLE_TO_UNSIGNED(bits,d) \
-  (uint##bits##_t)( \
+  (uint##bits##_t)(((uint32_t)((d)^SOX_SAMPLE_NEG))>>(32-bits))
-    sox_macro_temp_sample=(d), \
+#define SOX_SAMPLE_TO_SIGNED(bits,d) (int##bits##_t)(((uint32_t)(d))>>(32-bits))
-    sox_macro_temp_sample>(sox_sample_t)(SOX_SAMPLE_MAX-(1U<<(31-bits)))? \
+#define SOX_SIGNED_TO_SAMPLE(bits,d)(((sox_sample_t)(d)<<(32-bits))+(1<<(31-bits)))
-      ++(clips),SOX_UINT_MAX(bits): \
-      ((uint32_t)(sox_macro_temp_sample^SOX_SAMPLE_NEG)+(1U<<(31-bits)))>>(32-bits))
-#define SOX_SAMPLE_TO_SIGNED(bits,d,clips) \
-  (int##bits##_t)(SOX_SAMPLE_TO_UNSIGNED(bits,d,clips)^SOX_INT_MIN(bits))
-#define SOX_SIGNED_TO_SAMPLE(bits,d)((sox_sample_t)(d)<<(32-bits))
 #define SOX_UNSIGNED_TO_SAMPLE(bits,d)(SOX_SIGNED_TO_SAMPLE(bits,d)^SOX_SAMPLE_NEG)
 #define SOX_UNSIGNED_8BIT_TO_SAMPLE(d,clips) SOX_UNSIGNED_TO_SAMPLE(8,d)
 #define SOX_UNSIGNED_32BIT_TO_SAMPLE(d,clips) ((sox_sample_t)(d)^SOX_SAMPLE_NEG)
 #define SOX_SIGNED_32BIT_TO_SAMPLE(d,clips) (sox_sample_t)(d)
 #define SOX_FLOAT_32BIT_TO_SAMPLE SOX_FLOAT_64BIT_TO_SAMPLE
-#define SOX_FLOAT_64BIT_TO_SAMPLE(d,clips) (sox_macro_temp_double=(d),sox_macro_temp_double<-1?++(clips),(-SOX_SAMPLE_MAX):sox_macro_temp_double>1?++(clips),SOX_SAMPLE_MAX:(sox_sample_t)((uint32_t)((double)(sox_macro_temp_double)*SOX_SAMPLE_MAX+(SOX_SAMPLE_MAX+.5))-SOX_SAMPLE_MAX))
+#define SOX_FLOAT_64BIT_TO_SAMPLE(d,clips) (sox_macro_temp_double=(d)*(SOX_SAMPLE_MAX+1.)+.5,sox_macro_temp_double<SOX_SAMPLE_MIN?++(clips),SOX_SAMPLE_MIN:sox_macro_temp_double>=SOX_SAMPLE_MAX+1.?sox_macro_temp_double>SOX_SAMPLE_MAX+1.5?++(clips),SOX_SAMPLE_MAX:SOX_SAMPLE_MAX:(sox_sample_t)floor(sox_macro_temp_double))
-#define SOX_SAMPLE_TO_UNSIGNED_8BIT(d,clips) SOX_SAMPLE_TO_UNSIGNED(8,d,clips)
+#define SOX_SAMPLE_TO_UNSIGNED_8BIT(d) SOX_SAMPLE_TO_UNSIGNED(8,d)
-#define SOX_SAMPLE_TO_SIGNED_8BIT(d,clips) SOX_SAMPLE_TO_SIGNED(8,d,clips)
+#define SOX_SAMPLE_TO_SIGNED_8BIT(d) SOX_SAMPLE_TO_SIGNED(8,d)
-#define SOX_SAMPLE_TO_UNSIGNED_16BIT(d,clips) SOX_SAMPLE_TO_UNSIGNED(16,d,clips)
+#define SOX_SAMPLE_TO_UNSIGNED_16BIT(d) SOX_SAMPLE_TO_UNSIGNED(16,d)
-#define SOX_SAMPLE_TO_SIGNED_16BIT(d,clips) SOX_SAMPLE_TO_SIGNED(16,d,clips)
+#define SOX_SAMPLE_TO_SIGNED_16BIT(d) SOX_SAMPLE_TO_SIGNED(16,d)
-#define SOX_SAMPLE_TO_UNSIGNED_24BIT(d,clips) SOX_SAMPLE_TO_UNSIGNED(24,d,clips)
+#define SOX_SAMPLE_TO_UNSIGNED_24BIT(d) SOX_SAMPLE_TO_UNSIGNED(24,d)
-#define SOX_SAMPLE_TO_SIGNED_24BIT(d,clips) SOX_SAMPLE_TO_SIGNED(24,d,clips)
+#define SOX_SAMPLE_TO_SIGNED_24BIT(d) SOX_SAMPLE_TO_SIGNED(24,d)
-#define SOX_SAMPLE_TO_UNSIGNED_32BIT(d,clips) (uint32_t)((d)^SOX_SAMPLE_NEG)
+#define SOX_SAMPLE_TO_UNSIGNED_32BIT(d) (uint32_t)((d)^SOX_SAMPLE_NEG)
-#define SOX_SAMPLE_TO_SIGNED_32BIT(d,clips) (int32_t)(d)
+#define SOX_SAMPLE_TO_SIGNED_32BIT(d) (int32_t)(d)
 #define SOX_SAMPLE_TO_FLOAT_32BIT SOX_SAMPLE_TO_FLOAT_64BIT
-#define SOX_SAMPLE_TO_FLOAT_64BIT(d,clips) (sox_macro_temp_sample=(d),sox_macro_temp_sample==SOX_SAMPLE_MIN?++(clips),-1.0:((double)(sox_macro_temp_sample)*(1.0/SOX_SAMPLE_MAX)))
+#define SOX_SAMPLE_TO_FLOAT_64BIT(d) ((d)*(1./(SOX_SAMPLE_MAX+1.)))
 typedef struct { /* Encoding parameters */
   sox_encoding_t encoding; /* format of sample numbers */
   unsigned bits_per_sample;  /* 0 if unknown or variable; uncompressed value if lossless; compressed value if lossy */
+  sox_bool half_bit;
   double compression;      /* compression factor (where applicable) */
   /* If these 3 variables are set to DEFAULT, then, during
 #define SOX_EFF_MCHAN    16          /* Effect can handle multi-channel */
 #define SOX_EFF_NULL     32          /* Effect does nothing */
 #define SOX_EFF_DEPRECATED 64        /* Effect is living on borrowed time */
+#define SOX_EFF_GAIN     128         /* Effect does not support gain -r */
+#define SOX_EFF_MODIFY   256         /* Effect does not modify samples */
 typedef enum {sox_plot_off, sox_plot_octave, sox_plot_gnuplot} sox_plot_t;
 typedef struct sox_effect sox_effect_t;
   sox_sample_t **ibufc, **obufc; /* Channel interleave buffers */
   sox_effects_globals_t global_info;
   sox_encodinginfo_t const * in_enc;
-  sox_encodinginfo_t const * out_enc;
+  sox_encodinginfo_t * out_enc;
 };
 typedef struct sox_effects_chain sox_effects_chain_t;
 sox_effects_chain_t * sox_create_effects_chain(
-    sox_encodinginfo_t const * in_enc, sox_encodinginfo_t const * out_enc);
+    sox_encodinginfo_t const * in_enc, sox_encodinginfo_t * out_enc);
 void sox_delete_effects_chain(sox_effects_chain_t *ecp);
 int sox_add_effect( sox_effects_chain_t * chain, sox_effect_t * effp, sox_signalinfo_t * in, sox_signalinfo_t const * out);
 int sox_flow_effects(sox_effects_chain_t *, int (* callback)(sox_bool all_done));
 lsx_enum_item const * lsx_find_enum_text(char const * text, lsx_enum_item const * lsx_enum_items);
 lsx_enum_item const * lsx_find_enum_value(unsigned value, lsx_enum_item const * lsx_enum_items);
 int lsx_enum_option(int c, lsx_enum_item const * items);
+sox_bool lsx_strends(char const * str, char const * end);
 char const * lsx_find_file_extension(char const * pathname);
 char const * lsx_sigfigs3(size_t number);
 char const * lsx_sigfigs3p(double percentage);

src/sox_i.h+11−1

 #include <errno.h>
+#if defined(LSX_EFF_ALIAS)
+#undef lsx_debug
+#undef lsx_fail
+#undef lsx_report
+#undef lsx_warn
+#define lsx_debug sox_globals.subsystem=effp->handler.name,lsx_debug
+#define lsx_fail sox_globals.subsystem=effp->handler.name,lsx_fail
+#define lsx_report sox_globals.subsystem=effp->handler.name,lsx_report
+#define lsx_warn sox_globals.subsystem=effp->handler.name,lsx_warn
+#endif
 #define RANQD1 ranqd1(sox_globals.ranqd1)
 #define DRANQD1 dranqd1(sox_globals.ranqd1)
 int lsx_check_read_params(sox_format_t * ft, unsigned channels,
     sox_rate_t rate, sox_encoding_t encoding, unsigned bits_per_sample,
     off_t num_samples, sox_bool check_length);
-sox_sample_t lsx_sample_max(sox_encodinginfo_t const * encoding);
 #define SOX_FORMAT_HANDLER(name) \
 sox_format_handler_t const * sox_##name##_format_fn(void); \
 sox_format_handler_t const * sox_##name##_format_fn(void)

src/sox_sample_test.c+0−18

@@ -1,18 +0,0 @@
1	/* libSoX test code copyright (c) 2006 robs@users.sourceforge.net
2	*
3	* This program is free software; you can redistribute it and/or modify it
4	* under the terms of the GNU General Public License as published by the
5	* Free Software Foundation; either version 2 of the License, or (at your
6	* option) any later version.
7	*
8	* This program is distributed in the hope that it will be useful, but
9	* WITHOUT ANY WARRANTY; without even the implied warranty of
10	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
11	* Public License for more details.
12	*
13	* You should have received a copy of the GNU General Public License along
14	* with this program; if not, write to the Free Software Foundation, Inc.,
15	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
16	*/
17
18	#include "sox_sample_test.h"

src/sox_sample_test.h+0−207

@@ -1,207 +0,0 @@
1	/* libSoX test code copyright (c) 2006 robs@users.sourceforge.net
2	*
3	* This program is free software; you can redistribute it and/or modify it
4	* under the terms of the GNU General Public License as published by the
5	* Free Software Foundation; either version 2 of the License, or (at your
6	* option) any later version.
7	*
8	* This program is distributed in the hope that it will be useful, but
9	* WITHOUT ANY WARRANTY; without even the implied warranty of
10	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
11	* Public License for more details.
12	*
13	* You should have received a copy of the GNU General Public License along
14	* with this program; if not, write to the Free Software Foundation, Inc.,
15	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
16	*/
17
18	#define DEBUG
19	#include <assert.h>
20	#include "sox.h"
21
22	#define TEST_UINT(bits) \
23	uint##bits = 0; \
24	sample = SOX_UNSIGNED_TO_SAMPLE(bits,uint##bits); \
25	assert(sample == SOX_SAMPLE_MIN); \
26	uint##bits = SOX_SAMPLE_TO_UNSIGNED(bits,sample, clips); \
27	assert(uint##bits == 0 && clips == 0); \
28	\
29	uint##bits = 1; \
30	sample = SOX_UNSIGNED_TO_SAMPLE(bits,uint##bits); \
31	assert(sample > SOX_SAMPLE_MIN && sample < 0); \
32	uint##bits = SOX_SAMPLE_TO_UNSIGNED(bits,sample, clips); \
33	assert(uint##bits == 1 && clips == 0); \
34	\
35	uint##bits = SOX_INT_MAX(bits); \
36	sample = SOX_UNSIGNED_TO_SAMPLE(bits,uint##bits); \
37	assert(sample * SOX_INT_MAX(bits) == SOX_UNSIGNED_TO_SAMPLE(bits,1)); \
38	uint##bits = SOX_SAMPLE_TO_UNSIGNED(bits,sample, clips); \
39	assert(uint##bits == SOX_INT_MAX(bits) && clips == 0); \
40	\
41	sample =SOX_UNSIGNED_TO_SAMPLE(bits,1)+SOX_UNSIGNED_TO_SAMPLE(bits,SOX_INT_MAX(bits))/2; \
42	uint##bits = SOX_SAMPLE_TO_UNSIGNED(bits,sample, clips); \
43	assert(uint##bits == 1 && clips == 0); \
44	\
45	sample = SOX_UNSIGNED_TO_SAMPLE(bits,1)+SOX_UNSIGNED_TO_SAMPLE(bits,SOX_INT_MAX(bits))/2-1; \
46	uint##bits = SOX_SAMPLE_TO_UNSIGNED(bits,sample, clips); \
47	assert(uint##bits == 0 && clips == 0); \
48	\
49	uint##bits = (0^SOX_INT_MIN(bits)); \
50	sample = SOX_UNSIGNED_TO_SAMPLE(bits,uint##bits); \
51	assert(sample == 0); \
52	uint##bits = SOX_SAMPLE_TO_UNSIGNED(bits,sample, clips); \
53	assert(uint##bits == (0^SOX_INT_MIN(bits)) && clips == 0); \
54	\
55	uint##bits = ((0^SOX_INT_MIN(bits))+1); \
56	sample = SOX_UNSIGNED_TO_SAMPLE(bits,uint##bits); \
57	assert(sample > 0 && sample < SOX_SAMPLE_MAX); \
58	uint##bits = SOX_SAMPLE_TO_UNSIGNED(bits,sample, clips); \
59	assert(uint##bits == ((0^SOX_INT_MIN(bits))+1) && clips == 0); \
60	\
61	uint##bits = SOX_UINT_MAX(bits); \
62	sample = SOX_UNSIGNED_TO_SAMPLE(bits,uint##bits); \
63	assert(sample == SOX_INT_MAX(bits) * SOX_UNSIGNED_TO_SAMPLE(bits,((0^SOX_INT_MIN(bits))+1))); \
64	uint##bits = SOX_SAMPLE_TO_UNSIGNED(bits,sample, clips); \
65	assert(uint##bits == SOX_UINT_MAX(bits) && clips == 0); \
66	\
67	sample =SOX_UNSIGNED_TO_SAMPLE(bits,SOX_UINT_MAX(bits))+SOX_UNSIGNED_TO_SAMPLE(bits,((0^SOX_INT_MIN(bits))+1))/2-1; \
68	uint##bits = SOX_SAMPLE_TO_UNSIGNED(bits,sample, clips); \
69	assert(uint##bits == SOX_UINT_MAX(bits) && clips == 0); \
70	\
71	sample = SOX_UNSIGNED_TO_SAMPLE(bits,SOX_UINT_MAX(bits))+SOX_UNSIGNED_TO_SAMPLE(bits,((0^SOX_INT_MIN(bits))+1))/2; \
72	uint##bits = SOX_SAMPLE_TO_UNSIGNED(bits,sample, clips); \
73	assert(uint##bits == SOX_UINT_MAX(bits) && --clips == 0); \
74	\
75	sample = SOX_SAMPLE_MAX; \
76	uint##bits = SOX_SAMPLE_TO_UNSIGNED(bits,sample, clips); \
77	assert(uint##bits == SOX_UINT_MAX(bits) && --clips == 0); \
78
79	#define TEST_SINT(bits) \
80	int##bits = SOX_INT_MIN(bits); \
81	sample = SOX_SIGNED_TO_SAMPLE(bits,int##bits); \
82	assert(sample == SOX_SAMPLE_MIN); \
83	int##bits##_2 = SOX_SAMPLE_TO_SIGNED(bits,sample, clips); \
84	assert(int##bits##_2 == int##bits && clips == 0); \
85	\
86	int##bits = SOX_INT_MIN(bits)+1; \
87	sample = SOX_SIGNED_TO_SAMPLE(bits,int##bits); \
88	assert(sample > SOX_SAMPLE_MIN && sample < 0); \
89	int##bits##_2 = SOX_SAMPLE_TO_SIGNED(bits,sample, clips); \
90	assert(int##bits##_2 == int##bits && clips == 0); \
91	\
92	int##bits = SOX_UINT_MAX(bits) /* i.e. -1 */; \
93	sample = SOX_SIGNED_TO_SAMPLE(bits,int##bits); \
94	assert(sample * SOX_INT_MAX(bits) == SOX_SIGNED_TO_SAMPLE(bits,SOX_INT_MIN(bits)+1)); \
95	int##bits##_2 = SOX_SAMPLE_TO_SIGNED(bits,sample, clips); \
96	assert(int##bits##_2 == int##bits && clips == 0); \
97	\
98	int##bits = SOX_INT_MIN(bits)+1; \
99	sample =SOX_UNSIGNED_TO_SAMPLE(bits,1)+SOX_UNSIGNED_TO_SAMPLE(bits,SOX_INT_MAX(bits))/2; \
100	int##bits##_2 = SOX_SAMPLE_TO_SIGNED(bits,sample, clips); \
101	assert(int##bits##_2 == int##bits && clips == 0); \
102	\
103	int##bits = SOX_INT_MIN(bits); \
104	sample = SOX_UNSIGNED_TO_SAMPLE(bits,1)+SOX_UNSIGNED_TO_SAMPLE(bits,SOX_INT_MAX(bits))/2-1; \
105	int##bits##_2 = SOX_SAMPLE_TO_SIGNED(bits,sample, clips); \
106	assert(int##bits##_2 == int##bits && clips == 0); \
107	\
108	int##bits = 0; \
109	sample = SOX_SIGNED_TO_SAMPLE(bits,int##bits); \
110	assert(sample == 0); \
111	int##bits##_2 = SOX_SAMPLE_TO_SIGNED(bits,sample, clips); \
112	assert(int##bits##_2 == int##bits && clips == 0); \
113	\
114	int##bits = 1; \
115	sample = SOX_SIGNED_TO_SAMPLE(bits,int##bits); \
116	assert(sample > 0 && sample < SOX_SAMPLE_MAX); \
117	int##bits##_2 = SOX_SAMPLE_TO_SIGNED(bits,sample, clips); \
118	assert(int##bits##_2 == int##bits && clips == 0); \
119	\
120	int##bits = SOX_INT_MAX(bits); \
121	sample = SOX_SIGNED_TO_SAMPLE(bits,int##bits); \
122	assert(sample == SOX_INT_MAX(bits) * SOX_SIGNED_TO_SAMPLE(bits,1)); \
123	int##bits##_2 = SOX_SAMPLE_TO_SIGNED(bits,sample, clips); \
124	assert(int##bits##_2 == int##bits && clips == 0); \
125	\
126	sample =SOX_UNSIGNED_TO_SAMPLE(bits,SOX_UINT_MAX(bits))+SOX_UNSIGNED_TO_SAMPLE(bits,((0^SOX_INT_MIN(bits))+1))/2-1; \
127	int##bits##_2 = SOX_SAMPLE_TO_SIGNED(bits,sample, clips); \
128	assert(int##bits##_2 == int##bits && clips == 0); \
129	\
130	sample =SOX_UNSIGNED_TO_SAMPLE(bits,SOX_UINT_MAX(bits))+SOX_UNSIGNED_TO_SAMPLE(bits,((0^SOX_INT_MIN(bits))+1))/2; \
131	int##bits##_2 = SOX_SAMPLE_TO_SIGNED(bits,sample, clips); \
132	assert(int##bits##_2 == int##bits && --clips == 0); \
133	\
134	sample = SOX_SAMPLE_MAX; \
135	int##bits##_2 = SOX_SAMPLE_TO_SIGNED(bits,sample, clips); \
136	assert(int##bits##_2 == int##bits && --clips == 0);
137
138	#if defined __GNUC__
139	#pragma GCC system_header
140	#elif defined __SUNPRO_CC
141	#pragma disable_warn
142	#elif defined _MSC_VER
143	#pragma warning(push, 1)
144	#endif
145
146	#define epsilon 1e-16
147
148	int main()
149	{
150	int8_t int8;
151	int16_t int16;
152	int24_t int24;
153
154	uint8_t uint8;
155	uint16_t uint16;
156	uint24_t uint24;
157
158	int8_t int8_2;
159	int16_t int16_2;
160	int24_t int24_2;
161
162	sox_sample_t sample;
163	size_t clips = 0;
164
165	double d;
166	SOX_SAMPLE_LOCALS;
167
168	TEST_UINT(8)
169	TEST_UINT(16)
170	TEST_UINT(24)
171
172	TEST_SINT(8)
173	TEST_SINT(16)
174	TEST_SINT(24)
175
176	d = -1.0000000001;
177	sample = SOX_FLOAT_64BIT_TO_SAMPLE(d, clips);
178	assert(sample == -SOX_SAMPLE_MAX && --clips == 0);
179
180	d = -1;
181	sample = SOX_FLOAT_64BIT_TO_SAMPLE(d, clips);
182	assert(sample == -SOX_SAMPLE_MAX && clips == 0);
183	d = SOX_SAMPLE_TO_FLOAT_64BIT(sample,clips);
184	assert(fabs(d + 1) < epsilon && clips == 0);
185
186	--sample;
187	d = SOX_SAMPLE_TO_FLOAT_64BIT(sample,clips);
188	assert(fabs(d + 1) < epsilon && --clips == 0);
189
190	d = 1;
191	sample = SOX_FLOAT_64BIT_TO_SAMPLE(d, clips);
192	assert(sample == SOX_SAMPLE_MAX && clips == 0);
193	d = SOX_SAMPLE_TO_FLOAT_64BIT(sample,clips);
194	assert(fabs(d - 1) < epsilon && clips == 0);
195
196	d = 1.0000000001;
197	sample = SOX_FLOAT_64BIT_TO_SAMPLE(d, clips);
198	assert(sample == SOX_SAMPLE_MAX && --clips == 0);
199
200	return 0;
201	}
202
203	#if defined __SUNPRO_CC
204	#pragma enable_warn
205	#elif defined _MSC_VER
206	#pragma warning(pop)
207	#endif

src/spectrogram.c+3−4

     size_t * isamp, size_t * osamp)
 {
   priv_t * p = (priv_t *)effp->priv;
-  size_t len = min(*isamp, *osamp), dummy = 0; /* No need to clip count */
+  size_t len = min(*isamp, *osamp);
   int i;
   memcpy(obuf, ibuf, len * sizeof(*obuf)); /* Pass on audio unaffected */
   *isamp = *osamp = len;
   while (sox_true) {
-    SOX_SAMPLE_LOCALS;
     if (p->read == p->step_size) {
       memmove(p->buf, p->buf + p->step_size,
           (p->dft_size - p->step_size) * sizeof(*p->buf));
       p->read = 0;
     }
     for (; len && p->read < p->step_size; --len, ++p->read, --p->end)
-      p->buf[p->dft_size - p->step_size + p->read] = FROM_SOX(*ibuf++, dummy);
+      p->buf[p->dft_size - p->step_size + p->read] = FROM_SOX(*ibuf++);
     if (p->read != p->step_size)
       break;
 sox_effect_handler_t const * sox_spectrogram_effect_fn(void)
 {
   static sox_effect_handler_t handler = {
-    "spectrogram", 0, 0, getopts, start, flow, drain, stop, 0, sizeof(priv_t)};
+    "spectrogram", 0, SOX_EFF_MODIFY, getopts, start, flow, drain, stop, 0, sizeof(priv_t)};
   static char const * lines[] = {
     "[options]",
     "\t-x num\tX-axis pixels/second, default 100",

src/splice.c+1−1

@@ -185,7 +185,7 @@ buffering: · 184 unmodified lines
185	break;	185	break;
186	}	186	}
187	for (c = 0; c < effp->in_signal.channels; ++c)	187	for (c = 0; c < effp->in_signal.channels; ++c)
188	p->buffer[p->buffer_pos++] = SOX_SAMPLE_TO_FLOAT_32BIT(*ibuf++, effp->clips);	188	p->buffer[p->buffer_pos++] = SOX_SAMPLE_TO_FLOAT_32BIT(*ibuf++);
189	}	189	}
190	break;	190	break;
191	}	191	}

src/stat.c+2−3

     if (stat->fft) {
       for (x = 0; x < len; x++) {
-        SOX_SAMPLE_LOCALS;
+        stat->re_in[stat->fft_offset++] = SOX_SAMPLE_TO_FLOAT_32BIT(ibuf[x]);
-        stat->re_in[stat->fft_offset++] = SOX_SAMPLE_TO_FLOAT_32BIT(ibuf[x], effp->clips);
         if (stat->fft_offset >= stat->fft_size) {
           stat->fft_offset = 0;
 static sox_effect_handler_t sox_stat_effect = {
   "stat",
   "[ -s N ] [ -rms ] [-freq] [ -v ] [ -d ]",
-  SOX_EFF_MCHAN,
+  SOX_EFF_MCHAN | SOX_EFF_MODIFY,
   sox_stat_getopts,
   sox_stat_start,
   sox_stat_flow,

src/synth.c+6−10

   char *        length_str;
   channel_t *      getopts_channels;
   size_t    getopts_nchannels;
-  sox_sample_t  max;
   size_t    samples_done;
   size_t    samples_to_do;
   channel_t *      channels;
   priv_t * synth = (priv_t *) effp->priv;
   size_t i, j;
-  synth->max = lsx_sample_max(effp->out_encoding);
   synth->samples_done = 0;
   if (synth->length_str)
   return SOX_SUCCESS;
 }
-#define sign(d) ((d) < 0? -1. : 1.)
 #define elapsed_time_s synth->samples_done / effp->in_signal.rate
 static int flow(sox_effect_t * effp, const sox_sample_t * ibuf, sox_sample_t * obuf,
       synth_out = synth_out * (1 - fabs(chan->offset)) + chan->offset;
       switch (chan->combine) {
-        case synth_create: *obuf++ =  synth_out * synth->max; break;
+        case synth_create: synth_out *=  SOX_SAMPLE_MAX; break;
-        case synth_mix   : *obuf++ = (synth_out * synth->max + synth_input) * 0.5; break;
+        case synth_mix   : synth_out = (synth_out * SOX_SAMPLE_MAX + synth_input) * 0.5; break;
-        case synth_amod  : *obuf++ = (synth_out + 1) * synth_input * 0.5; break;
+        case synth_amod  : synth_out = (synth_out + 1) * synth_input * 0.5; break;
-        case synth_fmod  : *obuf++ =  synth_out * synth_input; break;
+        case synth_fmod  : synth_out *=  synth_input; break;
       }
+      *obuf++ = floor(synth_out + .5);
     }
     if (++synth->samples_done == synth->samples_to_do)
       result = SOX_EOF;
 {
   static sox_effect_handler_t handler = {
     "synth", "[len] {type [combine] [[%]freq[k][:|+|/|-[%]freq2[k]] [off [ph [p1 [p2 [p3]]]]]]}",
-    SOX_EFF_MCHAN | SOX_EFF_PREC |SOX_EFF_LENGTH,
+    SOX_EFF_MCHAN | SOX_EFF_PREC |SOX_EFF_LENGTH | SOX_EFF_GAIN,
     getopts, start, flow, 0, stop, kill, sizeof(priv_t)
   };
   return &handler;

src/tempo.c+1−1

@@ -272,7 +272,7 @@ static int flow(sox_effect_t * effp, const sox_sample_t * ibuf, · 271 unmodified lines
272	if (isamp && odone < osamp) {	272	if (isamp && odone < osamp) {
273	float * t = tempo_input(p->tempo, NULL, *isamp / effp->in_signal.channels);	273	float * t = tempo_input(p->tempo, NULL, *isamp / effp->in_signal.channels);
274	for (i = *isamp; i; --i)	274	for (i = *isamp; i; --i)
275	t++ = SOX_SAMPLE_TO_FLOAT_32BIT(ibuf++, effp->clips);	275	t++ = SOX_SAMPLE_TO_FLOAT_32BIT(ibuf++);
276	tempo_process(p->tempo);	276	tempo_process(p->tempo);
277	}	277	}
278	else *isamp = 0;	278	else *isamp = 0;

src/tests.sh+0−2

@@ -200,8 +200,6 @@ skip_check () { · 199 unmodified lines
200		200
201	# Run tests	201	# Run tests
202		202
203	${builddir}/sox_sample_test \|\| exit 1
204
205	skip_check caf flac mat4 mat5 paf w64 wv	203	skip_check caf flac mat4 mat5 paf w64 wv
206		204
207	vectors=0	205	vectors=0

src/trim.c+1−1

@@ -172,7 +172,7 @@ void sox_trim_clear_start(sox_effect_t * effp) · 171 unmodified lines
172	const sox_effect_handler_t *sox_trim_effect_fn(void)	172	const sox_effect_handler_t *sox_trim_effect_fn(void)
173	{	173	{
174	static sox_effect_handler_t handler = {	174	static sox_effect_handler_t handler = {
175	"trim", "start [length]", SOX_EFF_MCHAN\|SOX_EFF_LENGTH,	175	"trim", "start [length]", SOX_EFF_MCHAN \| SOX_EFF_LENGTH \| SOX_EFF_MODIFY,
176	sox_trim_getopts, sox_trim_start, sox_trim_flow,	176	sox_trim_getopts, sox_trim_start, sox_trim_flow,
177	NULL, NULL, kill, sizeof(priv_t)	177	NULL, NULL, kill, sizeof(priv_t)
178	};	178	};

src/util.c+6−0

 }
 #endif
+sox_bool lsx_strends(char const * str, char const * end)
+{
+  size_t str_len = strlen(str), end_len = strlen(end);
+  return str_len >= end_len && !strcmp(str + str_len - end_len, end);
+}
 char const * lsx_find_file_extension(char const * pathname)
 {
   /* First, chop off any path portions of filename.  This

src/util.h+12−2

 #ifdef _MSC_VER
 #define __STDC__ 1
-#define S_IFMT   _S_IFMT
-#define S_IFREG  _S_IFREG
 #define O_BINARY _O_BINARY
+#define O_CREAT _O_CREAT
+#define O_RDWR _O_RDWR
+#define O_TRUNC _O_TRUNC
+#define S_IFMT _S_IFMT
+#define S_IFREG _S_IFREG
+#define S_IREAD _S_IREAD
+#define S_IWRITE _S_IWRITE
+#define fdopen _fdopen
 #define fstat _fstat
 #define ftime _ftime
 #define inline __inline
 #define isatty _isatty
+#define mktemp _mktemp
 #define off_t _off_t
+#define open _open
 #define popen _popen
 #define stat _stat
 #define strdup _strdup
 #define M_SQRT2  sqrt(2.)
 #endif
+#define sign(x) ((x) < 0? -1 : 1)
 /* Numerical Recipes in C, p. 284 */
 #define ranqd1(x) ((x) = 1664525L * (x) + 1013904223L) /* int32_t x */
 #define dranqd1(x) (ranqd1(x) * (1. / (65536. * 32768.))) /* [-1,1) */

src/vectors/intermediate1_44100_-u_-1_wav_-N.s1+0−0

Binary file not shown.

src/vectors/intermediate1_44100_-u_-1_wav_-X.s1+0−0

Binary file not shown.

src/vectors/intermediate1_44100_-u_-1_wav_-X_-N.s1+0−0

Binary file not shown.

src/vectors/intermediate1_44100_-u_-1_wav_.s1+0−0

Binary file not shown.

src/voc.c+3−5

       /* Read the data in the file */
       if (v->size <= 4) {
         if (!v->adpcm.setup.sign) {
-          SOX_SAMPLE_LOCALS;
           if (lsx_readb(ft, &uc) == SOX_EOF) {
             lsx_warn("VOC input: short file");
             v->block_remaining = 0;
             return done;
           }
           *buf = SOX_UNSIGNED_8BIT_TO_SAMPLE(uc,);
-          lsx_adpcm_init(&v->adpcm, 6 - v->size, SOX_SAMPLE_TO_SIGNED_16BIT(*buf, ft->clips));
+          lsx_adpcm_init(&v->adpcm, 6 - v->size, SOX_SAMPLE_TO_SIGNED_16BIT(*buf));
           ++buf;
           --v->block_remaining;
           ++done;
   }
   v->samples += len;
   while (done < len) {
-    SOX_SAMPLE_LOCALS;
     if (ft->encoding.bits_per_sample == 8) {
-      uc = SOX_SAMPLE_TO_UNSIGNED_8BIT(*buf++, ft->clips);
+      uc = SOX_SAMPLE_TO_UNSIGNED_8BIT(*buf++);
       lsx_writeb(ft, uc);
     } else {
-      sw = (int) SOX_SAMPLE_TO_SIGNED_16BIT(*buf++, ft->clips);
+      sw = (int) SOX_SAMPLE_TO_SIGNED_16BIT(*buf++);
       lsx_writesw(ft, sw);
     }
     done++;

src/vol.c+1−22

@@ -178,28 +178,7 @@ static int stop(sox_effect_t * effp) · 177 unmodified lines
178	sox_effect_handler_t const * sox_vol_effect_fn(void)	178	sox_effect_handler_t const * sox_vol_effect_fn(void)
179	{	179	{
180	static sox_effect_handler_t handler = {	180	static sox_effect_handler_t handler = {
181	"vol", vol_usage, SOX_EFF_MCHAN, getopts, start, flow, 0, stop, 0, sizeof(priv_t)	181	"vol", vol_usage, SOX_EFF_MCHAN \| SOX_EFF_GAIN, getopts, start, flow, 0, stop, 0, sizeof(priv_t)
182	};	182	};
183	return &handler;	183	return &handler;
184	}	184	}
185
186	static int gain_getopts(sox_effect_t * effp, int argc, char * * argv)
187	{
188	char * args[] = {0, 0, "dB"};
189
190	if (argc != 2)
191	return lsx_usage(effp);
192	args[0] = argv[0];
193	args[1] = argv[1];
194	return sox_vol_effect_fn()->getopts(effp, (int)array_length(args), args);
195	}
196
197	sox_effect_handler_t const * sox_gain_effect_fn(void)
198	{
199	static sox_effect_handler_t handler;
200	handler = *sox_vol_effect_fn();
201	handler.name = "gain";
202	handler.usage = "dB-gain";
203	handler.getopts = gain_getopts;
204	return &handler;
205	}

src/wav.c+1−2

     ft->sox_errno = SOX_SUCCESS;
     while (done < len) {
-        SOX_SAMPLE_LOCALS;
         while ((wav->gsmindex < 160*2) && (done < len))
             wav->gsmsample[(wav->gsmindex)++] =
-                SOX_SAMPLE_TO_SIGNED_16BIT(buf[done++], ft->clips);
+                SOX_SAMPLE_TO_SIGNED_16BIT(buf[done++]);
         if (wav->gsmindex < 160*2)
             break;

src/wavpack.c+5−6

   int result;
   for (i = 0; i < len; ++i) switch (ft->encoding.bits_per_sample) {
-    SOX_SAMPLE_LOCALS;
+    case  8: obuf[i] = SOX_SAMPLE_TO_SIGNED_8BIT(buf[i]); break;
-    case  8: obuf[i] = SOX_SAMPLE_TO_SIGNED_8BIT(buf[i], ft->clips); break;
+    case 16: obuf[i] = SOX_SAMPLE_TO_SIGNED_16BIT(buf[i]); break;
-    case 16: obuf[i] = SOX_SAMPLE_TO_SIGNED_16BIT(buf[i], ft->clips); break;
+    case 24: obuf[i] = SOX_SAMPLE_TO_SIGNED_24BIT(buf[i]) << 8;
-    case 24: obuf[i] = SOX_SAMPLE_TO_SIGNED_24BIT(buf[i], ft->clips) << 8;
              obuf[i] >>= 8; break;
     case 32: obuf[i] = ft->encoding.encoding == SOX_ENCODING_WAVPACKF?
-      SOX_SAMPLE_TO_SIGNED_24BIT(*(float *)&buf[i], ft->clips) :
+      SOX_SAMPLE_TO_SIGNED_24BIT(*(float *)&buf[i]) :
-      SOX_SAMPLE_TO_SIGNED_32BIT(buf[i], ft->clips);
+      SOX_SAMPLE_TO_SIGNED_32BIT(buf[i]);
       break;
   }
   result = WavpackPackSamples(p->codec, obuf, (uint32_t) len / ft->signal.channels);

--guard, & associated changes

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code