MEGA65: implementing MEGA65 mixer #272

First try ...

Author: lgblgblgb

targets/mega65/audio65.c

@@ -31,22 +31,22 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 #include "configdb.h"
 
 
-int stereo_separation = AUDIO_DEFAULT_SEPARATION;
-int audio_volume      = AUDIO_DEFAULT_VOLUME;
-
 struct SidEmulation sid[NUMBER_OF_SIDS];
 
 static opl3_chip opl3;
 
 static SDL_AudioDeviceID audio = 0;		// SDL audio device
-static int stereo_separation_orig = 100;
-static int stereo_separation_other = 0;
 static int system_sound_mix_freq;		// playback sample rate (in Hz) of the emulator itself
 static int system_sid_cycles_per_sec;
 static double dma_audio_mixing_value;
 
 Uint8 mixer_register = 0x00;
-static Uint8 mixer_coeffs[0x100];
+static Uint8 mixer_bytes[0x100];
+static float mixer_floats[0x80];
+static int output_selection;			// $00 = HDMI/speakers, $C0 = headphones
+static int xemu_volume_int;
+static float xemu_volume_float;
+static bool mono_downmix;
 
 #if NUMBER_OF_SIDS != 4
 #	error "Currently NUMBER_OF_SIDS macro must be set to 4!"
@@ -222,35 +222,6 @@ static inline void render_dma_audio ( int channel, Sint16 *buffer, int len )
 }
 
 
-void audio_set_stereo_parameters ( int vol, int sep )
-{
-	if (sep == AUDIO_UNCHANGED_SEPARATION) {
-		sep = stereo_separation;
-	} else {
-		if (sep > 100)
-			sep = 100;
-		else if (sep < -100)
-			sep = -100;
-		stereo_separation = sep;
-	}
-	if (vol == AUDIO_UNCHANGED_VOLUME) {
-		vol = audio_volume;
-	} else {
-		if (vol > 100)
-			vol = 100;
-		else if (vol < 0)
-			vol = 0;
-		audio_volume = vol;
-	}
-	//sep = ((sep + 100) * 0x100) / 200;
-	sep = (sep + 100) / 2;
-	//sep = (sep + 100) * 0x100 / 200;
-	stereo_separation_orig  = (sep * vol) / 100;
-	stereo_separation_other = ((100 - sep) * vol) / 100;
-	DEBUGPRINT("AUDIO: volume is set to %d%%, stereo separation is %d%% [component-A is %d, component-B is %d]" NL, audio_volume, stereo_separation, stereo_separation_orig, stereo_separation_other);
-}
-
-
 // 10 channels, consist of: 4 channel for audio DMA, 4 channel for SIDs (each SIDs are pre-mixed to one channel by sid.c), 2 OPL3 channel (OPL3 is pre-mixed into two channels in opl3.c)
 #define MIXED_CHANNELS			10
 
@@ -264,6 +235,9 @@ void audio_set_stereo_parameters ( int vol, int sep )
 #define STREAMS(n)			(streams + ((n) * (AUDIO_BUFFER_SAMPLES_MAX)))
 #define STREAMS_SAMPLE(n,d)		((int)(STREAMS(n)[d]))
 
+static float scalers_left[MIXED_CHANNELS];
+static float scalers_right[MIXED_CHANNELS];
+
 
 static void audio_callback ( void *userdata, Uint8 *stereo_out_stream, int len )
 {
@@ -310,18 +284,16 @@ static void audio_callback ( void *userdata, Uint8 *stereo_out_stream, int len )
 	}
 	// Now mix the result ...
 	for (int i = 0, j = 0; i < len; i++) {
-		// mixing streams together
-		// Currently: put the first two SIDS to the left, the second two to the right, same for DMA audio channels, and OPL3 seems to need 2 channel
-		const register int orig_left  = STREAMS_SAMPLE(0, i) + STREAMS_SAMPLE(1, i) + STREAMS_SAMPLE(4, i) + STREAMS_SAMPLE(5, i) + STREAMS_SAMPLE(8, i);
-		const register int orig_right = STREAMS_SAMPLE(2, i) + STREAMS_SAMPLE(3, i) + STREAMS_SAMPLE(6, i) + STREAMS_SAMPLE(7, i) + STREAMS_SAMPLE(9, i);
-#if 1
-		// channel stereo separation (including inversion) + volume handling
-		int left  = ((orig_left  * stereo_separation_orig) / 100) + ((orig_right * stereo_separation_other) / 100);
-		int right = ((orig_right * stereo_separation_orig) / 100) + ((orig_left  * stereo_separation_other) / 100);
-#else
-		int left = orig_left;
-		int right = orig_right;
-#endif
+		// do the mixing stuff. NOTE: it seems on modern CPUs, using float/doubles can be even faster than integer math where I also need a division ...
+		float fl_left = 0, fl_right = 0;
+		for (int c = 0; c < MIXED_CHANNELS; c++) {
+			const float sample = (float)STREAMS_SAMPLE(c, i);
+			fl_left  += sample * scalers_left[c];
+			fl_right += sample * scalers_right[c];
+		}
+		// convert to integer
+		int left  = (int)fl_left;
+		int right = (int)fl_right;
 		// do some ugly clipping ...
 		if      (left  >  0x7FFF) left  =  0x7FFF;
 		else if (left  < -0x8000) left  = -0x8000;
@@ -355,6 +327,34 @@ void audio65_clear_regs ( void )
 }
 
 
