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

Author: mpg123 GitHub bot

NEWS

@@ -2,6 +2,8 @@
 ------
 - libout123: Add a safeguard to ensure variable-length records from buffer
   communication are always zero-terminated.
+- libsyn123: Use union work buffer to avoid casts that may look like breaking
+  strict aliasing.
 
 1.33.4
 ------

src/libsyn123/geiger.c

@@ -24,7 +24,7 @@
 static void white_generator(syn123_handle *sh, int samples)
 {
 	for(int i=0; i<samples; ++i)
-		sh->workbuf[1][i] = 2*rand_xorshift32(&sh->seed);
+		sh->workbuf.f64[1][i] = 2*rand_xorshift32(&sh->seed);
 }
 
 int attribute_align_arg
@@ -234,11 +234,11 @@ static void geiger_generator(syn123_handle *sh, int samples)
 {
 	struct geigerspace *gs = sh->handle;
 	for(int i=0; i<samples; ++i)
-		sh->workbuf[1][i] = speaker( gs
+		sh->workbuf.f64[1][i] = speaker( gs
 		,	discharge_force(gs, (rand_xorshift32(&sh->seed)+0.5)>gs->thres) );
 	// Soft clipping as speaker property. It can only move so far.
 	// Of course this could be produced by a nicely nonlinear force, too.
-	syn123_soft_clip( sh->workbuf[1], MPG123_ENC_FLOAT_64, samples
+	syn123_soft_clip( sh->workbuf.f64[1], MPG123_ENC_FLOAT_64, samples
 	,	1., 0.1, NULL );
 }
 

src/libsyn123/libsyn123.c

@@ -365,7 +365,7 @@ static void wave_add_buffer( double outbuf[bufblock], size_t samples
 static void silence_generator(syn123_handle *sh, int samples)
 {
 	for(int i=0; i<samples; ++i)
-		sh->workbuf[1][i] = 0;
+		sh->workbuf.f64[1][i] = 0;
 }
 
 // Clear the handle of generator data structures.
@@ -395,11 +395,11 @@ static void wave_generator(syn123_handle *sh, int samples)
 {
 	/* Initialise to zero amplitude. */
 	for(int i=0; i<samples; ++i)
-		sh->workbuf[1][i] = 1;
+		sh->workbuf.f64[1][i] = 1;
 	/* Add individual waves. */
 	for(size_t c=0; c<sh->wave_count; ++c)
-		wave_add_buffer( sh->workbuf[1], samples, sh->fmt.rate, sh->waves+c
-		,	sh->workbuf[0] );
+		wave_add_buffer( sh->workbuf.f64[1], samples, sh->fmt.rate, sh->waves+c
+		,	sh->workbuf.f64[0] );
 }
 
 /* Build internal table, allocate external table, convert to that one, */
@@ -625,11 +625,11 @@ static void sweep_generator(syn123_handle *sh, int samples)
 {
 	struct syn123_sweep *sw = sh->handle;
 	// Precompute phases into work buffer.
-	sweep_phase(sh, 0, sh->workbuf[0], samples);
+	sweep_phase(sh, 0, sh->workbuf.f64[0], samples);
 	// Initialise output to zero amplitude and multiply by the wave.
 	for(int i=0; i<samples; ++i)
-		sh->workbuf[1][i] = 1.;
-	evaluate_wave(sh->workbuf[1], samples, sw->wave.id, sh->workbuf[0]);
+		sh->workbuf.f64[1][i] = 1.;
+	evaluate_wave(sh->workbuf.f64[1], samples, sw->wave.id, sh->workbuf.f64[0]);
 	// Advance.
 	sw->i = (sw->i+samples) % (sw->d + sw->post);
 }
@@ -702,9 +702,9 @@ syn123_setup_sweep( syn123_handle* sh
 	// The last phase served by the sweep, and the one after that that
 	// tryly concludes the sweep (f==f2, not infinitesimally smaller).
 	mdebug("computing endphase, with 2 points from %zu - 1 on", duration);
-	sweep_phase(sh, duration-1, sh->workbuf[0], 2);
-	double before_endphase = sh->workbuf[0][0];
-	sw->endphase = sh->workbuf[0][1];
+	sweep_phase(sh, duration-1, sh->workbuf.f64[0], 2);
+	double before_endphase = sh->workbuf.f64[0][0];
+	sw->endphase = sh->workbuf.f64[0][1];
 	sw->post = 0; // Reset that again, only increasing if really needed.
 	// The phase that would smoothly continue the sweep, one sample
 	// after the last one.
@@ -895,22 +895,22 @@ syn123_read( syn123_handle *sh, void *dest, size_t dest_bytes )
 			// Compute data into workbuf[1], possibly using workbuf[0]
 			// in the process.
 			// TODO for the future: Compute only in single precision if
-			// it is enough.
+			// it is enough. Right now generators always write to workbuf.f64[1].
 			sh->generator(sh, block);
 			// Convert to external format, mono. We are abusing workbuf[0] here,
 			// because it is big enough.
 			// The converter does not use workbuf if converting from float. Dither is
 			// added on the fly.
 			int err = syn123_conv(
-				sh->workbuf[0], sh->fmt.encoding, sizeof(sh->workbuf[0])
-			,	sh->workbuf[1], MPG123_ENC_FLOAT_64, sizeof(double)*block
+				sh->workbuf.c[0], sh->fmt.encoding, sizeof(sh->workbuf.c[0])
+			,	sh->workbuf.c[1], MPG123_ENC_FLOAT_64, sizeof(double)*block
 			,	NULL, NULL, NULL );
 			if(err)
 			{
 				debug1("conv error: %i", err);
 				break;
 			}
-			syn123_mono2many( cdest, sh->workbuf[0]
+			syn123_mono2many( cdest, sh->workbuf.c[0]
 			,	sh->fmt.channels, samplesize, block );
 			cdest += framesize*block;
 			dest_samples -= block;

src/libsyn123/pinknoise.c

@@ -122,7 +122,7 @@ static float GeneratePinkNoise( PinkNoise *pink )
 static void pink_generator(syn123_handle *sh, int samples)
 {
 	for(int i=0; i<samples; ++i)
-		sh->workbuf[1][i] = GeneratePinkNoise(sh->handle);
+		sh->workbuf.f64[1][i] = GeneratePinkNoise(sh->handle);
 }
 
 int attribute_align_arg

src/libsyn123/sampleconv.c

@@ -189,23 +189,35 @@ syn123_soft_clip( void *buf, int encoding, size_t samples
 		if(!mixenc || !mixframe || !inframe)
 			return 0;
 		// Use the whole workbuf, both halves.
-		int mbufblock = 2*bufblock*sizeof(double)/mixframe;
+		int mbufblock = sizeof(sh->workbuf)/mixframe;
 		mdebug("mbufblock=%i (enc %i)", mbufblock, mixenc);
 		while(samples)
 		{
 			int block = (int)smin(samples, mbufblock);
-			int err = syn123_conv(
-				sh->workbuf, mixenc, sizeof(sh->workbuf)
-			,	cbuf, encoding, inframe*block
-			,	NULL, NULL, NULL );
+			int err = mixenc == MPG123_ENC_FLOAT_64
+			?	syn123_conv(
+					sh->workbuf.f64, mixenc, sizeof(sh->workbuf.f64)
+				,	cbuf, encoding, inframe*block
+				,	NULL, NULL, NULL )
+			:	syn123_conv(
+					sh->workbuf.f32, mixenc, sizeof(sh->workbuf.f32)
+				,	cbuf, encoding, inframe*block
+				,	NULL, NULL, NULL );
 			if(!err)
 			{
-				clipped += syn123_soft_clip(sh->workbuf, mixenc, block, limit, width, NULL);
+				clipped += mixenc == MPG123_ENC_FLOAT_64
+				?	syn123_soft_clip(sh->workbuf.f64, mixenc, block, limit, width, NULL)
+				:	syn123_soft_clip(sh->workbuf.f32, mixenc, block, limit, width, NULL);
 				// No additional clipping can happen here.
-				err = syn123_conv(
-					cbuf, encoding, inframe*block
-				,	sh->workbuf, mixenc, mixframe*block
-				,	NULL, NULL, NULL );
+				err = mixenc == MPG123_ENC_FLOAT_64
+				?	syn123_conv(
+						cbuf, encoding, inframe*block
+					,	sh->workbuf.f64, mixenc, mixframe*block
+					,	NULL, NULL, NULL )
+				:	syn123_conv(
+						cbuf, encoding, inframe*block
+					,	sh->workbuf.f32, mixenc, mixframe*block
+					,	NULL, NULL, NULL );
 			}
 			if(err)
 			{
@@ -542,7 +554,7 @@ syn123_conv( void * MPG123_RESTRICT dst, int dst_enc, size_t dst_size
 		if(!mixenc || !mixframe)
 			return SYN123_BAD_CONV;
 		// Use the whole workbuf, both halves.
-		int mbufblock = 2*bufblock*sizeof(double)/mixframe;
+		int mbufblock = sizeof(sh->workbuf)/mixframe;
 		mdebug("mbufblock=%i (enc %i)", mbufblock, mixenc);
 		// Abuse the handle workbuf for intermediate storage.
 		size_t samples_left = samples;
@@ -555,16 +567,26 @@ syn123_conv( void * MPG123_RESTRICT dst, int dst_enc, size_t dst_size
 		{
 			int block = (int)smin(samples_left, mbufblock);
 			size_t clipped_now = 0;
-			int err = syn123_conv(
-				sh->workbuf, mixenc, sizeof(sh->workbuf)
-			,	csrc, src_enc, srcframe*block
-			,	NULL, NULL, NULL );
+			int err = mixenc == MPG123_ENC_FLOAT_64
+			?	syn123_conv(
+					sh->workbuf.f64, mixenc, sizeof(sh->workbuf.f64)
+				,	csrc, src_enc, srcframe*block
+				,	NULL, NULL, NULL )
+			:	syn123_conv(
+					sh->workbuf.f32, mixenc, sizeof(sh->workbuf.f32)
+				,	csrc, src_enc, srcframe*block
+				,	NULL, NULL, NULL );
 			sh->do_dither = do_dither; // possibly dither now
 			if(!err)
-				err = syn123_conv(
-					cdst, dst_enc, dstframe*block
-				,	sh->workbuf, mixenc, mixframe*block
-				,	NULL, &clipped_now, sh );
+				err = mixenc == MPG123_ENC_FLOAT_64
+				?	syn123_conv(
+						cdst, dst_enc, dstframe*block
+					,	sh->workbuf.f64, mixenc, mixframe*block
+					,	NULL, &clipped_now, sh )
+				:	syn123_conv(
+						cdst, dst_enc, dstframe*block
+					,	sh->workbuf.f32, mixenc, mixframe*block
+					,	NULL, &clipped_now, sh );
 			if(err)
 			{
 				mdebug("conv error: %i", err);
@@ -861,6 +883,38 @@ static void syn123_mix_f64( double * MPG123_RESTRICT dst, int dst_channels
 	SYN123_MIX_FUNC(double)
 }
 
+// Call with f64 or f32 for conversion mixer code piece.
+#define CONVMIX(fXX) \
+	err = syn123_conv( \
+		sh->workbuf.fXX[0], mixenc, sizeof(sh->workbuf.fXX[0]) \
+	,	csrc, src_enc, srcframe*block \
+	,	NULL, NULL, NULL ); \
+	if(err) \
+		goto mix_end; \
+	/* Initialize to zero or convert from old output signal. */ \
+	if(silence) \
+		for(int i=0; i<block*dst_channels; ++i) \
+			sh->workbuf.fXX[1][i] = 0.; \
+	else \
+		err = syn123_conv( \
+			sh->workbuf.fXX[1], mixenc, sizeof(sh->workbuf.fXX[1]) \
+		,	cdst, dst_enc, dstframe*block \
+		,	NULL, NULL, NULL ); \
+	/* Now mix one work buffer into the other. */ \
+	if(err) \
+		goto mix_end; \
+	err = syn123_mix( sh->workbuf.fXX[1], mixenc, dst_channels \
+		,	sh->workbuf.fXX[0], mixenc, src_channels, mixmatrix, block \
+		,	0, NULL, NULL ); \
+	if(err) \
+		goto mix_end; \
+	/* And convert to the final output format. */ \
+	err = syn123_conv( \
+		cdst, dst_enc, dstframe*block \
+	,	sh->workbuf.fXX[1], mixenc, mixoutframe*block \
+	,	NULL, &clips_block, NULL );
+
+
 int attribute_align_arg
 syn123_mix( void * MPG123_RESTRICT dst, int dst_enc, int dst_channels
 ,	void * MPG123_RESTRICT src, int src_enc, int src_channels
@@ -926,7 +980,7 @@ syn123_mix( void * MPG123_RESTRICT dst, int dst_enc, int dst_channels
 			goto mix_end;
 		}
 		// Mix from buffblock[0] to buffblock[1].
-		int mbufblock = bufblock*sizeof(double)/mixframe;
+		int mbufblock = sizeof(sh->workbuf)/2/mixframe;
 		mdebug("mbufblock=%i (enc %i)", mbufblock, mixenc);
 		// Need at least one sample per round to avoid endless loop.
 		// Of course, we would prefer more, but it's your fault for
@@ -940,38 +994,15 @@ syn123_mix( void * MPG123_RESTRICT dst, int dst_enc, int dst_channels
 		while(samples)
 		{
 			int block = (int)smin(samples, mbufblock);
-			err = syn123_conv( sh->workbuf[0], mixenc, sizeof(sh->workbuf[0])
-			,	csrc, src_enc, srcframe*block
-			,	NULL, NULL, NULL );
-			if(err)
-				goto mix_end;
-			// Initialize to zero or convert from old output signal.
-			if(silence)
+			size_t clips_block = 0;
+			// The same logic for f64 and f32, just written explictly for buffer type clarity.
+			if(mixenc == MPG123_ENC_FLOAT_64)
+			{
+				CONVMIX(f64)
+			} else
 			{
-				if(mixenc == MPG123_ENC_FLOAT_32)
-					for(int i=0; i<block*dst_channels; ++i)
-						((float*)(sh->workbuf[1]))[i] = 0.;
-				else
-					for(int i=0; i<block*dst_channels; ++i)
-						sh->workbuf[1][i] = 0.;
+				CONVMIX(f32)
 			}
-			else
-				err = syn123_conv( sh->workbuf[1], mixenc, sizeof(sh->workbuf[1])
-				,	cdst, dst_enc, dstframe*block
-				,	NULL, NULL, NULL );
-			// Now mix one work buffer into the other.
-			if(!err)
-				err = syn123_mix( sh->workbuf[1], mixenc, dst_channels
-				,	sh->workbuf[0], mixenc, src_channels, mixmatrix, block
-				,	0, NULL, NULL );
-			if(err)
-				goto mix_end;
-			// And convert to the final output format.
-			size_t clips_block = 0;
-			err = syn123_conv(
-					cdst, dst_enc, dstframe*block
-				,	sh->workbuf[1], mixenc, mixoutframe*block
-				,	NULL, &clips_block, NULL );
 			clips += clips_block;
 			if(err)
 				goto mix_end;

src/libsyn123/syn123_int.h

@@ -79,10 +79,25 @@ struct syn123_struct
 	// This is a set of two to accomodate x and y=function(x, y).
 	// Working in blocks reduces function call overhead and gives
 	// chance of vectorization.
-	// This may also be used as buffer for data with output encoding,
-	// exploiting the fact that double is the biggest data type we
-	// handle, also with the biggest alignment.
-	double workbuf[2][bufblock];
+	// This may also be used as buffer for data with various encodings,
+	// hence a union to express this in the nicest possible way. This storage
+	// is used in a number of ways.
+	// All members have to be the same size, utilizing the whole storage
+	// block. Code using it assumes that sizeof(workbuf) gives the numbers
+	// of bytes accessible via any member.
+	union {
+		double   f64[2][bufblock];
+		float    f32[2][2*bufblock];
+		uint32_t u32[2][2*bufblock];
+		int32_t  i32[2][2*bufblock];
+		uint16_t u16[2][4*bufblock];
+		int16_t  i16[2][4*bufblock];
+		uint8_t   u8[2][8*bufblock];
+		int8_t    i8[2][8*bufblock];
+		// Yes, again the same, to be overly explicit about type names.
+		char           c[2][8*bufblock];
+		unsigned char uc[2][8*bufblock];
+	} workbuf;
 	struct mpg123_fmt fmt;
 	int dither; // if dithering is activated for the handle
 	int do_dither; // flag for recursive calls of syn123_conv()

src/libsyn123/volume.c

@@ -47,6 +47,25 @@ double attribute_align_arg syn123_lin2db(double volume)
 }
 
 
+#define CONVAMP(fXX) \
+	err = syn123_conv( \
+		sh->workbuf.fXX, mixenc, sizeof(sh->workbuf.fXX) \
+	,	cbuf, encoding, inframe*block \
+	,	NULL, NULL, NULL ); \
+	if(!err) \
+	{ \
+		err = syn123_amp( sh->workbuf.fXX, mixenc, block \
+		,	volume, offset, NULL, NULL ); \
+		if(err) \
+			return err; \
+		err = syn123_conv( \
+			cbuf, encoding, inframe*block \
+		,	sh->workbuf.fXX, mixenc, mixframe*block \
+		,	NULL, &clips_block, NULL ); \
+		clips += clips_block; \
+	}
+
+
 int attribute_align_arg
 syn123_amp( void* buf, int encoding, size_t samples
 ,	double volume, double offset, size_t *clipped, syn123_handle *sh )
@@ -94,22 +113,14 @@ syn123_amp( void* buf, int encoding, size_t samples
 		while(samples)
 		{
 			int block = (int)smin(samples, mbufblock);
-			int err = syn123_conv(
-				sh->workbuf, mixenc, sizeof(sh->workbuf)
-			,	cbuf, encoding, inframe*block
-			,	NULL, NULL, NULL );
-			if(!err)
+			size_t clips_block = 0;
+			int err = 0;
+			if(mixenc == MPG123_ENC_FLOAT_64)
+			{
+				CONVAMP(f64)
+			} else
 			{
-				err = syn123_amp( sh->workbuf, mixenc, block
-				,	volume, offset, NULL, NULL );
-				if(err)
-					return err;
-				size_t clips_block = 0;
-				err = syn123_conv(
-					cbuf, encoding, inframe*block
-				,	sh->workbuf, mixenc, mixframe*block
-				,	NULL, &clips_block, NULL );
-				clips += clips_block;
+				CONVAMP(f32)
 			}
 			if(err)
 			{