Merge remote-tracking branch 'mpg123/master' into master-with-github-ci

Author: mpg123 GitHub bot

NEWS

@@ -2,6 +2,8 @@
 ------
 - ports/cmake: now versioned library files (github PR 24 by madebr)
   This raises the minimum CMake version to 3.27.
+- fmt123.h: Check for obviously invalid encoding in MPG123_ENC_SIZE()
+  via the MPG123_ENC_ANY mask.
 
 1.33.6
 ------

src/include/fmt123.h

@@ -95,11 +95,17 @@ enum mpg123_enc_enum
  *  encoding to appear. But who knows? Perhaps the encoding type
  *  will be abused for funny things in future, not even plain PCM.
  *  And, by the way: Thomas really likes the ?: operator.
+ * 
+ *  This does a cheap check if any unknown bits are set, no deep
+ *  testing if the bit combination really is a valid encoding. It
+ *  shall be a quick macro. You can use out123_enc_name() to check
+ *  if your value is really a known encoding.
+ *
  * \param enc the encoding (mpg123_enc_enum value)
  * \return size of one sample in bytes
  */
 #define MPG123_SAMPLESIZE(enc) ( \
-	(enc) < 1 \
+	((enc) < 1 || ((enc) & ~MPG123_ENC_ANY)) \
 	?	0 \
 	:	( (enc) & MPG123_ENC_8 \
 		?	1 \

src/include/syn123.h

@@ -981,7 +981,7 @@ size_t syn123_resample_out(syn123_handle *sh, size_t ins, int *err);
  *
  *  This give you the minimal number of input samples needed right
  *  now to yield at least the specified amount of output samples.
- *  Since one input sample can result in several output sampels in one
+ *  Since one input sample can result in several output samples in one
  *  go, you have to check using syn123_resample_out() how many
  *  output samples to really expect.
  *

src/tests/Makemodule.am

@@ -10,6 +10,7 @@ endif
 TESTS += \
   src/tests/seek_whence.sh \
   src/tests/seek_accuracy.sh \
+  src/tests/resample_buffer \
   src/tests/resample_total \
   src/tests/text \
   src/tests/textprint \
@@ -41,7 +42,6 @@ check_PROGRAMS += \
   src/tests/decode_fixed \
   src/tests/seek_whence \
   src/tests/seek_accuracy \
-  src/tests/resample_total \
   src/tests/text \
   src/tests/textprint \
   src/tests/plain_id3
@@ -55,6 +55,12 @@ EXTRA_PROGRAMS += \
   src/tests/sweeper
 endif
 
+if BUILD_LIBSYN123
+check_PROGRAMS += \
+  src/tests/resample_total \
+  src/tests/resample_buffer
+endif
+
 src_tests_volume_SOURCES = \
   src/tests/volume.c
 src_tests_volume_LDADD = \
@@ -92,6 +98,11 @@ src_tests_sweeper_LDADD = \
   $(LIBSYN123) \
   $(LIBOUT123)
 
+src_tests_resample_buffer_SOURCES = \
+  src/tests/resample_buffer.c
+src_tests_resample_buffer_LDADD = \
+  $(LIBSYN123)
+
 src_tests_resample_total_SOURCES = \
   src/tests/resample_total.c
 src_tests_resample_total_LDADD = \

src/tests/resample_buffer.c

@@ -0,0 +1,97 @@
+// Test the various sample count computations and against output
+// buffer overflow of libsyn123.
+
+#include "mpg123config.h"
+#include <syn123.h>
+#include <inttypes.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "common/debug.h"
+
+const long arate = 22050;
+const long brate = 48000;
+const size_t outs = 0x10000;
+const int buffer_runs = 100;
+const float canary = 2317.;
+
+int main()
+{
+	size_t ins = syn123_resample_incount(arate, brate, outs);
+	size_t outs2 = syn123_resample_count(arate, brate, ins);
+	size_t fillins = syn123_resample_fillcount(arate, brate, outs);
+	size_t fillouts = syn123_resample_count(arate, brate, fillins);
+	printf("%zu output buffer size\n", outs);
+	printf("%zu minimal input samples to ensure we can fill that buffer\n", ins);
+	printf("%zu maximum output samples to result from the above\n", outs2);
+	printf("%zu maximum input samples to not overflow that buffer\n", fillins);
+	printf("%zu maximum output samples to result from the above\n", fillouts);
+	int err = 0;
+
+	syn123_handle *sh = syn123_new( brate, 1, MPG123_ENC_FLOAT_32, 1024, &err);
+	if(!sh)
+		mereturn(1, "handle alloc failure: %s", syn123_strerror(err));
+
+	// A dirty resampler.
+	if(SYN123_OK != (err =syn123_setup_resample(sh, arate, brate, 1, 1, 0)))
+		mereturn(1, "resample setup failure: %s", syn123_strerror(err));
+
+	// Default sine wave as source signal.
+	if( SYN123_OK !=
+		(err =syn123_setup_waves( sh, 0, NULL, NULL, NULL, NULL, NULL)) )
+		mereturn(1, "wave setup failure: %s", syn123_strerror(err));
+
+	float *inbuf = malloc(sizeof(float)*ins);
+	float *outbuf = malloc(sizeof(float)*(outs2+10));
+	if(!inbuf || !outbuf)
+		ereturn(1, "buffer alloc failure");
+
+	for(int r=0; r<buffer_runs; ++r)
+	{
+		// Prepare input, 
+		size_t got = syn123_read(sh, inbuf, sizeof(float)*ins);
+		if(got != sizeof(float)*ins)
+			mereturn( 1
+			,	"unexpected byte count from generator in run %d: %zu != %zu"
+			,	r, got, sizeof(float)*ins);
+		// Prime output buffer with some weird large number.
+		for(int o=0; o<(outs2+10); ++o) outbuf[o] = canary;
+		size_t exp = syn123_resample_out(sh, ins, NULL);
+		// Resample, check if anything is overwritten beyond the desired end.
+		got = syn123_resample(sh, outbuf, inbuf, ins);
+		if(!got || exp != got)
+			mereturn( 1
+			,	"got nothing or at least not what was expected"
+				" in run %d: %zu != %zu"
+			,	r, got, exp );
+		if(got < outs)
+			mereturn( 1
+			,	"got less than promised minimum output sample count"
+				" in run %d: %zu < %zu"
+			,	r, got, outs );
+		if(got > outs2)
+			mereturn( 1
+			,	"got more than promised maximum output sample count"
+				" in run %d: %zu > %zu"
+			,	r, got, outs2 );
+		size_t over = 0;
+		for(int o=outs2; o<(outs2+10); ++o)
+			if(outbuf[o] != canary)
+			{
+				merror( "resample output overflow at %zu+%zu in run %d: %f != %f"
+				,	outs2, o-outs2, r, outbuf[o], canary );
+				++over;
+			}
+		if(over)
+			mereturn(1, "%zu samples overflow in run %d", over, r);
+	}
+	printf("%d resampler runs without issue\n", buffer_runs);
+	printf("PASS\n");
+
+	free(outbuf);
+	free(inbuf);
+	syn123_del(sh);
+
+	return 0;
+}