+#define GETMIXFL(n) mixer_floats[((n) + output_selection) >> 1]
+
+
+static void recalulate_scalers ( void )
+{
+	const float master_left  = GETMIXFL(0x1E) * xemu_volume_float;
+	const float master_right = GETMIXFL(0x3E) * xemu_volume_float;
+	// Digi (audio DMA) channel 1-2 volume
+	scalers_left [0] = scalers_left [1] = GETMIXFL(0x10) * master_left;
+	scalers_right[0] = scalers_right[1] = GETMIXFL(0x30) * master_right;
+	// Digi (audio DMA) channel 3-4 volume
+	scalers_left [2] = scalers_left [3] = GETMIXFL(0x12) * master_left;
+	scalers_right[2] = scalers_right[3] = GETMIXFL(0x32) * master_right;
+	// SID 1-2 volume
+	scalers_left [4] = scalers_left [5] = GETMIXFL(0x00) * master_left;
+	scalers_right[4] = scalers_right[5] = GETMIXFL(0x20) * master_right;
+	// SID 3-4 volume
+	scalers_left [6] = scalers_left [7] = GETMIXFL(0x02) * master_left;
+	scalers_right[6] = scalers_right[7] = GETMIXFL(0x22) * master_right;
+	// OPL FM volume. NOTE: Xemu uses NukedOPL which emulates OPL3 [stereo], but MEGA65's OPL2(-ish?) implementation has only mono as OPL source
+	scalers_left [8] = scalers_left [9] = GETMIXFL(0x1C) * master_left;
+	scalers_right[8] = scalers_right[9] = GETMIXFL(0x3C) * master_right;
+	if (XEMU_UNLIKELY(mono_downmix))
+		for (int c = 0; c < MIXED_CHANNELS; c++)
+			scalers_left[c] = scalers_right[c] = (scalers_left[c] + scalers_right[c]) / 2;
+}
+
+
 void audio65_reset ( void )
 {
 	// We always initialize SIDs/OPL, even if no audio emulation is compiled in
@@ -389,34 +389,130 @@ void audio65_start ( void )
 
 Uint8 audio65_read_mixer_register ( void )
 {
-	return mixer_coeffs[mixer_register];
+	return mixer_bytes[mixer_register];
+}
+
+
+static inline void write_mixer_register ( const int reg, const Uint8 data )
+{
+	mixer_bytes[reg] = data;
+	mixer_floats[reg >> 1] = (float)((mixer_bytes[reg & 0xFE] << 8) + mixer_bytes[reg | 0x01]) / (float)0xFFFFU;
 }
 
 
 void audio65_write_mixer_register ( const Uint8 data )
 {
-	mixer_coeffs[mixer_register] = data;
-	if (mixer_register == 0x1E || mixer_register == 0x1F) {		// HDMI-LEFT?
-		int vol = (mixer_coeffs[0x1E] << 8) + mixer_coeffs[0x1F];
-		vol = vol * 100 / 65536;
-		audio_set_stereo_parameters(vol, AUDIO_UNCHANGED_SEPARATION);
-	}
-	if (mixer_register == 0x3E || mixer_register == 0x3F)   {	// HDMI-RIGHT?
-		int vol = (mixer_coeffs[0x3E] << 8) + mixer_coeffs[0x3F];
-		vol = vol * 100 / 65536;
-		audio_set_stereo_parameters(vol, AUDIO_UNCHANGED_SEPARATION);
+	if (mixer_bytes[mixer_register] != data) {
+		write_mixer_register(mixer_register, data);
+		recalulate_scalers();
 	}
 }
 
 
-void audio65_init ( int sid_cycles_per_sec, int sound_mix_freq, int volume, int separation, unsigned int buffer_size )
+static void default_mixer_helper ( const int basereg, const Uint16 value_l, const Uint16 value_r )
+{
+	write_mixer_register(basereg + 0x00, value_l >> 8);
+	write_mixer_register(basereg + 0x01, value_l & 0xFF);
+	write_mixer_register(basereg + 0x20, value_r >> 8);
+	write_mixer_register(basereg + 0x21, value_r & 0xFF);
+	// repeat the same for headphones output:
+	write_mixer_register(basereg + 0xC0, value_l >> 8);
+	write_mixer_register(basereg + 0xC1, value_l & 0xFF);
+	write_mixer_register(basereg + 0xE0, value_r >> 8);
+	write_mixer_register(basereg + 0xE1, value_r & 0xFF);
+}
+
+
+static void print_audio_info ( void )
+{
+	DEBUGPRINT("AUDIO: emu-volume = %d%%, mono-downmix = %s, output-reg-shift = $%02X" NL,
+		xemu_volume_int,
+		mono_downmix ? "ON" : "off",
+		output_selection
+	);
+}
+
+
+void audio65_reset_mixer ( void )
+{
+	mixer_register = 0;
+	for (int i = 0; i < 0x100; i++)
+		write_mixer_register(i, 0);
+	default_mixer_helper(0x00, 0xBEBE, 0x4040);	// SID-L input
+	default_mixer_helper(0x02, 0x4040, 0xBEBE);	// SID-R input
+	default_mixer_helper(0x10, 0xBEBE, 0x4040);	// DIGI-L input
+	default_mixer_helper(0x12, 0x4040, 0xBEBE);	// DIGI-R input
+	default_mixer_helper(0x1C, 0xBEBE, 0xBEBE);	// OPL FM! On MEGA65 OPL channel is maybe muted by default, btw ...
+	default_mixer_helper(0x1E, 0xFFFF, 0xFFFF);	// master volume
+	recalulate_scalers();
+}
+
+
+static void set_volume ( int vol )
+{
+	if (vol < 0) vol = 0;
+	else if (vol > 100) vol = 100;
+	xemu_volume_int = vol;
+	xemu_volume_float = (float)vol / (float)100.0;
+}
+
+
+void audio65_set_volume ( int vol )
+{
+	set_volume(vol);
+	recalulate_scalers();
+	print_audio_info();
+}
+
+
+int audio65_get_volume ( void )
+{
+	return xemu_volume_int;
+}
+
+
+void audio65_set_mono_downmix ( const bool status )
+{
+	mono_downmix = status;
+	recalulate_scalers();
+	print_audio_info();
+}
+
+
+bool audio65_get_mono_downmix ( void )
+{
+	return mono_downmix;
+}
+
+
+void audio65_set_output ( const int val )
+{
+	output_selection = val;
+	recalulate_scalers();
+	print_audio_info();
+}
+
+
+int audio65_get_output ( void )
+{
+	return output_selection;
+}
+
+
+void audio65_init ( int sid_cycles_per_sec, int sound_mix_freq, int volume, unsigned int buffer_size )
 {
 	static volatile int initialized = 0;
 	if (initialized) {
 		ERROR_WINDOW("Trying to reinitialize audio??\nRefusing to do so!!");
 		return;
 	}
 	initialized = 1;
+	// Setting these parameters should be followed by calling recalulate_scalers(). However, audio65_reset_mixer() at the end will call that anyway.
+	output_selection = AUDIO_OUTPUT_SPEAKERS;
+	mono_downmix = false;
+	set_volume(volume);
+	audio65_reset_mixer();
+	print_audio_info();
 	for (int i = 0; i < NUMBER_OF_SIDS; i++)
 		UNLOCK_SID("INIT", i);
 	UNLOCK_OPL("INIT");
@@ -451,7 +547,6 @@ void audio65_init ( int sid_cycles_per_sec, int sound_mix_freq, int volume, int
 		//}
 	} else
 		ERROR_WINDOW("Cannot open audio device!");
-	audio_set_stereo_parameters(volume, separation);
 #else
 	DEBUGPRINT("AUDIO: has been disabled at compilation time." NL);
 #endif

targets/mega65/audio65.h

@@ -33,16 +33,12 @@ extern struct SidEmulation sid[NUMBER_OF_SIDS];
 // You may want to disable audio emulation since it can disturb non-real-time emulation
 #define AUDIO_EMULATION
 
-#define AUDIO_DEFAULT_SEPARATION	60
-#define AUDIO_DEFAULT_VOLUME		100
-#define AUDIO_UNCHANGED_SEPARATION	-1000
-#define AUDIO_UNCHANGED_VOLUME		-1000
+#define AUDIO_OUTPUT_SPEAKERS	0x00
+#define AUDIO_OUTPUT_HEADPHONES	0xC0
 
-extern int stereo_separation;
-extern int audio_volume;
 extern Uint8 mixer_register;
 
-extern void audio65_init ( int sid_cycles_per_sec, int sound_mix_freq, int volume, int separation, unsigned int buffer_size );
+extern void audio65_init ( int sid_cycles_per_sec, int sound_mix_freq, int volume, unsigned int buffer_size );
 extern void audio65_reset ( void );
 extern void audio65_clear_regs ( void );
 extern void audio65_start ( void );
@@ -53,5 +49,12 @@ extern void audio_set_stereo_parameters ( int vol, int sep );
 
 extern Uint8 audio65_read_mixer_register  ( void );
 extern void  audio65_write_mixer_register ( const Uint8 data );
+extern void  audio65_reset_mixer ( void );
+extern void  audio65_set_volume ( int vol );
+extern int   audio65_get_volume ( void );
+extern void  audio65_set_mono_downmix ( const bool status );
+extern bool  audio65_get_mono_downmix ( void );
+extern void  audio65_set_output ( const int val );
+extern int   audio65_get_output ( void );
 
 #endif

targets/mega65/configdb.c

@@ -132,8 +132,7 @@ static const struct xemutools_configdef_num_st num_options[] = {
 	{ "umon", 0, "TCP-based dual mode (http / text) monitor port number [NOT YET WORKING]", &configdb.umon, 0, 0xFFFF },
 #endif
 	{ "sdlrenderquality", RENDER_SCALE_QUALITY, "Setting SDL hint for scaling method/quality on rendering (0, 1, 2)", &configdb.sdlrenderquality, 0, 2 },
-	{ "stereoseparation", AUDIO_DEFAULT_SEPARATION, "Audio stereo separation; 100(hard-stereo) ... 0(mono) ... -100(hard-reversed-stereo); default: " STRINGIFY(AUDIO_DEFAULT_SEPARATION), &configdb.stereoseparation, -100, 100 },
-	{ "mastervolume", AUDIO_DEFAULT_VOLUME, "Audio emulation mixing final volume (100=unchanged ... 0=silence); default: " STRINGIFY(AUDIO_DEFAULT_VOLUME), &configdb.mastervolume, 0, 100 },
+	{ "mastervolume", 100, "Audio emulation mixing final volume (100=default/full ... 0=silence)", &configdb.mastervolume, 0, 100 },
 	// FIXME: as a workaround, I set this to "0" PAL, as newer MEGA65's default is this. HOWEVER this should be not handled this way but using a newer Hyppo!
 	{ "videostd", 0, "Use given video standard at startup/reset (0 = PAL, 1 = NTSC, -1 = Hyppo default)", &configdb.videostd, -1, 1 },
 	{ "sidmask", 15, "Enabled SIDs of the four, in form of a bitmask", &configdb.sidmask, 0, 15 },

targets/mega65/configdb.h

@@ -105,7 +105,6 @@ struct configdb_st {
 	int	umon;
 #endif
 	int	sdlrenderquality;
-	int	stereoseparation;
 	int	mastervolume;
 	double	fast_mhz;
 	int	nosound;

targets/mega65/mega65.c

@@ -774,7 +774,6 @@ int main ( int argc, char **argv )
 		SID_CYCLES_PER_SEC,		// SID cycles per sec
 		AUDIO_SAMPLE_FREQ,		// sound mix freq
 		configdb.mastervolume,
-		configdb.stereoseparation,
 		configdb.audiobuffersize
 	);
 	DEBUGPRINT("MEM: UNHANDLED memory policy: %d" NL, configdb.skip_unhandled_mem);

targets/mega65/memory_mapper.c

@@ -268,9 +268,8 @@ static void  i2c_writer ( const Uint32 addr32, const Uint8 data ) {
 	if (rel >= I2C_NVRAM_OFFSET && rel < (I2C_NVRAM_OFFSET + I2C_NVRAM_SIZE)) {
 		//DEBUGPRINT("I2C: NVRAM write ($%02X->$%02X) @ NVRAM+$%X" NL, i2c_regs[rel], data, rel - I2C_NVRAM_OFFSET);
 		i2c_regs[rel] = data;
-	} else if (configdb.mega65_model == 3 && rel >= 0x1D0 && rel <= 0x1EF) {	// Hyppo needs this on PCB R3 for I2C target setup (audio mixer settings)
-		// TODO: emulate the mixer stuff
-		i2c_regs[rel] = data;
+	} else if (configdb.mega65_model == 3 && rel >= 0x1D0 && rel <= 0x1EF) {	// Hyppo needs this on PCB R3 for I2C target setup (audio amp chip settings?)
+		i2c_regs[rel] = data;							// ... though the audio amp is not emulated by Xemu
 	} else {
 		DEBUGPRINT("I2C: unhandled write ($%02X) @ I2C+$%X" NL, data, rel);
 	}