munt/DOSBox-mt32-patch/dosbox-0.74-mt32-patch.diff

diff --git a/src/Makefile.am b/src/Makefile.am
index 184469e..286638d 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -17,4 +17,4 @@ dosbox_LDADD = cpu/libcpu.a debug/libdebug.a dos/libdos.a fpu/libfpu.a  hardware
 
 EXTRA_DIST = winres.rc dosbox.ico
 
-
+LIBS +=  -lmt32emu
diff --git a/src/dosbox.cpp b/src/dosbox.cpp
index a4bf564..ad65fe6 100644
--- a/src/dosbox.cpp
+++ b/src/dosbox.cpp
@@ -467,7 +467,7 @@ void DOSBOX_Init(void) {
 	
 	const char* mputypes[] = { "intelligent", "uart", "none",0};
 	// FIXME: add some way to offer the actually available choices.
-	const char *devices[] = { "default", "win32", "alsa", "oss", "coreaudio", "coremidi","none", 0};
+	const char *devices[] = { "default", "win32", "alsa", "oss", "coreaudio", "coremidi", "mt32", "none", 0};
 	Pstring = secprop->Add_string("mpu401",Property::Changeable::WhenIdle,"intelligent");
 	Pstring->Set_values(mputypes);
 	Pstring->Set_help("Type of MPU-401 to emulate.");
@@ -480,6 +480,8 @@ void DOSBOX_Init(void) {
 	Pstring->Set_help("Special configuration options for the device driver. This is usually the id of the device you want to use.\n"
 	                  "  See the README/Manual for more details.");
 
+#include "mt32options.h"
+
 #if C_DEBUG
 	secprop=control->AddSection_prop("debug",&DEBUG_Init);
 #endif
diff --git a/src/gui/Makefile.am b/src/gui/Makefile.am
index 3fed5e6..d4aeabc 100644
--- a/src/gui/Makefile.am
+++ b/src/gui/Makefile.am
@@ -7,5 +7,5 @@ libgui_a_SOURCES = sdlmain.cpp sdl_mapper.cpp dosbox_logo.h \
 	render_templates_sai.h render_templates_hq.h \
 	render_templates_hq2x.h render_templates_hq3x.h \
 	midi.cpp midi_win32.h midi_oss.h midi_coreaudio.h midi_alsa.h \
-	midi_coremidi.h sdl_gui.cpp dosbox_splash.h
+	midi_coremidi.h midi_mt32.h sdl_gui.cpp dosbox_splash.h
 
diff --git a/src/gui/midi.cpp b/src/gui/midi.cpp
index 61d15e5..0ec8ebc 100644
--- a/src/gui/midi.cpp
+++ b/src/gui/midi.cpp
@@ -98,6 +98,11 @@ MidiHandler Midi_none;
 
 #endif
 
+#define DOSBOX_MIDI_H
+#include "midi_mt32.cpp"
+static MidiHandler_mt32 &Midi_mt32 = MidiHandler_mt32::GetInstance();
+#undef DOSBOX_MIDI_H
+
 static struct {
 	Bitu status;
 	Bitu cmd_len;
diff --git a/src/gui/midi_mt32.cpp b/src/gui/midi_mt32.cpp
new file mode 100644
index 0000000..3f66f66
--- /dev/null
+++ b/src/gui/midi_mt32.cpp
@@ -0,0 +1,298 @@
+#include <SDL_thread.h>
+#include <SDL_endian.h>
+#include "control.h"
+
+#ifndef DOSBOX_MIDI_H
+#include "midi.h"
+#endif
+
+#include "midi_mt32.h"
+
+static const Bitu MILLIS_PER_SECOND = 1000;
+
+MidiHandler_mt32 &MidiHandler_mt32::GetInstance() {
+	static MidiHandler_mt32 midiHandler_mt32;
+	return midiHandler_mt32;
+}
+
+const char *MidiHandler_mt32::GetName(void) {
+	return "mt32";
+}
+
+bool MidiHandler_mt32::Open(const char *conf) {
+	service = new MT32Emu::Service();
+	Bit32u version = service->getLibraryVersionInt();
+	if (version < 0x020100) {
+		delete service;
+		service = NULL;
+		LOG_MSG("MT32: libmt32emu version is too old: %s", service->getLibraryVersionString());
+		return false;
+	}
+	service->createContext(getReportHandlerInterface(), this);
+	mt32emu_return_code rc;
+
+	Section_prop *section = static_cast<Section_prop *>(control->GetSection("midi"));
+	const char *romDir = section->Get_string("mt32.romdir");
+	if (romDir == NULL) romDir = "./"; // Paranoid NULL-check, should never happen
+	size_t romDirLen = strlen(romDir);
+	bool addPathSeparator = false;
+	if (romDirLen < 1) {
+		romDir = "./";
+	} else if (4080 < romDirLen) {
+		LOG_MSG("MT32: mt32.romdir is too long, using the current dir.");
+		romDir = "./";
+	} else {
+		char lastChar = romDir[strlen(romDir) - 1];
+		addPathSeparator = lastChar != '/' && lastChar != '\\';
+	}
+
+	char pathName[4096];
+
+	makeROMPathName(pathName, romDir, "CM32L_CONTROL.ROM", addPathSeparator);
+	if (MT32EMU_RC_ADDED_CONTROL_ROM != service->addROMFile(pathName)) {
+		makeROMPathName(pathName, romDir, "MT32_CONTROL.ROM", addPathSeparator);
+		if (MT32EMU_RC_ADDED_CONTROL_ROM != service->addROMFile(pathName)) {
+			delete service;
+			service = NULL;
+			LOG_MSG("MT32: Control ROM file not found");
+			return false;
+		}
+	}
+	makeROMPathName(pathName, romDir, "CM32L_PCM.ROM", addPathSeparator);
+	if (MT32EMU_RC_ADDED_PCM_ROM != service->addROMFile(pathName)) {
+		makeROMPathName(pathName, romDir, "MT32_PCM.ROM", addPathSeparator);
+		if (MT32EMU_RC_ADDED_PCM_ROM != service->addROMFile(pathName)) {
+			delete service;
+			service = NULL;
+			LOG_MSG("MT32: PCM ROM file not found");
+			return false;
+		}
+	}
+
+	service->setPartialCount(Bit32u(section->Get_int("mt32.partials")));
+	service->setAnalogOutputMode((MT32Emu::AnalogOutputMode)section->Get_int("mt32.analog"));
+	int sampleRate = section->Get_int("mt32.rate");
+	service->setStereoOutputSampleRate(sampleRate);
+	service->setSamplerateConversionQuality((MT32Emu::SamplerateConversionQuality)section->Get_int("mt32.src.quality"));
+
+	if (MT32EMU_RC_OK != (rc = service->openSynth())) {
+		delete service;
+		service = NULL;
+		LOG_MSG("MT32: Error initialising emulation: %i", rc);
+		return false;
+	}
+
+	if (strcmp(section->Get_string("mt32.reverb.mode"), "auto") != 0) {
+		Bit8u reverbsysex[] = {0x10, 0x00, 0x01, 0x00, 0x05, 0x03};
+		reverbsysex[3] = (Bit8u)atoi(section->Get_string("mt32.reverb.mode"));
+		reverbsysex[4] = (Bit8u)section->Get_int("mt32.reverb.time");
+		reverbsysex[5] = (Bit8u)section->Get_int("mt32.reverb.level");
+		service->writeSysex(16, reverbsysex, 6);
+		service->setReverbOverridden(true);
+	}
+
+	service->setDACInputMode((MT32Emu::DACInputMode)section->Get_int("mt32.dac"));
+
+	service->setReversedStereoEnabled(section->Get_bool("mt32.reverse.stereo"));
+	noise = section->Get_bool("mt32.verbose");
+	renderInThread = section->Get_bool("mt32.thread");
+
+	if (noise) LOG_MSG("MT32: Set maximum number of partials %d", service->getPartialCount());
+
+	if (noise) LOG_MSG("MT32: Adding mixer channel at sample rate %d", sampleRate);
+	chan = MIXER_AddChannel(mixerCallBack, sampleRate, "MT32");
+
+	if (renderInThread) {
+		stopProcessing = false;
+		playPos = 0;
+		int chunkSize = section->Get_int("mt32.chunk");
+		minimumRenderFrames = (chunkSize * sampleRate) / MILLIS_PER_SECOND;
+		int latency = section->Get_int("mt32.prebuffer");
+		if (latency <= chunkSize) {
+			latency = 2 * chunkSize;
+			LOG_MSG("MT32: chunk length must be less than prebuffer length, prebuffer length reset to %i ms.", latency);
+		}
+		framesPerAudioBuffer = (latency * sampleRate) / MILLIS_PER_SECOND;
+		audioBufferSize = framesPerAudioBuffer << 1;
+		audioBuffer = new Bit16s[audioBufferSize];
+		service->renderBit16s(audioBuffer, framesPerAudioBuffer - 1);
+		renderPos = (framesPerAudioBuffer - 1) << 1;
+		playedBuffers = 1;
+		lock = SDL_CreateMutex();
+		framesInBufferChanged = SDL_CreateCond();
+		thread = SDL_CreateThread(processingThread, NULL);
+	}
+	chan->Enable(true);
+
+	open = true;
+	return true;
+}
+
+void MidiHandler_mt32::Close(void) {
+	if (!open) return;
+	chan->Enable(false);
+	if (renderInThread) {
+		stopProcessing = true;
+		SDL_LockMutex(lock);
+		SDL_CondSignal(framesInBufferChanged);
+		SDL_UnlockMutex(lock);
+		SDL_WaitThread(thread, NULL);
+		thread = NULL;
+		SDL_DestroyMutex(lock);
+		lock = NULL;
+		SDL_DestroyCond(framesInBufferChanged);
+		framesInBufferChanged = NULL;
+		delete[] audioBuffer;
+		audioBuffer = NULL;
+	}
+	MIXER_DelChannel(chan);
+	chan = NULL;
+	service->closeSynth();
+	delete service;
+	service = NULL;
+	open = false;
+}
+
+void MidiHandler_mt32::PlayMsg(Bit8u *msg) {
+	if (renderInThread) {
+		service->playMsgAt(SDL_SwapLE32(*(Bit32u *)msg), getMidiEventTimestamp());
+	} else {
+		service->playMsg(SDL_SwapLE32(*(Bit32u *)msg));
+	}
+}
+
+void MidiHandler_mt32::PlaySysex(Bit8u *sysex, Bitu len) {
+	if (renderInThread) {
+		service->playSysexAt(sysex, len, getMidiEventTimestamp());
+	} else {
+		service->playSysex(sysex, len);
+	}
+}
+
+void MidiHandler_mt32::mixerCallBack(Bitu len) {
+	MidiHandler_mt32::GetInstance().handleMixerCallBack(len);
+}
+
+int MidiHandler_mt32::processingThread(void *) {
+	MidiHandler_mt32::GetInstance().renderingLoop();
+	return 0;
+}
+
+void MidiHandler_mt32::makeROMPathName(char pathName[], const char romDir[], const char fileName[], bool addPathSeparator) {
+	strcpy(pathName, romDir);
+	if (addPathSeparator) {
+		strcat(pathName, "/");
+	}
+	strcat(pathName, fileName);
+}
+
+mt32emu_report_handler_i MidiHandler_mt32::getReportHandlerInterface() {
+	class ReportHandler {
+	public:
+		static mt32emu_report_handler_version getReportHandlerVersionID(mt32emu_report_handler_i) {
+			return MT32EMU_REPORT_HANDLER_VERSION_0;
+		}
+
+		static void printDebug(void *instance_data, const char *fmt, va_list list) {
+			MidiHandler_mt32 &midiHandler_mt32 = *(MidiHandler_mt32 *)instance_data;
+			if (midiHandler_mt32.noise) {
+				char s[1024];
+				vsnprintf(s, 1023, fmt, list);
+				LOG_MSG("MT32: %s", s);
+			}
+		}
+
+		static void onErrorControlROM(void *) {
+			LOG_MSG("MT32: Couldn't open Control ROM file");
+		}
+
+		static void onErrorPCMROM(void *) {
+			LOG_MSG("MT32: Couldn't open PCM ROM file");
+		}
+
+		static void showLCDMessage(void *, const char *message) {
+			LOG_MSG("MT32: LCD-Message: %s", message);
+		}
+	};
+
+	static const mt32emu_report_handler_i_v0 REPORT_HANDLER_V0_IMPL = {
+		ReportHandler::getReportHandlerVersionID,
+		ReportHandler::printDebug,
+		ReportHandler::onErrorControlROM,
+		ReportHandler::onErrorPCMROM,
+		ReportHandler::showLCDMessage
+	};
+
+	static const mt32emu_report_handler_i REPORT_HANDLER_I = { &REPORT_HANDLER_V0_IMPL };
+
+	return REPORT_HANDLER_I;
+}
+
+MidiHandler_mt32::MidiHandler_mt32() : open(false), chan(NULL), service(NULL), thread(NULL) {
+}
+
+MidiHandler_mt32::~MidiHandler_mt32() {
+	Close();
+}
+
+void MidiHandler_mt32::handleMixerCallBack(Bitu len) {
+	if (renderInThread) {
+		while (renderPos == playPos) {
+			SDL_LockMutex(lock);
+			SDL_CondWait(framesInBufferChanged, lock);
+			SDL_UnlockMutex(lock);
+			if (stopProcessing) return;
+		}
+		Bitu renderPosSnap = renderPos;
+		Bitu playPosSnap = playPos;
+		Bitu samplesReady = (renderPosSnap < playPosSnap) ? audioBufferSize - playPosSnap : renderPosSnap - playPosSnap;
+		if (len > (samplesReady >> 1)) {
+			len = samplesReady >> 1;
+		}
+		chan->AddSamples_s16(len, audioBuffer + playPosSnap);
+		playPosSnap += (len << 1);
+		while (audioBufferSize <= playPosSnap) {
+			playPosSnap -= audioBufferSize;
+			playedBuffers++;
+		}
+		playPos = playPosSnap;
+		renderPosSnap = renderPos;
+		const Bitu samplesFree = (renderPosSnap < playPosSnap) ? playPosSnap - renderPosSnap : audioBufferSize + playPosSnap - renderPosSnap;
+		if (minimumRenderFrames <= (samplesFree >> 1)) {
+			SDL_LockMutex(lock);
+			SDL_CondSignal(framesInBufferChanged);
+			SDL_UnlockMutex(lock);
+		}
+	} else {
+		service->renderBit16s((Bit16s *)MixTemp, len);
+		chan->AddSamples_s16(len, (Bit16s *)MixTemp);
+	}
+}
+
+void MidiHandler_mt32::renderingLoop() {
+	while (!stopProcessing) {
+		const Bitu renderPosSnap = renderPos;
+		const Bitu playPosSnap = playPos;
+		Bitu samplesToRender;
+		if (renderPosSnap < playPosSnap) {
+			samplesToRender = playPosSnap - renderPosSnap - 2;
+		} else {
+			samplesToRender = audioBufferSize - renderPosSnap;
+			if (playPosSnap == 0) samplesToRender -= 2;
+		}
+		Bitu framesToRender = samplesToRender >> 1;
+		if ((framesToRender == 0) || ((framesToRender < minimumRenderFrames) && (renderPosSnap < playPosSnap))) {
+			SDL_LockMutex(lock);
+			SDL_CondWait(framesInBufferChanged, lock);
+			SDL_UnlockMutex(lock);
+		} else {
+			service->renderBit16s(audioBuffer + renderPosSnap, framesToRender);
+			renderPos = (renderPosSnap + samplesToRender) % audioBufferSize;
+			if (renderPosSnap == playPos) {
+				SDL_LockMutex(lock);
+				SDL_CondSignal(framesInBufferChanged);
+				SDL_UnlockMutex(lock);
+			}
+		}
+	}
+}
diff --git a/src/gui/midi_mt32.h b/src/gui/midi_mt32.h
new file mode 100644
index 0000000..eb32729
--- /dev/null
+++ b/src/gui/midi_mt32.h
@@ -0,0 +1,55 @@
+#ifndef DOSBOX_MIDI_MT32_H
+#define DOSBOX_MIDI_MT32_H
+
+#include "mixer.h"
+
+#define MT32EMU_API_TYPE 3
+#include <mt32emu/mt32emu.h>
+
+#if MT32EMU_VERSION_MAJOR != 2 || MT32EMU_VERSION_MINOR < 1
+#error Incompatible mt32emu library version
+#endif
+
+struct SDL_Thread;
+
+class MidiHandler_mt32 : public MidiHandler {
+public:
+	static MidiHandler_mt32 &GetInstance(void);
+
+	const char *GetName(void);
+	bool Open(const char *conf);
+	void Close(void);
+	void PlayMsg(Bit8u *msg);
+	void PlaySysex(Bit8u *sysex, Bitu len);
+
+private:
+	MixerChannel *chan;
+	MT32Emu::Service *service;
+	SDL_Thread *thread;
+	SDL_mutex *lock;
+	SDL_cond *framesInBufferChanged;
+	Bit16s *audioBuffer;
+	Bitu audioBufferSize;
+	Bitu framesPerAudioBuffer;
+	Bitu minimumRenderFrames;
+	volatile Bitu renderPos, playPos, playedBuffers;
+	volatile bool stopProcessing;
+	bool open, noise, renderInThread;
+
+	static void mixerCallBack(Bitu len);
+	static int processingThread(void *);
+	static void makeROMPathName(char pathName[], const char romDir[], const char fileName[], bool addPathSeparator);
+	static mt32emu_report_handler_i getReportHandlerInterface();
+
+	MidiHandler_mt32();
+	~MidiHandler_mt32();
+
+	Bit32u inline getMidiEventTimestamp() {
+		return service->convertOutputToSynthTimestamp(Bit32u(playedBuffers * framesPerAudioBuffer + (playPos >> 1)));
+	}
+
+	void handleMixerCallBack(Bitu len);
+	void renderingLoop();
+};
+
+#endif /* DOSBOX_MIDI_MT32_H */
diff --git a/src/mt32options.h b/src/mt32options.h
new file mode 100644
index 0000000..1039d03
--- /dev/null
+++ b/src/mt32options.h
@@ -0,0 +1,108 @@
+Pstring = secprop->Add_string("mt32.romdir",Property::Changeable::WhenIdle,"");
+Pstring->Set_help("Name of the directory where MT-32 Control and PCM ROM files can be found. Emulation requires these files to work.\n"
+	"  Accepted file names are as follows:\n"
+	"    MT32_CONTROL.ROM or CM32L_CONTROL.ROM - control ROM file.\n"
+	"    MT32_PCM.ROM or CM32L_PCM.ROM - PCM ROM file.");
+
+Pbool = secprop->Add_bool("mt32.reverse.stereo",Property::Changeable::WhenIdle,false);
+Pbool->Set_help("Reverse stereo channels for MT-32 output");
+
+Pbool = secprop->Add_bool("mt32.verbose",Property::Changeable::WhenIdle,false);
+Pbool->Set_help("MT-32 debug logging");
+
+Pbool = secprop->Add_bool("mt32.thread",Property::Changeable::WhenIdle,false);
+Pbool->Set_help("MT-32 rendering in separate thread");
+
+const char *mt32chunk[] = {"2", "3", "16", "99", "100",0};
+Pint = secprop->Add_int("mt32.chunk",Property::Changeable::WhenIdle,16);
+Pint->Set_values(mt32chunk);
+Pint->SetMinMax(2,100);
+Pint->Set_help("Minimum milliseconds of data to render at once.\n"
+	"Increasing this value reduces rendering overhead which may improve performance but also increases audio lag.\n"
+	"Valid for rendering in separate thread only.");
+
+const char *mt32prebuffer[] = {"3", "4", "32", "199", "200",0};
+Pint = secprop->Add_int("mt32.prebuffer",Property::Changeable::WhenIdle,32);
+Pint->Set_values(mt32prebuffer);
+Pint->SetMinMax(3,200);
+Pint->Set_help("How many milliseconds of data to render ahead.\n"
+	"Increasing this value may help to avoid underruns but also increases audio lag.\n"
+	"Cannot be set less than or equal to mt32.chunk value.\n"
+	"Valid for rendering in separate thread only.");
+
+const char *mt32partials[] = {"8", "9", "32", "255", "256",0};
+Pint = secprop->Add_int("mt32.partials",Property::Changeable::WhenIdle,32);
+Pint->Set_values(mt32partials);
+Pint->SetMinMax(8,256);
+Pint->Set_help("The maximum number of partials playing simultaneously.");
+
+const char *mt32DACModes[] = {"0", "1", "2", "3",0};
+Pint = secprop->Add_int("mt32.dac",Property::Changeable::WhenIdle,0);
+Pint->Set_values(mt32DACModes);
+Pint->Set_help("MT-32 DAC input emulation mode\n"
+	"Nice = 0 - default\n"
+	"Produces samples at double the volume, without tricks.\n"
+	"Higher quality than the real devices\n\n"
+
+	"Pure = 1\n"
+	"Produces samples that exactly match the bits output from the emulated LA32.\n"
+	"Nicer overdrive characteristics than the DAC hacks (it simply clips samples within range)\n"
+	"Much less likely to overdrive than any other mode.\n"
+	"Half the volume of any of the other modes.\n"
+	"Perfect for developers while debugging :)\n\n"
+
+	"GENERATION1 = 2\n"
+	"Re-orders the LA32 output bits as in early generation MT-32s (according to Wikipedia).\n"
+	"Bit order at DAC (where each number represents the original LA32 output bit number, and XX means the bit is always low):\n"
+	"15 13 12 11 10 09 08 07 06 05 04 03 02 01 00 XX\n\n"
+
+	"GENERATION2 = 3\n"
+	"Re-orders the LA32 output bits as in later generations (personally confirmed on my CM-32L - KG).\n"
+	"Bit order at DAC (where each number represents the original LA32 output bit number):\n"
+	"15 13 12 11 10 09 08 07 06 05 04 03 02 01 00 14");
+
+const char *mt32analogModes[] = {"0", "1", "2", "3",0};
+Pint = secprop->Add_int("mt32.analog",Property::Changeable::WhenIdle,2);
+Pint->Set_values(mt32analogModes);
+Pint->Set_help("MT-32 analogue output emulation mode\n"
+	"Digital = 0\n"
+	"Only digital path is emulated. The output samples correspond to the digital output signal appeared at the DAC entrance.\n"
+	"Fastest mode.\n\n"
+
+	"Coarse = 1\n"
+	"Coarse emulation of LPF circuit. High frequencies are boosted, sample rate remains unchanged.\n"
+	"A bit better sounding but also a bit slower.\n\n"
+
+	"Accurate = 2 - default\n"
+	"Finer emulation of LPF circuit. Output signal is upsampled to 48 kHz to allow emulation of audible mirror spectra above 16 kHz,\n"
+	"which is passed through the LPF circuit without significant attenuation.\n"
+	"Sounding is closer to the analog output from real hardware but also slower than the modes 0 and 1.\n\n"
+
+	"Oversampled = 3\n"
+	"Same as the default mode 2 but the output signal is 2x oversampled, i.e. the output sample rate is 96 kHz.\n"
+	"Even slower than all the other modes but better retains highest frequencies while further resampled in DOSBox mixer.");
+
+const char *mt32reverbModes[] = {"0", "1", "2", "3", "auto",0};
+Pstring = secprop->Add_string("mt32.reverb.mode",Property::Changeable::WhenIdle,"auto");
+Pstring->Set_values(mt32reverbModes);
+Pstring->Set_help("MT-32 reverb mode");
+
+const char *mt32reverbTimes[] = {"0", "1", "2", "3", "4", "5", "6", "7",0};
+Pint = secprop->Add_int("mt32.reverb.time",Property::Changeable::WhenIdle,5);
+Pint->Set_values(mt32reverbTimes);
+Pint->Set_help("MT-32 reverb decaying time");
+
+const char *mt32reverbLevels[] = {"0", "1", "2", "3", "4", "5", "6", "7",0};
+Pint = secprop->Add_int("mt32.reverb.level",Property::Changeable::WhenIdle,3);
+Pint->Set_values(mt32reverbLevels);
+Pint->Set_help("MT-32 reverb level");
+
+Pint = secprop->Add_int("mt32.rate", Property::Changeable::WhenIdle, 44100);
+Pint->Set_values(rates);
+Pint->Set_help("Sample rate of MT-32 emulation.");
+
+const char *mt32srcQuality[] = {"0", "1", "2", "3",0};
+Pint = secprop->Add_int("mt32.src.quality", Property::Changeable::WhenIdle, 2);
+Pint->Set_values(mt32srcQuality);
+Pint->Set_help("MT-32 sample rate conversion quality\n"
+	"Value '0' is for the fastest conversion, value '3' provides for the best conversion quality. Default is 2.");