Revert "MT32: Update Munt to 2.0.0"

This reverts commit b4dbd6d3c275097b4be964b7da4478ff930cbaa7.

56 files changed, 836 insertions, 4328 deletions

diff --git a/COPYING.BSD b/COPYING.BSD
index a46bb675ce..e67b79359a 100644
--- a/COPYING.BSD
+++ b/COPYING.BSD
@@ -91,31 +91,3 @@ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
 PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS"
 BASIS, AND BROWN UNIVERSITY HAS NO OBLIGATION TO PROVIDE MAINTENANCE,
 SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
-
-
-Parts of the MT-32 emulator use the following license:
-
- Copyright (c) 2011, Micael Hildenborg
- All rights reserved.
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are met:
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
-    * Neither the name of Micael Hildenborg nor the
-      names of its contributors may be used to endorse or promote products
-      derived from this software without specific prior written permission.
-
- THIS SOFTWARE IS PROVIDED BY Micael Hildenborg ''AS IS'' AND ANY
- EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- DISCLAIMED. IN NO EVENT SHALL Micael Hildenborg BE LIABLE FOR ANY
- DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/NEWS b/NEWS
index 15f455df43..f1650f0b7e 100644
--- a/NEWS
+++ b/NEWS
@@ -7,7 +7,6 @@ For a more comprehensive changelog of the latest experimental code, see:
      the current or a specified directory.
    - Many options in GUI could be applied without closing the dialog.
    - On-the-fly language switching was implemented.
-   - Updated Munt MT-32 emulation code to version 2.0.0.
 
  AGOS:
    - Fixed subtitle speed setting in the Hebrew version of Simon the Sorcerer 1.
diff --git a/audio/softsynth/mt32.cpp b/audio/softsynth/mt32.cpp
index 8ed1e7cf71..aaf95b65da 100644
--- a/audio/softsynth/mt32.cpp
+++ b/audio/softsynth/mt32.cpp
@@ -20,18 +20,6 @@
  *
  */
 
-#define FORBIDDEN_SYMBOL_EXCEPTION_FILE
-#define FORBIDDEN_SYMBOL_EXCEPTION_fclose
-#define FORBIDDEN_SYMBOL_EXCEPTION_fopen
-#define FORBIDDEN_SYMBOL_EXCEPTION_fprintf
-#define FORBIDDEN_SYMBOL_EXCEPTION_fread
-#define FORBIDDEN_SYMBOL_EXCEPTION_fseek
-#define FORBIDDEN_SYMBOL_EXCEPTION_fwrite
-#define FORBIDDEN_SYMBOL_EXCEPTION_printf
-#define FORBIDDEN_SYMBOL_EXCEPTION_vfprintf
-#define FORBIDDEN_SYMBOL_EXCEPTION_vprintf
-#define FORBIDDEN_SYMBOL_EXCEPTION_time_h
-
 #include "common/scummsys.h"
 #include "common/system.h"
 
@@ -39,7 +27,6 @@
 
 #include "audio/softsynth/mt32/mt32emu.h"
 #include "audio/softsynth/mt32/ROMInfo.h"
-#include "audio/softsynth/mt32/sha1/sha1.h"
 
 #include "audio/softsynth/emumidi.h"
 #include "audio/musicplugin.h"
@@ -67,53 +54,6 @@
 
 namespace MT32Emu {
 
-class ScummVMFile : public MT32Emu::File {
-public:
-	ScummVMFile() {}
-
-	~ScummVMFile() {
-		close();
-	}
-
-	bool open(const char *fileName) {
-		if (!_file.open(fileName)) {
-			return false;
-		}
-
-		_data = (Bit8u *)malloc(getSize());
-		_file.read(_data, getSize());
-
-		Bit8u rawHash[20];
-		sha1::calc(_data, getSize(), rawHash);
-		sha1::toHexString(rawHash, _digest);
-
-		return true;
-	}
-
-	size_t getSize() {
-		return _file.size();
-	}
-
-	const Bit8u *getData() {
-		return _data;
-	}
-
-	const SHA1Digest &getSHA1() {
-		return _digest;
-	}
-
-	virtual void close() {
-		delete _data;
-		_data = nullptr;
-		_file.close();
-	}
-
-private:
-	byte *_data;
-	Common::File _file;
-	SHA1Digest _digest;
-};
-
 class ReportHandlerScummVM : public ReportHandler {
 friend class Synth;
 
@@ -158,7 +98,7 @@ private:
 	MT32Emu::Synth *_synth;
 	MT32Emu::ReportHandlerScummVM *_reportHandler;
 	const MT32Emu::ROMImage *_controlROM, *_pcmROM;
-	MT32Emu::ScummVMFile *_controlFile, *_pcmFile;
+	Common::File *_controlFile, *_pcmFile;
 	void deleteMuntStructures();
 
 	int _outputRate;
@@ -255,10 +195,10 @@ int MidiDriver_MT32::open() {
 
 	_initializing = true;
 	debug(4, _s("Initializing MT-32 Emulator"));
-	_controlFile = new MT32Emu::ScummVMFile();
+	_controlFile = new Common::File();
 	if (!_controlFile->open("CM32L_CONTROL.ROM") && !_controlFile->open("MT32_CONTROL.ROM"))
 		error("Error opening MT32_CONTROL.ROM / CM32L_CONTROL.ROM");
-	_pcmFile = new MT32Emu::ScummVMFile();
+	_pcmFile = new Common::File();
 	if (!_pcmFile->open("CM32L_PCM.ROM") && !_pcmFile->open("MT32_PCM.ROM"))
 		error("Error opening MT32_PCM.ROM / CM32L_PCM.ROM");
 	_controlROM = MT32Emu::ROMImage::makeROMImage(_controlFile);
diff --git a/audio/softsynth/mt32/Analog.cpp b/audio/softsynth/mt32/Analog.cpp
index a345c77656..8ac28e401a 100644
--- a/audio/softsynth/mt32/Analog.cpp
+++ b/audio/softsynth/mt32/Analog.cpp
@@ -1,5 +1,5 @@
 /* Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Dean Beeler, Jerome Fisher
- * Copyright (C) 2011-2016 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
+ * Copyright (C) 2011, 2012, 2013, 2014 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
@@ -15,12 +15,8 @@
  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <cstring>
-
-#include "internals.h"
-
+//#include <cstring>
 #include "Analog.h"
-#include "Synth.h"
 
 namespace MT32Emu {
 
@@ -110,6 +106,7 @@ static const Bit32u ACCURATE_LPF_DELTAS_OVERSAMPLED[][ACCURATE_LPF_NUMBER_OF_PHA
 class AbstractLowPassFilter {
 public:
 	static AbstractLowPassFilter &createLowPassFilter(AnalogOutputMode mode, bool oldMT32AnalogLPF);
+	static void muteRingBuffer(SampleEx *ringBuffer, unsigned int length);
 
 	virtual ~AbstractLowPassFilter() {}
 	virtual SampleEx process(SampleEx sample) = 0;
@@ -155,9 +152,9 @@ public:
 	void addPositionIncrement(unsigned int positionIncrement);
 };
 
-Analog::Analog(const AnalogOutputMode mode, const bool oldMT32AnalogLPF) :
-	leftChannelLPF(AbstractLowPassFilter::createLowPassFilter(mode, oldMT32AnalogLPF)),
-	rightChannelLPF(AbstractLowPassFilter::createLowPassFilter(mode, oldMT32AnalogLPF)),
+Analog::Analog(const AnalogOutputMode mode, const ControlROMFeatureSet *controlROMFeatures) :
+	leftChannelLPF(AbstractLowPassFilter::createLowPassFilter(mode, controlROMFeatures->isOldMT32AnalogLPF())),
+	rightChannelLPF(AbstractLowPassFilter::createLowPassFilter(mode, controlROMFeatures->isOldMT32AnalogLPF())),
 	synthGain(0),
 	reverbGain(0)
 {}
@@ -167,7 +164,7 @@ Analog::~Analog() {
 	delete &rightChannelLPF;
 }
 
-void Analog::process(Sample *outStream, const Sample *nonReverbLeft, const Sample *nonReverbRight, const Sample *reverbDryLeft, const Sample *reverbDryRight, const Sample *reverbWetLeft, const Sample *reverbWetRight, Bit32u outLength) {
+void Analog::process(Sample **outStream, const Sample *nonReverbLeft, const Sample *nonReverbRight, const Sample *reverbDryLeft, const Sample *reverbDryRight, const Sample *reverbWetLeft, const Sample *reverbWetRight, Bit32u outLength) {
 	if (outStream == NULL) {
 		leftChannelLPF.addPositionIncrement(outLength);
 		rightChannelLPF.addPositionIncrement(outLength);
@@ -194,8 +191,8 @@ void Analog::process(Sample *outStream, const Sample *nonReverbLeft, const Sampl
 			outSampleR = rightChannelLPF.process(inSampleR);
 		}
 
-		*(outStream++) = Synth::clipSampleEx(outSampleL);
-		*(outStream++) = Synth::clipSampleEx(outSampleR);
+		*((*outStream)++) = Synth::clipSampleEx(outSampleL);
+		*((*outStream)++) = Synth::clipSampleEx(outSampleR);
 	}
 }
 
@@ -239,6 +236,23 @@ AbstractLowPassFilter &AbstractLowPassFilter::createLowPassFilter(AnalogOutputMo
 	}
 }
 
+void AbstractLowPassFilter::muteRingBuffer(SampleEx *ringBuffer, unsigned int length) {
+
+#if MT32EMU_USE_FLOAT_SAMPLES
+
+	SampleEx *p = ringBuffer;
+	while (length--) {
+		*(p++) = 0.0f;
+	}
+
+#else
+
+	memset(ringBuffer, 0, length * sizeof(SampleEx));
+
+#endif
+
+}
+
 bool AbstractLowPassFilter::hasNextSample() const {
 	return false;
 }
@@ -259,7 +273,7 @@ CoarseLowPassFilter::CoarseLowPassFilter(bool oldMT32AnalogLPF) :
 	LPF_TAPS(oldMT32AnalogLPF ? COARSE_LPF_TAPS_MT32 : COARSE_LPF_TAPS_CM32L),
 	ringBufferPosition(0)
 {
-	Synth::muteSampleBuffer(ringBuffer, COARSE_LPF_DELAY_LINE_LENGTH);
+	muteRingBuffer(ringBuffer, COARSE_LPF_DELAY_LINE_LENGTH);
 }
 
 SampleEx CoarseLowPassFilter::process(const SampleEx inSample) {
@@ -289,7 +303,7 @@ AccurateLowPassFilter::AccurateLowPassFilter(const bool oldMT32AnalogLPF, const
 	ringBufferPosition(0),
 	phase(0)
 {
-	Synth::muteSampleBuffer(ringBuffer, ACCURATE_LPF_DELAY_LINE_LENGTH);
+	muteRingBuffer(ringBuffer, ACCURATE_LPF_DELAY_LINE_LENGTH);
 }
 
 SampleEx AccurateLowPassFilter::process(const SampleEx inSample) {
@@ -331,4 +345,4 @@ void AccurateLowPassFilter::addPositionIncrement(const unsigned int positionIncr
 	phase = (phase + positionIncrement * phaseIncrement) % ACCURATE_LPF_NUMBER_OF_PHASES;
 }
 
-} // namespace MT32Emu
+}
diff --git a/audio/softsynth/mt32/Analog.h b/audio/softsynth/mt32/Analog.h
index ee642f280d..a48db72485 100644
--- a/audio/softsynth/mt32/Analog.h
+++ b/audio/softsynth/mt32/Analog.h
@@ -1,5 +1,5 @@
 /* Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Dean Beeler, Jerome Fisher
- * Copyright (C) 2011-2016 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
+ * Copyright (C) 2011, 2012, 2013, 2014 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
@@ -18,10 +18,7 @@
 #ifndef MT32EMU_ANALOG_H
 #define MT32EMU_ANALOG_H
 
-#include "globals.h"
-#include "internals.h"
-#include "Types.h"
-#include "Enumerations.h"
+#include "mt32emu.h"
 
 namespace MT32Emu {
 
@@ -38,9 +35,9 @@ class AbstractLowPassFilter;
  */
 class Analog {
 public:
-	Analog(const AnalogOutputMode mode, const bool oldMT32AnalogLPF);
+	Analog(AnalogOutputMode mode, const ControlROMFeatureSet *controlROMFeatures);
 	~Analog();
-	void process(Sample *outStream, const Sample *nonReverbLeft, const Sample *nonReverbRight, const Sample *reverbDryLeft, const Sample *reverbDryRight, const Sample *reverbWetLeft, const Sample *reverbWetRight, Bit32u outLength);
+	void process(Sample **outStream, const Sample *nonReverbLeft, const Sample *nonReverbRight, const Sample *reverbDryLeft, const Sample *reverbDryRight, const Sample *reverbWetLeft, const Sample *reverbWetRight, const Bit32u outLength);
 	unsigned int getOutputSampleRate() const;
 	Bit32u getDACStreamsLength(Bit32u outputLength) const;
 	void setSynthOutputGain(float synthGain);
@@ -55,6 +52,6 @@ private:
 	Analog(Analog &);
 };
 
-} // namespace MT32Emu
+}
 
-#endif // #ifndef MT32EMU_ANALOG_H
+#endif
diff --git a/audio/softsynth/mt32/BReverbModel.cpp b/audio/softsynth/mt32/BReverbModel.cpp
index 891678eabc..5e02db8f99 100644
--- a/audio/softsynth/mt32/BReverbModel.cpp
+++ b/audio/softsynth/mt32/BReverbModel.cpp
@@ -1,5 +1,5 @@
 /* Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Dean Beeler, Jerome Fisher
- * Copyright (C) 2011-2016 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
+ * Copyright (C) 2011, 2012, 2013, 2014 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
@@ -15,12 +15,9 @@
  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <cstddef>
-
-#include "internals.h"
-
+//#include <cstring>
+#include "mt32emu.h"
 #include "BReverbModel.h"
-#include "Synth.h"
 
 // Analysing of state of reverb RAM address lines gives exact sizes of the buffers of filters used. This also indicates that
 // the reverb model implemented in the real devices consists of three series allpass filters preceded by a non-feedback comb (or a delay with a LPF)
@@ -46,14 +43,14 @@ const BReverbSettings &BReverbModel::getCM32L_LAPCSettings(const ReverbMode mode
 	static const Bit32u MODE_0_COMBS[] = {705 + PROCESS_DELAY, 2349, 2839, 3632};
 	static const Bit32u MODE_0_OUTL[] = {2349, 141, 1960};
 	static const Bit32u MODE_0_OUTR[] = {1174, 1570, 145};
-	static const Bit8u  MODE_0_COMB_FACTOR[] = {0xA0, 0x60, 0x60, 0x60};
-	static const Bit8u  MODE_0_COMB_FEEDBACK[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	static const Bit32u MODE_0_COMB_FACTOR[] = {0xA0, 0x60, 0x60, 0x60};
+	static const Bit32u MODE_0_COMB_FEEDBACK[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 	                                              0x28, 0x48, 0x60, 0x78, 0x80, 0x88, 0x90, 0x98,
 	                                              0x28, 0x48, 0x60, 0x78, 0x80, 0x88, 0x90, 0x98,
 	                                              0x28, 0x48, 0x60, 0x78, 0x80, 0x88, 0x90, 0x98};
-	static const Bit8u  MODE_0_DRY_AMP[] = {0xA0, 0xA0, 0xA0, 0xA0, 0xB0, 0xB0, 0xB0, 0xD0};
-	static const Bit8u  MODE_0_WET_AMP[] = {0x10, 0x30, 0x50, 0x70, 0x90, 0xC0, 0xF0, 0xF0};
-	static const Bit8u  MODE_0_LPF_AMP = 0x60;
+	static const Bit32u MODE_0_DRY_AMP[] = {0xA0, 0xA0, 0xA0, 0xA0, 0xB0, 0xB0, 0xB0, 0xD0};
+	static const Bit32u MODE_0_WET_AMP[] = {0x10, 0x30, 0x50, 0x70, 0x90, 0xC0, 0xF0, 0xF0};
+	static const Bit32u MODE_0_LPF_AMP = 0x60;
 
 	static const Bit32u MODE_1_NUMBER_OF_ALLPASSES = 3;
 	static const Bit32u MODE_1_ALLPASSES[] = {1324, 809, 176};
@@ -61,14 +58,14 @@ const BReverbSettings &BReverbModel::getCM32L_LAPCSettings(const ReverbMode mode
 	static const Bit32u MODE_1_COMBS[] = {961 + PROCESS_DELAY, 2619, 3545, 4519};
 	static const Bit32u MODE_1_OUTL[] = {2618, 1760, 4518};
 	static const Bit32u MODE_1_OUTR[] = {1300, 3532, 2274};
-	static const Bit8u  MODE_1_COMB_FACTOR[] = {0x80, 0x60, 0x60, 0x60};
-	static const Bit8u  MODE_1_COMB_FEEDBACK[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	static const Bit32u MODE_1_COMB_FACTOR[] = {0x80, 0x60, 0x60, 0x60};
+	static const Bit32u MODE_1_COMB_FEEDBACK[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 	                                              0x28, 0x48, 0x60, 0x70, 0x78, 0x80, 0x90, 0x98,
 	                                              0x28, 0x48, 0x60, 0x78, 0x80, 0x88, 0x90, 0x98,
 	                                              0x28, 0x48, 0x60, 0x78, 0x80, 0x88, 0x90, 0x98};
-	static const Bit8u  MODE_1_DRY_AMP[] = {0xA0, 0xA0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xE0};
-	static const Bit8u  MODE_1_WET_AMP[] = {0x10, 0x30, 0x50, 0x70, 0x90, 0xC0, 0xF0, 0xF0};
-	static const Bit8u  MODE_1_LPF_AMP = 0x60;
+	static const Bit32u MODE_1_DRY_AMP[] = {0xA0, 0xA0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xE0};
+	static const Bit32u MODE_1_WET_AMP[] = {0x10, 0x30, 0x50, 0x70, 0x90, 0xC0, 0xF0, 0xF0};
+	static const Bit32u MODE_1_LPF_AMP = 0x60;
 
 	static const Bit32u MODE_2_NUMBER_OF_ALLPASSES = 3;
 	static const Bit32u MODE_2_ALLPASSES[] = {969, 644, 157};
@@ -76,25 +73,25 @@ const BReverbSettings &BReverbModel::getCM32L_LAPCSettings(const ReverbMode mode
 	static const Bit32u MODE_2_COMBS[] = {116 + PROCESS_DELAY, 2259, 2839, 3539};
 	static const Bit32u MODE_2_OUTL[] = {2259, 718, 1769};
 	static const Bit32u MODE_2_OUTR[] = {1136, 2128, 1};
-	static const Bit8u  MODE_2_COMB_FACTOR[] = {0, 0x20, 0x20, 0x20};
-	static const Bit8u  MODE_2_COMB_FEEDBACK[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	static const Bit32u MODE_2_COMB_FACTOR[] = {0, 0x20, 0x20, 0x20};
+	static const Bit32u MODE_2_COMB_FEEDBACK[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 	                                              0x30, 0x58, 0x78, 0x88, 0xA0, 0xB8, 0xC0, 0xD0,
 	                                              0x30, 0x58, 0x78, 0x88, 0xA0, 0xB8, 0xC0, 0xD0,
 	                                              0x30, 0x58, 0x78, 0x88, 0xA0, 0xB8, 0xC0, 0xD0};
-	static const Bit8u  MODE_2_DRY_AMP[] = {0xA0, 0xA0, 0xB0, 0xB0, 0xB0, 0xB0, 0xC0, 0xE0};
-	static const Bit8u  MODE_2_WET_AMP[] = {0x10, 0x30, 0x50, 0x70, 0x90, 0xC0, 0xF0, 0xF0};
-	static const Bit8u  MODE_2_LPF_AMP = 0x80;
+	static const Bit32u MODE_2_DRY_AMP[] = {0xA0, 0xA0, 0xB0, 0xB0, 0xB0, 0xB0, 0xC0, 0xE0};
+	static const Bit32u MODE_2_WET_AMP[] = {0x10, 0x30, 0x50, 0x70, 0x90, 0xC0, 0xF0, 0xF0};
+	static const Bit32u MODE_2_LPF_AMP = 0x80;
 
 	static const Bit32u MODE_3_NUMBER_OF_ALLPASSES = 0;
 	static const Bit32u MODE_3_NUMBER_OF_COMBS = 1;
 	static const Bit32u MODE_3_DELAY[] = {16000 + MODE_3_FEEDBACK_DELAY + PROCESS_DELAY + MODE_3_ADDITIONAL_DELAY};
 	static const Bit32u MODE_3_OUTL[] = {400, 624, 960, 1488, 2256, 3472, 5280, 8000};
 	static const Bit32u MODE_3_OUTR[] = {800, 1248, 1920, 2976, 4512, 6944, 10560, 16000};
-	static const Bit8u  MODE_3_COMB_FACTOR[] = {0x68};
-	static const Bit8u  MODE_3_COMB_FEEDBACK[] = {0x68, 0x60};
-	static const Bit8u  MODE_3_DRY_AMP[] = {0x20, 0x50, 0x50, 0x50, 0x50, 0x50, 0x50, 0x50,
+	static const Bit32u MODE_3_COMB_FACTOR[] = {0x68};
+	static const Bit32u MODE_3_COMB_FEEDBACK[] = {0x68, 0x60};
+	static const Bit32u MODE_3_DRY_AMP[] = {0x20, 0x50, 0x50, 0x50, 0x50, 0x50, 0x50, 0x50,
 	                                        0x20, 0x50, 0x50, 0x50, 0x50, 0x50, 0x50, 0x50};
-	static const Bit8u  MODE_3_WET_AMP[] = {0x18, 0x18, 0x28, 0x40, 0x60, 0x80, 0xA8, 0xF8};
+	static const Bit32u MODE_3_WET_AMP[] = {0x18, 0x18, 0x28, 0x40, 0x60, 0x80, 0xA8, 0xF8};
 
 	static const BReverbSettings REVERB_MODE_0_SETTINGS = {MODE_0_NUMBER_OF_ALLPASSES, MODE_0_ALLPASSES, MODE_0_NUMBER_OF_COMBS, MODE_0_COMBS, MODE_0_OUTL, MODE_0_OUTR, MODE_0_COMB_FACTOR, MODE_0_COMB_FEEDBACK, MODE_0_DRY_AMP, MODE_0_WET_AMP, MODE_0_LPF_AMP};
 	static const BReverbSettings REVERB_MODE_1_SETTINGS = {MODE_1_NUMBER_OF_ALLPASSES, MODE_1_ALLPASSES, MODE_1_NUMBER_OF_COMBS, MODE_1_COMBS, MODE_1_OUTL, MODE_1_OUTR, MODE_1_COMB_FACTOR, MODE_1_COMB_FEEDBACK, MODE_1_DRY_AMP, MODE_1_WET_AMP, MODE_1_LPF_AMP};
@@ -115,14 +112,14 @@ const BReverbSettings &BReverbModel::getMT32Settings(const ReverbMode mode) {
 	static const Bit32u MODE_0_COMBS[] = {575 + PROCESS_DELAY, 2040, 2752, 3629};
 	static const Bit32u MODE_0_OUTL[] = {2040, 687, 1814};
 	static const Bit32u MODE_0_OUTR[] = {1019, 2072, 1};
-	static const Bit8u  MODE_0_COMB_FACTOR[] = {0xB0, 0x60, 0x60, 0x60};
-	static const Bit8u  MODE_0_COMB_FEEDBACK[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	static const Bit32u MODE_0_COMB_FACTOR[] = {0xB0, 0x60, 0x60, 0x60};
+	static const Bit32u MODE_0_COMB_FEEDBACK[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 	                                              0x28, 0x48, 0x60, 0x70, 0x78, 0x80, 0x90, 0x98,
 	                                              0x28, 0x48, 0x60, 0x78, 0x80, 0x88, 0x90, 0x98,
 	                                              0x28, 0x48, 0x60, 0x78, 0x80, 0x88, 0x90, 0x98};
-	static const Bit8u  MODE_0_DRY_AMP[] = {0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80};
-	static const Bit8u  MODE_0_WET_AMP[] = {0x10, 0x20, 0x30, 0x40, 0x50, 0x70, 0xA0, 0xE0};
-	static const Bit8u  MODE_0_LPF_AMP = 0x80;
+	static const Bit32u MODE_0_DRY_AMP[] = {0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80};
+	static const Bit32u MODE_0_WET_AMP[] = {0x10, 0x20, 0x30, 0x40, 0x50, 0x70, 0xA0, 0xE0};
+	static const Bit32u MODE_0_LPF_AMP = 0x80;
 
 	static const Bit32u MODE_1_NUMBER_OF_ALLPASSES = 3;
 	static const Bit32u MODE_1_ALLPASSES[] = {1324, 809, 176};
@@ -130,14 +127,14 @@ const BReverbSettings &BReverbModel::getMT32Settings(const ReverbMode mode) {
 	static const Bit32u MODE_1_COMBS[] = {961 + PROCESS_DELAY, 2619, 3545, 4519};
 	static const Bit32u MODE_1_OUTL[] = {2618, 1760, 4518};
 	static const Bit32u MODE_1_OUTR[] = {1300, 3532, 2274};
-	static const Bit8u  MODE_1_COMB_FACTOR[] = {0x90, 0x60, 0x60, 0x60};
-	static const Bit8u  MODE_1_COMB_FEEDBACK[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	static const Bit32u MODE_1_COMB_FACTOR[] = {0x90, 0x60, 0x60, 0x60};
+	static const Bit32u MODE_1_COMB_FEEDBACK[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 	                                              0x28, 0x48, 0x60, 0x70, 0x78, 0x80, 0x90, 0x98,
 	                                              0x28, 0x48, 0x60, 0x78, 0x80, 0x88, 0x90, 0x98,
 	                                              0x28, 0x48, 0x60, 0x78, 0x80, 0x88, 0x90, 0x98};
-	static const Bit8u  MODE_1_DRY_AMP[] = {0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80};
-	static const Bit8u  MODE_1_WET_AMP[] = {0x10, 0x20, 0x30, 0x40, 0x50, 0x70, 0xA0, 0xE0};
-	static const Bit8u  MODE_1_LPF_AMP = 0x80;
+	static const Bit32u MODE_1_DRY_AMP[] = {0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80};
+	static const Bit32u MODE_1_WET_AMP[] = {0x10, 0x20, 0x30, 0x40, 0x50, 0x70, 0xA0, 0xE0};
+	static const Bit32u MODE_1_LPF_AMP = 0x80;
 
 	static const Bit32u MODE_2_NUMBER_OF_ALLPASSES = 3;
 	static const Bit32u MODE_2_ALLPASSES[] = {969, 644, 157};
@@ -145,25 +142,25 @@ const BReverbSettings &BReverbModel::getMT32Settings(const ReverbMode mode) {
 	static const Bit32u MODE_2_COMBS[] = {116 + PROCESS_DELAY, 2259, 2839, 3539};
 	static const Bit32u MODE_2_OUTL[] = {2259, 718, 1769};
 	static const Bit32u MODE_2_OUTR[] = {1136, 2128, 1};
-	static const Bit8u  MODE_2_COMB_FACTOR[] = {0, 0x60, 0x60, 0x60};
-	static const Bit8u  MODE_2_COMB_FEEDBACK[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	static const Bit32u MODE_2_COMB_FACTOR[] = {0, 0x60, 0x60, 0x60};
+	static const Bit32u MODE_2_COMB_FEEDBACK[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 	                                              0x28, 0x48, 0x60, 0x70, 0x78, 0x80, 0x90, 0x98,
 	                                              0x28, 0x48, 0x60, 0x78, 0x80, 0x88, 0x90, 0x98,
 	                                              0x28, 0x48, 0x60, 0x78, 0x80, 0x88, 0x90, 0x98};
-	static const Bit8u  MODE_2_DRY_AMP[] = {0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80};
-	static const Bit8u  MODE_2_WET_AMP[] = {0x10, 0x20, 0x30, 0x40, 0x50, 0x70, 0xA0, 0xE0};
-	static const Bit8u  MODE_2_LPF_AMP = 0x80;
+	static const Bit32u MODE_2_DRY_AMP[] = {0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80};
+	static const Bit32u MODE_2_WET_AMP[] = {0x10, 0x20, 0x30, 0x40, 0x50, 0x70, 0xA0, 0xE0};
+	static const Bit32u MODE_2_LPF_AMP = 0x80;
 
 	static const Bit32u MODE_3_NUMBER_OF_ALLPASSES = 0;
 	static const Bit32u MODE_3_NUMBER_OF_COMBS = 1;
 	static const Bit32u MODE_3_DELAY[] = {16000 + MODE_3_FEEDBACK_DELAY + PROCESS_DELAY + MODE_3_ADDITIONAL_DELAY};
 	static const Bit32u MODE_3_OUTL[] = {400, 624, 960, 1488, 2256, 3472, 5280, 8000};
 	static const Bit32u MODE_3_OUTR[] = {800, 1248, 1920, 2976, 4512, 6944, 10560, 16000};
-	static const Bit8u  MODE_3_COMB_FACTOR[] = {0x68};
-	static const Bit8u  MODE_3_COMB_FEEDBACK[] = {0x68, 0x60};
-	static const Bit8u  MODE_3_DRY_AMP[] = {0x10, 0x10, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+	static const Bit32u MODE_3_COMB_FACTOR[] = {0x68};
+	static const Bit32u MODE_3_COMB_FEEDBACK[] = {0x68, 0x60};
+	static const Bit32u MODE_3_DRY_AMP[] = {0x10, 0x10, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 	                                        0x10, 0x20, 0x20, 0x10, 0x20, 0x10, 0x20, 0x10};
-	static const Bit8u  MODE_3_WET_AMP[] = {0x08, 0x18, 0x28, 0x40, 0x60, 0x80, 0xA8, 0xF8};
+	static const Bit32u MODE_3_WET_AMP[] = {0x08, 0x18, 0x28, 0x40, 0x60, 0x80, 0xA8, 0xF8};
 
 	static const BReverbSettings REVERB_MODE_0_SETTINGS = {MODE_0_NUMBER_OF_ALLPASSES, MODE_0_ALLPASSES, MODE_0_NUMBER_OF_COMBS, MODE_0_COMBS, MODE_0_OUTL, MODE_0_OUTR, MODE_0_COMB_FACTOR, MODE_0_COMB_FEEDBACK, MODE_0_DRY_AMP, MODE_0_WET_AMP, MODE_0_LPF_AMP};
 	static const BReverbSettings REVERB_MODE_1_SETTINGS = {MODE_1_NUMBER_OF_ALLPASSES, MODE_1_ALLPASSES, MODE_1_NUMBER_OF_COMBS, MODE_1_COMBS, MODE_1_OUTL, MODE_1_OUTR, MODE_1_COMB_FACTOR, MODE_1_COMB_FEEDBACK, MODE_1_DRY_AMP, MODE_1_WET_AMP, MODE_1_LPF_AMP};
@@ -255,7 +252,7 @@ Sample AllpassFilter::process(const Sample in) {
 #endif
 }
 
-CombFilter::CombFilter(const Bit32u useSize, const Bit8u useFilterFactor) : RingBuffer(useSize), filterFactor(useFilterFactor) {}
+CombFilter::CombFilter(const Bit32u useSize, const Bit32u useFilterFactor) : RingBuffer(useSize), filterFactor(useFilterFactor) {}
 
 void CombFilter::process(const Sample in) {
 	// This model corresponds to the comb filter implementation of the real CM-32L device
@@ -274,11 +271,11 @@ Sample CombFilter::getOutputAt(const Bit32u outIndex) const {
 	return buffer[(size + index - outIndex) % size];
 }
 
-void CombFilter::setFeedbackFactor(const Bit8u useFeedbackFactor) {
+void CombFilter::setFeedbackFactor(const Bit32u useFeedbackFactor) {
 	feedbackFactor = useFeedbackFactor;
 }
 
-DelayWithLowPassFilter::DelayWithLowPassFilter(const Bit32u useSize, const Bit8u useFilterFactor, const Bit8u useAmp)
+DelayWithLowPassFilter::DelayWithLowPassFilter(const Bit32u useSize, const Bit32u useFilterFactor, const Bit32u useAmp)
 	: CombFilter(useSize, useFilterFactor), amp(useAmp) {}
 
 void DelayWithLowPassFilter::process(const Sample in) {
@@ -295,7 +292,7 @@ void DelayWithLowPassFilter::process(const Sample in) {
 	buffer[index] = weirdMul(lpfOut, amp, 0xFF);
 }
 
-TapDelayCombFilter::TapDelayCombFilter(const Bit32u useSize, const Bit8u useFilterFactor) : CombFilter(useSize, useFilterFactor) {}
+TapDelayCombFilter::TapDelayCombFilter(const Bit32u useSize, const Bit32u useFilterFactor) : CombFilter(useSize, useFilterFactor) {}
 
 void TapDelayCombFilter::process(const Sample in) {
 	// the previously stored value
@@ -433,7 +430,7 @@ bool BReverbModel::isMT32Compatible(const ReverbMode mode) const {
 	return &currentSettings == &getMT32Settings(mode);
 }
 
-void BReverbModel::process(const Sample *inLeft, const Sample *inRight, Sample *outLeft, Sample *outRight, Bit32u numSamples) {
+void BReverbModel::process(const Sample *inLeft, const Sample *inRight, Sample *outLeft, Sample *outRight, unsigned long numSamples) {
 	if (combs == NULL) {
 		Synth::muteSampleBuffer(outLeft, numSamples);
 		Synth::muteSampleBuffer(outRight, numSamples);
@@ -528,4 +525,4 @@ void BReverbModel::process(const Sample *inLeft, const Sample *inRight, Sample *
 	}
 }
 
-} // namespace MT32Emu
+}
diff --git a/audio/softsynth/mt32/BReverbModel.h b/audio/softsynth/mt32/BReverbModel.h
index 8cfc5da8a3..764daf1a9e 100644
--- a/audio/softsynth/mt32/BReverbModel.h
+++ b/audio/softsynth/mt32/BReverbModel.h
@@ -1,5 +1,5 @@
 /* Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Dean Beeler, Jerome Fisher
- * Copyright (C) 2011-2016 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
+ * Copyright (C) 2011, 2012, 2013, 2014 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
@@ -18,10 +18,6 @@
 #ifndef MT32EMU_B_REVERB_MODEL_H
 #define MT32EMU_B_REVERB_MODEL_H
 
-#include "globals.h"
-#include "internals.h"
-#include "Types.h"
-
 namespace MT32Emu {
 
 struct BReverbSettings {
@@ -31,11 +27,11 @@ struct BReverbSettings {
 	const Bit32u * const combSizes;
 	const Bit32u * const outLPositions;
 	const Bit32u * const outRPositions;
-	const Bit8u * const filterFactors;
-	const Bit8u * const feedbackFactors;
-	const Bit8u * const dryAmps;
-	const Bit8u * const wetLevels;
-	const Bit8u lpfAmp;
+	const Bit32u * const filterFactors;
+	const Bit32u * const feedbackFactors;
+	const Bit32u * const dryAmps;
+	const Bit32u * const wetLevels;
+	const Bit32u lpfAmp;
 };
 
 class RingBuffer {
@@ -60,23 +56,23 @@ public:
 
 class CombFilter : public RingBuffer {
 protected:
-	const Bit8u filterFactor;
-	Bit8u feedbackFactor;
+	const Bit32u filterFactor;
+	Bit32u feedbackFactor;
 
 public:
-	CombFilter(const Bit32u size, const Bit8u useFilterFactor);
+	CombFilter(const Bit32u size, const Bit32u useFilterFactor);
 	virtual void process(const Sample in);
 	Sample getOutputAt(const Bit32u outIndex) const;
-	void setFeedbackFactor(const Bit8u useFeedbackFactor);
+	void setFeedbackFactor(const Bit32u useFeedbackFactor);
 };
 
 class DelayWithLowPassFilter : public CombFilter {
-	Bit8u amp;
+	Bit32u amp;
 
 public:
-	DelayWithLowPassFilter(const Bit32u useSize, const Bit8u useFilterFactor, const Bit8u useAmp);
+	DelayWithLowPassFilter(const Bit32u useSize, const Bit32u useFilterFactor, const Bit32u useAmp);
 	void process(const Sample in);
-	void setFeedbackFactor(const Bit8u) {}
+	void setFeedbackFactor(const Bit32u) {}
 };
 
 class TapDelayCombFilter : public CombFilter {
@@ -84,7 +80,7 @@ class TapDelayCombFilter : public CombFilter {
 	Bit32u outR;
 
 public:
-	TapDelayCombFilter(const Bit32u useSize, const Bit8u useFilterFactor);
+	TapDelayCombFilter(const Bit32u useSize, const Bit32u useFilterFactor);
 	void process(const Sample in);
 	Sample getLeftOutput() const;
 	Sample getRightOutput() const;
@@ -97,8 +93,8 @@ class BReverbModel {
 
 	const BReverbSettings &currentSettings;
 	const bool tapDelayMode;
-	Bit8u dryAmp;
-	Bit8u wetLevel;
+	Bit32u dryAmp;
+	Bit32u wetLevel;
 
 	static const BReverbSettings &getCM32L_LAPCSettings(const ReverbMode mode);
 	static const BReverbSettings &getMT32Settings(const ReverbMode mode);
@@ -112,11 +108,11 @@ public:
 	void close();
 	void mute();
 	void setParameters(Bit8u time, Bit8u level);
-	void process(const Sample *inLeft, const Sample *inRight, Sample *outLeft, Sample *outRight, Bit32u numSamples);
+	void process(const Sample *inLeft, const Sample *inRight, Sample *outLeft, Sample *outRight, unsigned long numSamples);
 	bool isActive() const;
 	bool isMT32Compatible(const ReverbMode mode) const;
 };
 
-} // namespace MT32Emu
+}
 
-#endif // #ifndef MT32EMU_B_REVERB_MODEL_H
+#endif
diff --git a/audio/softsynth/mt32/Enumerations.h b/audio/softsynth/mt32/Enumerations.h
deleted file mode 100644
index 9b0a35d0bf..0000000000
--- a/audio/softsynth/mt32/Enumerations.h
+++ /dev/null
@@ -1,155 +0,0 @@
-/* Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Dean Beeler, Jerome Fisher
- * Copyright (C) 2011-2016 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
- *
- *  This program is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU Lesser General Public License as published by
- *  the Free Software Foundation, either version 2.1 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU Lesser General Public License for more details.
- *
- *  You should have received a copy of the GNU Lesser General Public License
- *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/* Using two guards since this file may be included twice with different MT32EMU_C_ENUMERATIONS define. */
-
-#if (!defined MT32EMU_CPP_ENUMERATIONS_H && !defined MT32EMU_C_ENUMERATIONS) || (!defined MT32EMU_C_ENUMERATIONS_H && defined MT32EMU_C_ENUMERATIONS)
-
-#ifdef MT32EMU_C_ENUMERATIONS
-
-#define MT32EMU_C_ENUMERATIONS_H
-
-#define MT32EMU_DAC_INPUT_MODE_NAME mt32emu_dac_input_mode
-#define MT32EMU_DAC_INPUT_MODE(ident) MT32EMU_DAC_##ident
-
-#define MT32EMU_MIDI_DELAY_MODE_NAME mt32emu_midi_delay_mode
-#define MT32EMU_MIDI_DELAY_MODE(ident) MT32EMU_MDM_##ident
-
-#define MT32EMU_ANALOG_OUTPUT_MODE_NAME mt32emu_analog_output_mode
-#define MT32EMU_ANALOG_OUTPUT_MODE(ident) MT32EMU_AOM_##ident
-
-#define MT32EMU_PARTIAL_STATE_NAME mt32emu_partial_state
-#define MT32EMU_PARTIAL_STATE(ident) MT32EMU_PS_##ident
-
-#else /* #ifdef MT32EMU_C_ENUMERATIONS */
-
-#define MT32EMU_CPP_ENUMERATIONS_H
-
-#define MT32EMU_DAC_INPUT_MODE_NAME DACInputMode
-#define MT32EMU_DAC_INPUT_MODE(ident) DACInputMode_##ident
-
-#define MT32EMU_MIDI_DELAY_MODE_NAME MIDIDelayMode
-#define MT32EMU_MIDI_DELAY_MODE(ident) MIDIDelayMode_##ident
-
-#define MT32EMU_ANALOG_OUTPUT_MODE_NAME AnalogOutputMode
-#define MT32EMU_ANALOG_OUTPUT_MODE(ident) AnalogOutputMode_##ident
-
-#define MT32EMU_PARTIAL_STATE_NAME PartialState
-#define MT32EMU_PARTIAL_STATE(ident) PartialState_##ident
-
-namespace MT32Emu {
-
-#endif /* #ifdef MT32EMU_C_ENUMERATIONS */
-
-/**
- * Methods for emulating the connection between the LA32 and the DAC, which involves
- * some hacks in the real devices for doubling the volume.
- * See also http://en.wikipedia.org/wiki/Roland_MT-32#Digital_overflow
- */
-enum MT32EMU_DAC_INPUT_MODE_NAME {
-	/**
-	 * Produces samples at double the volume, without tricks.
-	 * Nicer overdrive characteristics than the DAC hacks (it simply clips samples within range)
-	 * Higher quality than the real devices
-	 */
-	MT32EMU_DAC_INPUT_MODE(NICE),
-
-	/**
-	 * Produces samples that exactly match the bits output from the emulated LA32.
-	 * Nicer overdrive characteristics than the DAC hacks (it simply clips samples within range)
-	 * Much less likely to overdrive than any other mode.
-	 * Half the volume of any of the other modes.
-	 * Output gain is ignored for both LA32 and reverb output.
-	 * Perfect for developers while debugging :)
-	 */
-	MT32EMU_DAC_INPUT_MODE(PURE),
-
-	/**
-	 * Re-orders the LA32 output bits as in early generation MT-32s (according to Wikipedia).
-	 * Bit order at DAC (where each number represents the original LA32 output bit number, and XX means the bit is always low):
-	 * 15 13 12 11 10 09 08 07 06 05 04 03 02 01 00 XX
-	 */
-	MT32EMU_DAC_INPUT_MODE(GENERATION1),
-
-	/**
-	 * Re-orders the LA32 output bits as in later generations (personally confirmed on my CM-32L - KG).
-	 * Bit order at DAC (where each number represents the original LA32 output bit number):
-	 * 15 13 12 11 10 09 08 07 06 05 04 03 02 01 00 14
-	 */
-	MT32EMU_DAC_INPUT_MODE(GENERATION2)
-};
-
-/** Methods for emulating the effective delay of incoming MIDI messages introduced by a MIDI interface. */
-enum MT32EMU_MIDI_DELAY_MODE_NAME {
-	/** Process incoming MIDI events immediately. */
-	MT32EMU_MIDI_DELAY_MODE(IMMEDIATE),
-
-	/**
-	 * Delay incoming short MIDI messages as if they where transferred via a MIDI cable to a real hardware unit and immediate sysex processing.
-	 * This ensures more accurate timing of simultaneous NoteOn messages.
-	 */
-	MT32EMU_MIDI_DELAY_MODE(DELAY_SHORT_MESSAGES_ONLY),
-
-	/** Delay all incoming MIDI events as if they where transferred via a MIDI cable to a real hardware unit.*/
-	MT32EMU_MIDI_DELAY_MODE(DELAY_ALL)
-};
-
-/** Methods for emulating the effects of analogue circuits of real hardware units on the output signal. */
-enum MT32EMU_ANALOG_OUTPUT_MODE_NAME {
-	/** Only digital path is emulated. The output samples correspond to the digital signal at the DAC entrance. */
-	MT32EMU_ANALOG_OUTPUT_MODE(DIGITAL_ONLY),
-	/** Coarse emulation of LPF circuit. High frequencies are boosted, sample rate remains unchanged. */
-	MT32EMU_ANALOG_OUTPUT_MODE(COARSE),
-	/**
-	 * Finer emulation of LPF circuit. Output signal is upsampled to 48 kHz to allow emulation of audible mirror spectra above 16 kHz,
-	 * which is passed through the LPF circuit without significant attenuation.
-	 */
-	MT32EMU_ANALOG_OUTPUT_MODE(ACCURATE),
-	/**
-	 * Same as AnalogOutputMode_ACCURATE mode but the output signal is 2x oversampled, i.e. the output sample rate is 96 kHz.
-	 * This makes subsequent resampling easier. Besides, due to nonlinear passband of the LPF emulated, it takes fewer number of MACs
-	 * compared to a regular LPF FIR implementations.
-	 */
-	MT32EMU_ANALOG_OUTPUT_MODE(OVERSAMPLED)
-};
-
-enum MT32EMU_PARTIAL_STATE_NAME {
-	MT32EMU_PARTIAL_STATE(INACTIVE),
-	MT32EMU_PARTIAL_STATE(ATTACK),
-	MT32EMU_PARTIAL_STATE(SUSTAIN),
-	MT32EMU_PARTIAL_STATE(RELEASE)
-};
-
-#ifndef MT32EMU_C_ENUMERATIONS
-
-} // namespace MT32Emu
-
-#endif
-
-#undef MT32EMU_DAC_INPUT_MODE_NAME
-#undef MT32EMU_DAC_INPUT_MODE
-
-#undef MT32EMU_MIDI_DELAY_MODE_NAME
-#undef MT32EMU_MIDI_DELAY_MODE
-
-#undef MT32EMU_ANALOG_OUTPUT_MODE_NAME
-#undef MT32EMU_ANALOG_OUTPUT_MODE
-
-#undef MT32EMU_PARTIAL_STATE_NAME
-#undef MT32EMU_PARTIAL_STATE
-
-#endif /* #if (!defined MT32EMU_CPP_ENUMERATIONS_H && !defined MT32EMU_C_ENUMERATIONS) || (!defined MT32EMU_C_ENUMERATIONS_H && defined MT32EMU_C_ENUMERATIONS) */
diff --git a/audio/softsynth/mt32/File.cpp b/audio/softsynth/mt32/File.cpp
deleted file mode 100644
index 643019d0c2..0000000000
--- a/audio/softsynth/mt32/File.cpp
+++ /dev/null
@@ -1,73 +0,0 @@
-/* Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Dean Beeler, Jerome Fisher
- * Copyright (C) 2011-2016 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
- *
- *  This program is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU Lesser General Public License as published by
- *  the Free Software Foundation, either version 2.1 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU Lesser General Public License for more details.
- *
- *  You should have received a copy of the GNU Lesser General Public License
- *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include <cstring>
-
-#include "internals.h"
-
-#include "File.h"
-#include "sha1/sha1.h"
-
-namespace MT32Emu {
-
-AbstractFile::AbstractFile() : sha1DigestCalculated(false), reserved(NULL) {
-	sha1Digest[0] = 0;
-}
-
-AbstractFile::AbstractFile(const SHA1Digest &useSHA1Digest) : sha1DigestCalculated(true), reserved(NULL) {
-	memcpy(sha1Digest, useSHA1Digest, sizeof(SHA1Digest) - 1);
-	sha1Digest[sizeof(SHA1Digest) - 1] = 0; // Ensure terminator char.
-}
-
-const File::SHA1Digest &AbstractFile::getSHA1() {
-	if (sha1DigestCalculated) {
-		return sha1Digest;
-	}
-	sha1DigestCalculated = true;
-
-	size_t size = getSize();
-	if (size == 0) {
-		return sha1Digest;
-	}
-
-	const Bit8u *data = getData();
-	if (data == NULL) {
-		return sha1Digest;
-	}
-
-	unsigned char fileDigest[20];
-
-	sha1::calc(data, (int)size, fileDigest);
-	sha1::toHexString(fileDigest, sha1Digest);
-	return sha1Digest;
-}
-
-ArrayFile::ArrayFile(const Bit8u *useData, size_t useSize) : data(useData), size(useSize)
-{}
-
-ArrayFile::ArrayFile(const Bit8u *useData, size_t useSize, const SHA1Digest &useSHA1Digest) : AbstractFile(useSHA1Digest), data(useData), size(useSize)
-{}
-
-size_t ArrayFile::getSize() {
-	return size;
-}
-
-const Bit8u *ArrayFile::getData() {
-	return data;
-}
-
-} // namespace MT32Emu
diff --git a/audio/softsynth/mt32/File.h b/audio/softsynth/mt32/File.h
deleted file mode 100644
index c9a7d582b4..0000000000
--- a/audio/softsynth/mt32/File.h
+++ /dev/null
@@ -1,73 +0,0 @@
-/* Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Dean Beeler, Jerome Fisher
- * Copyright (C) 2011-2016 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
- *
- *  This program is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU Lesser General Public License as published by
- *  the Free Software Foundation, either version 2.1 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU Lesser General Public License for more details.
- *
- *  You should have received a copy of the GNU Lesser General Public License
- *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef MT32EMU_FILE_H
-#define MT32EMU_FILE_H
-
-#include <cstddef>
-
-#include "globals.h"
-#include "Types.h"
-
-namespace MT32Emu {
-
-class MT32EMU_EXPORT File {
-public:
-	// Includes terminator char.
-	typedef char SHA1Digest[41];
-
-	virtual ~File() {}
-	virtual size_t getSize() = 0;
-	virtual const Bit8u *getData() = 0;
-	virtual const SHA1Digest &getSHA1() = 0;
-
-	virtual void close() = 0;
-};
-
-class MT32EMU_EXPORT AbstractFile : public File {
-public:
-	const SHA1Digest &getSHA1();
-
-protected:
-	AbstractFile();
-	AbstractFile(const SHA1Digest &sha1Digest);
-
-private:
-	bool sha1DigestCalculated;
-	SHA1Digest sha1Digest;
-
-	// Binary compatibility helper.
-	void *reserved;
-};
-
-class MT32EMU_EXPORT ArrayFile : public AbstractFile {
-public:
-	ArrayFile(const Bit8u *data, size_t size);
-	ArrayFile(const Bit8u *data, size_t size, const SHA1Digest &sha1Digest);
-
-	size_t getSize();
-	const Bit8u *getData();
-	void close() {}
-
-private:
-	const Bit8u *data;
-	size_t size;
-};
-
-} // namespace MT32Emu
-
-#endif // #ifndef MT32EMU_FILE_H
diff --git a/audio/softsynth/mt32/FileStream.cpp b/audio/softsynth/mt32/FileStream.cpp
deleted file mode 100644
index 0ed38dfebc..0000000000
--- a/audio/softsynth/mt32/FileStream.cpp
+++ /dev/null
@@ -1,83 +0,0 @@
-/* Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Dean Beeler, Jerome Fisher
- * Copyright (C) 2011-2016 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
- *
- *  This program is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU Lesser General Public License as published by
- *  the Free Software Foundation, either version 2.1 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU Lesser General Public License for more details.
- *
- *  You should have received a copy of the GNU Lesser General Public License
- *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "internals.h"
-
-#include "FileStream.h"
-
-namespace MT32Emu {
-
-using std::ios_base;
-
-FileStream::FileStream() : ifsp(*new std::ifstream), data(NULL), size(0)
-{}
-
-FileStream::~FileStream() {
-	// destructor closes ifsp
-	delete &ifsp;
-	delete[] data;
-}
-
-size_t FileStream::getSize() {
-	if (size != 0) {
-		return size;
-	}
-	if (!ifsp.is_open()) {
-		return 0;
-	}
-	ifsp.seekg(0, ios_base::end);
-	size = (size_t)ifsp.tellg();
-	return size;
-}
-
-const Bit8u *FileStream::getData() {
-	if (data != NULL) {
-		return data;
-	}
-	if (!ifsp.is_open()) {
-		return NULL;
-	}
-	if (getSize() == 0) {
-		return NULL;
-	}
-	Bit8u *fileData = new Bit8u[size];
-	if (fileData == NULL) {
-		return NULL;
-	}
-	ifsp.seekg(0);
-	ifsp.read((char *)fileData, (std::streamsize)size);
-	if ((size_t)ifsp.tellg() != size) {
-		delete[] fileData;
-		return NULL;
-	}
-	data = fileData;
-	close();
-	return data;
-}
-
-bool FileStream::open(const char *filename) {
-	ifsp.clear();
-	ifsp.open(filename, ios_base::in | ios_base::binary);
-	return !ifsp.fail();
-}
-
-void FileStream::close() {
-	ifsp.close();
-	ifsp.clear();
-}
-
-} // namespace MT32Emu
diff --git a/audio/softsynth/mt32/FileStream.h b/audio/softsynth/mt32/FileStream.h
deleted file mode 100644
index 2de6e801ff..0000000000
--- a/audio/softsynth/mt32/FileStream.h
+++ /dev/null
@@ -1,46 +0,0 @@
-/* Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Dean Beeler, Jerome Fisher
- * Copyright (C) 2011-2016 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
- *
- *  This program is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU Lesser General Public License as published by
- *  the Free Software Foundation, either version 2.1 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU Lesser General Public License for more details.
- *
- *  You should have received a copy of the GNU Lesser General Public License
- *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef MT32EMU_FILE_STREAM_H
-#define MT32EMU_FILE_STREAM_H
-
-#include <fstream>
-
-#include "globals.h"
-#include "Types.h"
-#include "File.h"
-
-namespace MT32Emu {
-
-class FileStream : public AbstractFile {
-public:
-	MT32EMU_EXPORT FileStream();
-	MT32EMU_EXPORT ~FileStream();
-	MT32EMU_EXPORT size_t getSize();
-	MT32EMU_EXPORT const Bit8u *getData();
-	MT32EMU_EXPORT bool open(const char *filename);
-	MT32EMU_EXPORT void close();
-
-private:
-	std::ifstream &ifsp;
-	const Bit8u *data;
-	size_t size;
-};
-
-} // namespace MT32Emu
-
-#endif // #ifndef MT32EMU_FILE_STREAM_H
diff --git a/audio/softsynth/mt32/LA32FloatWaveGenerator.cpp b/audio/softsynth/mt32/LA32FloatWaveGenerator.cpp
index 824204e81b..42d820ebad 100644
--- a/audio/softsynth/mt32/LA32FloatWaveGenerator.cpp
+++ b/audio/softsynth/mt32/LA32FloatWaveGenerator.cpp
@@ -1,5 +1,5 @@
 /* Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Dean Beeler, Jerome Fisher
- * Copyright (C) 2011-2016 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
+ * Copyright (C) 2011, 2012, 2013, 2014 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
@@ -15,11 +15,10 @@
  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef MT32EMU_LA32_WAVE_GENERATOR_CPP
-#error This file should be included from LA32WaveGenerator.cpp only.
-#endif
-
+//#include <cmath>
+#include "mt32emu.h"
 #include "mmath.h"
+#include "internals.h"
 
 namespace MT32Emu {
 
@@ -39,10 +38,10 @@ float LA32WaveGenerator::getPCMSample(unsigned int position) {
 	return ((pcmSample & 32768) == 0) ? sampleValue : -sampleValue;
 }
 
-void LA32WaveGenerator::initSynth(const bool useSawtoothWaveform, const Bit8u usePulseWidth, const Bit8u useResonance) {
-	sawtoothWaveform = useSawtoothWaveform;
-	pulseWidth = usePulseWidth;
-	resonance = useResonance;
+void LA32WaveGenerator::initSynth(const bool sawtoothWaveform, const Bit8u pulseWidth, const Bit8u resonance) {
+	this->sawtoothWaveform = sawtoothWaveform;
+	this->pulseWidth = pulseWidth;
+	this->resonance = resonance;
 
 	wavePos = 0.0f;
 	lastFreq = 0.0f;
@@ -51,24 +50,24 @@ void LA32WaveGenerator::initSynth(const bool useSawtoothWaveform, const Bit8u us
 	active = true;
 }
 
-void LA32WaveGenerator::initPCM(const Bit16s * const usePCMWaveAddress, const Bit32u usePCMWaveLength, const bool usePCMWaveLooped, const bool usePCMWaveInterpolated) {
-	pcmWaveAddress = usePCMWaveAddress;
-	pcmWaveLength = usePCMWaveLength;
-	pcmWaveLooped = usePCMWaveLooped;
-	pcmWaveInterpolated = usePCMWaveInterpolated;
+void LA32WaveGenerator::initPCM(const Bit16s * const pcmWaveAddress, const Bit32u pcmWaveLength, const bool pcmWaveLooped, const bool pcmWaveInterpolated) {
+	this->pcmWaveAddress = pcmWaveAddress;
+	this->pcmWaveLength = pcmWaveLength;
+	this->pcmWaveLooped = pcmWaveLooped;
+	this->pcmWaveInterpolated = pcmWaveInterpolated;
 
 	pcmPosition = 0.0f;
 	active = true;
 }
 
-// ampVal - Logarithmic amp of the wave generator
-// pitch - Logarithmic frequency of the resulting wave
-// cutoffRampVal - Composed of the base cutoff in range [78..178] left-shifted by 18 bits and the TVF modifier
 float LA32WaveGenerator::generateNextSample(const Bit32u ampVal, const Bit16u pitch, const Bit32u cutoffRampVal) {
 	if (!active) {
 		return 0.0f;
 	}
 
+	this->amp = amp;
+	this->pitch = pitch;
+
 	float sample = 0.0f;
 
 	// SEMI-CONFIRMED: From sample analysis:
@@ -285,9 +284,9 @@ bool LA32WaveGenerator::isPCMWave() const {
 	return pcmWaveAddress != NULL;
 }
 
-void LA32PartialPair::init(const bool useRingModulated, const bool useMixed) {
-	ringModulated = useRingModulated;
-	mixed = useMixed;
+void LA32PartialPair::init(const bool ringModulated, const bool mixed) {
+	this->ringModulated = ringModulated;
+	this->mixed = mixed;
 	masterOutputSample = 0.0f;
 	slaveOutputSample = 0.0f;
 }
@@ -355,4 +354,4 @@ bool LA32PartialPair::isActive(const PairType useMaster) const {
 	return useMaster == MASTER ? master.isActive() : slave.isActive();
 }
 
-} // namespace MT32Emu
+}
diff --git a/audio/softsynth/mt32/LA32FloatWaveGenerator.h b/audio/softsynth/mt32/LA32FloatWaveGenerator.h
index 89b6fe479a..329e5de258 100644
--- a/audio/softsynth/mt32/LA32FloatWaveGenerator.h
+++ b/audio/softsynth/mt32/LA32FloatWaveGenerator.h
@@ -1,5 +1,5 @@
 /* Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Dean Beeler, Jerome Fisher
- * Copyright (C) 2011-2016 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
+ * Copyright (C) 2011, 2012, 2013, 2014 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
@@ -16,15 +16,14 @@
  */
 
 #ifndef MT32EMU_LA32_WAVE_GENERATOR_H
-#error This file should be included from LA32WaveGenerator.h only.
-#endif
+#define MT32EMU_LA32_WAVE_GENERATOR_H
 
 namespace MT32Emu {
 
 /**
  * LA32WaveGenerator is aimed to represent the exact model of LA32 wave generator.
  * The output square wave is created by adding high / low linear segments in-between
- * the rising and falling cosine segments. Basically, it's very similar to the phase distortion synthesis.
+ * the rising and falling cosine segments. Basically, it’s very similar to the phase distortion synthesis.
  * Behaviour of a true resonance filter is emulated by adding decaying sine wave.
  * The beginning and the ending of the resonant sine is multiplied by a cosine window.
  * To synthesise sawtooth waves, the resulting square wave is multiplied by synchronous cosine wave.
@@ -39,6 +38,12 @@ class LA32WaveGenerator {
 	// True means the resulting square wave is to be multiplied by the synchronous cosine
 	bool sawtoothWaveform;
 
+	// Logarithmic amp of the wave generator
+	Bit32u amp;
+
+	// Logarithmic frequency of the resulting wave
+	Bit16u pitch;
+
 	// Values in range [1..31]
 	// Value 1 correspong to the minimum resonance
 	Bit8u resonance;
@@ -48,6 +53,9 @@ class LA32WaveGenerator {
 	// Value 255 corresponds to the maximum possible asymmetric of the resulting wave
 	Bit8u pulseWidth;
 
+	// Composed of the base cutoff in range [78..178] left-shifted by 18 bits and the TVF modifier
+	Bit32u cutoffVal;
+
 	// Logarithmic PCM sample start address
 	const Bit16s *pcmWaveAddress;
 
@@ -88,7 +96,7 @@ public:
 
 	// Return true if the WG engine generates PCM wave samples
 	bool isPCMWave() const;
-}; // class LA32WaveGenerator
+};
 
 // LA32PartialPair contains a structure of two partials being mixed / ring modulated
 class LA32PartialPair {
@@ -127,6 +135,8 @@ public:
 
 	// Return active state of the WG engine
 	bool isActive(const PairType master) const;
-}; // class LA32PartialPair
+};
 
 } // namespace MT32Emu
+
+#endif // #ifndef MT32EMU_LA32_WAVE_GENERATOR_H
diff --git a/audio/softsynth/mt32/LA32Ramp.cpp b/audio/softsynth/mt32/LA32Ramp.cpp
index a4da4f57a8..2b31a330d2 100644
--- a/audio/softsynth/mt32/LA32Ramp.cpp
+++ b/audio/softsynth/mt32/LA32Ramp.cpp
@@ -1,5 +1,5 @@
 /* Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Dean Beeler, Jerome Fisher
- * Copyright (C) 2011-2016 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
+ * Copyright (C) 2011, 2012, 2013, 2014 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
@@ -47,12 +47,12 @@ We haven't fully explored:
  - Values when ramping between levels (though this is probably correct).
  - Transition timing (may not be 100% accurate, especially for very fast ramps).
 */
+//#include <cmath>
 
+#include "mt32emu.h"
+#include "mmath.h"
 #include "internals.h"
 
-#include "LA32Ramp.h"
-#include "Tables.h"
-
 namespace MT32Emu {
 
 // SEMI-CONFIRMED from sample analysis.
@@ -152,4 +152,4 @@ void LA32Ramp::reset() {
 	interruptRaised = false;
 }
 
-} // namespace MT32Emu
+}
diff --git a/audio/softsynth/mt32/LA32Ramp.h b/audio/softsynth/mt32/LA32Ramp.h
index 5e4ddf720e..796b4d1eec 100644
--- a/audio/softsynth/mt32/LA32Ramp.h
+++ b/audio/softsynth/mt32/LA32Ramp.h
@@ -1,5 +1,5 @@
 /* Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Dean Beeler, Jerome Fisher
- * Copyright (C) 2011-2016 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
+ * Copyright (C) 2011, 2012, 2013, 2014 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
@@ -18,9 +18,6 @@
 #ifndef MT32EMU_LA32RAMP_H
 #define MT32EMU_LA32RAMP_H
 
-#include "globals.h"
-#include "Types.h"
-
 namespace MT32Emu {
 
 class LA32Ramp {
@@ -41,6 +38,6 @@ public:
 	void reset();
 };
 
-} // namespace MT32Emu
+}
 
-#endif // #ifndef MT32EMU_LA32RAMP_H
+#endif /* TVA_H_ */
diff --git a/audio/softsynth/mt32/LA32WaveGenerator.cpp b/audio/softsynth/mt32/LA32WaveGenerator.cpp
index 6a8a5b3998..765f75fa61 100644
--- a/audio/softsynth/mt32/LA32WaveGenerator.cpp
+++ b/audio/softsynth/mt32/LA32WaveGenerator.cpp
@@ -1,5 +1,5 @@
 /* Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Dean Beeler, Jerome Fisher
- * Copyright (C) 2011-2016 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
+ * Copyright (C) 2011, 2012, 2013, 2014 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
@@ -15,19 +15,15 @@
  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <cstddef>
-
-#include "internals.h"
-
-#include "LA32WaveGenerator.h"
-#include "Tables.h"
-
 #if MT32EMU_USE_FLOAT_SAMPLES
-#define MT32EMU_LA32_WAVE_GENERATOR_CPP
 #include "LA32FloatWaveGenerator.cpp"
-#undef MT32EMU_LA32_WAVE_GENERATOR_CPP
 #else
 
+//#include <cmath>
+#include "mt32emu.h"
+#include "mmath.h"
+#include "internals.h"
+
 namespace MT32Emu {
 
 static const Bit32u SINE_SEGMENT_RELATIVE_LENGTH = 1 << 18;
@@ -427,6 +423,6 @@ bool LA32PartialPair::isActive(const PairType useMaster) const {
 	return useMaster == MASTER ? master.isActive() : slave.isActive();
 }
 
-} // namespace MT32Emu
+}
 
 #endif // #if MT32EMU_USE_FLOAT_SAMPLES
diff --git a/audio/softsynth/mt32/LA32WaveGenerator.h b/audio/softsynth/mt32/LA32WaveGenerator.h
index e60c9d75a7..212abe2b19 100644
--- a/audio/softsynth/mt32/LA32WaveGenerator.h
+++ b/audio/softsynth/mt32/LA32WaveGenerator.h
@@ -1,5 +1,5 @@
 /* Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Dean Beeler, Jerome Fisher
- * Copyright (C) 2011-2016 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
+ * Copyright (C) 2011, 2012, 2013, 2014 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
@@ -15,17 +15,13 @@
  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef MT32EMU_LA32_WAVE_GENERATOR_H
-#define MT32EMU_LA32_WAVE_GENERATOR_H
-
-#include "globals.h"
-#include "internals.h"
-#include "Types.h"
-
 #if MT32EMU_USE_FLOAT_SAMPLES
 #include "LA32FloatWaveGenerator.h"
 #else
 
+#ifndef MT32EMU_LA32_WAVE_GENERATOR_H
+#define MT32EMU_LA32_WAVE_GENERATOR_H
+
 namespace MT32Emu {
 
 /**
@@ -59,7 +55,7 @@ public:
 /**
  * LA32WaveGenerator is aimed to represent the exact model of LA32 wave generator.
  * The output square wave is created by adding high / low linear segments in-between
- * the rising and falling cosine segments. Basically, it's very similar to the phase distortion synthesis.
+ * the rising and falling cosine segments. Basically, it’s very similar to the phase distortion synthesis.
  * Behaviour of a true resonance filter is emulated by adding decaying sine wave.
  * The beginning and the ending of the resonant sine is multiplied by a cosine window.
  * To synthesise sawtooth waves, the resulting square wave is multiplied by synchronous cosine wave.
@@ -204,7 +200,7 @@ public:
 
 	// Return current PCM interpolation factor
 	Bit32u getPCMInterpolationFactor() const;
-}; // class LA32WaveGenerator
+};
 
 // LA32PartialPair contains a structure of two partials being mixed / ring modulated
 class LA32PartialPair {
@@ -243,10 +239,10 @@ public:
 
 	// Return active state of the WG engine
 	bool isActive(const PairType master) const;
-}; // class LA32PartialPair
+};
 
 } // namespace MT32Emu
 
-#endif // #if MT32EMU_USE_FLOAT_SAMPLES
-
 #endif // #ifndef MT32EMU_LA32_WAVE_GENERATOR_H
+
+#endif // #if MT32EMU_USE_FLOAT_SAMPLES
diff --git a/audio/softsynth/mt32/MemoryRegion.h b/audio/softsynth/mt32/MemoryRegion.h
index f8d7da18f8..c0cb041e11 100644
--- a/audio/softsynth/mt32/MemoryRegion.h
+++ b/audio/softsynth/mt32/MemoryRegion.h
@@ -1,5 +1,5 @@
 /* Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Dean Beeler, Jerome Fisher
- * Copyright (C) 2011-2016 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
+ * Copyright (C) 2011, 2012, 2013, 2014 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
@@ -18,20 +18,12 @@
 #ifndef MT32EMU_MEMORY_REGION_H
 #define MT32EMU_MEMORY_REGION_H
 
-#include <cstddef>
-
-#include "globals.h"
-#include "Types.h"
-#include "Structures.h"
-
 namespace MT32Emu {
 
 enum MemoryRegionType {
 	MR_PatchTemp, MR_RhythmTemp, MR_TimbreTemp, MR_Patches, MR_Timbres, MR_System, MR_Display, MR_Reset
 };
 
-class Synth;
-
 class MemoryRegion {
 private:
 	Synth *synth;
@@ -92,7 +84,7 @@ public:
 	}
 	void read(unsigned int entry, unsigned int off, Bit8u *dst, unsigned int len) const;
 	void write(unsigned int entry, unsigned int off, const Bit8u *src, unsigned int len, bool init = false) const;
-}; // class MemoryRegion
+};
 
 class PatchTempMemoryRegion : public MemoryRegion {
 public:
@@ -120,13 +112,13 @@ public:
 };
 class DisplayMemoryRegion : public MemoryRegion {
 public:
-	DisplayMemoryRegion(Synth *useSynth) : MemoryRegion(useSynth, NULL, NULL, MR_Display, MT32EMU_MEMADDR(0x200000), SYSEX_BUFFER_SIZE - 1, 1) {}
+	DisplayMemoryRegion(Synth *useSynth) : MemoryRegion(useSynth, NULL, NULL, MR_Display, MT32EMU_MEMADDR(0x200000), MAX_SYSEX_SIZE - 1, 1) {}
 };
 class ResetMemoryRegion : public MemoryRegion {
 public:
 	ResetMemoryRegion(Synth *useSynth) : MemoryRegion(useSynth, NULL, NULL, MR_Reset, MT32EMU_MEMADDR(0x7F0000), 0x3FFF, 1) {}
 };
 
-} // namespace MT32Emu
+}
 
-#endif // #ifndef MT32EMU_MEMORY_REGION_H
+#endif
diff --git a/audio/softsynth/mt32/MidiEventQueue.h b/audio/softsynth/mt32/MidiEventQueue.h
index 1a5ff0ad33..b1948c5f8e 100644
--- a/audio/softsynth/mt32/MidiEventQueue.h
+++ b/audio/softsynth/mt32/MidiEventQueue.h
@@ -1,5 +1,5 @@
 /* Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Dean Beeler, Jerome Fisher
- * Copyright (C) 2011-2016 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
+ * Copyright (C) 2011, 2012, 2013, 2014 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
@@ -18,9 +18,6 @@
 #ifndef MT32EMU_MIDI_EVENT_QUEUE_H
 #define MT32EMU_MIDI_EVENT_QUEUE_H
 
-#include "globals.h"
-#include "Types.h"
-
 namespace MT32Emu {
 
 /**
@@ -63,9 +60,8 @@ public:
 	const MidiEvent *peekMidiEvent();
 	void dropMidiEvent();
 	bool isFull() const;
-	bool inline isEmpty() const;
 };
 
-} // namespace MT32Emu
+}
 
-#endif // #ifndef MT32EMU_MIDI_EVENT_QUEUE_H
+#endif
diff --git a/audio/softsynth/mt32/MidiStreamParser.cpp b/audio/softsynth/mt32/MidiStreamParser.cpp
deleted file mode 100644
index 74fa0c3e5a..0000000000
--- a/audio/softsynth/mt32/MidiStreamParser.cpp
+++ /dev/null
@@ -1,289 +0,0 @@
-/* Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Dean Beeler, Jerome Fisher
- * Copyright (C) 2011-2016 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
- *
- *  This program is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU Lesser General Public License as published by
- *  the Free Software Foundation, either version 2.1 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU Lesser General Public License for more details.
- *
- *  You should have received a copy of the GNU Lesser General Public License
- *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include <cstdio>
-#include <cstring>
-
-#include "internals.h"
-
-#include "MidiStreamParser.h"
-#include "Synth.h"
-
-using namespace MT32Emu;
-
-DefaultMidiStreamParser::DefaultMidiStreamParser(Synth &useSynth, Bit32u initialStreamBufferCapacity) :
-	MidiStreamParser(initialStreamBufferCapacity), synth(useSynth), timestampSet(false) {}
-
-void DefaultMidiStreamParser::setTimestamp(const Bit32u useTimestamp) {
-	timestampSet = true;
-	timestamp = useTimestamp;
-}
-
-void DefaultMidiStreamParser::resetTimestamp() {
-	timestampSet = false;
-}
-
-void DefaultMidiStreamParser::handleShortMessage(const Bit32u message) {
-	do {
-		if (timestampSet) {
-			if (synth.playMsg(message, timestamp)) return;
-		}
-		else {
-			if (synth.playMsg(message)) return;
-		}
-	} while (synth.reportHandler->onMIDIQueueOverflow());
-}
-
-void DefaultMidiStreamParser::handleSysex(const Bit8u *stream, const Bit32u length) {
-	do {
-		if (timestampSet) {
-			if (synth.playSysex(stream, length, timestamp)) return;
-		}
-		else {
-			if (synth.playSysex(stream, length)) return;
-		}
-	} while (synth.reportHandler->onMIDIQueueOverflow());
-}
-
-void DefaultMidiStreamParser::handleSystemRealtimeMessage(const Bit8u realtime) {
-	synth.reportHandler->onMIDISystemRealtime(realtime);
-}
-
-void DefaultMidiStreamParser::printDebug(const char *debugMessage) {
-	synth.printDebug("%s", debugMessage);
-}
-
-MidiStreamParser::MidiStreamParser(Bit32u initialStreamBufferCapacity) :
-	MidiStreamParserImpl(*this, *this, initialStreamBufferCapacity) {}
-
-MidiStreamParserImpl::MidiStreamParserImpl(MidiReceiver &useReceiver, MidiReporter &useReporter, Bit32u initialStreamBufferCapacity) :
-	midiReceiver(useReceiver), midiReporter(useReporter)
-{
-	if (initialStreamBufferCapacity < (Bit32u)SYSEX_BUFFER_SIZE) initialStreamBufferCapacity = SYSEX_BUFFER_SIZE;
-	if (MAX_STREAM_BUFFER_SIZE < initialStreamBufferCapacity) initialStreamBufferCapacity = MAX_STREAM_BUFFER_SIZE;
-	streamBufferCapacity = initialStreamBufferCapacity;
-	streamBuffer = new Bit8u[streamBufferCapacity];
-	streamBufferSize = 0;
-	runningStatus = 0;
-
-	reserved = NULL;
-}
-
-MidiStreamParserImpl::~MidiStreamParserImpl() {
-	delete[] streamBuffer;
-}
-
-void MidiStreamParserImpl::parseStream(const Bit8u *stream, Bit32u length) {
-	while (length > 0) {
-		Bit32u parsedMessageLength = 0;
-		if (0xF8 <= *stream) {
-			// Process System Realtime immediately and go on
-			midiReceiver.handleSystemRealtimeMessage(*stream);
-			parsedMessageLength = 1;
-			// No effect on the running status
-		} else if (streamBufferSize > 0) {
-			// Check if there is something in streamBuffer waiting for being processed
-			if (*streamBuffer == 0xF0) {
-				parsedMessageLength = parseSysexFragment(stream, length);
-			} else {
-				parsedMessageLength = parseShortMessageDataBytes(stream, length);
-			}
-		} else {
-			if (*stream == 0xF0) {
-				runningStatus = 0; // SysEx clears the running status
-				parsedMessageLength = parseSysex(stream, length);
-			} else {
-				parsedMessageLength = parseShortMessageStatus(stream);
-			}
-		}
-
-		// Parsed successfully
-		stream += parsedMessageLength;
-		length -= parsedMessageLength;
-	}
-}
-
-void MidiStreamParserImpl::processShortMessage(const Bit32u message) {
-	// Adds running status to the MIDI message if it doesn't contain one
-	Bit8u status = (Bit8u)message;
-	if (0xF8 <= status) {
-		midiReceiver.handleSystemRealtimeMessage(status);
-	} else if (processStatusByte(status)) {
-		midiReceiver.handleShortMessage((message << 8) | status);
-	} else if (0x80 <= status) { // If no running status available yet, skip this message
-		midiReceiver.handleShortMessage(message);
-	}
-}
-
-// We deal with SysEx messages below 512 bytes long in most cases. Nevertheless, it seems reasonable to support a possibility
-// to load bulk dumps using a single message. However, this is known to fail with a real device due to limited input buffer size.
-bool MidiStreamParserImpl::checkStreamBufferCapacity(const bool preserveContent) {
-	if (streamBufferSize < streamBufferCapacity) return true;
-	if (streamBufferCapacity < MAX_STREAM_BUFFER_SIZE) {
-		Bit8u *oldStreamBuffer = streamBuffer;
-		streamBufferCapacity = MAX_STREAM_BUFFER_SIZE;
-		streamBuffer = new Bit8u[streamBufferCapacity];
-		if (preserveContent) memcpy(streamBuffer, oldStreamBuffer, streamBufferSize);
-		delete[] oldStreamBuffer;
-		return true;
-	}
-	return false;
-}
-
-// Checks input byte whether it is a status byte. If not, replaces it with running status when available.
-// Returns true if the input byte was changed to running status.
-bool MidiStreamParserImpl::processStatusByte(Bit8u &status) {
-	if (status < 0x80) {
-		// First byte isn't status, try running status
-		if (runningStatus < 0x80) {
-			// No running status available yet
-			midiReporter.printDebug("processStatusByte: No valid running status yet, MIDI message ignored");
-			return false;
-		}
-		status = runningStatus;
-		return true;
-	} else if (status < 0xF0) {
-		// Store current status as running for a Voice message
-		runningStatus = status;
-	} else if (status < 0xF8) {
-		// System Common clears running status
-		runningStatus = 0;
-	} // System Realtime doesn't affect running status
-	return false;
-}
-
-// Returns # of bytes parsed
-Bit32u MidiStreamParserImpl::parseShortMessageStatus(const Bit8u stream[]) {
-	Bit8u status = *stream;
-	Bit32u parsedLength = processStatusByte(status) ? 0 : 1;
-	if (0x80 <= status) { // If no running status available yet, skip one byte
-		*streamBuffer = status;
-		++streamBufferSize;
-	}
-	return parsedLength;
-}
-
-// Returns # of bytes parsed
-Bit32u MidiStreamParserImpl::parseShortMessageDataBytes(const Bit8u stream[], Bit32u length) {
-	const Bit32u shortMessageLength = Synth::getShortMessageLength(*streamBuffer);
-	Bit32u parsedLength = 0;
-
-	// Append incoming bytes to streamBuffer
-	while ((streamBufferSize < shortMessageLength) && (length-- > 0)) {
-		Bit8u dataByte = *(stream++);
-		if (dataByte < 0x80) {
-			// Add data byte to streamBuffer
-			streamBuffer[streamBufferSize++] = dataByte;
-		} else if (dataByte < 0xF8) {
-			// Discard invalid bytes and start over
-			char s[128];
-			sprintf(s, "parseShortMessageDataBytes: Invalid short message: status %02x, expected length %i, actual %i -> ignored", *streamBuffer, shortMessageLength, streamBufferSize);
-			midiReporter.printDebug(s);
-			streamBufferSize = 0; // Clear streamBuffer
-			return parsedLength;
-		} else {
-			// Bypass System Realtime message
-			midiReceiver.handleSystemRealtimeMessage(dataByte);
-		}
-		++parsedLength;
-	}
-	if (streamBufferSize < shortMessageLength) return parsedLength; // Still lacks data bytes
-
-	// Assemble short message
-	Bit32u shortMessage = streamBuffer[0];
-	for (Bit32u i = 1; i < shortMessageLength; ++i) {
-		shortMessage |= streamBuffer[i] << (i << 3);
-	}
-	midiReceiver.handleShortMessage(shortMessage);
-	streamBufferSize = 0; // Clear streamBuffer
-	return parsedLength;
-}
-
-// Returns # of bytes parsed
-Bit32u MidiStreamParserImpl::parseSysex(const Bit8u stream[], const Bit32u length) {
-	// Find SysEx length
-	Bit32u sysexLength = 1;
-	while (sysexLength < length) {
-		Bit8u nextByte = stream[sysexLength++];
-		if (0x80 <= nextByte) {
-			if (nextByte == 0xF7) {
-				// End of SysEx
-				midiReceiver.handleSysex(stream, sysexLength);
-				return sysexLength;
-			}
-			if (0xF8 <= nextByte) {
-				// The System Realtime message must be processed right after return
-				// but the SysEx is actually fragmented and to be reconstructed in streamBuffer
-				--sysexLength;
-				break;
-			}
-			// Illegal status byte in SysEx message, aborting
-			midiReporter.printDebug("parseSysex: SysEx message lacks end-of-sysex (0xf7), ignored");
-			// Continue parsing from that point
-			return sysexLength - 1;
-		}
-	}
-
-	// Store incomplete SysEx message for further processing
-	streamBufferSize = sysexLength;
-	if (checkStreamBufferCapacity(false)) {
-		memcpy(streamBuffer, stream, sysexLength);
-	} else {
-		// Not enough buffer capacity, don't care about the real buffer content, just mark the first byte
-		*streamBuffer = *stream;
-		streamBufferSize = streamBufferCapacity;
-	}
-	return sysexLength;
-}
-
-// Returns # of bytes parsed
-Bit32u MidiStreamParserImpl::parseSysexFragment(const Bit8u stream[], const Bit32u length) {
-	Bit32u parsedLength = 0;
-	while (parsedLength < length) {
-		Bit8u nextByte = stream[parsedLength++];
-		if (nextByte < 0x80) {
-			// Add SysEx data byte to streamBuffer
-			if (checkStreamBufferCapacity(true)) streamBuffer[streamBufferSize++] = nextByte;
-			continue;
-		}
-		if (0xF8 <= nextByte) {
-			// Bypass System Realtime message
-			midiReceiver.handleSystemRealtimeMessage(nextByte);
-			continue;
-		}
-		if (nextByte != 0xF7) {
-			// Illegal status byte in SysEx message, aborting
-			midiReporter.printDebug("parseSysexFragment: SysEx message lacks end-of-sysex (0xf7), ignored");
-			// Clear streamBuffer and continue parsing from that point
-			streamBufferSize = 0;
-			--parsedLength;
-			break;
-		}
-		// End of SysEx
-		if (checkStreamBufferCapacity(true)) {
-			streamBuffer[streamBufferSize++] = nextByte;
-			midiReceiver.handleSysex(streamBuffer, streamBufferSize);
-			streamBufferSize = 0; // Clear streamBuffer
-			break;
-		}
-		// Encountered streamBuffer overrun
-		midiReporter.printDebug("parseSysexFragment: streamBuffer overrun while receiving SysEx message, ignored. Max allowed size of fragmented SysEx is 32768 bytes.");
-		streamBufferSize = 0; // Clear streamBuffer
-		break;
-	}
-	return parsedLength;
-}
diff --git a/audio/softsynth/mt32/MidiStreamParser.h b/audio/softsynth/mt32/MidiStreamParser.h
deleted file mode 100644
index bd31b77c89..0000000000
--- a/audio/softsynth/mt32/MidiStreamParser.h
+++ /dev/null
@@ -1,124 +0,0 @@
-/* Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Dean Beeler, Jerome Fisher
- * Copyright (C) 2011-2016 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
- *
- *  This program is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU Lesser General Public License as published by
- *  the Free Software Foundation, either version 2.1 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU Lesser General Public License for more details.
- *
- *  You should have received a copy of the GNU Lesser General Public License
- *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef MT32EMU_MIDI_STREAM_PARSER_H
-#define MT32EMU_MIDI_STREAM_PARSER_H
-
-#include "globals.h"
-#include "Types.h"
-
-namespace MT32Emu {
-
-class Synth;
-
-// Interface for a user-supplied class to receive parsed well-formed MIDI messages.
-class MT32EMU_EXPORT MidiReceiver {
-public:
-	// Invoked when a complete short MIDI message is parsed in the input MIDI stream.
-	virtual void handleShortMessage(const Bit32u message) = 0;
-
-	// Invoked when a complete well-formed System Exclusive MIDI message is parsed in the input MIDI stream.
-	virtual void handleSysex(const Bit8u stream[], const Bit32u length) = 0;
-
-	// Invoked when a System Realtime MIDI message is parsed in the input MIDI stream.
-	virtual void handleSystemRealtimeMessage(const Bit8u realtime) = 0;
-
-protected:
-	~MidiReceiver() {}
-};
-
-// Interface for a user-supplied class to receive notifications of input MIDI stream parse errors.
-class MT32EMU_EXPORT MidiReporter {
-public:
-	// Invoked when an error occurs during processing the input MIDI stream.
-	virtual void printDebug(const char *debugMessage) = 0;
-
-protected:
-	~MidiReporter() {}
-};
-
-// Provides a context for parsing a stream of MIDI events coming from a single source.
-// There can be multiple MIDI sources feeding MIDI events to a single Synth object.
-// NOTE: Calls from multiple threads which feed a single Synth object with data must be explicitly synchronised,
-// although, no synchronisation is required with the rendering thread.
-class MT32EMU_EXPORT MidiStreamParserImpl {
-public:
-	// The first two arguments provide for implementations of essential interfaces needed.
-	// The third argument specifies streamBuffer initial capacity. The buffer capacity should be large enough to fit the longest SysEx expected.
-	// If a longer SysEx occurs, streamBuffer is reallocated to the maximum size of MAX_STREAM_BUFFER_SIZE (32768 bytes).
-	// Default capacity is SYSEX_BUFFER_SIZE (1000 bytes) which is enough to fit SysEx messages in common use.
-	MidiStreamParserImpl(MidiReceiver &, MidiReporter &, Bit32u initialStreamBufferCapacity = SYSEX_BUFFER_SIZE);
-	virtual ~MidiStreamParserImpl();
-
-	// Parses a block of raw MIDI bytes. All the parsed MIDI messages are sent in sequence to the user-supplied methods for further processing.
-	// SysEx messages are allowed to be fragmented across several calls to this method. Running status is also handled for short messages.
-	// NOTE: the total length of a SysEx message being fragmented shall not exceed MAX_STREAM_BUFFER_SIZE (32768 bytes).
-	void parseStream(const Bit8u *stream, Bit32u length);
-
-	// Convenience method which accepts a Bit32u-encoded short MIDI message and sends it to the user-supplied method for further processing.
-	// The short MIDI message may contain no status byte, the running status is used in this case.
-	void processShortMessage(const Bit32u message);
-
-private:
-	Bit8u runningStatus;
-	Bit8u *streamBuffer;
-	Bit32u streamBufferCapacity;
-	Bit32u streamBufferSize;
-	MidiReceiver &midiReceiver;
-	MidiReporter &midiReporter;
-
-	// Binary compatibility helper.
-	void *reserved;
-
-	bool checkStreamBufferCapacity(const bool preserveContent);
-	bool processStatusByte(Bit8u &status);
-	Bit32u parseShortMessageStatus(const Bit8u stream[]);
-	Bit32u parseShortMessageDataBytes(const Bit8u stream[], Bit32u length);
-	Bit32u parseSysex(const Bit8u stream[], const Bit32u length);
-	Bit32u parseSysexFragment(const Bit8u stream[], const Bit32u length);
-}; // class MidiStreamParserImpl
-
-// An abstract class that provides a context for parsing a stream of MIDI events coming from a single source.
-class MT32EMU_EXPORT MidiStreamParser : public MidiStreamParserImpl, protected MidiReceiver, protected MidiReporter {
-public:
-	// The argument specifies streamBuffer initial capacity. The buffer capacity should be large enough to fit the longest SysEx expected.
-	// If a longer SysEx occurs, streamBuffer is reallocated to the maximum size of MAX_STREAM_BUFFER_SIZE (32768 bytes).
-	// Default capacity is SYSEX_BUFFER_SIZE (1000 bytes) which is enough to fit SysEx messages in common use.
-	explicit MidiStreamParser(Bit32u initialStreamBufferCapacity = SYSEX_BUFFER_SIZE);
-};
-
-class MT32EMU_EXPORT DefaultMidiStreamParser : public MidiStreamParser {
-public:
-	explicit DefaultMidiStreamParser(Synth &synth, Bit32u initialStreamBufferCapacity = SYSEX_BUFFER_SIZE);
-	void setTimestamp(const Bit32u useTimestamp);
-	void resetTimestamp();
-
-protected:
-	void handleShortMessage(const Bit32u message);
-	void handleSysex(const Bit8u *stream, const Bit32u length);
-	void handleSystemRealtimeMessage(const Bit8u realtime);
-	void printDebug(const char *debugMessage);
-
-private:
-	Synth &synth;
-	bool timestampSet;
-	Bit32u timestamp;
-};
-
-} // namespace MT32Emu
-
-#endif // MT32EMU_MIDI_STREAM_PARSER_H
diff --git a/audio/softsynth/mt32/Part.cpp b/audio/softsynth/mt32/Part.cpp
index cba198d651..cffc3ed744 100644
--- a/audio/softsynth/mt32/Part.cpp
+++ b/audio/softsynth/mt32/Part.cpp
@@ -1,5 +1,5 @@
 /* Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Dean Beeler, Jerome Fisher
- * Copyright (C) 2011-2016 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
+ * Copyright (C) 2011, 2012, 2013, 2014 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
@@ -15,16 +15,12 @@
  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <cstdio>
-#include <cstring>
+//#include <cstdio>
+//#include <cstring>
 
+#include "mt32emu.h"
 #include "internals.h"
-
-#include "Part.h"
-#include "Partial.h"
 #include "PartialManager.h"
-#include "Poly.h"
-#include "Synth.h"
 
 namespace MT32Emu {
 
@@ -166,7 +162,7 @@ void Part::refresh() {
 		patchCache[t].reverb = patchTemp->patch.reverbSwitch > 0;
 	}
 	memcpy(currentInstr, timbreTemp->common.name, 10);
-	synth->newTimbreSet(partNum, patchTemp->patch.timbreGroup, patchTemp->patch.timbreNum, currentInstr);
+	synth->newTimbreSet(partNum, patchTemp->patch.timbreGroup, currentInstr);
 	updatePitchBenderRange();
 }
 
@@ -511,7 +507,7 @@ void Part::playPoly(const PatchCache cache[4], const MemParams::RhythmTemp *rhyt
 #if MT32EMU_MONITOR_PARTIALS > 1
 	synth->printPartialUsage();
 #endif
-	synth->reportHandler->onPolyStateChanged((Bit8u)partNum);
+	synth->polyStateChanged(partNum);
 }
 
 void Part::allNotesOff() {
@@ -597,14 +593,16 @@ void Part::partialDeactivated(Poly *poly) {
 	if (!poly->isActive()) {
 		activePolys.remove(poly);
 		synth->partialManager->polyFreed(poly);
-		synth->reportHandler->onPolyStateChanged((Bit8u)partNum);
+		synth->polyStateChanged(partNum);
 	}
 }
 
+//#define POLY_LIST_DEBUG
+
 PolyList::PolyList() : firstPoly(NULL), lastPoly(NULL) {}
 
 bool PolyList::isEmpty() const {
-#ifdef MT32EMU_POLY_LIST_DEBUG
+#ifdef POLY_LIST_DEBUG
 	if ((firstPoly == NULL || lastPoly == NULL) && firstPoly != lastPoly) {
 		printf("PolyList: desynchronised firstPoly & lastPoly pointers\n");
 	}
@@ -621,7 +619,7 @@ Poly *PolyList::getLast() const {
 }
 
 void PolyList::prepend(Poly *poly) {
-#ifdef MT32EMU_POLY_LIST_DEBUG
+#ifdef POLY_LIST_DEBUG
 	if (poly->getNext() != NULL) {
 		printf("PolyList: Non-NULL next field in a Poly being prepended is ignored\n");
 	}
@@ -634,14 +632,14 @@ void PolyList::prepend(Poly *poly) {
 }
 
 void PolyList::append(Poly *poly) {
-#ifdef MT32EMU_POLY_LIST_DEBUG
+#ifdef POLY_LIST_DEBUG
 	if (poly->getNext() != NULL) {
 		printf("PolyList: Non-NULL next field in a Poly being appended is ignored\n");
 	}
 #endif
 	poly->setNext(NULL);
 	if (lastPoly != NULL) {
-#ifdef MT32EMU_POLY_LIST_DEBUG
+#ifdef POLY_LIST_DEBUG
 		if (lastPoly->getNext() != NULL) {
 			printf("PolyList: Non-NULL next field in the lastPoly\n");
 		}
@@ -658,7 +656,7 @@ Poly *PolyList::takeFirst() {
 	Poly *oldFirst = firstPoly;
 	firstPoly = oldFirst->getNext();
 	if (firstPoly == NULL) {
-#ifdef MT32EMU_POLY_LIST_DEBUG
+#ifdef POLY_LIST_DEBUG
 		if (lastPoly != oldFirst) {
 			printf("PolyList: firstPoly != lastPoly in a list with a single Poly\n");
 		}
@@ -677,7 +675,7 @@ void PolyList::remove(Poly * const polyToRemove) {
 	for (Poly *poly = firstPoly; poly != NULL; poly = poly->getNext()) {
 		if (poly->getNext() == polyToRemove) {
 			if (polyToRemove == lastPoly) {
-#ifdef MT32EMU_POLY_LIST_DEBUG
+#ifdef POLY_LIST_DEBUG
 				if (lastPoly->getNext() != NULL) {
 					printf("PolyList: Non-NULL next field in the lastPoly\n");
 				}
@@ -691,4 +689,4 @@ void PolyList::remove(Poly * const polyToRemove) {
 	}
 }
 
-} // namespace MT32Emu
+}
diff --git a/audio/softsynth/mt32/Part.h b/audio/softsynth/mt32/Part.h
index f5171589d6..b458fb3988 100644
--- a/audio/softsynth/mt32/Part.h
+++ b/audio/softsynth/mt32/Part.h
@@ -1,5 +1,5 @@
 /* Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Dean Beeler, Jerome Fisher
- * Copyright (C) 2011-2016 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
+ * Copyright (C) 2011, 2012, 2013, 2014 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
@@ -18,14 +18,9 @@
 #ifndef MT32EMU_PART_H
 #define MT32EMU_PART_H
 
-#include "globals.h"
-#include "internals.h"
-#include "Types.h"
-#include "Structures.h"
-
 namespace MT32Emu {
 
-class Poly;
+class PartialManager;
 class Synth;
 
 class PolyList {
@@ -128,7 +123,7 @@ public:
 	// Abort the first poly in PolyState_HELD, or if none exists, the first active poly in any state.
 	bool abortFirstPolyPreferHeld();
 	bool abortFirstPoly();
-}; // class Part
+};
 
 class RhythmPart: public Part {
 	// Pointer to the area of the MT-32's memory dedicated to rhythm
@@ -148,6 +143,5 @@ public:
 	void setProgram(unsigned int patchNum);
 };
 
-} // namespace MT32Emu
-
-#endif // #ifndef MT32EMU_PART_H
+}
+#endif
diff --git a/audio/softsynth/mt32/Partial.cpp b/audio/softsynth/mt32/Partial.cpp
index 563079ba79..7348087509 100644
--- a/audio/softsynth/mt32/Partial.cpp
+++ b/audio/softsynth/mt32/Partial.cpp
@@ -1,5 +1,5 @@
 /* Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Dean Beeler, Jerome Fisher
- * Copyright (C) 2011-2016 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
+ * Copyright (C) 2011, 2012, 2013, 2014 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
@@ -15,19 +15,14 @@
  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <cstddef>
+//#include <cmath>
+//#include <cstdlib>
+//#include <cstring>
 
+#include "mt32emu.h"
+#include "mmath.h"
 #include "internals.h"
 
-#include "Partial.h"
-#include "Part.h"
-#include "Poly.h"
-#include "Synth.h"
-#include "Tables.h"
-#include "TVA.h"
-#include "TVF.h"
-#include "TVP.h"
-
 namespace MT32Emu {
 
 static const Bit8u PAN_NUMERATOR_MASTER[] = {0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7};
@@ -59,7 +54,7 @@ int Partial::debugGetPartialNum() const {
 }
 
 // Only used for debugging purposes
-Bit32u Partial::debugGetSampleNum() const {
+unsigned long Partial::debugGetSampleNum() const {
 	return sampleNum;
 }
 
@@ -271,7 +266,7 @@ void Partial::backupCache(const PatchCache &cache) {
 	}
 }
 
-bool Partial::produceOutput(Sample *leftBuf, Sample *rightBuf, Bit32u length) {
+bool Partial::produceOutput(Sample *leftBuf, Sample *rightBuf, unsigned long length) {
 	if (!isActive() || alreadyOutputed || isRingModulatingSlave()) {
 		return false;
 	}
@@ -346,4 +341,4 @@ void Partial::startDecayAll() {
 	tvf->startDecay();
 }
 
-} // namespace MT32Emu
+}
diff --git a/audio/softsynth/mt32/Partial.h b/audio/softsynth/mt32/Partial.h
index 187665de51..749468135d 100644
--- a/audio/softsynth/mt32/Partial.h
+++ b/audio/softsynth/mt32/Partial.h
@@ -1,5 +1,5 @@
 /* Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Dean Beeler, Jerome Fisher
- * Copyright (C) 2011-2016 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
+ * Copyright (C) 2011, 2012, 2013, 2014 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
@@ -18,21 +18,11 @@
 #ifndef MT32EMU_PARTIAL_H
 #define MT32EMU_PARTIAL_H
 
-#include "globals.h"
-#include "internals.h"
-#include "Types.h"
-#include "Structures.h"
-#include "LA32Ramp.h"
-#include "LA32WaveGenerator.h"
-
 namespace MT32Emu {
 
-class Part;
-class Poly;
 class Synth;
+class Part;
 class TVA;
-class TVF;
-class TVP;
 struct ControlROMPCMStruct;
 
 // A partial represents one of up to four waveform generators currently playing within a poly.
@@ -42,7 +32,7 @@ private:
 	const int debugPartialNum; // Only used for debugging
 	// Number of the sample currently being rendered by produceOutput(), or 0 if no run is in progress
 	// This is only kept available for debugging purposes.
-	Bit32u sampleNum;
+	unsigned long sampleNum;
 
 	// Actually, this is a 4-bit register but we abuse this to emulate inverted mixing.
 	// Also we double the value to enable INACCURATE_SMOOTH_PAN, with respect to MoK.
@@ -87,7 +77,7 @@ public:
 	~Partial();
 
 	int debugGetPartialNum() const;
-	Bit32u debugGetSampleNum() const;
+	unsigned long debugGetSampleNum() const;
 
 	int getOwnerPart() const;
 	const Poly *getPoly() const;
@@ -110,9 +100,9 @@ public:
 	// Returns true only if data written to buffer
 	// This function (unlike the one below it) returns processed stereo samples
 	// made from combining this single partial with its pair, if it has one.
-	bool produceOutput(Sample *leftBuf, Sample *rightBuf, Bit32u length);
-}; // class Partial
+	bool produceOutput(Sample *leftBuf, Sample *rightBuf, unsigned long length);
+};
 
-} // namespace MT32Emu
+}
 
-#endif // #ifndef MT32EMU_PARTIAL_H
+#endif
diff --git a/audio/softsynth/mt32/PartialManager.cpp b/audio/softsynth/mt32/PartialManager.cpp
index 2c5bb62605..8ca6e4e3d7 100644
--- a/audio/softsynth/mt32/PartialManager.cpp
+++ b/audio/softsynth/mt32/PartialManager.cpp
@@ -1,5 +1,5 @@
 /* Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Dean Beeler, Jerome Fisher
- * Copyright (C) 2011-2016 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
+ * Copyright (C) 2011, 2012, 2013, 2014 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
@@ -15,16 +15,11 @@
  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <cstddef>
-#include <cstring>
+//#include <cstring>
 
+#include "mt32emu.h"
 #include "internals.h"
-
 #include "PartialManager.h"
-#include "Part.h"
-#include "Partial.h"
-#include "Poly.h"
-#include "Synth.h"
 
 namespace MT32Emu {
 
@@ -291,4 +286,4 @@ void PartialManager::polyFreed(Poly *poly) {
 	freePolys[firstFreePolyIndex] = poly;
 }
 
-} // namespace MT32Emu
+}
diff --git a/audio/softsynth/mt32/PartialManager.h b/audio/softsynth/mt32/PartialManager.h
index b2908a5c21..f2e8767bbb 100644
--- a/audio/softsynth/mt32/PartialManager.h
+++ b/audio/softsynth/mt32/PartialManager.h
@@ -1,5 +1,5 @@
 /* Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Dean Beeler, Jerome Fisher
- * Copyright (C) 2011-2016 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
+ * Copyright (C) 2011, 2012, 2013, 2014 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
@@ -18,15 +18,8 @@
 #ifndef MT32EMU_PARTIALMANAGER_H
 #define MT32EMU_PARTIALMANAGER_H
 
-#include "globals.h"
-#include "internals.h"
-#include "Types.h"
-
 namespace MT32Emu {
 
-class Part;
-class Partial;
-class Poly;
 class Synth;
 
 class PartialManager {
@@ -56,8 +49,8 @@ public:
 	const Partial *getPartial(unsigned int partialNum) const;
 	Poly *assignPolyToPart(Part *part);
 	void polyFreed(Poly *poly);
-}; // class PartialManager
+};
 
-} // namespace MT32Emu
+}
 
-#endif // #ifndef MT32EMU_PARTIALMANAGER_H
+#endif
diff --git a/audio/softsynth/mt32/Poly.cpp b/audio/softsynth/mt32/Poly.cpp
index 9a3948cf11..badcd8fb96 100644
--- a/audio/softsynth/mt32/Poly.cpp
+++ b/audio/softsynth/mt32/Poly.cpp
@@ -1,5 +1,5 @@
 /* Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Dean Beeler, Jerome Fisher
- * Copyright (C) 2011-2016 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
+ * Copyright (C) 2011, 2012, 2013, 2014 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
@@ -15,15 +15,9 @@
  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <cstddef>
-
+#include "mt32emu.h"
 #include "internals.h"
 
-#include "Poly.h"
-#include "Part.h"
-#include "Partial.h"
-#include "Synth.h"
-
 namespace MT32Emu {
 
 Poly::Poly() {
@@ -187,4 +181,4 @@ void Poly::setNext(Poly *poly) {
 	next = poly;
 }
 
-} // namespace MT32Emu
+}
diff --git a/audio/softsynth/mt32/Poly.h b/audio/softsynth/mt32/Poly.h
index 4b283231c8..e2614369bb 100644
--- a/audio/softsynth/mt32/Poly.h
+++ b/audio/softsynth/mt32/Poly.h
@@ -1,5 +1,5 @@
 /* Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Dean Beeler, Jerome Fisher
- * Copyright (C) 2011-2016 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
+ * Copyright (C) 2011, 2012, 2013, 2014 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
@@ -18,14 +18,17 @@
 #ifndef MT32EMU_POLY_H
 #define MT32EMU_POLY_H
 
-#include "globals.h"
-#include "internals.h"
-
 namespace MT32Emu {
 
 class Part;
 class Partial;
-struct PatchCache;
+
+enum PolyState {
+	POLY_Playing,
+	POLY_Held, // This marks keys that have been released on the keyboard, but are being held by the pedal
+	POLY_Releasing,
+	POLY_Inactive
+};
 
 class Poly {
 private:
@@ -63,8 +66,8 @@ public:
 
 	Poly *getNext() const;
 	void setNext(Poly *poly);
-}; // class Poly
+};
 
-} // namespace MT32Emu
+}
 
-#endif // #ifndef MT32EMU_POLY_H
+#endif /* POLY_H_ */
diff --git a/audio/softsynth/mt32/ROMInfo.cpp b/audio/softsynth/mt32/ROMInfo.cpp
index ce78e693aa..f6817c1a4d 100644
--- a/audio/softsynth/mt32/ROMInfo.cpp
+++ b/audio/softsynth/mt32/ROMInfo.cpp
@@ -1,5 +1,5 @@
 /* Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Dean Beeler, Jerome Fisher
- * Copyright (C) 2011-2016 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
+ * Copyright (C) 2011, 2012, 2013, 2014 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
@@ -15,27 +15,27 @@
  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <cstring>
-
-#include "internals.h"
-
+//#include <cstring>
 #include "ROMInfo.h"
 
 namespace MT32Emu {
 
-static const ROMInfo *getKnownROMInfoFromList(Bit32u index) {
+static const ROMInfo *getKnownROMInfoFromList(unsigned int index) {
+	static const ControlROMFeatureSet MT32_COMPATIBLE(true, true);
+	static const ControlROMFeatureSet CM32L_COMPATIBLE(false, false);
+
 	// Known ROMs
-	static const ROMInfo CTRL_MT32_V1_04 = {65536, "5a5cb5a77d7d55ee69657c2f870416daed52dea7", ROMInfo::Control, "ctrl_mt32_1_04", "MT-32 Control v1.04", ROMInfo::Full, NULL};
-	static const ROMInfo CTRL_MT32_V1_05 = {65536, "e17a3a6d265bf1fa150312061134293d2b58288c", ROMInfo::Control, "ctrl_mt32_1_05", "MT-32 Control v1.05", ROMInfo::Full, NULL};
-	static const ROMInfo CTRL_MT32_V1_06 = {65536, "a553481f4e2794c10cfe597fef154eef0d8257de", ROMInfo::Control, "ctrl_mt32_1_06", "MT-32 Control v1.06", ROMInfo::Full, NULL};
-	static const ROMInfo CTRL_MT32_V1_07 = {65536, "b083518fffb7f66b03c23b7eb4f868e62dc5a987", ROMInfo::Control, "ctrl_mt32_1_07", "MT-32 Control v1.07", ROMInfo::Full, NULL};
-	static const ROMInfo CTRL_MT32_BLUER = {65536, "7b8c2a5ddb42fd0732e2f22b3340dcf5360edf92", ROMInfo::Control, "ctrl_mt32_bluer", "MT-32 Control BlueRidge", ROMInfo::Full, NULL};
+	static const ROMInfo CTRL_MT32_V1_04 = {65536, "5a5cb5a77d7d55ee69657c2f870416daed52dea7", ROMInfo::Control, "ctrl_mt32_1_04", "MT-32 Control v1.04", ROMInfo::Full, NULL, &MT32_COMPATIBLE};
+	static const ROMInfo CTRL_MT32_V1_05 = {65536, "e17a3a6d265bf1fa150312061134293d2b58288c", ROMInfo::Control, "ctrl_mt32_1_05", "MT-32 Control v1.05", ROMInfo::Full, NULL, &MT32_COMPATIBLE};
+	static const ROMInfo CTRL_MT32_V1_06 = {65536, "a553481f4e2794c10cfe597fef154eef0d8257de", ROMInfo::Control, "ctrl_mt32_1_06", "MT-32 Control v1.06", ROMInfo::Full, NULL, &MT32_COMPATIBLE};
+	static const ROMInfo CTRL_MT32_V1_07 = {65536, "b083518fffb7f66b03c23b7eb4f868e62dc5a987", ROMInfo::Control, "ctrl_mt32_1_07", "MT-32 Control v1.07", ROMInfo::Full, NULL, &MT32_COMPATIBLE};
+	static const ROMInfo CTRL_MT32_BLUER = {65536, "7b8c2a5ddb42fd0732e2f22b3340dcf5360edf92", ROMInfo::Control, "ctrl_mt32_bluer", "MT-32 Control BlueRidge", ROMInfo::Full, NULL, &MT32_COMPATIBLE};
 
-	static const ROMInfo CTRL_CM32L_V1_00 = {65536, "73683d585cd6948cc19547942ca0e14a0319456d", ROMInfo::Control, "ctrl_cm32l_1_00", "CM-32L/LAPC-I Control v1.00", ROMInfo::Full, NULL};
-	static const ROMInfo CTRL_CM32L_V1_02 = {65536, "a439fbb390da38cada95a7cbb1d6ca199cd66ef8", ROMInfo::Control, "ctrl_cm32l_1_02", "CM-32L/LAPC-I Control v1.02", ROMInfo::Full, NULL};
+	static const ROMInfo CTRL_CM32L_V1_00 = {65536, "73683d585cd6948cc19547942ca0e14a0319456d", ROMInfo::Control, "ctrl_cm32l_1_00", "CM-32L/LAPC-I Control v1.00", ROMInfo::Full, NULL, &CM32L_COMPATIBLE};
+	static const ROMInfo CTRL_CM32L_V1_02 = {65536, "a439fbb390da38cada95a7cbb1d6ca199cd66ef8", ROMInfo::Control, "ctrl_cm32l_1_02", "CM-32L/LAPC-I Control v1.02", ROMInfo::Full, NULL, &CM32L_COMPATIBLE};
 
-	static const ROMInfo PCM_MT32 = {524288, "f6b1eebc4b2d200ec6d3d21d51325d5b48c60252", ROMInfo::PCM, "pcm_mt32", "MT-32 PCM ROM", ROMInfo::Full, NULL};
-	static const ROMInfo PCM_CM32L = {1048576, "289cc298ad532b702461bfc738009d9ebe8025ea", ROMInfo::PCM, "pcm_cm32l", "CM-32L/CM-64/LAPC-I PCM ROM", ROMInfo::Full, NULL};
+	static const ROMInfo PCM_MT32 = {524288, "f6b1eebc4b2d200ec6d3d21d51325d5b48c60252", ROMInfo::PCM, "pcm_mt32", "MT-32 PCM ROM", ROMInfo::Full, NULL, NULL};
+	static const ROMInfo PCM_CM32L = {1048576, "289cc298ad532b702461bfc738009d9ebe8025ea", ROMInfo::PCM, "pcm_cm32l", "CM-32L/CM-64/LAPC-I PCM ROM", ROMInfo::Full, NULL, NULL};
 
 	static const ROMInfo * const ROM_INFOS[] = {
 		&CTRL_MT32_V1_04,
@@ -52,11 +52,23 @@ static const ROMInfo *getKnownROMInfoFromList(Bit32u index) {
 	return ROM_INFOS[index];
 }
 
-const ROMInfo* ROMInfo::getROMInfo(File *file) {
-	size_t fileSize = file->getSize();
-	for (Bit32u i = 0; getKnownROMInfoFromList(i) != NULL; i++) {
+const ROMInfo* ROMInfo::getROMInfo(Common::File *file) {
+	size_t fileSize = file->size();
+	Common::String fileName = file->getName();
+	fileName.toUppercase();
+	bool isCM32LROM = fileName.hasPrefix("CM32L_");
+	// We haven't added the SHA1 checksum code in ScummVM, as the file size
+	// and ROM name suffices for our needs for now.
+	//const char *fileDigest = file->getSHA1();
+	for (int i = 0; getKnownROMInfoFromList(i) != NULL; i++) {
 		const ROMInfo *romInfo = getKnownROMInfoFromList(i);
-		if (fileSize == romInfo->fileSize && !strcmp(file->getSHA1(), romInfo->sha1Digest)) {
+		if (fileSize == romInfo->fileSize /*&& !strcmp(fileDigest, romInfo->sha1Digest)*/) {
+			if (fileSize == 65536) {
+				// If we are looking for a CM-32L ROM, make sure we return the first matching
+				// CM-32L ROM from the list, instead of the first matching MT-32 ROM
+				if (isCM32LROM && romInfo->controlROMFeatures->isDefaultReverbMT32Compatible())
+					continue;
+			}
 			return romInfo;
 		}
 	}
@@ -67,17 +79,17 @@ void ROMInfo::freeROMInfo(const ROMInfo *romInfo) {
 	(void) romInfo;
 }
 
-static Bit32u getROMCount() {
-	Bit32u count;
+static int getROMCount() {
+	int count;
 	for(count = 0; getKnownROMInfoFromList(count) != NULL; count++) {
 	}
 	return count;
 }
 
-const ROMInfo** ROMInfo::getROMInfoList(Bit32u types, Bit32u pairTypes) {
+const ROMInfo** ROMInfo::getROMInfoList(unsigned int types, unsigned int pairTypes) {
 	const ROMInfo **romInfoList = new const ROMInfo*[getROMCount() + 1];
 	const ROMInfo **currentROMInList = romInfoList;
-	for (Bit32u i = 0; getKnownROMInfoFromList(i) != NULL; i++) {
+	for(int i = 0; getKnownROMInfoFromList(i) != NULL; i++) {
 		const ROMInfo *romInfo = getKnownROMInfoFromList(i);
 		if ((types & (1 << romInfo->type)) && (pairTypes & (1 << romInfo->pairType))) {
 			*currentROMInList++ = romInfo;
@@ -91,22 +103,19 @@ void ROMInfo::freeROMInfoList(const ROMInfo **romInfoList) {
 	delete[] romInfoList;
 }
 
-ROMImage::ROMImage(File *useFile) : file(useFile), romInfo(ROMInfo::getROMInfo(file))
-{}
-
-ROMImage::~ROMImage() {
-	ROMInfo::freeROMInfo(romInfo);
-}
-
-const ROMImage* ROMImage::makeROMImage(File *file) {
-	return new ROMImage(file);
+const ROMImage* ROMImage::makeROMImage(Common::File *file) {
+	ROMImage *romImage = new ROMImage;
+	romImage->file = file;
+	romImage->romInfo = ROMInfo::getROMInfo(romImage->file);
+	return romImage;
 }
 
 void ROMImage::freeROMImage(const ROMImage *romImage) {
+	ROMInfo::freeROMInfo(romImage->romInfo);
 	delete romImage;
 }
 
-File* ROMImage::getFile() const {
+Common::File* ROMImage::getFile() const {
 	return file;
 }
 
@@ -114,4 +123,17 @@ const ROMInfo* ROMImage::getROMInfo() const {
 	return romInfo;
 }
 
-} // namespace MT32Emu
+ControlROMFeatureSet::ControlROMFeatureSet(bool useDefaultReverbMT32Compatible, bool useOldMT32AnalogLPF) :
+	defaultReverbMT32Compatible(useDefaultReverbMT32Compatible),
+	oldMT32AnalogLPF(useOldMT32AnalogLPF)
+{}
+
+bool ControlROMFeatureSet::isDefaultReverbMT32Compatible() const {
+	return defaultReverbMT32Compatible;
+}
+
+bool ControlROMFeatureSet::isOldMT32AnalogLPF() const {
+	return oldMT32AnalogLPF;
+}
+
+}
diff --git a/audio/softsynth/mt32/ROMInfo.h b/audio/softsynth/mt32/ROMInfo.h
index 8a5ad141b6..4682620a15 100644
--- a/audio/softsynth/mt32/ROMInfo.h
+++ b/audio/softsynth/mt32/ROMInfo.h
@@ -1,5 +1,5 @@
 /* Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Dean Beeler, Jerome Fisher
- * Copyright (C) 2011-2016 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
+ * Copyright (C) 2011, 2012, 2013, 2014 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
@@ -18,63 +18,73 @@
 #ifndef MT32EMU_ROMINFO_H
 #define MT32EMU_ROMINFO_H
 
-#include <cstddef>
-
-#include "globals.h"
-#include "File.h"
+//#include <cstddef>
+#include "common/file.h"
 
 namespace MT32Emu {
 
+struct ControlROMFeatureSet;
+
 // Defines vital info about ROM file to be used by synth and applications
 
 struct ROMInfo {
 public:
 	size_t fileSize;
-	const File::SHA1Digest &sha1Digest;
+	const char *sha1Digest;
 	enum Type {PCM, Control, Reverb} type;
 	const char *shortName;
 	const char *description;
 	enum PairType {Full, FirstHalf, SecondHalf, Mux0, Mux1} pairType;
 	ROMInfo *pairROMInfo;
+	const ControlROMFeatureSet *controlROMFeatures;
 
 	// Returns a ROMInfo struct by inspecting the size and the SHA1 hash
-	MT32EMU_EXPORT static const ROMInfo* getROMInfo(File *file);
+	static const ROMInfo* getROMInfo(Common::File *file);
 
 	// Currently no-op
-	MT32EMU_EXPORT static void freeROMInfo(const ROMInfo *romInfo);
+	static void freeROMInfo(const ROMInfo *romInfo);
 
 	// Allows retrieving a NULL-terminated list of ROMInfos for a range of types and pairTypes
 	// (specified by bitmasks)
 	// Useful for GUI/console app to output information on what ROMs it supports
-	MT32EMU_EXPORT static const ROMInfo** getROMInfoList(Bit32u types, Bit32u pairTypes);
+	static const ROMInfo** getROMInfoList(unsigned int types, unsigned int pairTypes);
 
 	// Frees the list of ROMInfos given
-	MT32EMU_EXPORT static void freeROMInfoList(const ROMInfo **romInfos);
+	static void freeROMInfoList(const ROMInfo **romInfos);
 };
 
 // Synth::open() is to require a full control ROMImage and a full PCM ROMImage to work
 
 class ROMImage {
 private:
-	File * const file;
-	const ROMInfo * const romInfo;
-
-	ROMImage(File *file);
-	~ROMImage();
+	Common::File *file;
+	const ROMInfo *romInfo;
 
 public:
+
 	// Creates a ROMImage object given a ROMInfo and a File. Keeps a reference
 	// to the File and ROMInfo given, which must be freed separately by the user
 	// after the ROMImage is freed
-	MT32EMU_EXPORT static const ROMImage* makeROMImage(File *file);
+	static const ROMImage* makeROMImage(Common::File *file);
 
 	// Must only be done after all Synths using the ROMImage are deleted
-	MT32EMU_EXPORT static void freeROMImage(const ROMImage *romImage);
+	static void freeROMImage(const ROMImage *romImage);
 
-	MT32EMU_EXPORT File *getFile() const;
-	MT32EMU_EXPORT const ROMInfo *getROMInfo() const;
+	Common::File *getFile() const;
+	const ROMInfo *getROMInfo() const;
+};
+
+struct ControlROMFeatureSet {
+private:
+	unsigned int defaultReverbMT32Compatible : 1;
+	unsigned int oldMT32AnalogLPF : 1;
+
+public:
+	ControlROMFeatureSet(bool defaultReverbMT32Compatible, bool oldMT32AnalogLPF);
+	bool isDefaultReverbMT32Compatible() const;
+	bool isOldMT32AnalogLPF() const;
 };
 
-} // namespace MT32Emu
+}
 
-#endif // #ifndef MT32EMU_ROMINFO_H
+#endif
diff --git a/audio/softsynth/mt32/Structures.h b/audio/softsynth/mt32/Structures.h
index 6dcb9c86a9..4dada3a847 100644
--- a/audio/softsynth/mt32/Structures.h
+++ b/audio/softsynth/mt32/Structures.h
@@ -1,5 +1,5 @@
 /* Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Dean Beeler, Jerome Fisher
- * Copyright (C) 2011-2016 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
+ * Copyright (C) 2011, 2012, 2013, 2014 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
@@ -18,9 +18,6 @@
 #ifndef MT32EMU_STRUCTURES_H
 #define MT32EMU_STRUCTURES_H
 
-#include "globals.h"
-#include "Types.h"
-
 namespace MT32Emu {
 
 // MT32EMU_MEMADDR() converts from sysex-padded, MT32EMU_SYSEXMEMADDR converts to it
@@ -105,8 +102,8 @@ struct TimbreParam {
 			Bit8u envTime[5]; // 0-100
 			Bit8u envLevel[4]; // 0-100 // [3]: SUSTAIN LEVEL
 		} MT32EMU_ALIGN_PACKED tva;
-	} MT32EMU_ALIGN_PACKED partial[4]; // struct PartialParam
-} MT32EMU_ALIGN_PACKED; // struct TimbreParam
+	} MT32EMU_ALIGN_PACKED partial[4];
+} MT32EMU_ALIGN_PACKED;
 
 struct PatchParam {
 	Bit8u timbreGroup; // TIMBRE GROUP  0-3 (group A, group B, Memory, Rhythm)
@@ -166,16 +163,7 @@ struct MemParams {
 		Bit8u chanAssign[9]; // MIDI CHANNEL (PART1) 0-16 (1-16,OFF)
 		Bit8u masterVol; // MASTER VOLUME 0-100
 	} MT32EMU_ALIGN_PACKED system;
-}; // struct MemParams
-
-struct SoundGroup {
-	Bit8u timbreNumberTableAddrLow;
-	Bit8u timbreNumberTableAddrHigh;
-	Bit8u displayPosition;
-	Bit8u name[9];
-	Bit8u timbreCount;
-	Bit8u pad;
-} MT32EMU_ALIGN_PACKED;
+};
 
 #if defined(_MSC_VER) || defined(__MINGW32__)
 #pragma pack(pop)
@@ -183,17 +171,10 @@ struct SoundGroup {
 #pragma pack()
 #endif
 
-struct ControlROMFeatureSet {
-	unsigned int quirkPitchEnvelopeOverflow : 1;
-
-	// Features below don't actually depend on control ROM version, which is used to identify hardware model
-	unsigned int defaultReverbMT32Compatible : 1;
-	unsigned int oldMT32AnalogLPF : 1;
-};
-
 struct ControlROMMap {
-	const char *shortName;
-	const ControlROMFeatureSet &featureSet;
+	Bit16u idPos;
+	Bit16u idLen;
+	const char *idBytes;
 	Bit16u pcmTable; // 4 * pcmCount bytes
 	Bit16u pcmCount;
 	Bit16u timbreAMap; // 128 bytes
@@ -213,8 +194,6 @@ struct ControlROMMap {
 	Bit16u patchMaxTable; // 16 bytes
 	Bit16u systemMaxTable; // 23 bytes
 	Bit16u timbreMaxTable; // 72 bytes
-	Bit16u soundGroupsTable; // 14 bytes each entry
-	Bit16u soundGroupsCount;
 };
 
 struct ControlROMPCMStruct {
@@ -236,7 +215,7 @@ struct PatchCache {
 	bool playPartial;
 	bool PCMPartial;
 	int pcm;
-	Bit8u waveform;
+	char waveform;
 
 	Bit32u structureMix;
 	int structurePosition;
@@ -254,6 +233,6 @@ struct PatchCache {
 	const TimbreParam::PartialParam *partialParam;
 };
 
-} // namespace MT32Emu
+}
 
-#endif // #ifndef MT32EMU_STRUCTURES_H
+#endif
diff --git a/audio/softsynth/mt32/Synth.cpp b/audio/softsynth/mt32/Synth.cpp
index ca28898205..6df7eb9e31 100644
--- a/audio/softsynth/mt32/Synth.cpp
+++ b/audio/softsynth/mt32/Synth.cpp
@@ -1,5 +1,5 @@
 /* Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Dean Beeler, Jerome Fisher
- * Copyright (C) 2011-2016 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
+ * Copyright (C) 2011, 2012, 2013, 2014 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
@@ -15,138 +15,42 @@
  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <cstdio>
+//#include <cerrno>
+//#include <cmath>
+//#include <cstdlib>
+//#include <cstring>
 
+#include "mt32emu.h"
+#include "mmath.h"
 #include "internals.h"
 
-#include "Synth.h"
 #include "Analog.h"
 #include "BReverbModel.h"
-#include "File.h"
 #include "MemoryRegion.h"
 #include "MidiEventQueue.h"
-#include "Part.h"
-#include "Partial.h"
 #include "PartialManager.h"
-#include "Poly.h"
-#include "ROMInfo.h"
-#include "TVA.h"
 
 namespace MT32Emu {
 
 // MIDI interface data transfer rate in samples. Used to simulate the transfer delay.
 static const double MIDI_DATA_TRANSFER_RATE = (double)SAMPLE_RATE / 31250.0 * 8.0;
 
-// FIXME: there should be more specific feature sets for various MT-32 control ROM versions
-static const ControlROMFeatureSet OLD_MT32_COMPATIBLE = { true, true, true };
-static const ControlROMFeatureSet CM32L_COMPATIBLE = { false, false, false };
-
 static const ControlROMMap ControlROMMaps[7] = {
-	//     ID                Features        PCMmap  PCMc  tmbrA  tmbrAO, tmbrAC tmbrB   tmbrBO  tmbrBC tmbrR   trC rhythm rhyC  rsrv   panpot   prog   rhyMax  patMax  sysMax  timMax  sndGrp sGC
-	{ "ctrl_mt32_1_04", OLD_MT32_COMPATIBLE, 0x3000, 128, 0x8000, 0x0000, false, 0xC000, 0x4000, false, 0x3200, 30, 0x73A6, 85, 0x57C7, 0x57E2, 0x57D0, 0x5252, 0x525E, 0x526E, 0x520A, 0x7064, 19 },
-	{ "ctrl_mt32_1_05", OLD_MT32_COMPATIBLE, 0x3000, 128, 0x8000, 0x0000, false, 0xC000, 0x4000, false, 0x3200, 30, 0x7414, 85, 0x57C7, 0x57E2, 0x57D0, 0x5252, 0x525E, 0x526E, 0x520A, 0x70CA, 19 },
-	{ "ctrl_mt32_1_06", OLD_MT32_COMPATIBLE, 0x3000, 128, 0x8000, 0x0000, false, 0xC000, 0x4000, false, 0x3200, 30, 0x7414, 85, 0x57D9, 0x57F4, 0x57E2, 0x5264, 0x5270, 0x5280, 0x521C, 0x70CA, 19 },
-	{ "ctrl_mt32_1_07", OLD_MT32_COMPATIBLE, 0x3000, 128, 0x8000, 0x0000, false, 0xC000, 0x4000, false, 0x3200, 30, 0x73fe, 85, 0x57B1, 0x57CC, 0x57BA, 0x523C, 0x5248, 0x5258, 0x51F4, 0x70B0, 19 }, // MT-32 revision 1
-	{"ctrl_mt32_bluer", OLD_MT32_COMPATIBLE, 0x3000, 128, 0x8000, 0x0000, false, 0xC000, 0x4000, false, 0x3200, 30, 0x741C, 85, 0x57E5, 0x5800, 0x57EE, 0x5270, 0x527C, 0x528C, 0x5228, 0x70CE, 19 }, // MT-32 Blue Ridge mod
-	{"ctrl_cm32l_1_00",  CM32L_COMPATIBLE,   0x8100, 256, 0x8000, 0x8000, true,  0x8080, 0x8000, true,  0x8500, 64, 0x8580, 85, 0x4F65, 0x4F80, 0x4F6E, 0x48A1, 0x48A5, 0x48BE, 0x48D5, 0x5A6C, 19 },
-	{"ctrl_cm32l_1_02",  CM32L_COMPATIBLE,   0x8100, 256, 0x8000, 0x8000, true,  0x8080, 0x8000, true,  0x8500, 64, 0x8580, 85, 0x4F93, 0x4FAE, 0x4F9C, 0x48CB, 0x48CF, 0x48E8, 0x48FF, 0x5A96, 19 }  // CM-32L
+	// ID    IDc IDbytes                     PCMmap  PCMc  tmbrA   tmbrAO, tmbrAC tmbrB   tmbrBO, tmbrBC tmbrR   trC  rhythm  rhyC  rsrv    panpot  prog    rhyMax  patMax  sysMax  timMax
+	{0x4014, 22, "\000 ver1.04 14 July 87 ", 0x3000,  128, 0x8000, 0x0000, false, 0xC000, 0x4000, false, 0x3200,  30, 0x73A6,  85,  0x57C7, 0x57E2, 0x57D0, 0x5252, 0x525E, 0x526E, 0x520A},
+	{0x4014, 22, "\000 ver1.05 06 Aug, 87 ", 0x3000,  128, 0x8000, 0x0000, false, 0xC000, 0x4000, false, 0x3200,  30, 0x7414,  85,  0x57C7, 0x57E2, 0x57D0, 0x5252, 0x525E, 0x526E, 0x520A},
+	{0x4014, 22, "\000 ver1.06 31 Aug, 87 ", 0x3000,  128, 0x8000, 0x0000, false, 0xC000, 0x4000, false, 0x3200,  30, 0x7414,  85,  0x57D9, 0x57F4, 0x57E2, 0x5264, 0x5270, 0x5280, 0x521C},
+	{0x4010, 22, "\000 ver1.07 10 Oct, 87 ", 0x3000,  128, 0x8000, 0x0000, false, 0xC000, 0x4000, false, 0x3200,  30, 0x73fe,  85,  0x57B1, 0x57CC, 0x57BA, 0x523C, 0x5248, 0x5258, 0x51F4}, // MT-32 revision 1
+	{0x4010, 22, "\000verX.XX  30 Sep, 88 ", 0x3000,  128, 0x8000, 0x0000, false, 0xC000, 0x4000, false, 0x3200,  30, 0x741C,  85,  0x57E5, 0x5800, 0x57EE, 0x5270, 0x527C, 0x528C, 0x5228}, // MT-32 Blue Ridge mod
+	{0x2205, 22, "\000CM32/LAPC1.00 890404", 0x8100,  256, 0x8000, 0x8000, false, 0x8080, 0x8000, false, 0x8500,  64, 0x8580,  85,  0x4F65, 0x4F80, 0x4F6E, 0x48A1, 0x48A5, 0x48BE, 0x48D5},
+	{0x2205, 22, "\000CM32/LAPC1.02 891205", 0x8100,  256, 0x8000, 0x8000, true,  0x8080, 0x8000, true,  0x8500,  64, 0x8580,  85,  0x4F93, 0x4FAE, 0x4F9C, 0x48CB, 0x48CF, 0x48E8, 0x48FF}  // CM-32L
 	// (Note that all but CM-32L ROM actually have 86 entries for rhythmTemp)
 };
 
-static const PartialState PARTIAL_PHASE_TO_STATE[8] = {
-	PartialState_ATTACK, PartialState_ATTACK, PartialState_ATTACK, PartialState_ATTACK,
-	PartialState_SUSTAIN, PartialState_SUSTAIN, PartialState_RELEASE, PartialState_INACTIVE
-};
-
-static inline PartialState getPartialState(PartialManager *partialManager, unsigned int partialNum) {
-	const Partial *partial = partialManager->getPartial(partialNum);
-	return partial->isActive() ? PARTIAL_PHASE_TO_STATE[partial->getTVA()->getPhase()] : PartialState_INACTIVE;
-}
-
-static inline Bit16s convertSample(float sample) {
-	return Synth::clipSampleEx(Bit32s(sample * 16384.0f)); // This multiplier takes into account the DAC bit shift
-}
-
-static inline float convertSample(Bit16s sample) {
-	return float(sample) / 16384.0f; // This multiplier takes into account the DAC bit shift
-}
-
-class SampleFormatConverter {
-protected:
-#if MT32EMU_USE_FLOAT_SAMPLES
-	Bit16s *outBuffer;
-#else
-	float *outBuffer;
-#endif
-
-public:
-	Sample *sampleBuffer;
-
-	SampleFormatConverter(Sample *buffer) : outBuffer(NULL), sampleBuffer(buffer) {}
-
-	inline bool isConversionNeeded() {
-		return outBuffer != NULL;
-	}
-
-	inline void convert(Bit32u len) {
-		if (sampleBuffer == NULL) return;
-		if (outBuffer == NULL) {
-			sampleBuffer += len;
-			return;
-		}
-		Sample *inBuffer = sampleBuffer;
-		while (len--) {
-			*(outBuffer++) = convertSample(*(inBuffer++));
-		}
-	}
-
-	inline void addSilence(Bit32u len) {
-		if (outBuffer != NULL) {
-			Synth::muteSampleBuffer(outBuffer, len);
-			outBuffer += len;
-		} else if (sampleBuffer != NULL) {
-			Synth::muteSampleBuffer(sampleBuffer, len);
-			sampleBuffer += len;
-		}
-	}
-};
-
-template <int BUFFER_SIZE_MULTIPLIER = 1>
-class BufferedSampleFormatConverter : public SampleFormatConverter {
-	Sample renderingBuffer[BUFFER_SIZE_MULTIPLIER * MAX_SAMPLES_PER_RUN];
-
-public:
-#if MT32EMU_USE_FLOAT_SAMPLES
-	BufferedSampleFormatConverter(Bit16s *buffer)
-#else
-	BufferedSampleFormatConverter(float *buffer)
-#endif
-		: SampleFormatConverter(renderingBuffer)
-	{
-		outBuffer = buffer;
-		if (buffer == NULL) sampleBuffer = NULL;
+static inline void advanceStreamPosition(Sample *&stream, Bit32u posDelta) {
+	if (stream != NULL) {
+		stream += posDelta;
 	}
-};
-
-class Renderer {
-	Synth &synth;
-
-public:
-	Renderer(Synth &useSynth) : synth(useSynth) {}
-
-	void render(SampleFormatConverter &converter, Bit32u len);
-	void renderStreams(SampleFormatConverter &nonReverbLeft, SampleFormatConverter &nonReverbRight, SampleFormatConverter &reverbDryLeft, SampleFormatConverter &reverbDryRight, SampleFormatConverter &reverbWetLeft, SampleFormatConverter &reverbWetRight, Bit32u len);
-	void produceLA32Output(Sample *buffer, Bit32u len);
-	void convertSamplesToOutput(Sample *buffer, Bit32u len);
-	void doRenderStreams(Sample *nonReverbLeft, Sample *nonReverbRight, Sample *reverbDryLeft, Sample *reverbDryRight, Sample *reverbWetLeft, Sample *reverbWetRight, Bit32u len);
-};
-
-Bit32u Synth::getLibraryVersionInt() {
-	return (MT32EMU_VERSION_MAJOR << 16) | (MT32EMU_VERSION_MINOR << 8) | (MT32EMU_VERSION_PATCH);
-}
-
-const char *Synth::getLibraryVersionString() {
-	return MT32EMU_VERSION;
 }
 
 Bit8u Synth::calcSysexChecksum(const Bit8u *data, const Bit32u len, const Bit8u initChecksum) {
@@ -157,17 +61,10 @@ Bit8u Synth::calcSysexChecksum(const Bit8u *data, const Bit32u len, const Bit8u
 	return Bit8u(checksum & 0x7f);
 }
 
-Bit32u Synth::getStereoOutputSampleRate(AnalogOutputMode analogOutputMode) {
-	static const unsigned int SAMPLE_RATES[] = {SAMPLE_RATE, SAMPLE_RATE, SAMPLE_RATE * 3 / 2, SAMPLE_RATE * 3};
-
-	return SAMPLE_RATES[analogOutputMode];
-}
-
-Synth::Synth(ReportHandler *useReportHandler) : mt32ram(*new MemParams), mt32default(*new MemParams), renderer(*new Renderer(*this)) {
-	opened = false;
+Synth::Synth(ReportHandler *useReportHandler) : mt32ram(*new MemParams()), mt32default(*new MemParams()) {
+	isOpen = false;
 	reverbOverridden = false;
 	partialCount = DEFAULT_MAX_PARTIALS;
-	controlROMMap = NULL;
 	controlROMFeatures = NULL;
 
 	if (useReportHandler == NULL) {
@@ -188,27 +85,11 @@ Synth::Synth(ReportHandler *useReportHandler) : mt32ram(*new MemParams), mt32def
 	setOutputGain(1.0f);
 	setReverbOutputGain(1.0f);
 	setReversedStereoEnabled(false);
-
-	patchTempMemoryRegion = NULL;
-	rhythmTempMemoryRegion = NULL;
-	timbreTempMemoryRegion = NULL;
-	patchesMemoryRegion = NULL;
-	timbresMemoryRegion = NULL;
-	systemMemoryRegion = NULL;
-	displayMemoryRegion = NULL;
-	resetMemoryRegion = NULL;
-	paddedTimbreMaxTable = NULL;
-
 	partialManager = NULL;
-	pcmWaves = NULL;
-	pcmROMData = NULL;
-	soundGroupNames = NULL;
 	midiQueue = NULL;
 	lastReceivedMIDIEventTimestamp = 0;
 	memset(parts, 0, sizeof(parts));
 	renderedSampleCount = 0;
-
-	reserved = NULL;
 }
 
 Synth::~Synth() {
@@ -218,52 +99,47 @@ Synth::~Synth() {
 	}
 	delete &mt32ram;
 	delete &mt32default;
-	delete &renderer;
 }
 
 void ReportHandler::showLCDMessage(const char *data) {
-	printf("WRITE-LCD: %s\n", data);
+	// We cannot use printf here. Since we already implement our own
+	// ReportHandler we simply disable the default implementation since it is
+	// never called anyway.
+#if 0
+	printf("WRITE-LCD: %s", data);
+	printf("\n");
+#endif
 }
 
 void ReportHandler::printDebug(const char *fmt, va_list list) {
+	// We cannot use (v)printf here. Since we already implement our own
+	// ReportHandler we simply disable the default implementation since it is
+	// never called anyway.
+#if 0
 	vprintf(fmt, list);
 	printf("\n");
+#endif
 }
 
-void Synth::newTimbreSet(Bit8u partNum, Bit8u timbreGroup, Bit8u timbreNumber, const char patchName[]) {
-	const char *soundGroupName;
-	switch (timbreGroup) {
-	case 1:
-		timbreNumber += 64;
-		// Fall-through
-	case 0:
-		soundGroupName = soundGroupNames[soundGroupIx[timbreNumber]];
-		break;
-	case 2:
-		soundGroupName = soundGroupNames[controlROMMap->soundGroupsCount - 2];
-		break;
-	case 3:
-		soundGroupName = soundGroupNames[controlROMMap->soundGroupsCount - 1];
-		break;
-	default:
-		soundGroupName = NULL;
-		break;
-	}
-	reportHandler->onProgramChanged(partNum, soundGroupName, patchName);
+void Synth::polyStateChanged(int partNum) {
+	reportHandler->onPolyStateChanged(partNum);
+}
+
+void Synth::newTimbreSet(int partNum, Bit8u timbreGroup, const char patchName[]) {
+	reportHandler->onProgramChanged(partNum, timbreGroup, patchName);
 }
 
 void Synth::printDebug(const char *fmt, ...) {
 	va_list ap;
 	va_start(ap, fmt);
 #if MT32EMU_DEBUG_SAMPLESTAMPS > 0
-	reportHandler->printDebug("[%u]", (va_list)&renderedSampleCount);
+	reportHandler->printDebug("[%u] ", (char *)&renderedSampleCount);
 #endif
 	reportHandler->printDebug(fmt, ap);
 	va_end(ap);
 }
 
 void Synth::setReverbEnabled(bool newReverbEnabled) {
-	if (!opened) return;
 	if (isReverbEnabled() == newReverbEnabled) return;
 	if (newReverbEnabled) {
 		bool oldReverbOverridden = reverbOverridden;
@@ -291,23 +167,30 @@ bool Synth::isReverbOverridden() const {
 }
 
 void Synth::setReverbCompatibilityMode(bool mt32CompatibleMode) {
-	if (!opened || (isMT32ReverbCompatibilityMode() == mt32CompatibleMode)) return;
-	bool oldReverbEnabled = isReverbEnabled();
-	setReverbEnabled(false);
-	for (int i = 0; i < 4; i++) {
-		delete reverbModels[i];
+	if (reverbModels[REVERB_MODE_ROOM] != NULL) {
+		if (isMT32ReverbCompatibilityMode() == mt32CompatibleMode) return;
+		setReverbEnabled(false);
+		for (int i = 0; i < 4; i++) {
+			delete reverbModels[i];
+		}
+	}
+	reverbModels[REVERB_MODE_ROOM] = new BReverbModel(REVERB_MODE_ROOM, mt32CompatibleMode);
+	reverbModels[REVERB_MODE_HALL] = new BReverbModel(REVERB_MODE_HALL, mt32CompatibleMode);
+	reverbModels[REVERB_MODE_PLATE] = new BReverbModel(REVERB_MODE_PLATE, mt32CompatibleMode);
+	reverbModels[REVERB_MODE_TAP_DELAY] = new BReverbModel(REVERB_MODE_TAP_DELAY, mt32CompatibleMode);
+#if !MT32EMU_REDUCE_REVERB_MEMORY
+	for (int i = REVERB_MODE_ROOM; i <= REVERB_MODE_TAP_DELAY; i++) {
+		reverbModels[i]->open();
+	}
+#endif
+	if (isOpen) {
+		setReverbOutputGain(reverbOutputGain);
+		setReverbEnabled(true);
 	}
-	initReverbModels(mt32CompatibleMode);
-	setReverbEnabled(oldReverbEnabled);
-	setReverbOutputGain(reverbOutputGain);
 }
 
 bool Synth::isMT32ReverbCompatibilityMode() const {
-	return opened && (reverbModels[REVERB_MODE_ROOM]->isMT32Compatible(REVERB_MODE_ROOM));
-}
-
-bool Synth::isDefaultReverbMT32Compatible() const {
-	return opened && controlROMFeatures->defaultReverbMT32Compatible;
+	return isOpen && (reverbModels[REVERB_MODE_ROOM]->isMT32Compatible(REVERB_MODE_ROOM));
 }
 
 void Synth::setDACInputMode(DACInputMode mode) {
@@ -356,18 +239,22 @@ void Synth::setReversedStereoEnabled(bool enabled) {
 	reversedStereoEnabled = enabled;
 }
 
-bool Synth::isReversedStereoEnabled() const {
+bool Synth::isReversedStereoEnabled() {
 	return reversedStereoEnabled;
 }
 
 bool Synth::loadControlROM(const ROMImage &controlROMImage) {
-	File *file = controlROMImage.getFile();
+	Common::File *file = controlROMImage.getFile();
 	const ROMInfo *controlROMInfo = controlROMImage.getROMInfo();
 	if ((controlROMInfo == NULL)
 			|| (controlROMInfo->type != ROMInfo::Control)
 			|| (controlROMInfo->pairType != ROMInfo::Full)) {
+		return false;
+	}
+	controlROMFeatures = controlROMImage.getROMInfo()->controlROMFeatures;
+	if (controlROMFeatures == NULL) {
 #if MT32EMU_MONITOR_INIT
-		printDebug("Invalid Control ROM Info provided");
+		printDebug("Invalid Control ROM Info provided without feature set");
 #endif
 		return false;
 	}
@@ -375,16 +262,13 @@ bool Synth::loadControlROM(const ROMImage &controlROMImage) {
 #if MT32EMU_MONITOR_INIT
 	printDebug("Found Control ROM: %s, %s", controlROMInfo->shortName, controlROMInfo->description);
 #endif
-	const Bit8u *fileData = file->getData();
-	memcpy(controlROMData, fileData, CONTROL_ROM_SIZE);
+	file->read(controlROMData, CONTROL_ROM_SIZE);
 
 	// Control ROM successfully loaded, now check whether it's a known type
 	controlROMMap = NULL;
-	controlROMFeatures = NULL;
 	for (unsigned int i = 0; i < sizeof(ControlROMMaps) / sizeof(ControlROMMaps[0]); i++) {
-		if (strcmp(controlROMInfo->shortName, ControlROMMaps[i].shortName) == 0) {
+		if (memcmp(&controlROMData[ControlROMMaps[i].idPos], ControlROMMaps[i].idBytes, ControlROMMaps[i].idLen) == 0) {
 			controlROMMap = &ControlROMMaps[i];
-			controlROMFeatures = &controlROMMap->featureSet;
 			return true;
 		}
 	}
@@ -395,7 +279,7 @@ bool Synth::loadControlROM(const ROMImage &controlROMImage) {
 }
 
 bool Synth::loadPCMROM(const ROMImage &pcmROMImage) {
-	File *file = pcmROMImage.getFile();
+	Common::File *file = pcmROMImage.getFile();
 	const ROMInfo *pcmROMInfo = pcmROMImage.getROMInfo();
 	if ((pcmROMInfo == NULL)
 			|| (pcmROMInfo->type != ROMInfo::PCM)
@@ -405,21 +289,24 @@ bool Synth::loadPCMROM(const ROMImage &pcmROMImage) {
 #if MT32EMU_MONITOR_INIT
 	printDebug("Found PCM ROM: %s, %s", pcmROMInfo->shortName, pcmROMInfo->description);
 #endif
-	size_t fileSize = file->getSize();
+	size_t fileSize = file->size();
 	if (fileSize != (2 * pcmROMSize)) {
 #if MT32EMU_MONITOR_INIT
 		printDebug("PCM ROM file has wrong size (expected %d, got %d)", 2 * pcmROMSize, fileSize);
 #endif
 		return false;
 	}
-	const Bit8u *fileData = file->getData();
+
+	byte *buffer = new byte[file->size()];
+	file->read(buffer, file->size());
+	const byte *fileData = buffer;
 	for (size_t i = 0; i < pcmROMSize; i++) {
 		Bit8u s = *(fileData++);
 		Bit8u c = *(fileData++);
 
 		int order[16] = {0, 9, 1, 2, 3, 4, 5, 6, 7, 10, 11, 12, 13, 14, 15, 8};
 
-		Bit16s log = 0;
+		signed short log = 0;
 		for (int u = 0; u < 15; u++) {
 			int bit;
 			if (order[u] < 8) {
@@ -427,10 +314,13 @@ bool Synth::loadPCMROM(const ROMImage &pcmROMImage) {
 			} else {
 				bit = (c >> (7 - (order[u] - 8))) & 0x1;
 			}
-			log = log | (Bit16s)(bit << (15 - u));
+			log = log | (short)(bit << (15 - u));
 		}
 		pcmROMData[i] = log;
 	}
+
+	delete[] buffer;
+
 	return true;
 }
 
@@ -455,7 +345,7 @@ bool Synth::initPCMList(Bit16u mapAddress, Bit16u count) {
 	return false;
 }
 
-bool Synth::initCompressedTimbre(Bit16u timbreNum, const Bit8u *src, Bit32u srcLen) {
+bool Synth::initCompressedTimbre(int timbreNum, const Bit8u *src, unsigned int srcLen) {
 	// "Compressed" here means that muted partials aren't present in ROM (except in the case of partial 0 being muted).
 	// Instead the data from the previous unmuted partial is used.
 	if (srcLen < sizeof(TimbreParam::CommonParam)) {
@@ -479,7 +369,7 @@ bool Synth::initCompressedTimbre(Bit16u timbreNum, const Bit8u *src, Bit32u srcL
 	return true;
 }
 
-bool Synth::initTimbres(Bit16u mapAddress, Bit16u offset, Bit16u count, Bit16u startTimbre, bool compressed) {
+bool Synth::initTimbres(Bit16u mapAddress, Bit16u offset, int count, int startTimbre, bool compressed) {
 	const Bit8u *timbreMap = &controlROMData[mapAddress];
 	for (Bit16u i = 0; i < count * 2; i += 2) {
 		Bit16u address = (timbreMap[i + 1] << 8) | timbreMap[i];
@@ -501,32 +391,12 @@ bool Synth::initTimbres(Bit16u mapAddress, Bit16u offset, Bit16u count, Bit16u s
 	return true;
 }
 
-void Synth::initReverbModels(bool mt32CompatibleMode) {
-	reverbModels[REVERB_MODE_ROOM] = new BReverbModel(REVERB_MODE_ROOM, mt32CompatibleMode);
-	reverbModels[REVERB_MODE_HALL] = new BReverbModel(REVERB_MODE_HALL, mt32CompatibleMode);
-	reverbModels[REVERB_MODE_PLATE] = new BReverbModel(REVERB_MODE_PLATE, mt32CompatibleMode);
-	reverbModels[REVERB_MODE_TAP_DELAY] = new BReverbModel(REVERB_MODE_TAP_DELAY, mt32CompatibleMode);
-#if !MT32EMU_REDUCE_REVERB_MEMORY
-	for (int i = REVERB_MODE_ROOM; i <= REVERB_MODE_TAP_DELAY; i++) {
-		reverbModels[i]->open();
-	}
-#endif
-}
-
-void Synth::initSoundGroups(char newSoundGroupNames[][9]) {
-	memcpy(soundGroupIx, &controlROMData[controlROMMap->soundGroupsTable - sizeof(soundGroupIx)], sizeof(soundGroupIx));
-	const SoundGroup *table = (SoundGroup *)&controlROMData[controlROMMap->soundGroupsTable];
-	for (unsigned int i = 0; i < controlROMMap->soundGroupsCount; i++) {
-		memcpy(&newSoundGroupNames[i][0], table[i].name, sizeof(table[i].name));
-	}
-}
-
 bool Synth::open(const ROMImage &controlROMImage, const ROMImage &pcmROMImage, AnalogOutputMode analogOutputMode) {
 	return open(controlROMImage, pcmROMImage, DEFAULT_MAX_PARTIALS, analogOutputMode);
 }
 
 bool Synth::open(const ROMImage &controlROMImage, const ROMImage &pcmROMImage, unsigned int usePartialCount, AnalogOutputMode analogOutputMode) {
-	if (opened) {
+	if (isOpen) {
 		return false;
 	}
 	partialCount = usePartialCount;
@@ -541,7 +411,6 @@ bool Synth::open(const ROMImage &controlROMImage, const ROMImage &pcmROMImage, u
 	if (!loadControlROM(controlROMImage)) {
 		printDebug("Init Error - Missing or invalid Control ROM image");
 		reportHandler->onErrorControlROM();
-		dispose();
 		return false;
 	}
 
@@ -559,24 +428,22 @@ bool Synth::open(const ROMImage &controlROMImage, const ROMImage &pcmROMImage, u
 	if (!loadPCMROM(pcmROMImage)) {
 		printDebug("Init Error - Missing PCM ROM image");
 		reportHandler->onErrorPCMROM();
-		dispose();
 		return false;
 	}
 
 #if MT32EMU_MONITOR_INIT
 	printDebug("Initialising Reverb Models");
 #endif
-	bool mt32CompatibleReverb = controlROMFeatures->defaultReverbMT32Compatible;
+	bool mt32CompatibleReverb = controlROMFeatures->isDefaultReverbMT32Compatible();
 #if MT32EMU_MONITOR_INIT
 	printDebug("Using %s Compatible Reverb Models", mt32CompatibleReverb ? "MT-32" : "CM-32L");
 #endif
-	initReverbModels(mt32CompatibleReverb);
+	setReverbCompatibilityMode(mt32CompatibleReverb);
 
 #if MT32EMU_MONITOR_INIT
 	printDebug("Initialising Timbre Bank A");
 #endif
 	if (!initTimbres(controlROMMap->timbreAMap, controlROMMap->timbreAOffset, 0x40, 0, controlROMMap->timbreACompressed)) {
-		dispose();
 		return false;
 	}
 
@@ -584,7 +451,6 @@ bool Synth::open(const ROMImage &controlROMImage, const ROMImage &pcmROMImage, u
 	printDebug("Initialising Timbre Bank B");
 #endif
 	if (!initTimbres(controlROMMap->timbreBMap, controlROMMap->timbreBOffset, 0x40, 64, controlROMMap->timbreBCompressed)) {
-		dispose();
 		return false;
 	}
 
@@ -592,7 +458,6 @@ bool Synth::open(const ROMImage &controlROMImage, const ROMImage &pcmROMImage, u
 	printDebug("Initialising Timbre Bank R");
 #endif
 	if (!initTimbres(controlROMMap->timbreRMap, 0, controlROMMap->timbreRCount, 192, true)) {
-		dispose();
 		return false;
 	}
 
@@ -654,10 +519,6 @@ bool Synth::open(const ROMImage &controlROMImage, const ROMImage &pcmROMImage, u
 	refreshSystem();
 	reverbOverridden = oldReverbOverridden;
 
-	char(*writableSoundGroupNames)[9] = new char[controlROMMap->soundGroupsCount][9];
-	soundGroupNames = writableSoundGroupNames;
-	initSoundGroups(writableSoundGroupNames);
-
 	for (int i = 0; i < 9; i++) {
 		MemParams::PatchTemp *patchTemp = &mt32ram.patchTemp[i];
 
@@ -689,12 +550,12 @@ bool Synth::open(const ROMImage &controlROMImage, const ROMImage &pcmROMImage, u
 
 	midiQueue = new MidiEventQueue();
 
-	analog = new Analog(analogOutputMode, controlROMFeatures->oldMT32AnalogLPF);
+	analog = new Analog(analogOutputMode, controlROMFeatures);
 	setOutputGain(outputGain);
 	setReverbOutputGain(reverbOutputGain);
 
-	opened = true;
-	activated = false;
+	isOpen = true;
+	isEnabled = false;
 
 #if MT32EMU_MONITOR_INIT
 	printDebug("*** Initialisation complete ***");
@@ -702,8 +563,10 @@ bool Synth::open(const ROMImage &controlROMImage, const ROMImage &pcmROMImage, u
 	return true;
 }
 
-void Synth::dispose() {
-	opened = false;
+void Synth::close(bool forced) {
+	if (!forced && !isOpen) {
+		return;
+	}
 
 	delete midiQueue;
 	midiQueue = NULL;
@@ -719,14 +582,8 @@ void Synth::dispose() {
 		parts[i] = NULL;
 	}
 
-	delete[] soundGroupNames;
-	soundGroupNames = NULL;
-
 	delete[] pcmWaves;
-	pcmWaves = NULL;
-
 	delete[] pcmROMData;
-	pcmROMData = NULL;
 
 	deleteMemoryRegions();
 
@@ -736,17 +593,7 @@ void Synth::dispose() {
 	}
 	reverbModel = NULL;
 	controlROMFeatures = NULL;
-	controlROMMap = NULL;
-}
-
-void Synth::close() {
-	if (opened) {
-		dispose();
-	}
-}
-
-bool Synth::isOpen() const {
-	return opened;
+	isOpen = false;
 }
 
 void Synth::flushMIDIQueue() {
@@ -817,19 +664,12 @@ bool Synth::playMsg(Bit32u msg) {
 }
 
 bool Synth::playMsg(Bit32u msg, Bit32u timestamp) {
-	if ((msg & 0xF8) == 0xF8) {
-		reportHandler->onMIDISystemRealtime((Bit8u)msg);
-		return true;
-	}
 	if (midiQueue == NULL) return false;
 	if (midiDelayMode != MIDIDelayMode_IMMEDIATE) {
 		timestamp = addMIDIInterfaceDelay(getShortMessageLength(msg), timestamp);
 	}
-	if (!activated) activated = true;
-	do {
-		if (midiQueue->pushShortMessage(msg, timestamp)) return true;
-	} while (reportHandler->onMIDIQueueOverflow());
-	return false;
+	if (!isEnabled) isEnabled = true;
+	return midiQueue->pushShortMessage(msg, timestamp);
 }
 
 bool Synth::playSysex(const Bit8u *sysex, Bit32u len) {
@@ -841,28 +681,24 @@ bool Synth::playSysex(const Bit8u *sysex, Bit32u len, Bit32u timestamp) {
 	if (midiDelayMode == MIDIDelayMode_DELAY_ALL) {
 		timestamp = addMIDIInterfaceDelay(len, timestamp);
 	}
-	if (!activated) activated = true;
-	do {
-		if (midiQueue->pushSysex(sysex, len, timestamp)) return true;
-	} while (reportHandler->onMIDIQueueOverflow());
-	return false;
+	if (!isEnabled) isEnabled = true;
+	return midiQueue->pushSysex(sysex, len, timestamp);
 }
 
 void Synth::playMsgNow(Bit32u msg) {
-	if (!opened) return;
-
 	// NOTE: Active sense IS implemented in real hardware. However, realtime processing is clearly out of the library scope.
 	//       It is assumed that realtime consumers of the library respond to these MIDI events as appropriate.
 
-	Bit8u code = (Bit8u)((msg & 0x0000F0) >> 4);
-	Bit8u chan = (Bit8u)(msg & 0x00000F);
-	Bit8u note = (Bit8u)((msg & 0x007F00) >> 8);
-	Bit8u velocity = (Bit8u)((msg & 0x7F0000) >> 16);
+	unsigned char code     = (unsigned char)((msg & 0x0000F0) >> 4);
+	unsigned char chan     = (unsigned char)(msg & 0x00000F);
+	unsigned char note     = (unsigned char)((msg & 0x007F00) >> 8);
+	unsigned char velocity = (unsigned char)((msg & 0x7F0000) >> 16);
+	if (!isEnabled) isEnabled = true;
 
 	//printDebug("Playing chan %d, code 0x%01x note: 0x%02x", chan, code, note);
 
-	Bit8u part = chantable[chan];
-	if (part > 8) {
+	char part = chantable[chan];
+	if (part < 0 || part > 8) {
 #if MT32EMU_MONITOR_MIDI > 0
 		printDebug("Play msg on unreg chan %d (%d): code=0x%01x, vel=%d", chan, part, code, velocity);
 #endif
@@ -871,12 +707,9 @@ void Synth::playMsgNow(Bit32u msg) {
 	playMsgOnPart(part, code, note, velocity);
 }
 
-void Synth::playMsgOnPart(Bit8u part, Bit8u code, Bit8u note, Bit8u velocity) {
-	if (!opened) return;
-
+void Synth::playMsgOnPart(unsigned char part, unsigned char code, unsigned char note, unsigned char velocity) {
 	Bit32u bend;
 
-	if (!activated) activated = true;
 	//printDebug("Synth::playMsgOnPart(%02x, %02x, %02x, %02x)", part, code, note, velocity);
 	switch (code) {
 	case 0x8:
@@ -1016,7 +849,7 @@ void Synth::playSysexWithoutFraming(const Bit8u *sysex, Bit32u len) {
 	playSysexWithoutHeader(sysex[1], sysex[3], sysex + 4, len - 4);
 }
 
-void Synth::playSysexWithoutHeader(Bit8u device, Bit8u command, const Bit8u *sysex, Bit32u len) {
+void Synth::playSysexWithoutHeader(unsigned char device, unsigned char command, const Bit8u *sysex, Bit32u len) {
 	if (device > 0x10) {
 		// We have device ID 0x10 (default, but changeable, on real MT-32), < 0x10 is for channels
 		printDebug("playSysexWithoutHeader: Message is not intended for this device ID (provided: %02x, expected: 0x10 or channel)", (int)device);
@@ -1028,13 +861,6 @@ void Synth::playSysexWithoutHeader(Bit8u device, Bit8u command, const Bit8u *sys
 		reset();
 		return;
 	}
-
-	if (command == SYSEX_CMD_EOD) {
-#if MT32EMU_MONITOR_SYSEX > 0
-		printDebug("playSysexWithoutHeader: Ignored unsupported command %02x", command);
-#endif
-		return;
-	}
 	if (len < 4) {
 		printDebug("playSysexWithoutHeader: Message is too short (%d bytes)!", len);
 		return;
@@ -1046,19 +872,12 @@ void Synth::playSysexWithoutHeader(Bit8u device, Bit8u command, const Bit8u *sys
 	}
 	len -= 1; // Exclude checksum
 	switch (command) {
-	case SYSEX_CMD_WSD:
-#if MT32EMU_MONITOR_SYSEX > 0
-		printDebug("playSysexWithoutHeader: Ignored unsupported command %02x", command);
-#endif
-		break;
 	case SYSEX_CMD_DAT:
-		/* Outcommented until we (ever) actually implement handshake communication
 		if (hasActivePartials()) {
 			printDebug("playSysexWithoutHeader: Got SYSEX_CMD_DAT but partials are active - ignoring");
 			// FIXME: We should send SYSEX_CMD_RJC in this case
 			break;
 		}
-		*/
 		// Deliberate fall-through
 	case SYSEX_CMD_DT1:
 		writeSysex(device, sysex, len);
@@ -1079,12 +898,11 @@ void Synth::playSysexWithoutHeader(Bit8u device, Bit8u command, const Bit8u *sys
 	}
 }
 
-void Synth::readSysex(Bit8u /*device*/, const Bit8u * /*sysex*/, Bit32u /*len*/) const {
+void Synth::readSysex(unsigned char /*device*/, const Bit8u * /*sysex*/, Bit32u /*len*/) const {
 	// NYI
 }
 
-void Synth::writeSysex(Bit8u device, const Bit8u *sysex, Bit32u len) {
-	if (!opened) return;
+void Synth::writeSysex(unsigned char device, const Bit8u *sysex, Bit32u len) {
 	reportHandler->onMIDIMessagePlayed();
 	Bit32u addr = (sysex[0] << 16) | (sysex[1] << 8) | (sysex[2]);
 	addr = MT32EMU_MEMADDR(addr);
@@ -1100,7 +918,7 @@ void Synth::writeSysex(Bit8u device, const Bit8u *sysex, Bit32u len) {
 #endif
 		if (/*addr >= MT32EMU_MEMADDR(0x000000) && */addr < MT32EMU_MEMADDR(0x010000)) {
 			int offset;
-			if (chantable[device] > 8) {
+			if (chantable[device] == -1) {
 #if MT32EMU_MONITOR_SYSEX > 0
 				printDebug(" (Channel not mapped to a part... 0 offset)");
 #endif
@@ -1121,7 +939,7 @@ void Synth::writeSysex(Bit8u device, const Bit8u *sysex, Bit32u len) {
 			addr += MT32EMU_MEMADDR(0x030110) - MT32EMU_MEMADDR(0x010000);
 		} else if (/*addr >= MT32EMU_MEMADDR(0x020000) && */ addr < MT32EMU_MEMADDR(0x030000)) {
 			int offset;
-			if (chantable[device] > 8) {
+			if (chantable[device] == -1) {
 #if MT32EMU_MONITOR_SYSEX > 0
 				printDebug(" (Channel not mapped to a part... 0 offset)");
 #endif
@@ -1168,7 +986,6 @@ void Synth::writeSysex(Bit8u device, const Bit8u *sysex, Bit32u len) {
 }
 
 void Synth::readMemory(Bit32u addr, Bit32u len, Bit8u *data) {
-	if (!opened) return;
 	const MemoryRegion *region = findMemoryRegion(addr);
 	if (region != NULL) {
 		readMemoryRegion(region, addr, len, data);
@@ -1462,16 +1279,16 @@ void Synth::writeMemoryRegion(const MemoryRegion *region, Bit32u addr, Bit32u le
 			if(firstPart < 0)
 				firstPart = 0;
 			int lastPart = off + len - SYSTEM_CHAN_ASSIGN_START_OFF;
-			if(lastPart > 8)
-				lastPart = 8;
-			refreshSystemChanAssign((Bit8u)firstPart, (Bit8u)lastPart);
+			if(lastPart > 9)
+				lastPart = 9;
+			refreshSystemChanAssign(firstPart, lastPart);
 		}
 		if (off <= SYSTEM_MASTER_VOL_OFF && off + len > SYSTEM_MASTER_VOL_OFF) {
 			refreshSystemMasterVol();
 		}
 		break;
 	case MR_Display:
-		char buf[SYSEX_BUFFER_SIZE];
+		char buf[MAX_SYSEX_SIZE];
 		memcpy(&buf, &data[0], len);
 		buf[len] = 0;
 #if MT32EMU_MONITOR_SYSEX > 0
@@ -1544,19 +1361,19 @@ void Synth::refreshSystemReserveSettings() {
 	partialManager->setReserve(rset);
 }
 
-void Synth::refreshSystemChanAssign(Bit8u firstPart, Bit8u lastPart) {
-	memset(chantable, 0xFF, sizeof(chantable));
+void Synth::refreshSystemChanAssign(unsigned int firstPart, unsigned int lastPart) {
+	memset(chantable, -1, sizeof(chantable));
 
 	// CONFIRMED: In the case of assigning a channel to multiple parts, the lower part wins.
-	for (Bit32u i = 0; i <= 8; i++) {
+	for (unsigned int i = 0; i <= 8; i++) {
 		if (parts[i] != NULL && i >= firstPart && i <= lastPart) {
 			// CONFIRMED: Decay is started for all polys, and all controllers are reset, for every part whose assignment was touched by the sysex write.
 			parts[i]->allSoundOff();
 			parts[i]->resetAllControllers();
 		}
-		Bit8u chan = mt32ram.system.chanAssign[i];
-		if (chan < 16 && chantable[chan] > 8) {
-			chantable[chan] = (Bit8u)i;
+		int chan = mt32ram.system.chanAssign[i];
+		if (chan != 16 && chantable[chan] == -1) {
+			chantable[chan] = i;
 		}
 	}
 
@@ -1581,7 +1398,6 @@ void Synth::refreshSystem() {
 }
 
 void Synth::reset() {
-	if (!opened) return;
 #if MT32EMU_MONITOR_SYSEX > 0
 	printDebug("RESET");
 #endif
@@ -1597,7 +1413,7 @@ void Synth::reset() {
 		}
 	}
 	refreshSystem();
-	isActive();
+	isEnabled = false;
 }
 
 MidiEvent::~MidiEvent() {
@@ -1661,7 +1477,7 @@ bool MidiEventQueue::pushSysex(const Bit8u *sysexData, Bit32u sysexLength, Bit32
 }
 
 const MidiEvent *MidiEventQueue::peekMidiEvent() {
-	return isEmpty() ? NULL : &ringBuffer[startPosition];
+	return (startPosition == endPosition) ? NULL : &ringBuffer[startPosition];
 }
 
 void MidiEventQueue::dropMidiEvent() {
@@ -1675,24 +1491,15 @@ bool MidiEventQueue::isFull() const {
 	return startPosition == ((endPosition + 1) & ringBufferMask);
 }
 
-bool MidiEventQueue::isEmpty() const {
-	return startPosition == endPosition;
-}
-
-Bit32u Synth::getStereoOutputSampleRate() const {
+unsigned int Synth::getStereoOutputSampleRate() const {
 	return (analog == NULL) ? SAMPLE_RATE : analog->getOutputSampleRate();
 }
 
-void Renderer::render(SampleFormatConverter &converter, Bit32u len) {
-	if (!synth.opened) {
-		converter.addSilence(len << 1);
-		return;
-	}
-
-	if (!synth.activated) {
-		synth.renderedSampleCount += synth.analog->getDACStreamsLength(len);
-		synth.analog->process(NULL, NULL, NULL, NULL, NULL, NULL, NULL, len);
-		converter.addSilence(len << 1);
+void Synth::render(Sample *stream, Bit32u len) {
+	if (!isEnabled) {
+		renderedSampleCount += analog->getDACStreamsLength(len);
+		analog->process(NULL, NULL, NULL, NULL, NULL, NULL, NULL, len);
+		muteSampleBuffer(stream, len << 1);
 		return;
 	}
 
@@ -1703,53 +1510,19 @@ void Renderer::render(SampleFormatConverter &converter, Bit32u len) {
 
 	while (len > 0) {
 		Bit32u thisPassLen = len > MAX_SAMPLES_PER_RUN ? MAX_SAMPLES_PER_RUN : len;
-		synth.renderStreams(tmpNonReverbLeft, tmpNonReverbRight, tmpReverbDryLeft, tmpReverbDryRight, tmpReverbWetLeft, tmpReverbWetRight, synth.analog->getDACStreamsLength(thisPassLen));
-		synth.analog->process(converter.sampleBuffer, tmpNonReverbLeft, tmpNonReverbRight, tmpReverbDryLeft, tmpReverbDryRight, tmpReverbWetLeft, tmpReverbWetRight, thisPassLen);
-		converter.convert(thisPassLen << 1);
+		renderStreams(tmpNonReverbLeft, tmpNonReverbRight, tmpReverbDryLeft, tmpReverbDryRight, tmpReverbWetLeft, tmpReverbWetRight, analog->getDACStreamsLength(thisPassLen));
+		analog->process(&stream, tmpNonReverbLeft, tmpNonReverbRight, tmpReverbDryLeft, tmpReverbDryRight, tmpReverbWetLeft, tmpReverbWetRight, thisPassLen);
 		len -= thisPassLen;
 	}
 }
 
-void Synth::render(Bit16s *stream, Bit32u len) {
-#if MT32EMU_USE_FLOAT_SAMPLES
-	BufferedSampleFormatConverter<2> converter(stream);
-#else
-	SampleFormatConverter converter(stream);
-#endif
-	renderer.render(converter, len);
-}
-
-void Synth::render(float *stream, Bit32u len) {
-#if MT32EMU_USE_FLOAT_SAMPLES
-	SampleFormatConverter converter(stream);
-#else
-	BufferedSampleFormatConverter<2> converter(stream);
-#endif
-	renderer.render(converter, len);
-}
-
-void Renderer::renderStreams(
-	SampleFormatConverter &nonReverbLeft, SampleFormatConverter &nonReverbRight,
-	SampleFormatConverter &reverbDryLeft, SampleFormatConverter &reverbDryRight,
-	SampleFormatConverter &reverbWetLeft, SampleFormatConverter &reverbWetRight,
-	Bit32u len)
-{
-	if (!synth.opened) {
-		nonReverbLeft.addSilence(len);
-		nonReverbRight.addSilence(len);
-		reverbDryLeft.addSilence(len);
-		reverbDryRight.addSilence(len);
-		reverbWetLeft.addSilence(len);
-		reverbWetRight.addSilence(len);
-		return;
-	}
-
+void Synth::renderStreams(Sample *nonReverbLeft, Sample *nonReverbRight, Sample *reverbDryLeft, Sample *reverbDryRight, Sample *reverbWetLeft, Sample *reverbWetRight, Bit32u len) {
 	while (len > 0) {
 		// We need to ensure zero-duration notes will play so add minimum 1-sample delay.
 		Bit32u thisLen = 1;
-		if (!synth.isAbortingPoly()) {
-			const MidiEvent *nextEvent = synth.midiQueue->peekMidiEvent();
-			Bit32s samplesToNextEvent = (nextEvent != NULL) ? Bit32s(nextEvent->timestamp - synth.renderedSampleCount) : MAX_SAMPLES_PER_RUN;
+		if (!isAbortingPoly()) {
+			const MidiEvent *nextEvent = midiQueue->peekMidiEvent();
+			Bit32s samplesToNextEvent = (nextEvent != NULL) ? Bit32s(nextEvent->timestamp - renderedSampleCount) : MAX_SAMPLES_PER_RUN;
 			if (samplesToNextEvent > 0) {
 				thisLen = len > MAX_SAMPLES_PER_RUN ? MAX_SAMPLES_PER_RUN : len;
 				if (thisLen > (Bit32u)samplesToNextEvent) {
@@ -1757,85 +1530,37 @@ void Renderer::renderStreams(
 				}
 			} else {
 				if (nextEvent->sysexData == NULL) {
-					synth.playMsgNow(nextEvent->shortMessageData);
+					playMsgNow(nextEvent->shortMessageData);
 					// If a poly is aborting we don't drop the event from the queue.
 					// Instead, we'll return to it again when the abortion is done.
-					if (!synth.isAbortingPoly()) {
-						synth.midiQueue->dropMidiEvent();
+					if (!isAbortingPoly()) {
+						midiQueue->dropMidiEvent();
 					}
 				} else {
-					synth.playSysexNow(nextEvent->sysexData, nextEvent->sysexLength);
-					synth.midiQueue->dropMidiEvent();
+					playSysexNow(nextEvent->sysexData, nextEvent->sysexLength);
+					midiQueue->dropMidiEvent();
 				}
 			}
 		}
-		doRenderStreams(
-			nonReverbLeft.sampleBuffer, nonReverbRight.sampleBuffer,
-			reverbDryLeft.sampleBuffer, reverbDryRight.sampleBuffer,
-			reverbWetLeft.sampleBuffer, reverbWetRight.sampleBuffer,
-			thisLen);
-		nonReverbLeft.convert(thisLen);
-		nonReverbRight.convert(thisLen);
-		reverbDryLeft.convert(thisLen);
-		reverbDryRight.convert(thisLen);
-		reverbWetLeft.convert(thisLen);
-		reverbWetRight.convert(thisLen);
+		doRenderStreams(nonReverbLeft, nonReverbRight, reverbDryLeft, reverbDryRight, reverbWetLeft, reverbWetRight, thisLen);
+		advanceStreamPosition(nonReverbLeft, thisLen);
+		advanceStreamPosition(nonReverbRight, thisLen);
+		advanceStreamPosition(reverbDryLeft, thisLen);
+		advanceStreamPosition(reverbDryRight, thisLen);
+		advanceStreamPosition(reverbWetLeft, thisLen);
+		advanceStreamPosition(reverbWetRight, thisLen);
 		len -= thisLen;
 	}
 }
 
-void Synth::renderStreams(
-	Bit16s *nonReverbLeft, Bit16s *nonReverbRight,
-	Bit16s *reverbDryLeft, Bit16s *reverbDryRight,
-	Bit16s *reverbWetLeft, Bit16s *reverbWetRight,
-	Bit32u len)
-{
-#if MT32EMU_USE_FLOAT_SAMPLES
-	BufferedSampleFormatConverter<> convNonReverbLeft(nonReverbLeft), convNonReverbRight(nonReverbRight);
-	BufferedSampleFormatConverter<> convReverbDryLeft(reverbDryLeft), convReverbDryRight(reverbDryRight);
-	BufferedSampleFormatConverter<> convReverbWetLeft(reverbWetLeft), convReverbWetRight(reverbWetRight);
-#else
-	SampleFormatConverter convNonReverbLeft(nonReverbLeft), convNonReverbRight(nonReverbRight);
-	SampleFormatConverter convReverbDryLeft(reverbDryLeft), convReverbDryRight(reverbDryRight);
-	SampleFormatConverter convReverbWetLeft(reverbWetLeft), convReverbWetRight(reverbWetRight);
-#endif
-	renderer.renderStreams(
-		convNonReverbLeft, convNonReverbRight,
-		convReverbDryLeft, convReverbDryRight,
-		convReverbWetLeft, convReverbWetRight,
-		len);
-}
-
-void Synth::renderStreams(
-	float *nonReverbLeft, float *nonReverbRight,
-	float *reverbDryLeft, float *reverbDryRight,
-	float *reverbWetLeft, float *reverbWetRight,
-	Bit32u len)
-{
-#if MT32EMU_USE_FLOAT_SAMPLES
-	SampleFormatConverter convNonReverbLeft(nonReverbLeft), convNonReverbRight(nonReverbRight);
-	SampleFormatConverter convReverbDryLeft(reverbDryLeft), convReverbDryRight(reverbDryRight);
-	SampleFormatConverter convReverbWetLeft(reverbWetLeft), convReverbWetRight(reverbWetRight);
-#else
-	BufferedSampleFormatConverter<> convNonReverbLeft(nonReverbLeft), convNonReverbRight(nonReverbRight);
-	BufferedSampleFormatConverter<> convReverbDryLeft(reverbDryLeft), convReverbDryRight(reverbDryRight);
-	BufferedSampleFormatConverter<> convReverbWetLeft(reverbWetLeft), convReverbWetRight(reverbWetRight);
-#endif
-	renderer.renderStreams(
-		convNonReverbLeft, convNonReverbRight,
-		convReverbDryLeft, convReverbDryRight,
-		convReverbWetLeft, convReverbWetRight,
-		len);
-}
-
 // In GENERATION2 units, the output from LA32 goes to the Boss chip already bit-shifted.
 // In NICE mode, it's also better to increase volume before the reverb processing to preserve accuracy.
-void Renderer::produceLA32Output(Sample *buffer, Bit32u len) {
+void Synth::produceLA32Output(Sample *buffer, Bit32u len) {
 #if MT32EMU_USE_FLOAT_SAMPLES
 	(void)buffer;
 	(void)len;
 #else
-	switch (synth.dacInputMode) {
+	switch (dacInputMode) {
 		case DACInputMode_GENERATION2:
 			while (len--) {
 				*buffer = (*buffer & 0x8000) | ((*buffer << 1) & 0x7FFE) | ((*buffer >> 14) & 0x0001);
@@ -1844,7 +1569,7 @@ void Renderer::produceLA32Output(Sample *buffer, Bit32u len) {
 			break;
 		case DACInputMode_NICE:
 			while (len--) {
-				*buffer = Synth::clipSampleEx(SampleEx(*buffer) << 1);
+				*buffer = clipSampleEx(SampleEx(*buffer) << 1);
 				++buffer;
 			}
 			break;
@@ -1854,12 +1579,12 @@ void Renderer::produceLA32Output(Sample *buffer, Bit32u len) {
 #endif
 }
 
-void Renderer::convertSamplesToOutput(Sample *buffer, Bit32u len) {
+void Synth::convertSamplesToOutput(Sample *buffer, Bit32u len) {
 #if MT32EMU_USE_FLOAT_SAMPLES
 	(void)buffer;
 	(void)len;
 #else
-	if (synth.dacInputMode == DACInputMode_GENERATION1) {
+	if (dacInputMode == DACInputMode_GENERATION1) {
 		while (len--) {
 			*buffer = Sample((*buffer & 0x8000) | ((*buffer << 1) & 0x7FFE));
 			++buffer;
@@ -1868,7 +1593,7 @@ void Renderer::convertSamplesToOutput(Sample *buffer, Bit32u len) {
 #endif
 }
 
-void Renderer::doRenderStreams(Sample *nonReverbLeft, Sample *nonReverbRight, Sample *reverbDryLeft, Sample *reverbDryRight, Sample *reverbWetLeft, Sample *reverbWetRight, Bit32u len) {
+void Synth::doRenderStreams(Sample *nonReverbLeft, Sample *nonReverbRight, Sample *reverbDryLeft, Sample *reverbDryRight, Sample *reverbWetLeft, Sample *reverbWetRight, Bit32u len) {
 	// Even if LA32 output isn't desired, we proceed anyway with temp buffers
 	Sample tmpBufNonReverbLeft[MAX_SAMPLES_PER_RUN], tmpBufNonReverbRight[MAX_SAMPLES_PER_RUN];
 	if (nonReverbLeft == NULL) nonReverbLeft = tmpBufNonReverbLeft;
@@ -1878,30 +1603,30 @@ void Renderer::doRenderStreams(Sample *nonReverbLeft, Sample *nonReverbRight, Sa
 	if (reverbDryLeft == NULL) reverbDryLeft = tmpBufReverbDryLeft;
 	if (reverbDryRight == NULL) reverbDryRight = tmpBufReverbDryRight;
 
-	if (synth.activated) {
-		Synth::muteSampleBuffer(nonReverbLeft, len);
-		Synth::muteSampleBuffer(nonReverbRight, len);
-		Synth::muteSampleBuffer(reverbDryLeft, len);
-		Synth::muteSampleBuffer(reverbDryRight, len);
+	if (isEnabled) {
+		muteSampleBuffer(nonReverbLeft, len);
+		muteSampleBuffer(nonReverbRight, len);
+		muteSampleBuffer(reverbDryLeft, len);
+		muteSampleBuffer(reverbDryRight, len);
 
-		for (unsigned int i = 0; i < synth.getPartialCount(); i++) {
-			if (synth.partialManager->shouldReverb(i)) {
-				synth.partialManager->produceOutput(i, reverbDryLeft, reverbDryRight, len);
+		for (unsigned int i = 0; i < getPartialCount(); i++) {
+			if (partialManager->shouldReverb(i)) {
+				partialManager->produceOutput(i, reverbDryLeft, reverbDryRight, len);
 			} else {
-				synth.partialManager->produceOutput(i, nonReverbLeft, nonReverbRight, len);
+				partialManager->produceOutput(i, nonReverbLeft, nonReverbRight, len);
 			}
 		}
 
 		produceLA32Output(reverbDryLeft, len);
 		produceLA32Output(reverbDryRight, len);
 
-		if (synth.isReverbEnabled()) {
-			synth.reverbModel->process(reverbDryLeft, reverbDryRight, reverbWetLeft, reverbWetRight, len);
+		if (isReverbEnabled()) {
+			reverbModel->process(reverbDryLeft, reverbDryRight, reverbWetLeft, reverbWetRight, len);
 			if (reverbWetLeft != NULL) convertSamplesToOutput(reverbWetLeft, len);
 			if (reverbWetRight != NULL) convertSamplesToOutput(reverbWetRight, len);
 		} else {
-			Synth::muteSampleBuffer(reverbWetLeft, len);
-			Synth::muteSampleBuffer(reverbWetRight, len);
+			muteSampleBuffer(reverbWetLeft, len);
+			muteSampleBuffer(reverbWetRight, len);
 		}
 
 		// Don't bother with conversion if the output is going to be unused
@@ -1917,32 +1642,29 @@ void Renderer::doRenderStreams(Sample *nonReverbLeft, Sample *nonReverbRight, Sa
 		if (reverbDryRight != tmpBufReverbDryRight) convertSamplesToOutput(reverbDryRight, len);
 	} else {
 		// Avoid muting buffers that wasn't requested
-		if (nonReverbLeft != tmpBufNonReverbLeft) Synth::muteSampleBuffer(nonReverbLeft, len);
-		if (nonReverbRight != tmpBufNonReverbRight) Synth::muteSampleBuffer(nonReverbRight, len);
-		if (reverbDryLeft != tmpBufReverbDryLeft) Synth::muteSampleBuffer(reverbDryLeft, len);
-		if (reverbDryRight != tmpBufReverbDryRight) Synth::muteSampleBuffer(reverbDryRight, len);
-		Synth::muteSampleBuffer(reverbWetLeft, len);
-		Synth::muteSampleBuffer(reverbWetRight, len);
+		if (nonReverbLeft != tmpBufNonReverbLeft) muteSampleBuffer(nonReverbLeft, len);
+		if (nonReverbRight != tmpBufNonReverbRight) muteSampleBuffer(nonReverbRight, len);
+		if (reverbDryLeft != tmpBufReverbDryLeft) muteSampleBuffer(reverbDryLeft, len);
+		if (reverbDryRight != tmpBufReverbDryRight) muteSampleBuffer(reverbDryRight, len);
+		muteSampleBuffer(reverbWetLeft, len);
+		muteSampleBuffer(reverbWetRight, len);
 	}
 
-	synth.partialManager->clearAlreadyOutputed();
-	synth.renderedSampleCount += len;
+	partialManager->clearAlreadyOutputed();
+	renderedSampleCount += len;
 }
 
-void Synth::printPartialUsage(Bit32u sampleOffset) {
+void Synth::printPartialUsage(unsigned long sampleOffset) {
 	unsigned int partialUsage[9];
 	partialManager->getPerPartPartialUsage(partialUsage);
 	if (sampleOffset > 0) {
-		printDebug("[+%u] Partial Usage: 1:%02d 2:%02d 3:%02d 4:%02d 5:%02d 6:%02d 7:%02d 8:%02d R: %02d  TOTAL: %02d", sampleOffset, partialUsage[0], partialUsage[1], partialUsage[2], partialUsage[3], partialUsage[4], partialUsage[5], partialUsage[6], partialUsage[7], partialUsage[8], getPartialCount() - partialManager->getFreePartialCount());
+		printDebug("[+%lu] Partial Usage: 1:%02d 2:%02d 3:%02d 4:%02d 5:%02d 6:%02d 7:%02d 8:%02d R: %02d  TOTAL: %02d", sampleOffset, partialUsage[0], partialUsage[1], partialUsage[2], partialUsage[3], partialUsage[4], partialUsage[5], partialUsage[6], partialUsage[7], partialUsage[8], getPartialCount() - partialManager->getFreePartialCount());
 	} else {
 		printDebug("Partial Usage: 1:%02d 2:%02d 3:%02d 4:%02d 5:%02d 6:%02d 7:%02d 8:%02d R: %02d  TOTAL: %02d", partialUsage[0], partialUsage[1], partialUsage[2], partialUsage[3], partialUsage[4], partialUsage[5], partialUsage[6], partialUsage[7], partialUsage[8], getPartialCount() - partialManager->getFreePartialCount());
 	}
 }
 
 bool Synth::hasActivePartials() const {
-	if (!opened) {
-		return false;
-	}
 	for (unsigned int partialNum = 0; partialNum < getPartialCount(); partialNum++) {
 		if (partialManager->getPartial(partialNum)->isActive()) {
 			return true;
@@ -1951,76 +1673,46 @@ bool Synth::hasActivePartials() const {
 	return false;
 }
 
-bool Synth::isActive() {
-	if (!opened) {
-		return false;
-	}
-	if (!midiQueue->isEmpty() || hasActivePartials()) {
+bool Synth::isAbortingPoly() const {
+	return abortingPoly != NULL;
+}
+
+bool Synth::isActive() const {
+	if (hasActivePartials()) {
 		return true;
 	}
-	if (isReverbEnabled() && reverbModel->isActive()) {
-		return true;
+	if (isReverbEnabled()) {
+		return reverbModel->isActive();
 	}
-	activated = false;
 	return false;
 }
 
-Bit32u Synth::getPartialCount() const {
+unsigned int Synth::getPartialCount() const {
 	return partialCount;
 }
 
 void Synth::getPartStates(bool *partStates) const {
-	if (!opened) {
-		memset(partStates, 0, 9 * sizeof(bool));
-		return;
-	}
 	for (int partNumber = 0; partNumber < 9; partNumber++) {
 		const Part *part = parts[partNumber];
 		partStates[partNumber] = part->getActiveNonReleasingPartialCount() > 0;
 	}
 }
 
-Bit32u Synth::getPartStates() const {
-	if (!opened) return 0;
-	bool partStates[9];
-	getPartStates(partStates);
-	Bit32u bitSet = 0;
-	for (int partNumber = 8; partNumber >= 0; partNumber--) {
-		bitSet = (bitSet << 1) | (partStates[partNumber] ? 1 : 0);
-	}
-	return bitSet;
-}
-
 void Synth::getPartialStates(PartialState *partialStates) const {
-	if (!opened) {
-		memset(partialStates, 0, partialCount * sizeof(PartialState));
-		return;
-	}
-	for (unsigned int partialNum = 0; partialNum < partialCount; partialNum++) {
-		partialStates[partialNum] = getPartialState(partialManager, partialNum);
-	}
-}
+	static const PartialState partialPhaseToState[8] = {
+		PartialState_ATTACK, PartialState_ATTACK, PartialState_ATTACK, PartialState_ATTACK,
+		PartialState_SUSTAIN, PartialState_SUSTAIN, PartialState_RELEASE, PartialState_INACTIVE
+	};
 
-void Synth::getPartialStates(Bit8u *partialStates) const {
-	if (!opened) {
-		memset(partialStates, 0, ((partialCount + 3) >> 2));
-		return;
-	}
-	for (unsigned int quartNum = 0; (4 * quartNum) < partialCount; quartNum++) {
-		Bit8u packedStates = 0;
-		for (unsigned int i = 0; i < 4; i++) {
-			unsigned int partialNum = (4 * quartNum) + i;
-			if (partialCount <= partialNum) break;
-			PartialState partialState = getPartialState(partialManager, partialNum);
-			packedStates |= (partialState & 3) << (2 * i);
-		}
-		partialStates[quartNum] = packedStates;
+	for (unsigned int partialNum = 0; partialNum < getPartialCount(); partialNum++) {
+		const Partial *partial = partialManager->getPartial(partialNum);
+		partialStates[partialNum] = partial->isActive() ? partialPhaseToState[partial->getTVA()->getPhase()] : PartialState_INACTIVE;
 	}
 }
 
-Bit32u Synth::getPlayingNotes(Bit8u partNumber, Bit8u *keys, Bit8u *velocities) const {
-	Bit32u playingNotes = 0;
-	if (opened && (partNumber < 9)) {
+unsigned int Synth::getPlayingNotes(unsigned int partNumber, Bit8u *keys, Bit8u *velocities) const {
+	unsigned int playingNotes = 0;
+	if (isOpen && (partNumber < 9)) {
 		const Part *part = parts[partNumber];
 		const Poly *poly = part->getFirstActivePoly();
 		while (poly != NULL) {
@@ -2033,11 +1725,11 @@ Bit32u Synth::getPlayingNotes(Bit8u partNumber, Bit8u *keys, Bit8u *velocities)
 	return playingNotes;
 }
 
-const char *Synth::getPatchName(Bit8u partNumber) const {
-	return (!opened || partNumber > 8) ? NULL : parts[partNumber]->getCurrentInstr();
+const char *Synth::getPatchName(unsigned int partNumber) const {
+	return (!isOpen || partNumber > 8) ? NULL : parts[partNumber]->getCurrentInstr();
 }
 
-const Part *Synth::getPart(Bit8u partNum) const {
+const Part *Synth::getPart(unsigned int partNum) const {
 	if (partNum > 8) {
 		return NULL;
 	}
@@ -2115,4 +1807,4 @@ void MemoryRegion::write(unsigned int entry, unsigned int off, const Bit8u *src,
 	}
 }
 
-} // namespace MT32Emu
+}
diff --git a/audio/softsynth/mt32/Synth.h b/audio/softsynth/mt32/Synth.h
index 5561d8d5db..97d4644ee2 100644
--- a/audio/softsynth/mt32/Synth.h
+++ b/audio/softsynth/mt32/Synth.h
@@ -1,5 +1,5 @@
 /* Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Dean Beeler, Jerome Fisher
- * Copyright (C) 2011-2016 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
+ * Copyright (C) 2011, 2012, 2013, 2014 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
@@ -18,13 +18,8 @@
 #ifndef MT32EMU_SYNTH_H
 #define MT32EMU_SYNTH_H
 
-#include <cstdarg>
-#include <cstddef>
-#include <cstring>
-
-#include "globals.h"
-#include "Types.h"
-#include "Enumerations.h"
+//#include <cstdarg>
+//#include <cstring>
 
 namespace MT32Emu {
 
@@ -36,8 +31,6 @@ class Part;
 class Poly;
 class Partial;
 class PartialManager;
-class Renderer;
-class ROMImage;
 
 class PatchTempMemoryRegion;
 class RhythmTempMemoryRegion;
@@ -48,11 +41,82 @@ class SystemMemoryRegion;
 class DisplayMemoryRegion;
 class ResetMemoryRegion;
 
-struct ControlROMFeatureSet;
 struct ControlROMMap;
 struct PCMWaveEntry;
 struct MemParams;
 
+/**
+ * Methods for emulating the connection between the LA32 and the DAC, which involves
+ * some hacks in the real devices for doubling the volume.
+ * See also http://en.wikipedia.org/wiki/Roland_MT-32#Digital_overflow
+ */
+enum DACInputMode {
+	// Produces samples at double the volume, without tricks.
+	// * Nicer overdrive characteristics than the DAC hacks (it simply clips samples within range)
+	// * Higher quality than the real devices
+	DACInputMode_NICE,
+
+	// Produces samples that exactly match the bits output from the emulated LA32.
+	// * Nicer overdrive characteristics than the DAC hacks (it simply clips samples within range)
+	// * Much less likely to overdrive than any other mode.
+	// * Half the volume of any of the other modes.
+	// * Output gain is ignored for both LA32 and reverb output.
+	// * Perfect for developers while debugging :)
+	DACInputMode_PURE,
+
+	// Re-orders the LA32 output bits as in early generation MT-32s (according to Wikipedia).
+	// Bit order at DAC (where each number represents the original LA32 output bit number, and XX means the bit is always low):
+	// 15 13 12 11 10 09 08 07 06 05 04 03 02 01 00 XX
+	DACInputMode_GENERATION1,
+
+	// Re-orders the LA32 output bits as in later generations (personally confirmed on my CM-32L - KG).
+	// Bit order at DAC (where each number represents the original LA32 output bit number):
+	// 15 13 12 11 10 09 08 07 06 05 04 03 02 01 00 14
+	DACInputMode_GENERATION2
+};
+
+// Methods for emulating the effective delay of incoming MIDI messages introduced by a MIDI interface.
+enum MIDIDelayMode {
+	// Process incoming MIDI events immediately.
+	MIDIDelayMode_IMMEDIATE,
+
+	// Delay incoming short MIDI messages as if they where transferred via a MIDI cable to a real hardware unit and immediate sysex processing.
+	// This ensures more accurate timing of simultaneous NoteOn messages.
+	MIDIDelayMode_DELAY_SHORT_MESSAGES_ONLY,
+
+	// Delay all incoming MIDI events as if they where transferred via a MIDI cable to a real hardware unit.
+	MIDIDelayMode_DELAY_ALL
+};
+
+// Methods for emulating the effects of analogue circuits of real hardware units on the output signal.
+enum AnalogOutputMode {
+	// Only digital path is emulated. The output samples correspond to the digital signal at the DAC entrance.
+	AnalogOutputMode_DIGITAL_ONLY,
+	// Coarse emulation of LPF circuit. High frequencies are boosted, sample rate remains unchanged.
+	AnalogOutputMode_COARSE,
+	// Finer emulation of LPF circuit. Output signal is upsampled to 48 kHz to allow emulation of audible mirror spectra above 16 kHz,
+	// which is passed through the LPF circuit without significant attenuation.
+	AnalogOutputMode_ACCURATE,
+	// Same as AnalogOutputMode_ACCURATE mode but the output signal is 2x oversampled, i.e. the output sample rate is 96 kHz.
+	// This makes subsequent resampling easier. Besides, due to nonlinear passband of the LPF emulated, it takes fewer number of MACs
+	// compared to a regular LPF FIR implementations.
+	AnalogOutputMode_OVERSAMPLED
+};
+
+enum ReverbMode {
+	REVERB_MODE_ROOM,
+	REVERB_MODE_HALL,
+	REVERB_MODE_PLATE,
+	REVERB_MODE_TAP_DELAY
+};
+
+enum PartialState {
+	PartialState_INACTIVE,
+	PartialState_ATTACK,
+	PartialState_SUSTAIN,
+	PartialState_RELEASE
+};
+
 const Bit8u SYSEX_MANUFACTURER_ROLAND = 0x41;
 
 const Bit8u SYSEX_MDL_MT32 = 0x16;
@@ -68,64 +132,47 @@ const Bit8u SYSEX_CMD_EOD = 0x45; // End of data
 const Bit8u SYSEX_CMD_ERR = 0x4E; // Communications error
 const Bit8u SYSEX_CMD_RJC = 0x4F; // Rejection
 
-const Bit32u CONTROL_ROM_SIZE = 64 * 1024;
-
-// Set of multiplexed output streams appeared at the DAC entrance.
-template <class T>
-struct DACOutputStreams {
-	T *nonReverbLeft;
-	T *nonReverbRight;
-	T *reverbDryLeft;
-	T *reverbDryRight;
-	T *reverbWetLeft;
-	T *reverbWetRight;
-};
+const int MAX_SYSEX_SIZE = 512; // FIXME: Does this correspond to a real MIDI buffer used in h/w devices?
+
+const unsigned int CONTROL_ROM_SIZE = 64 * 1024;
+
+class ReportHandler {
+friend class Synth;
 
-// Class for the client to supply callbacks for reporting various errors and information
-class MT32EMU_EXPORT ReportHandler {
 public:
 	virtual ~ReportHandler() {}
 
+protected:
+
 	// Callback for debug messages, in vprintf() format
 	virtual void printDebug(const char *fmt, va_list list);
-	// Callbacks for reporting errors
+
+	// Callbacks for reporting various errors and information
 	virtual void onErrorControlROM() {}
 	virtual void onErrorPCMROM() {}
-	// Callback for reporting about displaying a new custom message on LCD
 	virtual void showLCDMessage(const char *message);
-	// Callback for reporting actual processing of a MIDI message
 	virtual void onMIDIMessagePlayed() {}
-	// Callback for reporting an overflow of the input MIDI queue.
-	// Returns true if a recovery action was taken and yet another attempt to enqueue the MIDI event is desired.
-	virtual bool onMIDIQueueOverflow() { return false; }
-	// Callback invoked when a System Realtime MIDI message is detected at the input.
-	virtual void onMIDISystemRealtime(Bit8u /* systemRealtime */) {}
-	// Callbacks for reporting system events
 	virtual void onDeviceReset() {}
 	virtual void onDeviceReconfig() {}
-	// Callbacks for reporting changes of reverb settings
 	virtual void onNewReverbMode(Bit8u /* mode */) {}
 	virtual void onNewReverbTime(Bit8u /* time */) {}
 	virtual void onNewReverbLevel(Bit8u /* level */) {}
-	// Callbacks for reporting various information
-	virtual void onPolyStateChanged(Bit8u /* partNum */) {}
-	virtual void onProgramChanged(Bit8u /* partNum */, const char * /* soundGroupName */, const char * /* patchName */) {}
+	virtual void onPolyStateChanged(int /* partNum */) {}
+	virtual void onProgramChanged(int /* partNum */, int /* bankNum */, const char * /* patchName */) {}
 };
 
 class Synth {
-friend class DefaultMidiStreamParser;
 friend class Part;
+friend class RhythmPart;
+friend class Poly;
 friend class Partial;
 friend class PartialManager;
-friend class Poly;
-friend class Renderer;
-friend class RhythmPart;
+friend class Tables;
+friend class MemoryRegion;
 friend class TVA;
+friend class TVF;
 friend class TVP;
-
 private:
-	// **************************** Implementation fields **************************
-
 	PatchTempMemoryRegion *patchTempMemoryRegion;
 	RhythmTempMemoryRegion *rhythmTempMemoryRegion;
 	TimbreTempMemoryRegion *timbreTempMemoryRegion;
@@ -137,6 +184,8 @@ private:
 
 	Bit8u *paddedTimbreMaxTable;
 
+	bool isEnabled;
+
 	PCMWaveEntry *pcmWaves; // Array
 
 	const ControlROMFeatureSet *controlROMFeatures;
@@ -145,11 +194,8 @@ private:
 	Bit16s *pcmROMData;
 	size_t pcmROMSize; // This is in 16-bit samples, therefore half the number of bytes in the ROM
 
-	Bit8u soundGroupIx[128]; // For each standard timbre
-	const char (*soundGroupNames)[9]; // Array
-
-	Bit32u partialCount;
-	Bit8u chantable[16]; // NOTE: value above 8 means that the channel is not assigned
+	unsigned int partialCount;
+	Bit8s chantable[32]; // FIXME: Need explanation why 32 is set, obviously it should be 16
 
 	MidiEventQueue *midiQueue;
 	volatile Bit32u lastReceivedMIDIEventTimestamp;
@@ -169,8 +215,7 @@ private:
 
 	bool reversedStereoEnabled;
 
-	bool opened;
-	bool activated;
+	bool isOpen;
 
 	bool isDefaultReportHandler;
 	ReportHandler *reportHandler;
@@ -184,17 +229,15 @@ private:
 	Poly *abortingPoly;
 
 	Analog *analog;
-	Renderer &renderer;
-
-	// Binary compatibility helper.
-	void *reserved;
-
-	// **************************** Implementation methods **************************
 
 	Bit32u addMIDIInterfaceDelay(Bit32u len, Bit32u timestamp);
-	bool isAbortingPoly() const { return abortingPoly != NULL; }
 
-	void readSysex(Bit8u channel, const Bit8u *sysex, Bit32u len) const;
+	void produceLA32Output(Sample *buffer, Bit32u len);
+	void convertSamplesToOutput(Sample *buffer, Bit32u len);
+	bool isAbortingPoly() const;
+	void doRenderStreams(Sample *nonReverbLeft, Sample *nonReverbRight, Sample *reverbDryLeft, Sample *reverbDryRight, Sample *reverbWetLeft, Sample *reverbWetRight, Bit32u len);
+
+	void readSysex(unsigned char channel, const Bit8u *sysex, Bit32u len) const;
 	void initMemoryRegions();
 	void deleteMemoryRegions();
 	MemoryRegion *findMemoryRegion(Bit32u addr);
@@ -205,97 +248,79 @@ private:
 	bool loadPCMROM(const ROMImage &pcmROMImage);
 
 	bool initPCMList(Bit16u mapAddress, Bit16u count);
-	bool initTimbres(Bit16u mapAddress, Bit16u offset, Bit16u timbreCount, Bit16u startTimbre, bool compressed);
-	bool initCompressedTimbre(Bit16u drumNum, const Bit8u *mem, Bit32u memLen);
-	void initReverbModels(bool mt32CompatibleMode);
-	void initSoundGroups(char newSoundGroupNames[][9]);
+	bool initTimbres(Bit16u mapAddress, Bit16u offset, int timbreCount, int startTimbre, bool compressed);
+	bool initCompressedTimbre(int drumNum, const Bit8u *mem, unsigned int memLen);
 
 	void refreshSystemMasterTune();
 	void refreshSystemReverbParameters();
 	void refreshSystemReserveSettings();
-	void refreshSystemChanAssign(Bit8u firstPart, Bit8u lastPart);
+	void refreshSystemChanAssign(unsigned int firstPart, unsigned int lastPart);
 	void refreshSystemMasterVol();
 	void refreshSystem();
 	void reset();
-	void dispose();
 
-	void printPartialUsage(Bit32u sampleOffset = 0);
+	void printPartialUsage(unsigned long sampleOffset = 0);
 
-	void newTimbreSet(Bit8u partNum, Bit8u timbreGroup, Bit8u timbreNumber, const char patchName[]);
+	void polyStateChanged(int partNum);
+	void newTimbreSet(int partNum, Bit8u timbreGroup, const char patchName[]);
 	void printDebug(const char *fmt, ...);
 
 	// partNum should be 0..7 for Part 1..8, or 8 for Rhythm
-	const Part *getPart(Bit8u partNum) const;
+	const Part *getPart(unsigned int partNum) const;
 
 public:
-	static inline Bit16s clipSampleEx(Bit32s sampleEx) {
+	static inline Sample clipSampleEx(SampleEx sampleEx) {
+#if MT32EMU_USE_FLOAT_SAMPLES
+		return sampleEx;
+#else
 		// Clamp values above 32767 to 32767, and values below -32768 to -32768
 		// FIXME: Do we really need this stuff? I think these branches are very well predicted. Instead, this introduces a chain.
 		// The version below is actually a bit faster on my system...
-		//return ((sampleEx + 0x8000) & ~0xFFFF) ? Bit16s((sampleEx >> 31) ^ 0x7FFF) : (Bit16s)sampleEx;
-		return ((-0x8000 <= sampleEx) && (sampleEx <= 0x7FFF)) ? Bit16s(sampleEx) : Bit16s((sampleEx >> 31) ^ 0x7FFF);
-	}
-
-	static inline float clipSampleEx(float sampleEx) {
-		return sampleEx;
+		//return ((sampleEx + 0x8000) & ~0xFFFF) ? (sampleEx >> 31) ^ 0x7FFF : (Sample)sampleEx;
+		return ((-0x8000 <= sampleEx) && (sampleEx <= 0x7FFF)) ? (Sample)sampleEx : (sampleEx >> 31) ^ 0x7FFF;
+#endif
 	}
 
-	template <class S>
-	static inline void muteSampleBuffer(S *buffer, Bit32u len) {
+	static inline void muteSampleBuffer(Sample *buffer, Bit32u len) {
 		if (buffer == NULL) return;
-		memset(buffer, 0, len * sizeof(S));
-	}
 
-	static inline void muteSampleBuffer(float *buffer, Bit32u len) {
-		if (buffer == NULL) return;
+#if MT32EMU_USE_FLOAT_SAMPLES
 		// FIXME: Use memset() where compatibility is guaranteed (if this turns out to be a win)
 		while (len--) {
 			*(buffer++) = 0.0f;
 		}
+#else
+		memset(buffer, 0, len * sizeof(Sample));
+#endif
 	}
 
-	// Returns library version as an integer in format: 0x00MMmmpp, where:
-	// MM - major version number
-	// mm - minor version number
-	// pp - patch number
-	MT32EMU_EXPORT static Bit32u getLibraryVersionInt();
-	// Returns library version as a C-string in format: "MAJOR.MINOR.PATCH"
-	MT32EMU_EXPORT static const char *getLibraryVersionString();
-
-	MT32EMU_EXPORT static Bit32u getShortMessageLength(Bit32u msg);
-	MT32EMU_EXPORT static Bit8u calcSysexChecksum(const Bit8u *data, const Bit32u len, const Bit8u initChecksum = 0);
-
-	// Returns output sample rate used in emulation of stereo analog circuitry of hardware units.
-	// See comment for AnalogOutputMode.
-	MT32EMU_EXPORT static Bit32u getStereoOutputSampleRate(AnalogOutputMode analogOutputMode);
+	static Bit32u getShortMessageLength(Bit32u msg);
+	static Bit8u calcSysexChecksum(const Bit8u *data, const Bit32u len, const Bit8u initChecksum = 0);
 
 	// Optionally sets callbacks for reporting various errors, information and debug messages
-	MT32EMU_EXPORT explicit Synth(ReportHandler *useReportHandler = NULL);
-	MT32EMU_EXPORT ~Synth();
+	Synth(ReportHandler *useReportHandler = NULL);
+	~Synth();
 
 	// Used to initialise the MT-32. Must be called before any other function.
 	// Returns true if initialization was sucessful, otherwise returns false.
 	// controlROMImage and pcmROMImage represent Control and PCM ROM images for use by synth.
 	// usePartialCount sets the maximum number of partials playing simultaneously for this session (optional).
 	// analogOutputMode sets the mode for emulation of analogue circuitry of the hardware units (optional).
-	MT32EMU_EXPORT bool open(const ROMImage &controlROMImage, const ROMImage &pcmROMImage, Bit32u usePartialCount = DEFAULT_MAX_PARTIALS, AnalogOutputMode analogOutputMode = AnalogOutputMode_COARSE);
+	bool open(const ROMImage &controlROMImage, const ROMImage &pcmROMImage, unsigned int usePartialCount = DEFAULT_MAX_PARTIALS, AnalogOutputMode analogOutputMode = AnalogOutputMode_COARSE);
 
 	// Overloaded method which opens the synth with default partial count.
-	MT32EMU_EXPORT bool open(const ROMImage &controlROMImage, const ROMImage &pcmROMImage, AnalogOutputMode analogOutputMode);
+	bool open(const ROMImage &controlROMImage, const ROMImage &pcmROMImage, AnalogOutputMode analogOutputMode);
 
 	// Closes the MT-32 and deallocates any memory used by the synthesizer
-	MT32EMU_EXPORT void close();
-
-	// Returns true if the synth is in completely initialized state, otherwise returns false.
-	MT32EMU_EXPORT bool isOpen() const;
+	void close(bool forced = false);
 
 	// All the enqueued events are processed by the synth immediately.
-	MT32EMU_EXPORT void flushMIDIQueue();
+	void flushMIDIQueue();
 
 	// Sets size of the internal MIDI event queue. The queue size is set to the minimum power of 2 that is greater or equal to the size specified.
 	// The queue is flushed before reallocation.
 	// Returns the actual queue size being used.
-	MT32EMU_EXPORT Bit32u setMIDIEventQueueSize(Bit32u);
+	Bit32u setMIDIEventQueueSize(Bit32u);
 
 	// Enqueues a MIDI event for subsequent playback.
 	// The MIDI event will be processed not before the specified timestamp.
@@ -305,15 +330,14 @@ public:
 	// Calls from multiple threads must be synchronised, although, no synchronisation is required with the rendering thread.
 	// The methods return false if the MIDI event queue is full and the message cannot be enqueued.
 
-	// Enqueues a single short MIDI message to play at specified time. The message must contain a status byte.
-	MT32EMU_EXPORT bool playMsg(Bit32u msg, Bit32u timestamp);
-	// Enqueues a single well formed System Exclusive MIDI message to play at specified time.
-	MT32EMU_EXPORT bool playSysex(const Bit8u *sysex, Bit32u len, Bit32u timestamp);
+	// Enqueues a single short MIDI message. The message must contain a status byte.
+	bool playMsg(Bit32u msg, Bit32u timestamp);
+	// Enqueues a single well formed System Exclusive MIDI message.
+	bool playSysex(const Bit8u *sysex, Bit32u len, Bit32u timestamp);
 
-	// Enqueues a single short MIDI message to be processed ASAP. The message must contain a status byte.
-	MT32EMU_EXPORT bool playMsg(Bit32u msg);
-	// Enqueues a single well formed System Exclusive MIDI message to be processed ASAP.
-	MT32EMU_EXPORT bool playSysex(const Bit8u *sysex, Bit32u len);
+	// Overloaded methods for the MIDI events to be processed ASAP.
+	bool playMsg(Bit32u msg);
+	bool playSysex(const Bit8u *sysex, Bit32u len);
 
 	// WARNING:
 	// The methods below don't ensure minimum 1-sample delay between sequential MIDI events,
@@ -321,60 +345,40 @@ public:
 	// A thread that invokes these methods must be explicitly synchronised with the thread performing sample rendering.
 
 	// Sends a short MIDI message to the synth for immediate playback. The message must contain a status byte.
-	// See the WARNING above.
-	MT32EMU_EXPORT void playMsgNow(Bit32u msg);
-	// Sends unpacked short MIDI message to the synth for immediate playback. The message must contain a status byte.
-	// See the WARNING above.
-	MT32EMU_EXPORT void playMsgOnPart(Bit8u part, Bit8u code, Bit8u note, Bit8u velocity);
-
-	// Sends a single well formed System Exclusive MIDI message for immediate processing. The length is in bytes.
-	// See the WARNING above.
-	MT32EMU_EXPORT void playSysexNow(const Bit8u *sysex, Bit32u len);
-	// Sends inner body of a System Exclusive MIDI message for direct processing. The length is in bytes.
-	// See the WARNING above.
-	MT32EMU_EXPORT void playSysexWithoutFraming(const Bit8u *sysex, Bit32u len);
-	// Sends inner body of a System Exclusive MIDI message for direct processing. The length is in bytes.
-	// See the WARNING above.
-	MT32EMU_EXPORT void playSysexWithoutHeader(Bit8u device, Bit8u command, const Bit8u *sysex, Bit32u len);
-	// Sends inner body of a System Exclusive MIDI message for direct processing. The length is in bytes.
-	// See the WARNING above.
-	MT32EMU_EXPORT void writeSysex(Bit8u channel, const Bit8u *sysex, Bit32u len);
-
-	// Allows to disable wet reverb output altogether.
-	MT32EMU_EXPORT void setReverbEnabled(bool reverbEnabled);
-	// Returns whether wet reverb output is enabled.
-	MT32EMU_EXPORT bool isReverbEnabled() const;
+	void playMsgNow(Bit32u msg);
+	void playMsgOnPart(unsigned char part, unsigned char code, unsigned char note, unsigned char velocity);
+
+	// Sends a string of Sysex commands to the MT-32 for immediate interpretation
+	// The length is in bytes
+	void playSysexNow(const Bit8u *sysex, Bit32u len);
+	void playSysexWithoutFraming(const Bit8u *sysex, Bit32u len);
+	void playSysexWithoutHeader(unsigned char device, unsigned char command, const Bit8u *sysex, Bit32u len);
+	void writeSysex(unsigned char channel, const Bit8u *sysex, Bit32u len);
+
+	void setReverbEnabled(bool reverbEnabled);
+	bool isReverbEnabled() const;
 	// Sets override reverb mode. In this mode, emulation ignores sysexes (or the related part of them) which control the reverb parameters.
 	// This mode is in effect until it is turned off. When the synth is re-opened, the override mode is unchanged but the state
 	// of the reverb model is reset to default.
-	MT32EMU_EXPORT void setReverbOverridden(bool reverbOverridden);
-	// Returns whether reverb settings are overridden.
-	MT32EMU_EXPORT bool isReverbOverridden() const;
+	void setReverbOverridden(bool reverbOverridden);
+	bool isReverbOverridden() const;
 	// Forces reverb model compatibility mode. By default, the compatibility mode corresponds to the used control ROM version.
 	// Invoking this method with the argument set to true forces emulation of old MT-32 reverb circuit.
 	// When the argument is false, emulation of the reverb circuit used in new generation of MT-32 compatible modules is enforced
 	// (these include CM-32L and LAPC-I).
-	MT32EMU_EXPORT void setReverbCompatibilityMode(bool mt32CompatibleMode);
-	// Returns whether reverb is in old MT-32 compatibility mode.
-	MT32EMU_EXPORT bool isMT32ReverbCompatibilityMode() const;
-	// Returns whether default reverb compatibility mode is the old MT-32 compatibility mode.
-	MT32EMU_EXPORT bool isDefaultReverbMT32Compatible() const;
-	// Sets new DAC input mode. See DACInputMode for details.
-	MT32EMU_EXPORT void setDACInputMode(DACInputMode mode);
-	// Returns current DAC input mode. See DACInputMode for details.
-	MT32EMU_EXPORT DACInputMode getDACInputMode() const;
-	// Sets new MIDI delay mode. See MIDIDelayMode for details.
-	MT32EMU_EXPORT void setMIDIDelayMode(MIDIDelayMode mode);
-	// Returns current MIDI delay mode. See MIDIDelayMode for details.
-	MT32EMU_EXPORT MIDIDelayMode getMIDIDelayMode() const;
+	void setReverbCompatibilityMode(bool mt32CompatibleMode);
+	bool isMT32ReverbCompatibilityMode() const;
+	void setDACInputMode(DACInputMode mode);
+	DACInputMode getDACInputMode() const;
+	void setMIDIDelayMode(MIDIDelayMode mode);
+	MIDIDelayMode getMIDIDelayMode() const;
 
 	// Sets output gain factor for synth output channels. Applied to all output samples and unrelated with the synth's Master volume,
 	// it rather corresponds to the gain of the output analog circuitry of the hardware units. However, together with setReverbOutputGain()
 	// it offers to the user a capability to control the gain of reverb and non-reverb output channels independently.
 	// Ignored in DACInputMode_PURE
-	MT32EMU_EXPORT void setOutputGain(float gain);
-	// Returns current output gain factor for synth output channels.
-	MT32EMU_EXPORT float getOutputGain() const;
+	void setOutputGain(float);
+	float getOutputGain() const;
 
 	// Sets output gain factor for the reverb wet output channels. It rather corresponds to the gain of the output
 	// analog circuitry of the hardware units. However, together with setOutputGain() it offers to the user a capability
@@ -385,85 +389,59 @@ public:
 	// there is a difference in the reverb analogue circuit, and the resulting output gain is 0.68
 	// of that for LA32 analogue output. This factor is applied to the reverb output gain.
 	// Ignored in DACInputMode_PURE
-	MT32EMU_EXPORT void setReverbOutputGain(float gain);
-	// Returns current output gain factor for reverb wet output channels.
-	MT32EMU_EXPORT float getReverbOutputGain() const;
+	void setReverbOutputGain(float);
+	float getReverbOutputGain() const;
 
-	// Swaps left and right output channels.
-	MT32EMU_EXPORT void setReversedStereoEnabled(bool enabled);
-	// Returns whether left and right output channels are swapped.
-	MT32EMU_EXPORT bool isReversedStereoEnabled() const;
+	void setReversedStereoEnabled(bool enabled);
+	bool isReversedStereoEnabled();
 
 	// Returns actual sample rate used in emulation of stereo analog circuitry of hardware units.
 	// See comment for render() below.
-	MT32EMU_EXPORT Bit32u getStereoOutputSampleRate() const;
+	unsigned int getStereoOutputSampleRate() const;
 
 	// Renders samples to the specified output stream as if they were sampled at the analog stereo output.
-	// When AnalogOutputMode is set to ACCURATE (OVERSAMPLED), the output signal is upsampled to 48 (96) kHz in order
+	// When AnalogOutputMode is set to ACCURATE, the output signal is upsampled to 48 kHz in order
 	// to retain emulation accuracy in whole audible frequency spectra. Otherwise, native digital signal sample rate is retained.
 	// getStereoOutputSampleRate() can be used to query actual sample rate of the output signal.
-	// The length is in frames, not bytes (in 16-bit stereo, one frame is 4 bytes). Uses NATIVE byte ordering.
-	MT32EMU_EXPORT void render(Bit16s *stream, Bit32u len);
-	// Same as above but outputs to a float stereo stream.
-	MT32EMU_EXPORT void render(float *stream, Bit32u len);
+	// The length is in frames, not bytes (in 16-bit stereo, one frame is 4 bytes).
+	void render(Sample *stream, Bit32u len);
 
 	// Renders samples to the specified output streams as if they appeared at the DAC entrance.
 	// No further processing performed in analog circuitry emulation is applied to the signal.
-	// NULL may be specified in place of any or all of the stream buffers to skip it.
-	// The length is in samples, not bytes. Uses NATIVE byte ordering.
-	MT32EMU_EXPORT void renderStreams(Bit16s *nonReverbLeft, Bit16s *nonReverbRight, Bit16s *reverbDryLeft, Bit16s *reverbDryRight, Bit16s *reverbWetLeft, Bit16s *reverbWetRight, Bit32u len);
-	void renderStreams(const DACOutputStreams<Bit16s> &streams, Bit32u len) {
-		renderStreams(streams.nonReverbLeft, streams.nonReverbRight, streams.reverbDryLeft, streams.reverbDryRight, streams.reverbWetLeft, streams.reverbWetRight, len);
-	}
-	// Same as above but outputs to float streams.
-	MT32EMU_EXPORT void renderStreams(float *nonReverbLeft, float *nonReverbRight, float *reverbDryLeft, float *reverbDryRight, float *reverbWetLeft, float *reverbWetRight, Bit32u len);
-	void renderStreams(const DACOutputStreams<float> &streams, Bit32u len) {
-		renderStreams(streams.nonReverbLeft, streams.nonReverbRight, streams.reverbDryLeft, streams.reverbDryRight, streams.reverbWetLeft, streams.reverbWetRight, len);
-	}
+	// NULL may be specified in place of any or all of the stream buffers.
+	// The length is in samples, not bytes.
+	void renderStreams(Sample *nonReverbLeft, Sample *nonReverbRight, Sample *reverbDryLeft, Sample *reverbDryRight, Sample *reverbWetLeft, Sample *reverbWetRight, Bit32u len);
 
 	// Returns true when there is at least one active partial, otherwise false.
-	MT32EMU_EXPORT bool hasActivePartials() const;
+	bool hasActivePartials() const;
 
-	// Returns true if the synth is active and subsequent calls to render() may result in non-trivial output (i.e. silence).
-	// The synth is considered active when either there are pending MIDI events in the queue, there is at least one active partial,
-	// or the reverb is (somewhat unreliably) detected as being active.
-	MT32EMU_EXPORT bool isActive();
+	// Returns true if hasActivePartials() returns true, or reverb is (somewhat unreliably) detected as being active.
+	bool isActive() const;
 
 	// Returns the maximum number of partials playing simultaneously.
-	MT32EMU_EXPORT Bit32u getPartialCount() const;
+	unsigned int getPartialCount() const;
 
 	// Fills in current states of all the parts into the array provided. The array must have at least 9 entries to fit values for all the parts.
 	// If the value returned for a part is true, there is at least one active non-releasing partial playing on this part.
 	// This info is useful in emulating behaviour of LCD display of the hardware units.
-	MT32EMU_EXPORT void getPartStates(bool *partStates) const;
-
-	// Returns current states of all the parts as a bit set. The least significant bit corresponds to the state of part 1,
-	// total of 9 bits hold the states of all the parts. If the returned bit for a part is set, there is at least one active
-	// non-releasing partial playing on this part. This info is useful in emulating behaviour of LCD display of the hardware units.
-	MT32EMU_EXPORT Bit32u getPartStates() const;
+	void getPartStates(bool *partStates) const;
 
 	// Fills in current states of all the partials into the array provided. The array must be large enough to accommodate states of all the partials.
-	MT32EMU_EXPORT void getPartialStates(PartialState *partialStates) const;
-
-	// Fills in current states of all the partials into the array provided. Each byte in the array holds states of 4 partials
-	// starting from the least significant bits. The state of each partial is packed in a pair of bits.
-	// The array must be large enough to accommodate states of all the partials (see getPartialCount()).
-	MT32EMU_EXPORT void getPartialStates(Bit8u *partialStates) const;
+	void getPartialStates(PartialState *partialStates) const;
 
 	// Fills in information about currently playing notes on the specified part into the arrays provided. The arrays must be large enough
 	// to accommodate data for all the playing notes. The maximum number of simultaneously playing notes cannot exceed the number of partials.
 	// Argument partNumber should be 0..7 for Part 1..8, or 8 for Rhythm.
 	// Returns the number of currently playing notes on the specified part.
-	MT32EMU_EXPORT Bit32u getPlayingNotes(Bit8u partNumber, Bit8u *keys, Bit8u *velocities) const;
+	unsigned int getPlayingNotes(unsigned int partNumber, Bit8u *keys, Bit8u *velocities) const;
 
 	// Returns name of the patch set on the specified part.
 	// Argument partNumber should be 0..7 for Part 1..8, or 8 for Rhythm.
-	MT32EMU_EXPORT const char *getPatchName(Bit8u partNumber) const;
+	const char *getPatchName(unsigned int partNumber) const;
 
-	// Stores internal state of emulated synth into an array provided (as it would be acquired from hardware).
-	MT32EMU_EXPORT void readMemory(Bit32u addr, Bit32u len, Bit8u *data);
-}; // class Synth
+	void readMemory(Bit32u addr, Bit32u len, Bit8u *data);
+};
 
-} // namespace MT32Emu
+}
 
-#endif // #ifndef MT32EMU_SYNTH_H
+#endif
diff --git a/audio/softsynth/mt32/TVA.cpp b/audio/softsynth/mt32/TVA.cpp
index 465480a24e..894e53f14a 100644
--- a/audio/softsynth/mt32/TVA.cpp
+++ b/audio/softsynth/mt32/TVA.cpp
@@ -1,5 +1,5 @@
 /* Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Dean Beeler, Jerome Fisher
- * Copyright (C) 2011-2016 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
+ * Copyright (C) 2011, 2012, 2013, 2014 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
@@ -19,23 +19,19 @@
  * This class emulates the calculations performed by the 8095 microcontroller in order to configure the LA-32's amplitude ramp for a single partial at each stage of its TVA envelope.
  * Unless we introduced bugs, it should be pretty much 100% accurate according to Mok's specifications.
 */
+//#include <cmath>
 
+#include "mt32emu.h"
+#include "mmath.h"
 #include "internals.h"
 
-#include "TVA.h"
-#include "Part.h"
-#include "Partial.h"
-#include "Poly.h"
-#include "Synth.h"
-#include "Tables.h"
-
 namespace MT32Emu {
 
 // CONFIRMED: Matches a table in ROM - haven't got around to coming up with a formula for it yet.
 static Bit8u biasLevelToAmpSubtractionCoeff[13] = {255, 187, 137, 100, 74, 54, 40, 29, 21, 15, 10, 5, 0};
 
 TVA::TVA(const Partial *usePartial, LA32Ramp *useAmpRamp) :
-	partial(usePartial), ampRamp(useAmpRamp), system(&usePartial->getSynth()->mt32ram.system), phase(TVA_PHASE_DEAD) {
+	partial(usePartial), ampRamp(useAmpRamp), system_(&usePartial->getSynth()->mt32ram.system), phase(TVA_PHASE_DEAD) {
 }
 
 void TVA::startRamp(Bit8u newTarget, Bit8u newIncrement, int newPhase) {
@@ -99,11 +95,11 @@ static int calcVeloAmpSubtraction(Bit8u veloSensitivity, unsigned int velocity)
 	return absVelocityMult - (velocityMult >> 8); // PORTABILITY NOTE: Assumes arithmetic shift
 }
 
-static int calcBasicAmp(const Tables *tables, const Partial *partial, const MemParams::System *system, const TimbreParam::PartialParam *partialParam, const MemParams::PatchTemp *patchTemp, const MemParams::RhythmTemp *rhythmTemp, int biasAmpSubtraction, int veloAmpSubtraction, Bit8u expression) {
+static int calcBasicAmp(const Tables *tables, const Partial *partial, const MemParams::System *system_, const TimbreParam::PartialParam *partialParam, const MemParams::PatchTemp *patchTemp, const MemParams::RhythmTemp *rhythmTemp, int biasAmpSubtraction, int veloAmpSubtraction, Bit8u expression) {
 	int amp = 155;
 
 	if (!partial->isRingModulatingSlave()) {
-		amp -= tables->masterVolToAmpSubtraction[system->masterVol];
+		amp -= tables->masterVolToAmpSubtraction[system_->masterVol];
 		if (amp < 0) {
 			return 0;
 		}
@@ -144,7 +140,7 @@ static int calcBasicAmp(const Tables *tables, const Partial *partial, const MemP
 	return amp;
 }
 
-static int calcKeyTimeSubtraction(Bit8u envTimeKeyfollow, int key) {
+int calcKeyTimeSubtraction(Bit8u envTimeKeyfollow, int key) {
 	if (envTimeKeyfollow == 0) {
 		return 0;
 	}
@@ -169,7 +165,7 @@ void TVA::reset(const Part *newPart, const TimbreParam::PartialParam *newPartial
 	biasAmpSubtraction = calcBiasAmpSubtractions(partialParam, key);
 	veloAmpSubtraction = calcVeloAmpSubtraction(partialParam->tva.veloSensitivity, velocity);
 
-	int newTarget = calcBasicAmp(tables, partial, system, partialParam, patchTemp, newRhythmTemp, biasAmpSubtraction, veloAmpSubtraction, part->getExpression());
+	int newTarget = calcBasicAmp(tables, partial, system_, partialParam, patchTemp, newRhythmTemp, biasAmpSubtraction, veloAmpSubtraction, part->getExpression());
 	int newPhase;
 	if (partialParam->tva.envTime[0] == 0) {
 		// Initially go to the TVA_PHASE_ATTACK target amp, and spend the next phase going from there to the TVA_PHASE_2 target amp
@@ -221,7 +217,7 @@ void TVA::recalcSustain() {
 	}
 	// We're sustaining. Recalculate all the values
 	const Tables *tables = &Tables::getInstance();
-	int newTarget = calcBasicAmp(tables, partial, system, partialParam, patchTemp, rhythmTemp, biasAmpSubtraction, veloAmpSubtraction, part->getExpression());
+	int newTarget = calcBasicAmp(tables, partial, system_, partialParam, patchTemp, rhythmTemp, biasAmpSubtraction, veloAmpSubtraction, part->getExpression());
 	newTarget += partialParam->tva.envLevel[3];
 	// Since we're in TVA_PHASE_SUSTAIN at this point, we know that target has been reached and an interrupt fired, so we can rely on it being the current amp.
 	int targetDelta = newTarget - target;
@@ -283,7 +279,7 @@ void TVA::nextPhase() {
 	int envPointIndex = phase;
 
 	if (!allLevelsZeroFromNowOn) {
-		newTarget = calcBasicAmp(tables, partial, system, partialParam, patchTemp, rhythmTemp, biasAmpSubtraction, veloAmpSubtraction, part->getExpression());
+		newTarget = calcBasicAmp(tables, partial, system_, partialParam, patchTemp, rhythmTemp, biasAmpSubtraction, veloAmpSubtraction, part->getExpression());
 
 		if (newPhase == TVA_PHASE_SUSTAIN || newPhase == TVA_PHASE_RELEASE) {
 			if (partialParam->tva.envLevel[3] == 0) {
@@ -367,4 +363,4 @@ void TVA::nextPhase() {
 	startRamp((Bit8u)newTarget, (Bit8u)newIncrement, newPhase);
 }
 
-} // namespace MT32Emu
+}
diff --git a/audio/softsynth/mt32/TVA.h b/audio/softsynth/mt32/TVA.h
index f593b4e7d1..a100107a69 100644
--- a/audio/softsynth/mt32/TVA.h
+++ b/audio/softsynth/mt32/TVA.h
@@ -1,5 +1,5 @@
 /* Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Dean Beeler, Jerome Fisher
- * Copyright (C) 2011-2016 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
+ * Copyright (C) 2011, 2012, 2013, 2014 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
@@ -18,15 +18,9 @@
 #ifndef MT32EMU_TVA_H
 #define MT32EMU_TVA_H
 
-#include "globals.h"
-#include "Types.h"
-#include "Structures.h"
-
 namespace MT32Emu {
 
-class LA32Ramp;
 class Part;
-class Partial;
 
 // Note that when entering nextPhase(), newPhase is set to phase + 1, and the descriptions/names below refer to
 // newPhase's value.
@@ -63,7 +57,7 @@ class TVA {
 private:
 	const Partial * const partial;
 	LA32Ramp *ampRamp;
-	const MemParams::System * const system;
+	const MemParams::System * const system_;
 
 	const Part *part;
 	const TimbreParam::PartialParam *partialParam;
@@ -93,8 +87,8 @@ public:
 
 	bool isPlaying() const;
 	int getPhase() const;
-}; // class TVA
+};
 
-} // namespace MT32Emu
+}
 
-#endif // #ifndef MT32EMU_TVA_H
+#endif /* TVA_H_ */
diff --git a/audio/softsynth/mt32/TVF.cpp b/audio/softsynth/mt32/TVF.cpp
index d603883bd4..164cf2b4cb 100644
--- a/audio/softsynth/mt32/TVF.cpp
+++ b/audio/softsynth/mt32/TVF.cpp
@@ -1,5 +1,5 @@
 /* Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Dean Beeler, Jerome Fisher
- * Copyright (C) 2011-2016 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
+ * Copyright (C) 2011, 2012, 2013, 2014 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
@@ -15,13 +15,11 @@
  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "internals.h"
+//#include <cmath>
 
-#include "TVF.h"
-#include "LA32Ramp.h"
-#include "Partial.h"
-#include "Poly.h"
-#include "Tables.h"
+#include "mt32emu.h"
+#include "mmath.h"
+#include "internals.h"
 
 namespace MT32Emu {
 
@@ -77,7 +75,7 @@ static int calcBaseCutoff(const TimbreParam::PartialParam *partialParam, Bit32u
 		// biasPoint range here: 64 to 127
 		int bias = biasPoint - 31 - key; // bias range here: -75 to 84
 		if (bias < 0) {
-			baseCutoff += bias * biasLevelToBiasMult[partialParam->tvf.biasLevel]; // Calculation range: -6375 to 6375
+			baseCutoff += bias * biasLevelToBiasMult[partialParam->tvf.biasLevel]; // Calculation range: −6375 to 6375
 			// baseCutoff range now: -9399 to 9399
 		}
 	}
@@ -230,4 +228,4 @@ void TVF::nextPhase() {
 	startRamp(newTarget, newIncrement, newPhase);
 }
 
-} // namespace MT32Emu
+}
diff --git a/audio/softsynth/mt32/TVF.h b/audio/softsynth/mt32/TVF.h
index 38dcef708c..1e2c6d1728 100644
--- a/audio/softsynth/mt32/TVF.h
+++ b/audio/softsynth/mt32/TVF.h
@@ -1,5 +1,5 @@
 /* Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Dean Beeler, Jerome Fisher
- * Copyright (C) 2011-2016 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
+ * Copyright (C) 2011, 2012, 2013, 2014 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
@@ -18,15 +18,8 @@
 #ifndef MT32EMU_TVF_H
 #define MT32EMU_TVF_H
 
-#include "globals.h"
-#include "Types.h"
-#include "Structures.h"
-
 namespace MT32Emu {
 
-class LA32Ramp;
-class Partial;
-
 class TVF {
 private:
 	const Partial * const partial;
@@ -54,8 +47,8 @@ public:
 	Bit8u getBaseCutoff() const;
 	void handleInterrupt();
 	void startDecay();
-}; // class TVF
+};
 
-} // namespace MT32Emu
+}
 
-#endif // #ifndef MT32EMU_TVF_H
+#endif
diff --git a/audio/softsynth/mt32/TVP.cpp b/audio/softsynth/mt32/TVP.cpp
index e1ecb0f681..a8003d96dc 100644
--- a/audio/softsynth/mt32/TVP.cpp
+++ b/audio/softsynth/mt32/TVP.cpp
@@ -1,5 +1,5 @@
 /* Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Dean Beeler, Jerome Fisher
- * Copyright (C) 2011-2016 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
+ * Copyright (C) 2011, 2012, 2013, 2014 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
@@ -15,17 +15,12 @@
  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <cstdlib>
+//#include <cmath>
+//#include <cstdlib>
 
+#include "mt32emu.h"
 #include "internals.h"
 
-#include "TVP.h"
-#include "Part.h"
-#include "Partial.h"
-#include "Poly.h"
-#include "Synth.h"
-#include "TVA.h"
-
 namespace MT32Emu {
 
 // FIXME: Add Explanation
@@ -52,7 +47,7 @@ static Bit16u keyToPitchTable[] = {
 };
 
 TVP::TVP(const Partial *usePartial) :
-	partial(usePartial), system(&usePartial->getSynth()->mt32ram.system) {
+	partial(usePartial), system_(&usePartial->getSynth()->mt32ram.system) {
 	// We want to do processing 4000 times per second. FIXME: This is pretty arbitrary.
 	maxCounter = SAMPLE_RATE / 4000;
 	// The timer runs at 500kHz. We only need to bother updating it every maxCounter samples, before we do processing.
@@ -145,7 +140,7 @@ void TVP::reset(const Part *usePart, const TimbreParam::PartialParam *usePartial
 	phase = 0;
 
 	if (partialParam->pitchEnv.timeKeyfollow) {
-		timeKeyfollowSubtraction = (Bit32s)(key - 60) >> (5 - partialParam->pitchEnv.timeKeyfollow); // PORTABILITY NOTE: Assumes arithmetic shift
+		timeKeyfollowSubtraction = (key - 60) >> (5 - partialParam->pitchEnv.timeKeyfollow); // PORTABILITY NOTE: Assumes arithmetic shift
 	} else {
 		timeKeyfollowSubtraction = 0;
 	}
@@ -168,7 +163,7 @@ void TVP::updatePitch() {
 	if (!partial->isPCM() || (partial->getControlROMPCMStruct()->len & 0x01) == 0) { // FIXME: Use !partial->pcmWaveEntry->unaffectedByMasterTune instead
 		// FIXME: masterTune recalculation doesn't really happen here, and there are various bugs not yet emulated
 		// 171 is ~half a semitone.
-		newPitch += ((system->masterTune - 64) * 171) >> 6; // PORTABILITY NOTE: Assumes arithmetic shift.
+		newPitch += ((system_->masterTune - 64) * 171) >> 6; // PORTABILITY NOTE: Assumes arithmetic shift.
 	}
 	if ((partialParam->wg.pitchBenderEnabled & 1) != 0) {
 		newPitch += part->getPitchBend();
@@ -177,12 +172,13 @@ void TVP::updatePitch() {
 		newPitch = 0;
 	}
 
-	// Skipping this check seems about right emulation of MT-32 GEN0 quirk exploited in Colonel's Bequest timbre "Lightning"
-	if (partial->getSynth()->controlROMFeatures->quirkPitchEnvelopeOverflow == 0) {
-		if (newPitch > 59392) {
-			newPitch = 59392;
-		}
+// Note: Temporary #ifdef until we have proper "quirk" configuration
+// This is about right emulation of MT-32 GEN0 quirk exploited in Colonel's Bequest timbre "Lightning"
+#ifndef MT32EMU_QUIRK_PITCH_ENVELOPE_OVERFLOW_MT32
+	if (newPitch > 59392) {
+		newPitch = 59392;
 	}
+#endif
 	pitch = (Bit16u)newPitch;
 
 	// FIXME: We're doing this here because that's what the CM-32L does - we should probably move this somewhere more appropriate in future.
@@ -327,4 +323,4 @@ void TVP::process() {
 	updatePitch();
 }
 
-} // namespace MT32Emu
+}
diff --git a/audio/softsynth/mt32/TVP.h b/audio/softsynth/mt32/TVP.h
index be90f0ff08..e9d05ffa7a 100644
--- a/audio/softsynth/mt32/TVP.h
+++ b/audio/softsynth/mt32/TVP.h
@@ -1,5 +1,5 @@
 /* Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Dean Beeler, Jerome Fisher
- * Copyright (C) 2011-2016 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
+ * Copyright (C) 2011, 2012, 2013, 2014 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
@@ -18,19 +18,12 @@
 #ifndef MT32EMU_TVP_H
 #define MT32EMU_TVP_H
 
-#include "globals.h"
-#include "Types.h"
-#include "Structures.h"
-
 namespace MT32Emu {
 
-class Part;
-class Partial;
-
 class TVP {
 private:
 	const Partial * const partial;
-	const MemParams::System * const system; // FIXME: Only necessary because masterTune calculation is done in the wrong place atm.
+	const MemParams::System * const system_; // FIXME: Only necessary because masterTune calculation is done in the wrong place atm.
 
 	const Part *part;
 	const TimbreParam::PartialParam *partialParam;
@@ -67,8 +60,8 @@ public:
 	Bit32u getBasePitch() const;
 	Bit16u nextPitch();
 	void startDecay();
-}; // class TVP
+};
 
-} // namespace MT32Emu
+}
 
-#endif // #ifndef MT32EMU_TVP_H
+#endif
diff --git a/audio/softsynth/mt32/Tables.cpp b/audio/softsynth/mt32/Tables.cpp
index d5dca83a00..7e165b5a7a 100644
--- a/audio/softsynth/mt32/Tables.cpp
+++ b/audio/softsynth/mt32/Tables.cpp
@@ -1,5 +1,5 @@
 /* Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Dean Beeler, Jerome Fisher
- * Copyright (C) 2011-2016 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
+ * Copyright (C) 2011, 2012, 2013, 2014 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
@@ -15,10 +15,11 @@
  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "internals.h"
+//#include <cmath>
 
-#include "Tables.h"
+#include "mt32emu.h"
 #include "mmath.h"
+#include "Tables.h"
 
 namespace MT32Emu {
 
@@ -47,9 +48,7 @@ Tables::Tables() {
 		envLogarithmicTime[lf] = (Bit8u)ceil(64.0f + LOG2F((float)lf) * 8.0f);
 	}
 
-#if 0
-	// The table below is to be used in conjunction with emulation of VCA of newer generation units which is currently missing.
-	// These relatively small values are rather intended to fine-tune the overall amplification of the VCA.
+#ifdef EMULATE_LAPC_I // Dummy #ifdef - we'll have runtime emulation mode selection in future.
 	// CONFIRMED: Based on a table found by Mok in the LAPC-I control ROM
 	// Note that this matches the MT-32 table, but with the values clamped to a maximum of 8.
 	memset(masterVolToAmpSubtraction, 8, 71);
@@ -65,12 +64,12 @@ Tables::Tables() {
 	// CONFIRMED: Based on a table found by Mok in the MT-32 control ROM
 	masterVolToAmpSubtraction[0] = 255;
 	for (int masterVol = 1; masterVol <= 100; masterVol++) {
-		masterVolToAmpSubtraction[masterVol] = (Bit8u)(106.31 - 16.0f * LOG2F((float)masterVol));
+		masterVolToAmpSubtraction[masterVol] = (int)(106.31 - 16.0f * LOG2F((float)masterVol));
 	}
 #endif
 
 	for (int i = 0; i <= 100; i++) {
-		pulseWidth100To255[i] = (Bit8u)(i * 255 / 100.0f + 0.5f);
+		pulseWidth100To255[i] = (int)(i * 255 / 100.0f + 0.5f);
 		//synth->printDebug("%d: %d", i, pulseWidth100To255[i]);
 	}
 
@@ -95,4 +94,4 @@ Tables::Tables() {
 	resAmpDecayFactor = resAmpDecayFactorTable;
 }
 
-} // namespace MT32Emu
+}
diff --git a/audio/softsynth/mt32/Tables.h b/audio/softsynth/mt32/Tables.h
index 249e32919a..8865c7fac8 100644
--- a/audio/softsynth/mt32/Tables.h
+++ b/audio/softsynth/mt32/Tables.h
@@ -1,5 +1,5 @@
 /* Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Dean Beeler, Jerome Fisher
- * Copyright (C) 2011-2016 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
+ * Copyright (C) 2011, 2012, 2013, 2014 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
@@ -18,9 +18,6 @@
 #ifndef MT32EMU_TABLES_H
 #define MT32EMU_TABLES_H
 
-#include "globals.h"
-#include "Types.h"
-
 namespace MT32Emu {
 
 class Tables {
@@ -55,8 +52,8 @@ public:
 	Bit16u logsin9[512];
 
 	const Bit8u *resAmpDecayFactor;
-}; // class Tables
+};
 
-} // namespace MT32Emu
+}
 
-#endif // #ifndef MT32EMU_TABLES_H
+#endif
diff --git a/audio/softsynth/mt32/Types.h b/audio/softsynth/mt32/Types.h
index f90dce19a4..934b1a1173 100644
--- a/audio/softsynth/mt32/Types.h
+++ b/audio/softsynth/mt32/Types.h
@@ -1,5 +1,5 @@
 /* Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Dean Beeler, Jerome Fisher
- * Copyright (C) 2011-2016 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
+ * Copyright (C) 2011, 2012, 2013, 2014 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
@@ -27,6 +27,14 @@ typedef   signed short int Bit16s;
 typedef unsigned char      Bit8u;
 typedef   signed char      Bit8s;
 
+#if MT32EMU_USE_FLOAT_SAMPLES
+typedef float Sample;
+typedef float SampleEx;
+#else
+typedef Bit16s Sample;
+typedef Bit32s SampleEx;
+#endif
+
 }
 
 #endif
diff --git a/audio/softsynth/mt32/c_interface/c_interface.cpp b/audio/softsynth/mt32/c_interface/c_interface.cpp
deleted file mode 100644
index a13c88bbe8..0000000000
--- a/audio/softsynth/mt32/c_interface/c_interface.cpp
+++ /dev/null
@@ -1,624 +0,0 @@
-/* Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Dean Beeler, Jerome Fisher
- * Copyright (C) 2011-2016 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
- *
- *  This program is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU Lesser General Public License as published by
- *  the Free Software Foundation, either version 2.1 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU Lesser General Public License for more details.
- *
- *  You should have received a copy of the GNU Lesser General Public License
- *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "../globals.h"
-#include "../Types.h"
-#include "../File.h"
-#include "../FileStream.h"
-#include "../ROMInfo.h"
-#include "../Synth.h"
-#include "../MidiStreamParser.h"
-
-#include "c_types.h"
-#include "c_interface.h"
-
-using namespace MT32Emu;
-
-namespace MT32Emu {
-
-static mt32emu_service_version getSynthVersionID(mt32emu_service_i) {
-	return MT32EMU_SERVICE_VERSION_CURRENT;
-}
-
-static const mt32emu_service_i_v0 SERVICE_VTABLE = {
-	getSynthVersionID,
-	mt32emu_get_supported_report_handler_version,
-	mt32emu_get_supported_midi_receiver_version,
-	mt32emu_get_library_version_int,
-	mt32emu_get_library_version_string,
-	mt32emu_get_stereo_output_samplerate,
-	mt32emu_create_context,
-	mt32emu_free_context,
-	mt32emu_add_rom_data,
-	mt32emu_add_rom_file,
-	mt32emu_get_rom_info,
-	mt32emu_set_partial_count,
-	mt32emu_set_analog_output_mode,
-	mt32emu_open_synth,
-	mt32emu_close_synth,
-	mt32emu_is_open,
-	mt32emu_get_actual_stereo_output_samplerate,
-	mt32emu_flush_midi_queue,
-	mt32emu_set_midi_event_queue_size,
-	mt32emu_set_midi_receiver,
-	mt32emu_parse_stream,
-	mt32emu_parse_stream_at,
-	mt32emu_play_short_message,
-	mt32emu_play_short_message_at,
-	mt32emu_play_msg,
-	mt32emu_play_sysex,
-	mt32emu_play_msg_at,
-	mt32emu_play_sysex_at,
-	mt32emu_play_msg_now,
-	mt32emu_play_msg_on_part,
-	mt32emu_play_sysex_now,
-	mt32emu_write_sysex,
-	mt32emu_set_reverb_enabled,
-	mt32emu_is_reverb_enabled,
-	mt32emu_set_reverb_overridden,
-	mt32emu_is_reverb_overridden,
-	mt32emu_set_reverb_compatibility_mode,
-	mt32emu_is_mt32_reverb_compatibility_mode,
-	mt32emu_is_default_reverb_mt32_compatible,
-	mt32emu_set_dac_input_mode,
-	mt32emu_get_dac_input_mode,
-	mt32emu_set_midi_delay_mode,
-	mt32emu_get_midi_delay_mode,
-	mt32emu_set_output_gain,
-	mt32emu_get_output_gain,
-	mt32emu_set_reverb_output_gain,
-	mt32emu_get_reverb_output_gain,
-	mt32emu_set_reversed_stereo_enabled,
-	mt32emu_is_reversed_stereo_enabled,
-	mt32emu_render_bit16s,
-	mt32emu_render_float,
-	mt32emu_render_bit16s_streams,
-	mt32emu_render_float_streams,
-	mt32emu_has_active_partials,
-	mt32emu_is_active,
-	mt32emu_get_partial_count,
-	mt32emu_get_part_states,
-	mt32emu_get_partial_states,
-	mt32emu_get_playing_notes,
-	mt32emu_get_patch_name,
-	mt32emu_read_memory
-};
-
-} // namespace MT32Emu
-
-struct mt32emu_data {
-	ReportHandler *reportHandler;
-	Synth *synth;
-	const ROMImage *controlROMImage;
-	const ROMImage *pcmROMImage;
-	DefaultMidiStreamParser *midiParser;
-	Bit32u partialCount;
-	AnalogOutputMode analogOutputMode;
-};
-
-// Internal C++ utility stuff
-
-namespace MT32Emu {
-
-class DelegatingReportHandlerAdapter : public ReportHandler {
-public:
-	DelegatingReportHandlerAdapter(mt32emu_report_handler_i useReportHandler, void *useInstanceData) :
-		delegate(useReportHandler), instanceData(useInstanceData) {}
-
-protected:
-	const mt32emu_report_handler_i delegate;
-	void * const instanceData;
-
-private:
-	void printDebug(const char *fmt, va_list list) {
-		if (delegate.v0->printDebug == NULL) {
-			ReportHandler::printDebug(fmt, list);
-		} else {
-			delegate.v0->printDebug(instanceData, fmt, list);
-		}
-	}
-
-	void onErrorControlROM() {
-		if (delegate.v0->onErrorControlROM == NULL) {
-			ReportHandler::onErrorControlROM();
-		} else {
-			delegate.v0->onErrorControlROM(instanceData);
-		}
-	}
-
-	void onErrorPCMROM() {
-		if (delegate.v0->onErrorPCMROM == NULL) {
-			ReportHandler::onErrorPCMROM();
-		} else {
-			delegate.v0->onErrorPCMROM(instanceData);
-		}
-	}
-
-	void showLCDMessage(const char *message) {
-		if (delegate.v0->showLCDMessage == NULL) {
-			ReportHandler::showLCDMessage(message);
-		} else {
-			delegate.v0->showLCDMessage(instanceData, message);
-		}
-	}
-
-	void onMIDIMessagePlayed() {
-		if (delegate.v0->onMIDIMessagePlayed == NULL) {
-			ReportHandler::onMIDIMessagePlayed();
-		} else {
-			delegate.v0->onMIDIMessagePlayed(instanceData);
-		}
-	}
-
-	bool onMIDIQueueOverflow() {
-		if (delegate.v0->onMIDIQueueOverflow == NULL) {
-			return ReportHandler::onMIDIQueueOverflow();
-		}
-		return delegate.v0->onMIDIQueueOverflow(instanceData) != MT32EMU_BOOL_FALSE;
-	}
-
-	void onMIDISystemRealtime(Bit8u systemRealtime) {
-		if (delegate.v0->onMIDISystemRealtime == NULL) {
-			ReportHandler::onMIDISystemRealtime(systemRealtime);
-		} else {
-			delegate.v0->onMIDISystemRealtime(instanceData, systemRealtime);
-		}
-	}
-
-	void onDeviceReset() {
-		if (delegate.v0->onDeviceReset == NULL) {
-			ReportHandler::onDeviceReset();
-		} else {
-			delegate.v0->onDeviceReset(instanceData);
-		}
-	}
-
-	void onDeviceReconfig() {
-		if (delegate.v0->onDeviceReconfig == NULL) {
-			ReportHandler::onDeviceReconfig();
-		} else {
-			delegate.v0->onDeviceReconfig(instanceData);
-		}
-	}
-
-	void onNewReverbMode(Bit8u mode) {
-		if (delegate.v0->onNewReverbMode == NULL) {
-			ReportHandler::onNewReverbMode(mode);
-		} else {
-			delegate.v0->onNewReverbMode(instanceData, mode);
-		}
-	}
-
-	void onNewReverbTime(Bit8u time) {
-		if (delegate.v0->onNewReverbTime == NULL) {
-			ReportHandler::onNewReverbTime(time);
-		} else {
-			delegate.v0->onNewReverbTime(instanceData, time);
-		}
-	}
-
-	void onNewReverbLevel(Bit8u level) {
-		if (delegate.v0->onNewReverbLevel == NULL) {
-			ReportHandler::onNewReverbLevel(level);
-		} else {
-			delegate.v0->onNewReverbLevel(instanceData, level);
-		}
-	}
-
-	void onPolyStateChanged(Bit8u partNum) {
-		if (delegate.v0->onPolyStateChanged == NULL) {
-			ReportHandler::onPolyStateChanged(partNum);
-		} else {
-			delegate.v0->onPolyStateChanged(instanceData, partNum);
-		}
-	}
-
-	void onProgramChanged(Bit8u partNum, const char *soundGroupName, const char *patchName) {
-		if (delegate.v0->onProgramChanged == NULL) {
-			ReportHandler::onProgramChanged(partNum, soundGroupName, patchName);
-		} else {
-			delegate.v0->onProgramChanged(instanceData, partNum, soundGroupName, patchName);
-		}
-	}
-};
-
-class DelegatingMidiStreamParser : public DefaultMidiStreamParser {
-public:
-	DelegatingMidiStreamParser(const mt32emu_data *useData, mt32emu_midi_receiver_i useMIDIReceiver, void *useInstanceData) :
-		DefaultMidiStreamParser(*useData->synth), delegate(useMIDIReceiver), instanceData(useInstanceData) {}
-
-protected:
-	mt32emu_midi_receiver_i delegate;
-	void *instanceData;
-
-private:
-	void handleShortMessage(const Bit32u message) {
-		if (delegate.v0->handleShortMessage == NULL) {
-			DefaultMidiStreamParser::handleShortMessage(message);
-		} else {
-			delegate.v0->handleShortMessage(instanceData, message);
-		}
-	}
-
-	void handleSysex(const Bit8u *stream, const Bit32u length) {
-		if (delegate.v0->handleSysex == NULL) {
-			DefaultMidiStreamParser::handleSysex(stream, length);
-		} else {
-			delegate.v0->handleSysex(instanceData, stream, length);
-		}
-	}
-
-	void handleSystemRealtimeMessage(const Bit8u realtime) {
-		if (delegate.v0->handleSystemRealtimeMessage == NULL) {
-			DefaultMidiStreamParser::handleSystemRealtimeMessage(realtime);
-		} else {
-			delegate.v0->handleSystemRealtimeMessage(instanceData, realtime);
-		}
-	}
-};
-
-static mt32emu_return_code addROMFile(mt32emu_data *data, File *file) {
-	const ROMImage *image = ROMImage::makeROMImage(file);
-	const ROMInfo *info = image->getROMInfo();
-	if (info == NULL) {
-		ROMImage::freeROMImage(image);
-		return MT32EMU_RC_ROM_NOT_IDENTIFIED;
-	}
-	if (info->type == ROMInfo::Control) {
-		if (data->controlROMImage != NULL) {
-			delete data->controlROMImage->getFile();
-			ROMImage::freeROMImage(data->controlROMImage);
-		}
-		data->controlROMImage = image;
-		return MT32EMU_RC_ADDED_CONTROL_ROM;
-	} else if (info->type == ROMInfo::PCM) {
-		if (data->pcmROMImage != NULL) {
-			delete data->pcmROMImage->getFile();
-			ROMImage::freeROMImage(data->pcmROMImage);
-		}
-		data->pcmROMImage = image;
-		return MT32EMU_RC_ADDED_PCM_ROM;
-	}
-	ROMImage::freeROMImage(image);
-	return MT32EMU_RC_OK; // No support for reverb ROM yet.
-}
-
-} // namespace MT32Emu
-
-// C-visible implementation
-
-extern "C" {
-
-const mt32emu_service_i mt32emu_get_service_i() {
-	mt32emu_service_i i = { &SERVICE_VTABLE };
-	return i;
-}
-
-mt32emu_report_handler_version mt32emu_get_supported_report_handler_version() {
-	return MT32EMU_REPORT_HANDLER_VERSION_CURRENT;
-}
-
-mt32emu_midi_receiver_version mt32emu_get_supported_midi_receiver_version() {
-	return MT32EMU_MIDI_RECEIVER_VERSION_CURRENT;
-}
-
-mt32emu_bit32u mt32emu_get_library_version_int() {
-	return Synth::getLibraryVersionInt();
-}
-
-const char *mt32emu_get_library_version_string() {
-	return Synth::getLibraryVersionString();
-}
-
-mt32emu_bit32u mt32emu_get_stereo_output_samplerate(const mt32emu_analog_output_mode analog_output_mode) {
-	return Synth::getStereoOutputSampleRate(static_cast<AnalogOutputMode>(analog_output_mode));
-}
-
-mt32emu_context mt32emu_create_context(mt32emu_report_handler_i report_handler, void *instance_data) {
-	mt32emu_data *data = new mt32emu_data;
-	data->reportHandler = (report_handler.v0 != NULL) ? new DelegatingReportHandlerAdapter(report_handler, instance_data) : new ReportHandler;
-	data->synth = new Synth(data->reportHandler);
-	data->midiParser = new DefaultMidiStreamParser(*data->synth);
-	data->controlROMImage = NULL;
-	data->pcmROMImage = NULL;
-	data->partialCount = DEFAULT_MAX_PARTIALS;
-	data->analogOutputMode = AnalogOutputMode_COARSE;
-	return data;
-}
-
-void mt32emu_free_context(mt32emu_context data) {
-	if (data == NULL) return;
-	if (data->controlROMImage != NULL) {
-		delete data->controlROMImage->getFile();
-		ROMImage::freeROMImage(data->controlROMImage);
-		data->controlROMImage = NULL;
-	}
-	if (data->pcmROMImage != NULL) {
-		delete data->pcmROMImage->getFile();
-		ROMImage::freeROMImage(data->pcmROMImage);
-		data->pcmROMImage = NULL;
-	}
-	delete data->midiParser;
-	data->midiParser = NULL;
-	delete data->synth;
-	data->synth = NULL;
-	delete data->reportHandler;
-	data->reportHandler = NULL;
-	delete data;
-}
-
-mt32emu_return_code mt32emu_add_rom_data(mt32emu_context context, const mt32emu_bit8u *data, size_t data_size, const mt32emu_sha1_digest *sha1_digest) {
-	if (sha1_digest == NULL) return addROMFile(context, new ArrayFile(data, data_size));
-	return addROMFile(context, new ArrayFile(data, data_size, *sha1_digest));
-}
-
-mt32emu_return_code mt32emu_add_rom_file(mt32emu_context context, const char *filename) {
-	mt32emu_return_code rc = MT32EMU_RC_OK;
-	FileStream *fs = new FileStream;
-	if (fs->open(filename)) {
-		if (fs->getData() != NULL) {
-			rc = addROMFile(context, fs);
-			if (rc > 0) return rc;
-		} else {
-			rc = MT32EMU_RC_FILE_NOT_LOADED;
-		}
-	} else {
-		rc = MT32EMU_RC_FILE_NOT_FOUND;
-	}
-	delete fs;
-	return rc;
-}
-
-void mt32emu_get_rom_info(mt32emu_const_context context, mt32emu_rom_info *rom_info) {
-	const ROMInfo *romInfo = context->controlROMImage == NULL ? NULL : context->controlROMImage->getROMInfo();
-	if (romInfo != NULL) {
-		rom_info->control_rom_id = romInfo->shortName;
-		rom_info->control_rom_description = romInfo->description;
-		rom_info->control_rom_sha1_digest = romInfo->sha1Digest;
-	} else {
-		rom_info->control_rom_id = NULL;
-		rom_info->control_rom_description = NULL;
-		rom_info->control_rom_sha1_digest = NULL;
-	}
-	romInfo = context->pcmROMImage == NULL ? NULL : context->pcmROMImage->getROMInfo();
-	if (romInfo != NULL) {
-		rom_info->pcm_rom_id = romInfo->shortName;
-		rom_info->pcm_rom_description = romInfo->description;
-		rom_info->pcm_rom_sha1_digest = romInfo->sha1Digest;
-	} else {
-		rom_info->pcm_rom_id = NULL;
-		rom_info->pcm_rom_description = NULL;
-		rom_info->pcm_rom_sha1_digest = NULL;
-	}
-}
-
-void mt32emu_set_partial_count(mt32emu_context context, const mt32emu_bit32u partial_count) {
-	context->partialCount = partial_count;
-}
-
-void mt32emu_set_analog_output_mode(mt32emu_context context, const mt32emu_analog_output_mode analog_output_mode) {
-	context->analogOutputMode = static_cast<AnalogOutputMode>(analog_output_mode);
-}
-
-mt32emu_return_code mt32emu_open_synth(mt32emu_const_context context) {
-	if ((context->controlROMImage == NULL) || (context->pcmROMImage == NULL)) {
-		return MT32EMU_RC_MISSING_ROMS;
-	}
-	if (context->synth->open(*context->controlROMImage, *context->pcmROMImage, context->partialCount, context->analogOutputMode)) {
-		return MT32EMU_RC_OK;
-	}
-	return MT32EMU_RC_FAILED;
-}
-
-void mt32emu_close_synth(mt32emu_const_context context) {
-	context->synth->close();
-}
-
-mt32emu_boolean mt32emu_is_open(mt32emu_const_context context) {
-	return context->synth->isOpen() ? MT32EMU_BOOL_TRUE : MT32EMU_BOOL_FALSE;
-}
-
-mt32emu_bit32u mt32emu_get_actual_stereo_output_samplerate(mt32emu_const_context context) {
-	return context->synth->getStereoOutputSampleRate();
-}
-
-void mt32emu_flush_midi_queue(mt32emu_const_context context) {
-	context->synth->flushMIDIQueue();
-}
-
-mt32emu_bit32u mt32emu_set_midi_event_queue_size(mt32emu_const_context context, const mt32emu_bit32u queue_size) {
-	return context->synth->setMIDIEventQueueSize(queue_size);
-}
-
-void mt32emu_set_midi_receiver(mt32emu_context context, mt32emu_midi_receiver_i midi_receiver, void *instance_data) {
-	delete context->midiParser;
-	context->midiParser = (midi_receiver.v0 != NULL) ? new DelegatingMidiStreamParser(context, midi_receiver, instance_data) : new DefaultMidiStreamParser(*context->synth);
-}
-
-void mt32emu_parse_stream(mt32emu_const_context context, const mt32emu_bit8u *stream, mt32emu_bit32u length) {
-	context->midiParser->resetTimestamp();
-	context->midiParser->parseStream(stream, length);
-}
-
-void mt32emu_parse_stream_at(mt32emu_const_context context, const mt32emu_bit8u *stream, mt32emu_bit32u length, mt32emu_bit32u timestamp) {
-	context->midiParser->setTimestamp(timestamp);
-	context->midiParser->parseStream(stream, length);
-}
-
-void mt32emu_play_short_message(mt32emu_const_context context, mt32emu_bit32u message) {
-	context->midiParser->resetTimestamp();
-	context->midiParser->processShortMessage(message);
-}
-
-void mt32emu_play_short_message_at(mt32emu_const_context context, mt32emu_bit32u message, mt32emu_bit32u timestamp) {
-	context->midiParser->setTimestamp(timestamp);
-	context->midiParser->processShortMessage(message);
-}
-
-mt32emu_return_code mt32emu_play_msg(mt32emu_const_context context, mt32emu_bit32u msg) {
-	if (!context->synth->isOpen()) return MT32EMU_RC_NOT_OPENED;
-	return (context->synth->playMsg(msg)) ? MT32EMU_RC_OK : MT32EMU_RC_QUEUE_FULL;
-}
-
-mt32emu_return_code mt32emu_play_sysex(mt32emu_const_context context, const mt32emu_bit8u *sysex, mt32emu_bit32u len) {
-	if (!context->synth->isOpen()) return MT32EMU_RC_NOT_OPENED;
-	return (context->synth->playSysex(sysex, len)) ? MT32EMU_RC_OK : MT32EMU_RC_QUEUE_FULL;
-}
-
-mt32emu_return_code mt32emu_play_msg_at(mt32emu_const_context context, mt32emu_bit32u msg, mt32emu_bit32u timestamp) {
-	if (!context->synth->isOpen()) return MT32EMU_RC_NOT_OPENED;
-	return (context->synth->playMsg(msg, timestamp)) ? MT32EMU_RC_OK : MT32EMU_RC_QUEUE_FULL;
-}
-
-mt32emu_return_code mt32emu_play_sysex_at(mt32emu_const_context context, const mt32emu_bit8u *sysex, mt32emu_bit32u len, mt32emu_bit32u timestamp) {
-	if (!context->synth->isOpen()) return MT32EMU_RC_NOT_OPENED;
-	return (context->synth->playSysex(sysex, len, timestamp)) ? MT32EMU_RC_OK : MT32EMU_RC_QUEUE_FULL;
-}
-
-void mt32emu_play_msg_now(mt32emu_const_context context, mt32emu_bit32u msg) {
-	context->synth->playMsgNow(msg);
-}
-
-void mt32emu_play_msg_on_part(mt32emu_const_context context, mt32emu_bit8u part, mt32emu_bit8u code, mt32emu_bit8u note, mt32emu_bit8u velocity) {
-	context->synth->playMsgOnPart(part, code, note, velocity);
-}
-
-void mt32emu_play_sysex_now(mt32emu_const_context context, const mt32emu_bit8u *sysex, mt32emu_bit32u len) {
-	context->synth->playSysexNow(sysex, len);
-}
-
-void mt32emu_write_sysex(mt32emu_const_context context, mt32emu_bit8u channel, const mt32emu_bit8u *sysex, mt32emu_bit32u len) {
-	context->synth->writeSysex(channel, sysex, len);
-}
-
-void mt32emu_set_reverb_enabled(mt32emu_const_context context, const mt32emu_boolean reverb_enabled) {
-	context->synth->setReverbEnabled(reverb_enabled != MT32EMU_BOOL_FALSE);
-}
-
-mt32emu_boolean mt32emu_is_reverb_enabled(mt32emu_const_context context) {
-	return context->synth->isReverbEnabled() ? MT32EMU_BOOL_TRUE : MT32EMU_BOOL_FALSE;
-}
-
-void mt32emu_set_reverb_overridden(mt32emu_const_context context, const mt32emu_boolean reverb_overridden) {
-	context->synth->setReverbOverridden(reverb_overridden != MT32EMU_BOOL_FALSE);
-}
-
-mt32emu_boolean mt32emu_is_reverb_overridden(mt32emu_const_context context) {
-	return context->synth->isReverbOverridden() ? MT32EMU_BOOL_TRUE : MT32EMU_BOOL_FALSE;
-}
-
-void mt32emu_set_reverb_compatibility_mode(mt32emu_const_context context, const mt32emu_boolean mt32_compatible_mode) {
-	context->synth->setReverbCompatibilityMode(mt32_compatible_mode != MT32EMU_BOOL_FALSE);
-}
-
-mt32emu_boolean mt32emu_is_mt32_reverb_compatibility_mode(mt32emu_const_context context) {
-	return context->synth->isMT32ReverbCompatibilityMode() ? MT32EMU_BOOL_TRUE : MT32EMU_BOOL_FALSE;
-}
-
-mt32emu_boolean mt32emu_is_default_reverb_mt32_compatible(mt32emu_const_context context) {
-	return context->synth->isDefaultReverbMT32Compatible() ? MT32EMU_BOOL_TRUE : MT32EMU_BOOL_FALSE;
-}
-
-void mt32emu_set_dac_input_mode(mt32emu_const_context context, const mt32emu_dac_input_mode mode) {
-	context->synth->setDACInputMode(static_cast<DACInputMode>(mode));
-}
-
-mt32emu_dac_input_mode mt32emu_get_dac_input_mode(mt32emu_const_context context) {
-	return static_cast<mt32emu_dac_input_mode>(context->synth->getDACInputMode());
-}
-
-void mt32emu_set_midi_delay_mode(mt32emu_const_context context, const mt32emu_midi_delay_mode mode) {
-	context->synth->setMIDIDelayMode(static_cast<MIDIDelayMode>(mode));
-}
-
-mt32emu_midi_delay_mode mt32emu_get_midi_delay_mode(mt32emu_const_context context) {
-	return static_cast<mt32emu_midi_delay_mode>(context->synth->getMIDIDelayMode());
-}
-
-void mt32emu_set_output_gain(mt32emu_const_context context, float gain) {
-	context->synth->setOutputGain(gain);
-}
-
-float mt32emu_get_output_gain(mt32emu_const_context context) {
-	return context->synth->getOutputGain();
-}
-
-void mt32emu_set_reverb_output_gain(mt32emu_const_context context, float gain) {
-	context->synth->setReverbOutputGain(gain);
-}
-
-float mt32emu_get_reverb_output_gain(mt32emu_const_context context) {
-	return context->synth->getReverbOutputGain();
-}
-
-void mt32emu_set_reversed_stereo_enabled(mt32emu_const_context context, const mt32emu_boolean enabled) {
-	context->synth->setReversedStereoEnabled(enabled != MT32EMU_BOOL_FALSE);
-}
-
-mt32emu_boolean mt32emu_is_reversed_stereo_enabled(mt32emu_const_context context) {
-	return context->synth->isReversedStereoEnabled() ? MT32EMU_BOOL_TRUE : MT32EMU_BOOL_FALSE;
-}
-
-void mt32emu_render_bit16s(mt32emu_const_context context, mt32emu_bit16s *stream, mt32emu_bit32u len) {
-	context->synth->render(stream, len);
-}
-
-void mt32emu_render_float(mt32emu_const_context context, float *stream, mt32emu_bit32u len) {
-	context->synth->render(stream, len);
-}
-
-void mt32emu_render_bit16s_streams(mt32emu_const_context context, const mt32emu_dac_output_bit16s_streams *streams, mt32emu_bit32u len) {
-	context->synth->renderStreams(*(const DACOutputStreams<Bit16s> *)streams, len);
-}
-
-void mt32emu_render_float_streams(mt32emu_const_context context, const mt32emu_dac_output_float_streams *streams, mt32emu_bit32u len) {
-	context->synth->renderStreams(*(const DACOutputStreams<float> *)streams, len);
-}
-
-mt32emu_boolean mt32emu_has_active_partials(mt32emu_const_context context) {
-	return context->synth->hasActivePartials() ? MT32EMU_BOOL_TRUE : MT32EMU_BOOL_FALSE;
-}
-
-mt32emu_boolean mt32emu_is_active(mt32emu_const_context context) {
-	return context->synth->isActive() ? MT32EMU_BOOL_TRUE : MT32EMU_BOOL_FALSE;
-}
-
-mt32emu_bit32u mt32emu_get_partial_count(mt32emu_const_context context) {
-	return context->synth->getPartialCount();
-}
-
-mt32emu_bit32u mt32emu_get_part_states(mt32emu_const_context context) {
-	return context->synth->getPartStates();
-}
-
-void mt32emu_get_partial_states(mt32emu_const_context context, mt32emu_bit8u *partial_states) {
-	context->synth->getPartialStates(partial_states);
-}
-
-mt32emu_bit32u mt32emu_get_playing_notes(mt32emu_const_context context, mt32emu_bit8u part_number, mt32emu_bit8u *keys, mt32emu_bit8u *velocities) {
-	return context->synth->getPlayingNotes(part_number, keys, velocities);
-}
-
-const char *mt32emu_get_patch_name(mt32emu_const_context context, mt32emu_bit8u part_number) {
-	return context->synth->getPatchName(part_number);
-}
-
-void mt32emu_read_memory(mt32emu_const_context context, mt32emu_bit32u addr, mt32emu_bit32u len, mt32emu_bit8u *data) {
-	context->synth->readMemory(addr, len, data);
-}
-
-} // extern "C"
diff --git a/audio/softsynth/mt32/c_interface/c_interface.h b/audio/softsynth/mt32/c_interface/c_interface.h
deleted file mode 100644
index a2bdcb1254..0000000000
--- a/audio/softsynth/mt32/c_interface/c_interface.h
+++ /dev/null
@@ -1,362 +0,0 @@
-/* Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Dean Beeler, Jerome Fisher
- * Copyright (C) 2011-2016 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
- *
- *  This program is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU Lesser General Public License as published by
- *  the Free Software Foundation, either version 2.1 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU Lesser General Public License for more details.
- *
- *  You should have received a copy of the GNU Lesser General Public License
- *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef MT32EMU_C_INTERFACE_H
-#define MT32EMU_C_INTERFACE_H
-
-#include <stddef.h>
-
-#include "../globals.h"
-#include "c_types.h"
-
-#undef MT32EMU_EXPORT
-#define MT32EMU_EXPORT MT32EMU_EXPORT_ATTRIBUTE
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* == Context-independent functions == */
-
-/* === Interface handling === */
-
-/** Returns mt32emu_service_i interface. */
-MT32EMU_EXPORT const mt32emu_service_i mt32emu_get_service_i();
-
-#if MT32EMU_EXPORTS_TYPE == 2
-#undef MT32EMU_EXPORT
-#define MT32EMU_EXPORT
-#endif
-
-/**
- * Returns the version ID of mt32emu_report_handler_i interface the library has been compiled with.
- * This allows a client to fall-back gracefully instead of silently not receiving expected event reports.
- */
-MT32EMU_EXPORT mt32emu_report_handler_version mt32emu_get_supported_report_handler_version();
-
-/**
- * Returns the version ID of mt32emu_midi_receiver_version_i interface the library has been compiled with.
- * This allows a client to fall-back gracefully instead of silently not receiving expected MIDI messages.
- */
-MT32EMU_EXPORT mt32emu_midi_receiver_version mt32emu_get_supported_midi_receiver_version();
-
-/**
- * Returns library version as an integer in format: 0x00MMmmpp, where:
- * MM - major version number
- * mm - minor version number
- * pp - patch number
- */
-MT32EMU_EXPORT mt32emu_bit32u mt32emu_get_library_version_int();
-
-/**
- * Returns library version as a C-string in format: "MAJOR.MINOR.PATCH".
- */
-MT32EMU_EXPORT const char *mt32emu_get_library_version_string();
-
-/**
- * Returns output sample rate used in emulation of stereo analog circuitry of hardware units for particular analog_output_mode.
- * See comment for mt32emu_analog_output_mode.
- */
-MT32EMU_EXPORT mt32emu_bit32u mt32emu_get_stereo_output_samplerate(const mt32emu_analog_output_mode analog_output_mode);
-
-/* == Context-dependent functions == */
-
-/** Initialises a new emulation context and installs custom report handler if non-NULL. */
-MT32EMU_EXPORT mt32emu_context mt32emu_create_context(mt32emu_report_handler_i report_handler, void *instance_data);
-
-/** Closes and destroys emulation context. */
-MT32EMU_EXPORT void mt32emu_free_context(mt32emu_context context);
-
-/**
- * Adds new ROM identified by its SHA1 digest to the emulation context replacing previously added ROM of the same type if any.
- * Argument sha1_digest can be NULL, in this case the digest will be computed using the actual ROM data.
- * If sha1_digest is set to non-NULL, it is assumed being correct and will not be recomputed.
- * This function doesn't immediately change the state of already opened synth. Newly added ROM will take effect upon next call of mt32emu_open_synth().
- * Returns positive value upon success.
- */
-MT32EMU_EXPORT mt32emu_return_code mt32emu_add_rom_data(mt32emu_context context, const mt32emu_bit8u *data, size_t data_size, const mt32emu_sha1_digest *sha1_digest);
-
-/**
- * Loads a ROM file, identify it by SHA1 digest, and adds it to the emulation context replacing previously added ROM of the same type if any.
- * This function doesn't immediately change the state of already opened synth. Newly added ROM will take effect upon next call of mt32emu_open_synth().
- * Returns positive value upon success.
- */
-MT32EMU_EXPORT mt32emu_return_code mt32emu_add_rom_file(mt32emu_context context, const char *filename);
-
-/**
- * Fills in mt32emu_rom_info structure with identifiers and descriptions of control and PCM ROM files identified and added to the synth context.
- * If one of the ROM files is not loaded and identified yet, NULL is returned in the corresponding fields of the mt32emu_rom_info structure.
- */
-MT32EMU_EXPORT void mt32emu_get_rom_info(mt32emu_const_context context, mt32emu_rom_info *rom_info);
-
-/**
- * Allows to override the default maximum number of partials playing simultaneously within the emulation session.
- * This function doesn't immediately change the state of already opened synth. Newly set vale will take effect upon next call of mt32emu_open_synth().
- */
-MT32EMU_EXPORT void mt32emu_set_partial_count(mt32emu_context context, const mt32emu_bit32u partial_count);
-
-/**
- * Allows to override the default mode for emulation of analogue circuitry of the hardware units within the emulation session.
- * This function doesn't immediately change the state of already opened synth. Newly set vale will take effect upon next call of mt32emu_open_synth().
- */
-MT32EMU_EXPORT void mt32emu_set_analog_output_mode(mt32emu_context context, const mt32emu_analog_output_mode analog_output_mode);
-
-/**
- * Prepares the emulation context to receive MIDI messages and produce output audio data using aforehand added set of ROMs,
- * and optionally set the maximum partial count and the analog output mode.
- * Returns MT32EMU_RC_OK upon success.
- */
-MT32EMU_EXPORT mt32emu_return_code mt32emu_open_synth(mt32emu_const_context context);
-
-/** Closes the emulation context freeing allocated resources. Added ROMs remain unaffected and ready for reuse. */
-MT32EMU_EXPORT void mt32emu_close_synth(mt32emu_const_context context);
-
-/** Returns true if the synth is in completely initialized state, otherwise returns false. */
-MT32EMU_EXPORT mt32emu_boolean mt32emu_is_open(mt32emu_const_context context);
-
-/**
- * Returns actual output sample rate used in emulation of stereo analog circuitry of hardware units.
- * See comment for mt32emu_analog_output_mode.
- */
-MT32EMU_EXPORT mt32emu_bit32u mt32emu_get_actual_stereo_output_samplerate(mt32emu_const_context context);
-
-/** All the enqueued events are processed by the synth immediately. */
-MT32EMU_EXPORT void mt32emu_flush_midi_queue(mt32emu_const_context context);
-
-/**
- * Sets size of the internal MIDI event queue. The queue size is set to the minimum power of 2 that is greater or equal to the size specified.
- * The queue is flushed before reallocation.
- * Returns the actual queue size being used.
- */
-MT32EMU_EXPORT mt32emu_bit32u mt32emu_set_midi_event_queue_size(mt32emu_const_context context, const mt32emu_bit32u queue_size);
-
-/**
- * Installs custom MIDI receiver object intended for receiving MIDI messages generated by MIDI stream parser.
- * MIDI stream parser is involved when functions mt32emu_parse_stream() and mt32emu_play_short_message() or the likes are called.
- * By default, parsed short MIDI messages and System Exclusive messages are sent to the synth input MIDI queue.
- * This function allows to override default behaviour. If midi_receiver argument is set to NULL, the default behaviour is restored.
- */
-MT32EMU_EXPORT void mt32emu_set_midi_receiver(mt32emu_context context, mt32emu_midi_receiver_i midi_receiver, void *instance_data);
-
-/* Enqueues a MIDI event for subsequent playback.
- * The MIDI event will be processed not before the specified timestamp.
- * The timestamp is measured as the global rendered sample count since the synth was created (at the native sample rate 32000 Hz).
- * The minimum delay involves emulation of the delay introduced while the event is transferred via MIDI interface
- * and emulation of the MCU busy-loop while it frees partials for use by a new Poly.
- * Calls from multiple threads must be synchronised, although, no synchronisation is required with the rendering thread.
- * onMIDIQueueOverflow callback is invoked when the MIDI event queue is full and the message cannot be enqueued.
- */
-
-/**
- * Parses a block of raw MIDI bytes and enqueues parsed MIDI messages for further processing ASAP.
- * SysEx messages are allowed to be fragmented across several calls to this method. Running status is also handled for short messages.
- * When a System Realtime MIDI message is parsed, onMIDISystemRealtime callback is invoked.
- * NOTE: the total length of a SysEx message being fragmented shall not exceed MT32EMU_MAX_STREAM_BUFFER_SIZE (32768 bytes).
- */
-MT32EMU_EXPORT void mt32emu_parse_stream(mt32emu_const_context context, const mt32emu_bit8u *stream, mt32emu_bit32u length);
-
-/**
- * Parses a block of raw MIDI bytes and enqueues parsed MIDI messages to play at specified time.
- * SysEx messages are allowed to be fragmented across several calls to this method. Running status is also handled for short messages.
- * When a System Realtime MIDI message is parsed, onMIDISystemRealtime callback is invoked.
- * NOTE: the total length of a SysEx message being fragmented shall not exceed MT32EMU_MAX_STREAM_BUFFER_SIZE (32768 bytes).
- */
-MT32EMU_EXPORT void mt32emu_parse_stream_at(mt32emu_const_context context, const mt32emu_bit8u *stream, mt32emu_bit32u length, mt32emu_bit32u timestamp);
-
-/**
- * Enqueues a single mt32emu_bit32u-encoded short MIDI message with full processing ASAP.
- * The short MIDI message may contain no status byte, the running status is used in this case.
- * When the argument is a System Realtime MIDI message, onMIDISystemRealtime callback is invoked.
- */
-MT32EMU_EXPORT void mt32emu_play_short_message(mt32emu_const_context context, mt32emu_bit32u message);
-
-/**
- * Enqueues a single mt32emu_bit32u-encoded short MIDI message to play at specified time with full processing.
- * The short MIDI message may contain no status byte, the running status is used in this case.
- * When the argument is a System Realtime MIDI message, onMIDISystemRealtime callback is invoked.
- */
-MT32EMU_EXPORT void mt32emu_play_short_message_at(mt32emu_const_context context, mt32emu_bit32u message, mt32emu_bit32u timestamp);
-
-/** Enqueues a single short MIDI message to be processed ASAP. The message must contain a status byte. */
-MT32EMU_EXPORT mt32emu_return_code mt32emu_play_msg(mt32emu_const_context context, mt32emu_bit32u msg);
-/** Enqueues a single well formed System Exclusive MIDI message to be processed ASAP. */
-MT32EMU_EXPORT mt32emu_return_code mt32emu_play_sysex(mt32emu_const_context context, const mt32emu_bit8u *sysex, mt32emu_bit32u len);
-
-/** Enqueues a single short MIDI message to play at specified time. The message must contain a status byte. */
-MT32EMU_EXPORT mt32emu_return_code mt32emu_play_msg_at(mt32emu_const_context context, mt32emu_bit32u msg, mt32emu_bit32u timestamp);
-/** Enqueues a single well formed System Exclusive MIDI message to play at specified time. */
-MT32EMU_EXPORT mt32emu_return_code mt32emu_play_sysex_at(mt32emu_const_context context, const mt32emu_bit8u *sysex, mt32emu_bit32u len, mt32emu_bit32u timestamp);
-
-/* WARNING:
- * The methods below don't ensure minimum 1-sample delay between sequential MIDI events,
- * and a sequence of NoteOn and immediately succeeding NoteOff messages is always silent.
- * A thread that invokes these methods must be explicitly synchronised with the thread performing sample rendering.
- */
-
-/**
- * Sends a short MIDI message to the synth for immediate playback. The message must contain a status byte.
- * See the WARNING above.
- */
-MT32EMU_EXPORT void mt32emu_play_msg_now(mt32emu_const_context context, mt32emu_bit32u msg);
-/**
- * Sends unpacked short MIDI message to the synth for immediate playback. The message must contain a status byte.
- * See the WARNING above.
- */
-MT32EMU_EXPORT void mt32emu_play_msg_on_part(mt32emu_const_context context, mt32emu_bit8u part, mt32emu_bit8u code, mt32emu_bit8u note, mt32emu_bit8u velocity);
-
-/**
- * Sends a single well formed System Exclusive MIDI message for immediate processing. The length is in bytes.
- * See the WARNING above.
- */
-MT32EMU_EXPORT void mt32emu_play_sysex_now(mt32emu_const_context context, const mt32emu_bit8u *sysex, mt32emu_bit32u len);
-/**
- * Sends inner body of a System Exclusive MIDI message for direct processing. The length is in bytes.
- * See the WARNING above.
- */
-MT32EMU_EXPORT void mt32emu_write_sysex(mt32emu_const_context context, mt32emu_bit8u channel, const mt32emu_bit8u *sysex, mt32emu_bit32u len);
-
-/** Allows to disable wet reverb output altogether. */
-MT32EMU_EXPORT void mt32emu_set_reverb_enabled(mt32emu_const_context context, const mt32emu_boolean reverb_enabled);
-/** Returns whether wet reverb output is enabled. */
-MT32EMU_EXPORT mt32emu_boolean mt32emu_is_reverb_enabled(mt32emu_const_context context);
-/**
- * Sets override reverb mode. In this mode, emulation ignores sysexes (or the related part of them) which control the reverb parameters.
- * This mode is in effect until it is turned off. When the synth is re-opened, the override mode is unchanged but the state
- * of the reverb model is reset to default.
- */
-MT32EMU_EXPORT void mt32emu_set_reverb_overridden(mt32emu_const_context context, const mt32emu_boolean reverb_overridden);
-/** Returns whether reverb settings are overridden. */
-MT32EMU_EXPORT mt32emu_boolean mt32emu_is_reverb_overridden(mt32emu_const_context context);
-/**
- * Forces reverb model compatibility mode. By default, the compatibility mode corresponds to the used control ROM version.
- * Invoking this method with the argument set to true forces emulation of old MT-32 reverb circuit.
- * When the argument is false, emulation of the reverb circuit used in new generation of MT-32 compatible modules is enforced
- * (these include CM-32L and LAPC-I).
- */
-MT32EMU_EXPORT void mt32emu_set_reverb_compatibility_mode(mt32emu_const_context context, const mt32emu_boolean mt32_compatible_mode);
-/** Returns whether reverb is in old MT-32 compatibility mode. */
-MT32EMU_EXPORT mt32emu_boolean mt32emu_is_mt32_reverb_compatibility_mode(mt32emu_const_context context);
-/** Returns whether default reverb compatibility mode is the old MT-32 compatibility mode. */
-MT32EMU_EXPORT mt32emu_boolean mt32emu_is_default_reverb_mt32_compatible(mt32emu_const_context context);
-
-/** Sets new DAC input mode. See mt32emu_dac_input_mode for details. */
-MT32EMU_EXPORT void mt32emu_set_dac_input_mode(mt32emu_const_context context, const mt32emu_dac_input_mode mode);
-/** Returns current DAC input mode. See mt32emu_dac_input_mode for details. */
-MT32EMU_EXPORT mt32emu_dac_input_mode mt32emu_get_dac_input_mode(mt32emu_const_context context);
-
-/** Sets new MIDI delay mode. See mt32emu_midi_delay_mode for details. */
-MT32EMU_EXPORT void mt32emu_set_midi_delay_mode(mt32emu_const_context context, const mt32emu_midi_delay_mode mode);
-/** Returns current MIDI delay mode. See mt32emu_midi_delay_mode for details. */
-MT32EMU_EXPORT mt32emu_midi_delay_mode mt32emu_get_midi_delay_mode(mt32emu_const_context context);
-
-/**
- * Sets output gain factor for synth output channels. Applied to all output samples and unrelated with the synth's Master volume,
- * it rather corresponds to the gain of the output analog circuitry of the hardware units. However, together with mt32emu_set_reverb_output_gain()
- * it offers to the user a capability to control the gain of reverb and non-reverb output channels independently.
- * Ignored in MT32EMU_DAC_PURE mode.
- */
-MT32EMU_EXPORT void mt32emu_set_output_gain(mt32emu_const_context context, float gain);
-/** Returns current output gain factor for synth output channels. */
-MT32EMU_EXPORT float mt32emu_get_output_gain(mt32emu_const_context context);
-
-/**
- * Sets output gain factor for the reverb wet output channels. It rather corresponds to the gain of the output
- * analog circuitry of the hardware units. However, together with mt32emu_set_output_gain() it offers to the user a capability
- * to control the gain of reverb and non-reverb output channels independently.
- *
- * Note: We're currently emulate CM-32L/CM-64 reverb quite accurately and the reverb output level closely
- * corresponds to the level of digital capture. Although, according to the CM-64 PCB schematic,
- * there is a difference in the reverb analogue circuit, and the resulting output gain is 0.68
- * of that for LA32 analogue output. This factor is applied to the reverb output gain.
- * Ignored in MT32EMU_DAC_PURE mode.
- */
-MT32EMU_EXPORT void mt32emu_set_reverb_output_gain(mt32emu_const_context context, float gain);
-/** Returns current output gain factor for reverb wet output channels. */
-MT32EMU_EXPORT float mt32emu_get_reverb_output_gain(mt32emu_const_context context);
-
-/** Swaps left and right output channels. */
-MT32EMU_EXPORT void mt32emu_set_reversed_stereo_enabled(mt32emu_const_context context, const mt32emu_boolean enabled);
-/** Returns whether left and right output channels are swapped. */
-MT32EMU_EXPORT mt32emu_boolean mt32emu_is_reversed_stereo_enabled(mt32emu_const_context context);
-
-/**
- * Renders samples to the specified output stream as if they were sampled at the analog stereo output.
- * When mt32emu_analog_output_mode is set to ACCURATE (OVERSAMPLED), the output signal is upsampled to 48 (96) kHz in order
- * to retain emulation accuracy in whole audible frequency spectra. Otherwise, native digital signal sample rate is retained.
- * mt32emu_get_actual_stereo_output_samplerate() can be used to query actual sample rate of the output signal.
- * The length is in frames, not bytes (in 16-bit stereo, one frame is 4 bytes). Uses NATIVE byte ordering.
- */
-MT32EMU_EXPORT void mt32emu_render_bit16s(mt32emu_const_context context, mt32emu_bit16s *stream, mt32emu_bit32u len);
-/** Same as above but outputs to a float stereo stream. */
-MT32EMU_EXPORT void mt32emu_render_float(mt32emu_const_context context, float *stream, mt32emu_bit32u len);
-
-/**
- * Renders samples to the specified output streams as if they appeared at the DAC entrance.
- * No further processing performed in analog circuitry emulation is applied to the signal.
- * NULL may be specified in place of any or all of the stream buffers to skip it.
- * The length is in samples, not bytes. Uses NATIVE byte ordering.
- */
-MT32EMU_EXPORT void mt32emu_render_bit16s_streams(mt32emu_const_context context, const mt32emu_dac_output_bit16s_streams *streams, mt32emu_bit32u len);
-/** Same as above but outputs to float streams. */
-MT32EMU_EXPORT void mt32emu_render_float_streams(mt32emu_const_context context, const mt32emu_dac_output_float_streams *streams, mt32emu_bit32u len);
-
-/** Returns true when there is at least one active partial, otherwise false. */
-MT32EMU_EXPORT mt32emu_boolean mt32emu_has_active_partials(mt32emu_const_context context);
-
-/** Returns true if mt32emu_has_active_partials() returns true, or reverb is (somewhat unreliably) detected as being active. */
-MT32EMU_EXPORT mt32emu_boolean mt32emu_is_active(mt32emu_const_context context);
-
-/** Returns the maximum number of partials playing simultaneously. */
-MT32EMU_EXPORT mt32emu_bit32u mt32emu_get_partial_count(mt32emu_const_context context);
-
-/**
- * Returns current states of all the parts as a bit set. The least significant bit corresponds to the state of part 1,
- * total of 9 bits hold the states of all the parts. If the returned bit for a part is set, there is at least one active
- * non-releasing partial playing on this part. This info is useful in emulating behaviour of LCD display of the hardware units.
- */
-MT32EMU_EXPORT mt32emu_bit32u mt32emu_get_part_states(mt32emu_const_context context);
-
-/**
- * Fills in current states of all the partials into the array provided. Each byte in the array holds states of 4 partials
- * starting from the least significant bits. The state of each partial is packed in a pair of bits.
- * The array must be large enough to accommodate states of all the partials.
- * @see getPartialCount()
- */
-MT32EMU_EXPORT void mt32emu_get_partial_states(mt32emu_const_context context, mt32emu_bit8u *partial_states);
-
-/**
- * Fills in information about currently playing notes on the specified part into the arrays provided. The arrays must be large enough
- * to accommodate data for all the playing notes. The maximum number of simultaneously playing notes cannot exceed the number of partials.
- * Argument partNumber should be 0..7 for Part 1..8, or 8 for Rhythm.
- * Returns the number of currently playing notes on the specified part.
- */
-MT32EMU_EXPORT mt32emu_bit32u mt32emu_get_playing_notes(mt32emu_const_context context, mt32emu_bit8u part_number, mt32emu_bit8u *keys, mt32emu_bit8u *velocities);
-
-/**
- * Returns name of the patch set on the specified part.
- * Argument partNumber should be 0..7 for Part 1..8, or 8 for Rhythm.
- */
-MT32EMU_EXPORT const char *mt32emu_get_patch_name(mt32emu_const_context context, mt32emu_bit8u part_number);
-
-/** Stores internal state of emulated synth into an array provided (as it would be acquired from hardware). */
-MT32EMU_EXPORT void mt32emu_read_memory(mt32emu_const_context context, mt32emu_bit32u addr, mt32emu_bit32u len, mt32emu_bit8u *data);
-
-#ifdef __cplusplus
-} // extern "C"
-#endif
-
-#endif /* #ifndef MT32EMU_C_INTERFACE_H */
diff --git a/audio/softsynth/mt32/c_interface/c_types.h b/audio/softsynth/mt32/c_interface/c_types.h
deleted file mode 100644
index 3cd8744235..0000000000
--- a/audio/softsynth/mt32/c_interface/c_types.h
+++ /dev/null
@@ -1,298 +0,0 @@
-/* Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Dean Beeler, Jerome Fisher
- * Copyright (C) 2011-2016 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
- *
- *  This program is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU Lesser General Public License as published by
- *  the Free Software Foundation, either version 2.1 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU Lesser General Public License for more details.
- *
- *  You should have received a copy of the GNU Lesser General Public License
- *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef MT32EMU_C_TYPES_H
-#define MT32EMU_C_TYPES_H
-
-#include <stdarg.h>
-#include <stddef.h>
-
-#include "../globals.h"
-
-#define MT32EMU_C_ENUMERATIONS
-#include "../Enumerations.h"
-#undef MT32EMU_C_ENUMERATIONS
-
-typedef unsigned int       mt32emu_bit32u;
-typedef   signed int       mt32emu_bit32s;
-typedef unsigned short int mt32emu_bit16u;
-typedef   signed short int mt32emu_bit16s;
-typedef unsigned char      mt32emu_bit8u;
-typedef   signed char      mt32emu_bit8s;
-
-typedef char mt32emu_sha1_digest[41];
-
-typedef enum {
-	MT32EMU_BOOL_FALSE, MT32EMU_BOOL_TRUE
-} mt32emu_boolean;
-
-typedef enum {
-	/* Operation completed normally. */
-	MT32EMU_RC_OK = 0,
-	MT32EMU_RC_ADDED_CONTROL_ROM = 1,
-	MT32EMU_RC_ADDED_PCM_ROM = 2,
-
-	/* Definite error occurred. */
-	MT32EMU_RC_ROM_NOT_IDENTIFIED = -1,
-	MT32EMU_RC_FILE_NOT_FOUND = -2,
-	MT32EMU_RC_FILE_NOT_LOADED = -3,
-	MT32EMU_RC_MISSING_ROMS = -4,
-	MT32EMU_RC_NOT_OPENED = -5,
-	MT32EMU_RC_QUEUE_FULL = -6,
-
-	/* Undefined error occurred. */
-	MT32EMU_RC_FAILED = -100
-} mt32emu_return_code;
-
-/** Emulation context */
-typedef struct mt32emu_data *mt32emu_context;
-typedef const struct mt32emu_data *mt32emu_const_context;
-
-/* Convenience aliases */
-#ifndef __cplusplus
-typedef enum mt32emu_analog_output_mode mt32emu_analog_output_mode;
-typedef enum mt32emu_dac_input_mode mt32emu_dac_input_mode;
-typedef enum mt32emu_midi_delay_mode mt32emu_midi_delay_mode;
-typedef enum mt32emu_partial_state mt32emu_partial_state;
-#endif
-
-/** Contains identifiers and descriptions of ROM files being used. */
-typedef struct {
-	const char *control_rom_id;
-	const char *control_rom_description;
-	const char *control_rom_sha1_digest;
-	const char *pcm_rom_id;
-	const char *pcm_rom_description;
-	const char *pcm_rom_sha1_digest;
-} mt32emu_rom_info;
-
-/** Set of multiplexed output bit16s streams appeared at the DAC entrance. */
-typedef struct {
-	mt32emu_bit16s *nonReverbLeft;
-	mt32emu_bit16s *nonReverbRight;
-	mt32emu_bit16s *reverbDryLeft;
-	mt32emu_bit16s *reverbDryRight;
-	mt32emu_bit16s *reverbWetLeft;
-	mt32emu_bit16s *reverbWetRight;
-} mt32emu_dac_output_bit16s_streams;
-
-/** Set of multiplexed output float streams appeared at the DAC entrance. */
-typedef struct {
-	float *nonReverbLeft;
-	float *nonReverbRight;
-	float *reverbDryLeft;
-	float *reverbDryRight;
-	float *reverbWetLeft;
-	float *reverbWetRight;
-} mt32emu_dac_output_float_streams;
-
-/* === Interface handling === */
-
-/** Report handler interface versions */
-typedef enum {
-	MT32EMU_REPORT_HANDLER_VERSION_0 = 0,
-	MT32EMU_REPORT_HANDLER_VERSION_CURRENT = MT32EMU_REPORT_HANDLER_VERSION_0
-} mt32emu_report_handler_version;
-
-/** MIDI receiver interface versions */
-typedef enum {
-	MT32EMU_MIDI_RECEIVER_VERSION_0 = 0,
-	MT32EMU_MIDI_RECEIVER_VERSION_CURRENT = MT32EMU_MIDI_RECEIVER_VERSION_0
-} mt32emu_midi_receiver_version;
-
-/** Synth interface versions */
-typedef enum {
-	MT32EMU_SERVICE_VERSION_0 = 0,
-	MT32EMU_SERVICE_VERSION_CURRENT = MT32EMU_SERVICE_VERSION_0
-} mt32emu_service_version;
-
-/* === Report Handler Interface === */
-
-typedef union mt32emu_report_handler_i mt32emu_report_handler_i;
-
-/** Interface for handling reported events (initial version) */
-typedef struct {
-	/** Returns the actual interface version ID */
-	mt32emu_report_handler_version (*getVersionID)(mt32emu_report_handler_i i);
-
-	/** Callback for debug messages, in vprintf() format */
-	void (*printDebug)(void *instance_data, const char *fmt, va_list list);
-	/** Callbacks for reporting errors */
-	void (*onErrorControlROM)(void *instance_data);
-	void (*onErrorPCMROM)(void *instance_data);
-	/** Callback for reporting about displaying a new custom message on LCD */
-	void (*showLCDMessage)(void *instance_data, const char *message);
-	/** Callback for reporting actual processing of a MIDI message */
-	void (*onMIDIMessagePlayed)(void *instance_data);
-	/**
-	 * Callback for reporting an overflow of the input MIDI queue.
-	 * Returns MT32EMU_BOOL_TRUE if a recovery action was taken
-	 * and yet another attempt to enqueue the MIDI event is desired.
-	 */
-	mt32emu_boolean (*onMIDIQueueOverflow)(void *instance_data);
-	/**
-	 * Callback invoked when a System Realtime MIDI message is detected in functions
-	 * mt32emu_parse_stream and mt32emu_play_short_message and the likes.
-	 */
-	void (*onMIDISystemRealtime)(void *instance_data, mt32emu_bit8u system_realtime);
-	/** Callbacks for reporting system events */
-	void (*onDeviceReset)(void *instance_data);
-	void (*onDeviceReconfig)(void *instance_data);
-	/** Callbacks for reporting changes of reverb settings */
-	void (*onNewReverbMode)(void *instance_data, mt32emu_bit8u mode);
-	void (*onNewReverbTime)(void *instance_data, mt32emu_bit8u time);
-	void (*onNewReverbLevel)(void *instance_data, mt32emu_bit8u level);
-	/** Callbacks for reporting various information */
-	void (*onPolyStateChanged)(void *instance_data, mt32emu_bit8u part_num);
-	void (*onProgramChanged)(void *instance_data, mt32emu_bit8u part_num, const char *sound_group_name, const char *patch_name);
-} mt32emu_report_handler_i_v0;
-
-/**
- * Extensible interface for handling reported events.
- * Union intended to view an interface of any subsequent version as any parent interface not requiring a cast.
- * Elements are to be addressed using the tag of the interface version when they were introduced.
- */
-union mt32emu_report_handler_i {
-	const mt32emu_report_handler_i_v0 *v0;
-};
-
-/* === MIDI Receiver Interface === */
-
-typedef union mt32emu_midi_receiver_i mt32emu_midi_receiver_i;
-
-/** Interface for receiving MIDI messages generated by MIDI stream parser (initial version) */
-typedef struct {
-	/** Returns the actual interface version ID */
-	mt32emu_midi_receiver_version (*getVersionID)(mt32emu_midi_receiver_i i);
-
-	/** Invoked when a complete short MIDI message is parsed in the input MIDI stream. */
-	void (*handleShortMessage)(void *instance_data, const mt32emu_bit32u message);
-
-	/** Invoked when a complete well-formed System Exclusive MIDI message is parsed in the input MIDI stream. */
-	void (*handleSysex)(void *instance_data, const mt32emu_bit8u stream[], const mt32emu_bit32u length);
-
-	/** Invoked when a System Realtime MIDI message is parsed in the input MIDI stream. */
-	void (*handleSystemRealtimeMessage)(void *instance_data, const mt32emu_bit8u realtime);
-} mt32emu_midi_receiver_i_v0;
-
-/**
- * Extensible interface for receiving MIDI messages.
- * Union intended to view an interface of any subsequent version as any parent interface not requiring a cast.
- * Elements are to be addressed using the tag of the interface version when they were introduced.
- */
-union mt32emu_midi_receiver_i {
-	const mt32emu_midi_receiver_i_v0 *v0;
-};
-
-/* === Service Interface === */
-
-typedef union mt32emu_service_i mt32emu_service_i;
-
-/**
- * Basic interface that defines all the library services (initial version).
- * The members closely resemble C functions declared in c_interface.h, and the intention is to provide for easier
- * access when the library is dynamically loaded in run-time, e.g. as a plugin. This way the client only needs
- * to bind to mt32emu_get_service_i() function instead of binding to each function it needs to use.
- * See c_interface.h for parameter description.
- */
-typedef struct {
-	/** Returns the actual interface version ID */
-	mt32emu_service_version (*getVersionID)(mt32emu_service_i i);
-	mt32emu_report_handler_version (*getSupportedReportHandlerVersionID)();
-	mt32emu_midi_receiver_version (*getSupportedMIDIReceiverVersionID)();
-
-	mt32emu_bit32u (*getLibraryVersionInt)();
-	const char *(*getLibraryVersionString)();
-
-	mt32emu_bit32u (*getStereoOutputSamplerate)(const mt32emu_analog_output_mode analog_output_mode);
-
-	mt32emu_context (*createContext)(mt32emu_report_handler_i report_handler, void *instance_data);
-	void (*freeContext)(mt32emu_context context);
-	mt32emu_return_code (*addROMData)(mt32emu_context context, const mt32emu_bit8u *data, size_t data_size, const mt32emu_sha1_digest *sha1_digest);
-	mt32emu_return_code (*addROMFile)(mt32emu_context context, const char *filename);
-	void (*getROMInfo)(mt32emu_const_context context, mt32emu_rom_info *rom_info);
-	void (*setPartialCount)(mt32emu_context context, const mt32emu_bit32u partial_count);
-	void (*setAnalogOutputMode)(mt32emu_context context, const mt32emu_analog_output_mode analog_output_mode);
-	mt32emu_return_code (*openSynth)(mt32emu_const_context context);
-	void (*closeSynth)(mt32emu_const_context context);
-	mt32emu_boolean (*isOpen)(mt32emu_const_context context);
-	mt32emu_bit32u (*getActualStereoOutputSamplerate)(mt32emu_const_context context);
-	void (*flushMIDIQueue)(mt32emu_const_context context);
-	mt32emu_bit32u (*setMIDIEventQueueSize)(mt32emu_const_context context, const mt32emu_bit32u queue_size);
-	void (*setMIDIReceiver)(mt32emu_context context, mt32emu_midi_receiver_i midi_receiver, void *instance_data);
-
-	void (*parseStream)(mt32emu_const_context context, const mt32emu_bit8u *stream, mt32emu_bit32u length);
-	void (*parseStream_At)(mt32emu_const_context context, const mt32emu_bit8u *stream, mt32emu_bit32u length, mt32emu_bit32u timestamp);
-	void (*playShortMessage)(mt32emu_const_context context, mt32emu_bit32u message);
-	void (*playShortMessageAt)(mt32emu_const_context context, mt32emu_bit32u message, mt32emu_bit32u timestamp);
-	mt32emu_return_code (*playMsg)(mt32emu_const_context context, mt32emu_bit32u msg);
-	mt32emu_return_code (*playSysex)(mt32emu_const_context context, const mt32emu_bit8u *sysex, mt32emu_bit32u len);
-	mt32emu_return_code (*playMsgAt)(mt32emu_const_context context, mt32emu_bit32u msg, mt32emu_bit32u timestamp);
-	mt32emu_return_code (*playSysexAt)(mt32emu_const_context context, const mt32emu_bit8u *sysex, mt32emu_bit32u len, mt32emu_bit32u timestamp);
-
-	void (*playMsgNow)(mt32emu_const_context context, mt32emu_bit32u msg);
-	void (*playMsgOnPart)(mt32emu_const_context context, mt32emu_bit8u part, mt32emu_bit8u code, mt32emu_bit8u note, mt32emu_bit8u velocity);
-	void (*playSysexNow)(mt32emu_const_context context, const mt32emu_bit8u *sysex, mt32emu_bit32u len);
-	void (*writeSysex)(mt32emu_const_context context, mt32emu_bit8u channel, const mt32emu_bit8u *sysex, mt32emu_bit32u len);
-
-	void (*setReverbEnabled)(mt32emu_const_context context, const mt32emu_boolean reverb_enabled);
-	mt32emu_boolean (*isReverbEnabled)(mt32emu_const_context context);
-	void (*setReverbOverridden)(mt32emu_const_context context, const mt32emu_boolean reverb_overridden);
-	mt32emu_boolean (*isReverbOverridden)(mt32emu_const_context context);
-	void (*setReverbCompatibilityMode)(mt32emu_const_context context, const mt32emu_boolean mt32_compatible_mode);
-	mt32emu_boolean (*isMT32ReverbCompatibilityMode)(mt32emu_const_context context);
-	mt32emu_boolean (*isDefaultReverbMT32Compatible)(mt32emu_const_context context);
-
-	void (*setDACInputMode)(mt32emu_const_context context, const mt32emu_dac_input_mode mode);
-	mt32emu_dac_input_mode (*getDACInputMode)(mt32emu_const_context context);
-
-	void (*setMIDIDelayMode)(mt32emu_const_context context, const mt32emu_midi_delay_mode mode);
-	mt32emu_midi_delay_mode (*getMIDIDelayMode)(mt32emu_const_context context);
-
-	void (*setOutputGain)(mt32emu_const_context context, float gain);
-	float (*getOutputGain)(mt32emu_const_context context);
-	void (*setReverbOutputGain)(mt32emu_const_context context, float gain);
-	float (*getReverbOutputGain)(mt32emu_const_context context);
-
-	void (*setReversedStereoEnabled)(mt32emu_const_context context, const mt32emu_boolean enabled);
-	mt32emu_boolean (*isReversedStereoEnabled)(mt32emu_const_context context);
-
-	void (*renderBit16s)(mt32emu_const_context context, mt32emu_bit16s *stream, mt32emu_bit32u len);
-	void (*renderFloat)(mt32emu_const_context context, float *stream, mt32emu_bit32u len);
-	void (*renderBit16sStreams)(mt32emu_const_context context, const mt32emu_dac_output_bit16s_streams *streams, mt32emu_bit32u len);
-	void (*renderFloatStreams)(mt32emu_const_context context, const mt32emu_dac_output_float_streams *streams, mt32emu_bit32u len);
-
-	mt32emu_boolean (*hasActivePartials)(mt32emu_const_context context);
-	mt32emu_boolean (*isActive)(mt32emu_const_context context);
-	mt32emu_bit32u (*getPartialCount)(mt32emu_const_context context);
-	mt32emu_bit32u (*getPartStates)(mt32emu_const_context context);
-	void (*getPartialStates)(mt32emu_const_context context, mt32emu_bit8u *partial_states);
-	mt32emu_bit32u (*getPlayingNotes)(mt32emu_const_context context, mt32emu_bit8u part_number, mt32emu_bit8u *keys, mt32emu_bit8u *velocities);
-	const char *(*getPatchName)(mt32emu_const_context context, mt32emu_bit8u part_number);
-	void (*readMemory)(mt32emu_const_context context, mt32emu_bit32u addr, mt32emu_bit32u len, mt32emu_bit8u *data);
-} mt32emu_service_i_v0;
-
-/**
- * Extensible interface for all the library services.
- * Union intended to view an interface of any subsequent version as any parent interface not requiring a cast.
- * Elements are to be addressed using the tag of the interface version when they were introduced.
- */
-union mt32emu_service_i {
-	const mt32emu_service_i_v0 *v0;
-};
-
-#endif /* #ifndef MT32EMU_C_TYPES_H */
diff --git a/audio/softsynth/mt32/c_interface/cpp_interface.h b/audio/softsynth/mt32/c_interface/cpp_interface.h
deleted file mode 100644
index 41ddebcc02..0000000000
--- a/audio/softsynth/mt32/c_interface/cpp_interface.h
+++ /dev/null
@@ -1,436 +0,0 @@
-/* Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Dean Beeler, Jerome Fisher
- * Copyright (C) 2011-2016 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
- *
- *  This program is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU Lesser General Public License as published by
- *  the Free Software Foundation, either version 2.1 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU Lesser General Public License for more details.
- *
- *  You should have received a copy of the GNU Lesser General Public License
- *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef MT32EMU_CPP_INTERFACE_H
-#define MT32EMU_CPP_INTERFACE_H
-
-#include <cstdarg>
-
-#include "../globals.h"
-#include "c_types.h"
-
-#include "../Types.h"
-#include "../Enumerations.h"
-
-#if MT32EMU_API_TYPE == 2
-
-#define mt32emu_get_supported_report_handler_version i.v0->getSupportedReportHandlerVersionID
-#define mt32emu_get_supported_midi_receiver_version i.v0->getSupportedMIDIReceiverVersionID
-#define mt32emu_get_library_version_int i.v0->getLibraryVersionInt
-#define mt32emu_get_library_version_string i.v0->getLibraryVersionString
-#define mt32emu_get_stereo_output_samplerate i.v0->getStereoOutputSamplerate
-#define mt32emu_create_context i.v0->createContext
-#define mt32emu_free_context i.v0->freeContext
-#define mt32emu_add_rom_data i.v0->addROMData
-#define mt32emu_add_rom_file i.v0->addROMFile
-#define mt32emu_get_rom_info i.v0->getROMInfo
-#define mt32emu_set_partial_count i.v0->setPartialCount
-#define mt32emu_set_analog_output_mode i.v0->setAnalogOutputMode
-#define mt32emu_open_synth i.v0->openSynth
-#define mt32emu_close_synth i.v0->closeSynth
-#define mt32emu_is_open i.v0->isOpen
-#define mt32emu_get_actual_stereo_output_samplerate i.v0->getActualStereoOutputSamplerate
-#define mt32emu_flush_midi_queue i.v0->flushMIDIQueue
-#define mt32emu_set_midi_event_queue_size i.v0->setMIDIEventQueueSize
-#define mt32emu_set_midi_receiver i.v0->setMIDIReceiver
-#define mt32emu_parse_stream i.v0->parseStream
-#define mt32emu_parse_stream_at i.v0->parseStream_At
-#define mt32emu_play_short_message i.v0->playShortMessage
-#define mt32emu_play_short_message_at i.v0->playShortMessageAt
-#define mt32emu_play_msg i.v0->playMsg
-#define mt32emu_play_sysex i.v0->playSysex
-#define mt32emu_play_msg_at i.v0->playMsgAt
-#define mt32emu_play_sysex_at i.v0->playSysexAt
-#define mt32emu_play_msg_now i.v0->playMsgNow
-#define mt32emu_play_msg_on_part i.v0->playMsgOnPart
-#define mt32emu_play_sysex_now i.v0->playSysexNow
-#define mt32emu_write_sysex i.v0->writeSysex
-#define mt32emu_set_reverb_enabled i.v0->setReverbEnabled
-#define mt32emu_is_reverb_enabled i.v0->isReverbEnabled
-#define mt32emu_set_reverb_overridden i.v0->setReverbOverridden
-#define mt32emu_is_reverb_overridden i.v0->isReverbOverridden
-#define mt32emu_set_reverb_compatibility_mode i.v0->setReverbCompatibilityMode
-#define mt32emu_is_mt32_reverb_compatibility_mode i.v0->isMT32ReverbCompatibilityMode
-#define mt32emu_is_default_reverb_mt32_compatible i.v0->isDefaultReverbMT32Compatible
-#define mt32emu_set_dac_input_mode i.v0->setDACInputMode
-#define mt32emu_get_dac_input_mode i.v0->getDACInputMode
-#define mt32emu_set_midi_delay_mode i.v0->setMIDIDelayMode
-#define mt32emu_get_midi_delay_mode i.v0->getMIDIDelayMode
-#define mt32emu_set_output_gain i.v0->setOutputGain
-#define mt32emu_get_output_gain i.v0->getOutputGain
-#define mt32emu_set_reverb_output_gain i.v0->setReverbOutputGain
-#define mt32emu_get_reverb_output_gain i.v0->getReverbOutputGain
-#define mt32emu_set_reversed_stereo_enabled i.v0->setReversedStereoEnabled
-#define mt32emu_is_reversed_stereo_enabled i.v0->isReversedStereoEnabled
-#define mt32emu_render_bit16s i.v0->renderBit16s
-#define mt32emu_render_float i.v0->renderFloat
-#define mt32emu_render_bit16s_streams i.v0->renderBit16sStreams
-#define mt32emu_render_float_streams i.v0->renderFloatStreams
-#define mt32emu_has_active_partials i.v0->hasActivePartials
-#define mt32emu_is_active i.v0->isActive
-#define mt32emu_get_partial_count i.v0->getPartialCount
-#define mt32emu_get_part_states i.v0->getPartStates
-#define mt32emu_get_partial_states i.v0->getPartialStates
-#define mt32emu_get_playing_notes i.v0->getPlayingNotes
-#define mt32emu_get_patch_name i.v0->getPatchName
-#define mt32emu_read_memory i.v0->readMemory
-
-#else // #if MT32EMU_API_TYPE == 2
-
-#include "c_interface.h"
-
-#endif // #if MT32EMU_API_TYPE == 2
-
-namespace MT32Emu {
-
-namespace CppInterfaceImpl {
-
-static const mt32emu_report_handler_i NULL_REPORT_HANDLER = { NULL };
-static mt32emu_report_handler_i getReportHandlerThunk();
-static mt32emu_midi_receiver_i getMidiReceiverThunk();
-
-}
-
-/*
- * The classes below correspond to the interfaces defined in c_types.h and provided for convenience when using C++.
- * The approach used makes no assumption of any internal class data memory layout, since the C++ standard does not
- * provide any detail in this area and leaves it up to the implementation. Therefore, this way portability is guaranteed,
- * despite the implementation may be a little inefficient.
- * See c_types.h and c_interface.h for description of the corresponding interface methods.
- */
-
-// Defines the interface for handling reported events.
-// Corresponds to the current version of mt32emu_report_handler_i interface.
-class ReportHandler {
-public:
-	virtual void printDebug(const char *fmt, va_list list) = 0;
-	virtual void onErrorControlROM() = 0;
-	virtual void onErrorPCMROM() = 0;
-	virtual void showLCDMessage(const char *message) = 0;
-	virtual void onMIDIMessagePlayed() = 0;
-	virtual bool onMIDIQueueOverflow() = 0;
-	virtual void onMIDISystemRealtime(Bit8u system_realtime) = 0;
-	virtual void onDeviceReset() = 0;
-	virtual void onDeviceReconfig() = 0;
-	virtual void onNewReverbMode(Bit8u mode) = 0;
-	virtual void onNewReverbTime(Bit8u time) = 0;
-	virtual void onNewReverbLevel(Bit8u level) = 0;
-	virtual void onPolyStateChanged(Bit8u part_num) = 0;
-	virtual void onProgramChanged(Bit8u part_num, const char *sound_group_name, const char *patch_name) = 0;
-
-protected:
-	~ReportHandler() {}
-};
-
-// Defines the interface for receiving MIDI messages generated by MIDI stream parser.
-// Corresponds to the current version of mt32emu_midi_receiver_i interface.
-class MidiReceiver {
-public:
-	virtual void handleShortMessage(const Bit32u message) = 0;
-	virtual void handleSysex(const Bit8u stream[], const Bit32u length) = 0;
-	virtual void handleSystemRealtimeMessage(const Bit8u realtime) = 0;
-
-protected:
-	~MidiReceiver() {}
-};
-
-// Defines all the library services.
-// Corresponds to the current version of mt32emu_service_i interface.
-class Service {
-public:
-#if MT32EMU_API_TYPE == 2
-	explicit Service(mt32emu_service_i interface, mt32emu_context context = NULL) : i(interface), c(context) {}
-#else
-	explicit Service(mt32emu_context context = NULL) : c(context) {}
-#endif
-	~Service() { if (c != NULL) mt32emu_free_context(c); }
-
-	// Context-independent methods
-
-#if MT32EMU_API_TYPE == 2
-	mt32emu_service_version getVersionID() { return i.v0->getVersionID(i); }
-#endif
-	mt32emu_report_handler_version getSupportedReportHandlerVersionID() { return mt32emu_get_supported_report_handler_version(); }
-	mt32emu_midi_receiver_version getSupportedMIDIReceiverVersionID() { return mt32emu_get_supported_midi_receiver_version(); }
-
-	Bit32u getLibraryVersionInt() { return mt32emu_get_library_version_int(); }
-	const char *getLibraryVersionString() { return mt32emu_get_library_version_string(); }
-
-	Bit32u getStereoOutputSamplerate(const AnalogOutputMode analog_output_mode) { return mt32emu_get_stereo_output_samplerate(static_cast<mt32emu_analog_output_mode>(analog_output_mode)); }
-
-	// Context-dependent methods
-
-	mt32emu_context getContext() { return c; }
-	void createContext(mt32emu_report_handler_i report_handler = CppInterfaceImpl::NULL_REPORT_HANDLER, void *instance_data = NULL) { freeContext(); c = mt32emu_create_context(report_handler, instance_data); }
-	void createContext(ReportHandler &report_handler) { createContext(CppInterfaceImpl::getReportHandlerThunk(), &report_handler); }
-	void freeContext() { if (c != NULL) { mt32emu_free_context(c); c = NULL; } }
-	mt32emu_return_code addROMData(const Bit8u *data, size_t data_size, const mt32emu_sha1_digest *sha1_digest = NULL) { return mt32emu_add_rom_data(c, data, data_size, sha1_digest); }
-	mt32emu_return_code addROMFile(const char *filename) { return mt32emu_add_rom_file(c, filename); }
-	void getROMInfo(mt32emu_rom_info *rom_info) { mt32emu_get_rom_info(c, rom_info); }
-	void setPartialCount(const Bit32u partial_count) { mt32emu_set_partial_count(c, partial_count); }
-	void setAnalogOutputMode(const AnalogOutputMode analog_output_mode) { mt32emu_set_analog_output_mode(c, static_cast<mt32emu_analog_output_mode>(analog_output_mode)); }
-	mt32emu_return_code openSynth() { return mt32emu_open_synth(c); }
-	void closeSynth() { mt32emu_close_synth(c); }
-	bool isOpen() { return mt32emu_is_open(c) != MT32EMU_BOOL_FALSE; }
-	Bit32u getActualStereoOutputSamplerate() { return mt32emu_get_actual_stereo_output_samplerate(c); }
-	void flushMIDIQueue() { mt32emu_flush_midi_queue(c); }
-	Bit32u setMIDIEventQueueSize(const Bit32u queue_size) { return mt32emu_set_midi_event_queue_size(c, queue_size); }
-	void setMIDIReceiver(mt32emu_midi_receiver_i midi_receiver, void *instance_data) { mt32emu_set_midi_receiver(c, midi_receiver, instance_data); }
-	void setMIDIReceiver(MidiReceiver &midi_receiver) { setMIDIReceiver(CppInterfaceImpl::getMidiReceiverThunk(), &midi_receiver); }
-
-	void parseStream(const Bit8u *stream, Bit32u length) { mt32emu_parse_stream(c, stream, length); }
-	void parseStream_At(const Bit8u *stream, Bit32u length, Bit32u timestamp) { mt32emu_parse_stream_at(c, stream, length, timestamp); }
-	void playShortMessage(Bit32u message) { mt32emu_play_short_message(c, message); }
-	void playShortMessageAt(Bit32u message, Bit32u timestamp) { mt32emu_play_short_message_at(c, message, timestamp); }
-	mt32emu_return_code playMsg(Bit32u msg) { return mt32emu_play_msg(c, msg); }
-	mt32emu_return_code playSysex(const Bit8u *sysex, Bit32u len) { return mt32emu_play_sysex(c, sysex, len); }
-	mt32emu_return_code playMsgAt(Bit32u msg, Bit32u timestamp) { return mt32emu_play_msg_at(c, msg, timestamp); }
-	mt32emu_return_code playSysexAt(const Bit8u *sysex, Bit32u len, Bit32u timestamp) { return mt32emu_play_sysex_at(c, sysex, len, timestamp); }
-
-	void playMsgNow(Bit32u msg) { mt32emu_play_msg_now(c, msg); }
-	void playMsgOnPart(Bit8u part, Bit8u code, Bit8u note, Bit8u velocity) { mt32emu_play_msg_on_part(c, part, code, note, velocity); }
-	void playSysexNow(const Bit8u *sysex, Bit32u len) { mt32emu_play_sysex_now(c, sysex, len); }
-	void writeSysex(Bit8u channel, const Bit8u *sysex, Bit32u len) { mt32emu_write_sysex(c, channel, sysex, len); }
-
-	void setReverbEnabled(const bool reverb_enabled) { mt32emu_set_reverb_enabled(c, reverb_enabled ? MT32EMU_BOOL_TRUE : MT32EMU_BOOL_FALSE); }
-	bool isReverbEnabled() { return mt32emu_is_reverb_enabled(c) != MT32EMU_BOOL_FALSE; }
-	void setReverbOverridden(const bool reverb_overridden) { mt32emu_set_reverb_overridden(c, reverb_overridden ? MT32EMU_BOOL_TRUE : MT32EMU_BOOL_FALSE); }
-	bool isReverbOverridden() { return mt32emu_is_reverb_overridden(c) != MT32EMU_BOOL_FALSE; }
-	void setReverbCompatibilityMode(const bool mt32_compatible_mode) { mt32emu_set_reverb_compatibility_mode(c, mt32_compatible_mode ? MT32EMU_BOOL_TRUE : MT32EMU_BOOL_FALSE); }
-	bool isMT32ReverbCompatibilityMode() { return mt32emu_is_mt32_reverb_compatibility_mode(c) != MT32EMU_BOOL_FALSE; }
-	bool isDefaultReverbMT32Compatible() { return mt32emu_is_default_reverb_mt32_compatible(c) != MT32EMU_BOOL_FALSE; }
-
-	void setDACInputMode(const DACInputMode mode) { mt32emu_set_dac_input_mode(c, static_cast<mt32emu_dac_input_mode>(mode)); }
-	DACInputMode getDACInputMode() { return static_cast<DACInputMode>(mt32emu_get_dac_input_mode(c)); }
-
-	void setMIDIDelayMode(const MIDIDelayMode mode) { mt32emu_set_midi_delay_mode(c, static_cast<mt32emu_midi_delay_mode>(mode)); }
-	MIDIDelayMode getMIDIDelayMode() { return static_cast<MIDIDelayMode>(mt32emu_get_midi_delay_mode(c)); }
-
-	void setOutputGain(float gain) { mt32emu_set_output_gain(c, gain); }
-	float getOutputGain() { return mt32emu_get_output_gain(c); }
-	void setReverbOutputGain(float gain) { mt32emu_set_reverb_output_gain(c, gain); }
-	float getReverbOutputGain() { return mt32emu_get_reverb_output_gain(c); }
-
-	void setReversedStereoEnabled(const bool enabled) { mt32emu_set_reversed_stereo_enabled(c, enabled ? MT32EMU_BOOL_TRUE : MT32EMU_BOOL_FALSE); }
-	bool isReversedStereoEnabled() { return mt32emu_is_reversed_stereo_enabled(c) != MT32EMU_BOOL_FALSE; }
-
-	void renderBit16s(Bit16s *stream, Bit32u len) { mt32emu_render_bit16s(c, stream, len); }
-	void renderFloat(float *stream, Bit32u len) { mt32emu_render_float(c, stream, len); }
-	void renderBit16sStreams(const mt32emu_dac_output_bit16s_streams *streams, Bit32u len) { mt32emu_render_bit16s_streams(c, streams, len); }
-	void renderFloatStreams(const mt32emu_dac_output_float_streams *streams, Bit32u len) { mt32emu_render_float_streams(c, streams, len); }
-
-	bool hasActivePartials() { return mt32emu_has_active_partials(c) != MT32EMU_BOOL_FALSE; }
-	bool isActive() { return mt32emu_is_active(c) != MT32EMU_BOOL_FALSE; }
-	Bit32u getPartialCount() { return mt32emu_get_partial_count(c); }
-	Bit32u getPartStates() { return mt32emu_get_part_states(c); }
-	void getPartialStates(Bit8u *partial_states) { mt32emu_get_partial_states(c, partial_states); }
-	Bit32u getPlayingNotes(Bit8u part_number, Bit8u *keys, Bit8u *velocities) { return mt32emu_get_playing_notes(c, part_number, keys, velocities); }
-	const char *getPatchName(Bit8u part_number) { return mt32emu_get_patch_name(c, part_number); }
-	void readMemory(Bit32u addr, Bit32u len, Bit8u *data) { mt32emu_read_memory(c, addr, len, data); }
-
-private:
-#if MT32EMU_API_TYPE == 2
-	const mt32emu_service_i i;
-#endif
-	mt32emu_context c;
-};
-
-namespace CppInterfaceImpl {
-
-static mt32emu_report_handler_version getReportHandlerVersionID(mt32emu_report_handler_i) {
-	return MT32EMU_REPORT_HANDLER_VERSION_CURRENT;
-}
-
-static void printDebug(void *instance_data, const char *fmt, va_list list) {
-	((ReportHandler *)instance_data)->printDebug(fmt, list);
-}
-
-static void onErrorControlROM(void *instance_data) {
-	((ReportHandler *)instance_data)->onErrorControlROM();
-}
-
-static void onErrorPCMROM(void *instance_data) {
-	((ReportHandler *)instance_data)->onErrorPCMROM();
-}
-
-static void showLCDMessage(void *instance_data, const char *message) {
-	((ReportHandler *)instance_data)->showLCDMessage(message);
-}
-
-static void onMIDIMessagePlayed(void *instance_data) {
-	((ReportHandler *)instance_data)->onMIDIMessagePlayed();
-}
-
-static mt32emu_boolean onMIDIQueueOverflow(void *instance_data) {
-	return ((ReportHandler *)instance_data)->onMIDIQueueOverflow() ? MT32EMU_BOOL_TRUE : MT32EMU_BOOL_FALSE;
-}
-
-static void onMIDISystemRealtime(void *instance_data, mt32emu_bit8u system_realtime) {
-	((ReportHandler *)instance_data)->onMIDISystemRealtime(system_realtime);
-}
-
-static void onDeviceReset(void *instance_data) {
-	((ReportHandler *)instance_data)->onDeviceReset();
-}
-
-static void onDeviceReconfig(void *instance_data) {
-	((ReportHandler *)instance_data)->onDeviceReconfig();
-}
-
-static void onNewReverbMode(void *instance_data, mt32emu_bit8u mode) {
-	((ReportHandler *)instance_data)->onNewReverbMode(mode);
-}
-
-static void onNewReverbTime(void *instance_data, mt32emu_bit8u time) {
-	((ReportHandler *)instance_data)->onNewReverbTime(time);
-}
-
-static void onNewReverbLevel(void *instance_data, mt32emu_bit8u level) {
-	((ReportHandler *)instance_data)->onNewReverbLevel(level);
-}
-
-static void onPolyStateChanged(void *instance_data, mt32emu_bit8u part_num) {
-	((ReportHandler *)instance_data)->onPolyStateChanged(part_num);
-}
-
-static void onProgramChanged(void *instance_data, mt32emu_bit8u part_num, const char *sound_group_name, const char *patch_name) {
-	((ReportHandler *)instance_data)->onProgramChanged(part_num, sound_group_name, patch_name);
-}
-
-static mt32emu_report_handler_i getReportHandlerThunk() {
-	static const mt32emu_report_handler_i_v0 REPORT_HANDLER_V0_THUNK = {
-		getReportHandlerVersionID,
-		printDebug,
-		onErrorControlROM,
-		onErrorPCMROM,
-		showLCDMessage,
-		onMIDIMessagePlayed,
-		onMIDIQueueOverflow,
-		onMIDISystemRealtime,
-		onDeviceReset,
-		onDeviceReconfig,
-		onNewReverbMode,
-		onNewReverbTime,
-		onNewReverbLevel,
-		onPolyStateChanged,
-		onProgramChanged
-	};
-
-	static const mt32emu_report_handler_i REPORT_HANDLER_THUNK = { &REPORT_HANDLER_V0_THUNK };
-
-	return REPORT_HANDLER_THUNK;
-}
-
-static mt32emu_midi_receiver_version getMidiReceiverVersionID(mt32emu_midi_receiver_i) {
-	return MT32EMU_MIDI_RECEIVER_VERSION_CURRENT;
-}
-
-static void handleShortMessage(void *instance_data, const mt32emu_bit32u message) {
-	((MidiReceiver *)instance_data)->handleShortMessage(message);
-}
-
-static void handleSysex(void *instance_data, const mt32emu_bit8u stream[], const mt32emu_bit32u length) {
-	((MidiReceiver *)instance_data)->handleSysex(stream, length);
-}
-
-static void handleSystemRealtimeMessage(void *instance_data, const mt32emu_bit8u realtime) {
-	((MidiReceiver *)instance_data)->handleSystemRealtimeMessage(realtime);
-}
-
-static mt32emu_midi_receiver_i getMidiReceiverThunk() {
-	static const mt32emu_midi_receiver_i_v0 MIDI_RECEIVER_V0_THUNK = {
-		getMidiReceiverVersionID,
-		handleShortMessage,
-		handleSysex,
-		handleSystemRealtimeMessage
-	};
-
-	static const mt32emu_midi_receiver_i MIDI_RECEIVER_THUNK = { &MIDI_RECEIVER_V0_THUNK };
-
-	return MIDI_RECEIVER_THUNK;
-}
-
-} // namespace CppInterfaceImpl
-
-} // namespace MT32Emu
-
-#if MT32EMU_API_TYPE == 2
-
-#undef mt32emu_get_supported_report_handler_version
-#undef mt32emu_get_supported_midi_receiver_version
-#undef mt32emu_get_library_version_int
-#undef mt32emu_get_library_version_string
-#undef mt32emu_get_stereo_output_samplerate
-#undef mt32emu_create_context
-#undef mt32emu_free_context
-#undef mt32emu_add_rom_data
-#undef mt32emu_add_rom_file
-#undef mt32emu_get_rom_info
-#undef mt32emu_set_partial_count
-#undef mt32emu_set_analog_output_mode
-#undef mt32emu_open_synth
-#undef mt32emu_close_synth
-#undef mt32emu_is_open
-#undef mt32emu_get_actual_stereo_output_samplerate
-#undef mt32emu_flush_midi_queue
-#undef mt32emu_set_midi_event_queue_size
-#undef mt32emu_set_midi_receiver
-#undef mt32emu_parse_stream
-#undef mt32emu_parse_stream_at
-#undef mt32emu_play_short_message
-#undef mt32emu_play_short_message_at
-#undef mt32emu_play_msg
-#undef mt32emu_play_sysex
-#undef mt32emu_play_msg_at
-#undef mt32emu_play_sysex_at
-#undef mt32emu_play_msg_now
-#undef mt32emu_play_msg_on_part
-#undef mt32emu_play_sysex_now
-#undef mt32emu_write_sysex
-#undef mt32emu_set_reverb_enabled
-#undef mt32emu_is_reverb_enabled
-#undef mt32emu_set_reverb_overridden
-#undef mt32emu_is_reverb_overridden
-#undef mt32emu_set_reverb_compatibility_mode
-#undef mt32emu_is_mt32_reverb_compatibility_mode
-#undef mt32emu_is_default_reverb_mt32_compatible
-#undef mt32emu_set_dac_input_mode
-#undef mt32emu_get_dac_input_mode
-#undef mt32emu_set_midi_delay_mode
-#undef mt32emu_get_midi_delay_mode
-#undef mt32emu_set_output_gain
-#undef mt32emu_get_output_gain
-#undef mt32emu_set_reverb_output_gain
-#undef mt32emu_get_reverb_output_gain
-#undef mt32emu_set_reversed_stereo_enabled
-#undef mt32emu_is_reversed_stereo_enabled
-#undef mt32emu_render_bit16s
-#undef mt32emu_render_float
-#undef mt32emu_render_bit16s_streams
-#undef mt32emu_render_float_streams
-#undef mt32emu_has_active_partials
-#undef mt32emu_is_active
-#undef mt32emu_get_partial_count
-#undef mt32emu_get_part_states
-#undef mt32emu_get_partial_states
-#undef mt32emu_get_playing_notes
-#undef mt32emu_get_patch_name
-#undef mt32emu_read_memory
-
-#endif // #if MT32EMU_API_TYPE == 2
-
-#endif /* #ifndef MT32EMU_CPP_INTERFACE_H */
diff --git a/audio/softsynth/mt32/config.h b/audio/softsynth/mt32/config.h
deleted file mode 100644
index c62ae6f23f..0000000000
--- a/audio/softsynth/mt32/config.h
+++ /dev/null
@@ -1,28 +0,0 @@
-/* Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Dean Beeler, Jerome Fisher
- * Copyright (C) 2011-2016 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
- *
- *  This program is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU Lesser General Public License as published by
- *  the Free Software Foundation, either version 2.1 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU Lesser General Public License for more details.
- *
- *  You should have received a copy of the GNU Lesser General Public License
- *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef MT32EMU_CONFIG_H
-#define MT32EMU_CONFIG_H
-
-#define MT32EMU_VERSION      "2.0.0"
-#define MT32EMU_VERSION_MAJOR 2
-#define MT32EMU_VERSION_MINOR 0
-#define MT32EMU_VERSION_PATCH 0
-
-#define MT32EMU_EXPORTS_TYPE  0
-
-#endif
diff --git a/audio/softsynth/mt32/globals.h b/audio/softsynth/mt32/globals.h
deleted file mode 100644
index 49a5ecc250..0000000000
--- a/audio/softsynth/mt32/globals.h
+++ /dev/null
@@ -1,119 +0,0 @@
-/* Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Dean Beeler, Jerome Fisher
- * Copyright (C) 2011-2016 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
- *
- *  This program is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU Lesser General Public License as published by
- *  the Free Software Foundation, either version 2.1 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU Lesser General Public License for more details.
- *
- *  You should have received a copy of the GNU Lesser General Public License
- *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef MT32EMU_GLOBALS_H
-#define MT32EMU_GLOBALS_H
-
-#include "config.h"
-
-/* Support for compiling shared library. */
-#ifdef MT32EMU_SHARED
-#if defined _WIN32 || defined __CYGWIN__
-#ifdef _MSC_VER
-#ifdef mt32emu_EXPORTS
-#define MT32EMU_EXPORT_ATTRIBUTE _declspec(dllexport)
-#else /* #ifdef mt32emu_EXPORTS */
-#define MT32EMU_EXPORT_ATTRIBUTE _declspec(dllimport)
-#endif /* #ifdef mt32emu_EXPORTS */
-#else /* #ifdef _MSC_VER */
-#ifdef mt32emu_EXPORTS
-#define MT32EMU_EXPORT_ATTRIBUTE __attribute__ ((dllexport))
-#else /* #ifdef mt32emu_EXPORTS */
-#define MT32EMU_EXPORT_ATTRIBUTE __attribute__ ((dllimport))
-#endif /* #ifdef mt32emu_EXPORTS */
-#endif /* #ifdef _MSC_VER */
-#else /* #if defined _WIN32 || defined __CYGWIN__ */
-#define MT32EMU_EXPORT_ATTRIBUTE __attribute__ ((visibility("default")))
-#endif /* #if defined _WIN32 || defined __CYGWIN__ */
-#else /* #ifdef MT32EMU_SHARED */
-#define MT32EMU_EXPORT_ATTRIBUTE
-#endif /* #ifdef MT32EMU_SHARED */
-
-#if MT32EMU_EXPORTS_TYPE == 1 || MT32EMU_EXPORTS_TYPE == 2
-#define MT32EMU_EXPORT
-#else
-#define MT32EMU_EXPORT MT32EMU_EXPORT_ATTRIBUTE
-#endif
-
-/* Useful constants */
-
-/* Sample rate to use in mixing. With the progress of development, we've found way too many thing dependent.
- * In order to achieve further advance in emulation accuracy, sample rate made fixed throughout the emulator,
- * except the emulation of analogue path.
- * The output from the synth is supposed to be resampled externally in order to convert to the desired sample rate.
- */
-#define MT32EMU_SAMPLE_RATE 32000
-
-/* The default value for the maximum number of partials playing simultaneously. */
-#define MT32EMU_DEFAULT_MAX_PARTIALS 32
-
-/* The higher this number, the more memory will be used, but the more samples can be processed in one run -
- * various parts of sample generation can be processed more efficiently in a single run.
- * A run's maximum length is that given to Synth::render(), so giving a value here higher than render() is ever
- * called with will give no gain (but simply waste the memory).
- * Note that this value does *not* in any way impose limitations on the length given to render(), and has no effect
- * on the generated audio.
- * This value must be >= 1.
- */
-#define MT32EMU_MAX_SAMPLES_PER_RUN 4096
-
-/* The default size of the internal MIDI event queue.
- * It holds the incoming MIDI events before the rendering engine actually processes them.
- * The main goal is to fairly emulate the real hardware behaviour which obviously
- * uses an internal MIDI event queue to gather incoming data as well as the delays
- * introduced by transferring data via the MIDI interface.
- * This also facilitates building of an external rendering loop
- * as the queue stores timestamped MIDI events.
- */
-#define MT32EMU_DEFAULT_MIDI_EVENT_QUEUE_SIZE 1024
-
-/* Maximum allowed size of MIDI parser input stream buffer.
- * Should suffice for any reasonable bulk dump SysEx, as the h/w units have only 32K of RAM onboard.
- */
-#define MT32EMU_MAX_STREAM_BUFFER_SIZE 32768
-
-/* This should correspond to the MIDI buffer size used in real h/w devices.
- * CM-32L control ROM seems using 1000 bytes, old MT-32 isn't confirmed by now.
- */
-#define MT32EMU_SYSEX_BUFFER_SIZE 1000
-
-#if defined(__cplusplus) && MT32EMU_API_TYPE != 1
-
-namespace MT32Emu
-{
-const unsigned int SAMPLE_RATE = MT32EMU_SAMPLE_RATE;
-#undef MT32EMU_SAMPLE_RATE
-
-const unsigned int DEFAULT_MAX_PARTIALS = MT32EMU_DEFAULT_MAX_PARTIALS;
-#undef MT32EMU_DEFAULT_MAX_PARTIALS
-
-const unsigned int MAX_SAMPLES_PER_RUN = MT32EMU_MAX_SAMPLES_PER_RUN;
-#undef MT32EMU_MAX_SAMPLES_PER_RUN
-
-const unsigned int DEFAULT_MIDI_EVENT_QUEUE_SIZE = MT32EMU_DEFAULT_MIDI_EVENT_QUEUE_SIZE;
-#undef MT32EMU_DEFAULT_MIDI_EVENT_QUEUE_SIZE
-
-const unsigned int MAX_STREAM_BUFFER_SIZE = MT32EMU_MAX_STREAM_BUFFER_SIZE;
-#undef MT32EMU_MAX_STREAM_BUFFER_SIZE
-
-const unsigned int SYSEX_BUFFER_SIZE = MT32EMU_SYSEX_BUFFER_SIZE;
-#undef MT32EMU_SYSEX_BUFFER_SIZE
-}
-
-#endif /* #if defined(__cplusplus) && MT32EMU_API_TYPE != 1 */
-
-#endif /* #ifndef MT32EMU_GLOBALS_H */
diff --git a/audio/softsynth/mt32/internals.h b/audio/softsynth/mt32/internals.h
index c64ba39212..ef56819a42 100644
--- a/audio/softsynth/mt32/internals.h
+++ b/audio/softsynth/mt32/internals.h
@@ -1,5 +1,5 @@
 /* Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Dean Beeler, Jerome Fisher
- * Copyright (C) 2011-2016 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
+ * Copyright (C) 2011, 2012, 2013, 2014 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
@@ -18,111 +18,66 @@
 #ifndef MT32EMU_INTERNALS_H
 #define MT32EMU_INTERNALS_H
 
-#include "Types.h"
-
 // Debugging
 
 // 0: Standard debug output is not stamped with the rendered sample count
 // 1: Standard debug output is stamped with the rendered sample count
 // NOTE: The "samplestamp" corresponds to the end of the last completed rendering run.
 //       This is important to bear in mind for debug output that occurs during a run.
-#ifndef MT32EMU_DEBUG_SAMPLESTAMPS
 #define MT32EMU_DEBUG_SAMPLESTAMPS 0
-#endif
 
 // 0: No debug output for initialisation progress
 // 1: Debug output for initialisation progress
-#ifndef MT32EMU_MONITOR_INIT
 #define MT32EMU_MONITOR_INIT 0
-#endif
 
 // 0: No debug output for MIDI events
 // 1: Debug output for weird MIDI events
-#ifndef MT32EMU_MONITOR_MIDI
 #define MT32EMU_MONITOR_MIDI 0
-#endif
 
 // 0: No debug output for note on/off
 // 1: Basic debug output for note on/off
 // 2: Comprehensive debug output for note on/off
-#ifndef MT32EMU_MONITOR_INSTRUMENTS
 #define MT32EMU_MONITOR_INSTRUMENTS 0
-#endif
 
 // 0: No debug output for partial allocations
 // 1: Show partial stats when an allocation fails
 // 2: Show partial stats with every new poly
 // 3: Show individual partial allocations/deactivations
-#ifndef MT32EMU_MONITOR_PARTIALS
 #define MT32EMU_MONITOR_PARTIALS 0
-#endif
 
 // 0: No debug output for sysex
 // 1: Basic debug output for sysex
-#ifndef MT32EMU_MONITOR_SYSEX
 #define MT32EMU_MONITOR_SYSEX 0
-#endif
 
 // 0: No debug output for sysex writes to the timbre areas
 // 1: Debug output with the name and location of newly-written timbres
 // 2: Complete dump of timbre parameters for newly-written timbres
-#ifndef MT32EMU_MONITOR_TIMBRES
 #define MT32EMU_MONITOR_TIMBRES 0
-#endif
 
 // 0: No TVA/TVF-related debug output.
 // 1: Shows changes to TVA/TVF target, increment and phase.
-#ifndef MT32EMU_MONITOR_TVA
 #define MT32EMU_MONITOR_TVA 0
-#endif
-#ifndef MT32EMU_MONITOR_TVF
 #define MT32EMU_MONITOR_TVF 0
-#endif
 
 // Configuration
 
-// 0: Use 16-bit signed samples and refined wave generator based on logarithmic fixed-point computations and LUTs. Maximum emulation accuracy and speed.
-// 1: Use float samples in the wave generator and renderer. Maximum output quality and minimum noise.
-#ifndef MT32EMU_USE_FLOAT_SAMPLES
-#define MT32EMU_USE_FLOAT_SAMPLES 0
-#endif
-
 // If non-zero, deletes reverb buffers that are not in use to save memory.
 // If zero, keeps reverb buffers for all modes around all the time to avoid allocating/freeing in the critical path.
-#ifndef MT32EMU_REDUCE_REVERB_MEMORY
 #define MT32EMU_REDUCE_REVERB_MEMORY 1
-#endif
 
 // 0: Maximum speed at the cost of a bit lower emulation accuracy.
 // 1: Maximum achievable emulation accuracy.
-#ifndef MT32EMU_BOSS_REVERB_PRECISE_MODE
 #define MT32EMU_BOSS_REVERB_PRECISE_MODE 0
-#endif
 
-namespace MT32Emu {
+#include "Structures.h"
+#include "Tables.h"
+#include "Poly.h"
+#include "LA32Ramp.h"
+#include "LA32WaveGenerator.h"
+#include "TVA.h"
+#include "TVP.h"
+#include "TVF.h"
+#include "Partial.h"
+#include "Part.h"
 
-enum PolyState {
-	POLY_Playing,
-	POLY_Held, // This marks keys that have been released on the keyboard, but are being held by the pedal
-	POLY_Releasing,
-	POLY_Inactive
-};
-
-enum ReverbMode {
-	REVERB_MODE_ROOM,
-	REVERB_MODE_HALL,
-	REVERB_MODE_PLATE,
-	REVERB_MODE_TAP_DELAY
-};
-
-#if MT32EMU_USE_FLOAT_SAMPLES
-typedef float Sample;
-typedef float SampleEx;
-#else
-typedef Bit16s Sample;
-typedef Bit32s SampleEx;
 #endif
-
-}
-
-#endif // #ifndef MT32EMU_INTERNALS_H
diff --git a/audio/softsynth/mt32/mmath.h b/audio/softsynth/mt32/mmath.h
index f233bedcbb..602242e74f 100644
--- a/audio/softsynth/mt32/mmath.h
+++ b/audio/softsynth/mt32/mmath.h
@@ -1,5 +1,5 @@
 /* Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Dean Beeler, Jerome Fisher
- * Copyright (C) 2011-2016 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
+ * Copyright (C) 2011, 2012, 2013, 2014 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
@@ -18,7 +18,12 @@
 #ifndef MT32EMU_MMATH_H
 #define MT32EMU_MMATH_H
 
-#include <cmath>
+#define FIXEDPOINT_UDIV(x, y, point) (((x) << (point)) / ((y)))
+#define FIXEDPOINT_SDIV(x, y, point) (((x) * (1 << point)) / ((y)))
+#define FIXEDPOINT_UMULT(x, y, point) (((x) * (y)) >> point)
+#define FIXEDPOINT_SMULT(x, y, point) (((x) * (y)) / (1 << point))
+
+#define FIXEDPOINT_MAKE(x, point) ((Bit32u)((1 << point) * x))
 
 namespace MT32Emu {
 
@@ -41,7 +46,7 @@ static inline float EXPF(float x) {
 static inline float EXP2F(float x) {
 #ifdef __APPLE__
 	// on OSX exp2f() is 1.59 times faster than "exp() and the multiplication with FLOAT_LN_2"
-	return exp2f(x);
+	return exp2(x);
 #else
 	return exp(FLOAT_LN_2 * x);
 #endif
@@ -63,6 +68,6 @@ static inline float LOG10F(float x) {
 	return log10(x);
 }
 
-} // namespace MT32Emu
+}
 
-#endif // #ifndef MT32EMU_MMATH_H
+#endif
diff --git a/audio/softsynth/mt32/module.mk b/audio/softsynth/mt32/module.mk
index b8e2adad7b..f966da8d08 100644
--- a/audio/softsynth/mt32/module.mk
+++ b/audio/softsynth/mt32/module.mk
@@ -3,11 +3,8 @@ MODULE := audio/softsynth/mt32
 MODULE_OBJS := \
 	Analog.o \
 	BReverbModel.o \
-	File.o \
-	FileStream.o \
 	LA32Ramp.o \
 	LA32WaveGenerator.o \
-	MidiStreamParser.o \
 	Part.o \
 	Partial.o \
 	PartialManager.o \
@@ -17,8 +14,7 @@ MODULE_OBJS := \
 	Tables.o \
 	TVA.o \
 	TVF.o \
-	TVP.o \
-	sha1/sha1.o
+	TVP.o
 
 # Include common rules
 include $(srcdir)/rules.mk
diff --git a/audio/softsynth/mt32/mt32emu.h b/audio/softsynth/mt32/mt32emu.h
index 9f2b058250..1574c08f0d 100644
--- a/audio/softsynth/mt32/mt32emu.h
+++ b/audio/softsynth/mt32/mt32emu.h
@@ -1,5 +1,5 @@
 /* Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Dean Beeler, Jerome Fisher
- * Copyright (C) 2011-2016 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
+ * Copyright (C) 2011, 2012, 2013, 2014 Dean Beeler, Jerome Fisher, Sergey V. Mikayev
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
@@ -18,66 +18,44 @@
 #ifndef MT32EMU_MT32EMU_H
 #define MT32EMU_MT32EMU_H
 
-#include "config.h"
-
-/* API Configuration */
-
-/* 0: Use full-featured C++ API. Well suitable when the library is to be linked statically.
- *    When the library is shared, ABI compatibility may be an issue. Therefore, it should
- *    only be used within a project comprising of several modules to share the library code.
- * 1: Use C-compatible API. Make the library looks as a regular C library with well-defined ABI.
- *    This is also crucial when the library is to be linked with modules in a different
- *    language, either statically or dynamically.
- * 2: Use plugin-like API via C-interface wrapped in a C++ class. This is mainly intended
- *    for a shared library being dynamically loaded in run-time. To get access to all the library
- *    services, a client application only needs to bind with a single factory function.
- * 3: Use optimised C++ API compatible with the plugin API (type 2). The facade class also wraps
- *    the C functions but they are invoked directly. This enables the compiler to generate better
- *    code for the library when linked statically yet being consistent with the plugin-like API.
- */
-
-#ifdef MT32EMU_API_TYPE
-#if MT32EMU_API_TYPE == 0 && (MT32EMU_EXPORTS_TYPE == 1 || MT32EMU_EXPORTS_TYPE == 2)
-#error Incompatible setting MT32EMU_API_TYPE=0
-#elif MT32EMU_API_TYPE == 1 && (MT32EMU_EXPORTS_TYPE == 0 || MT32EMU_EXPORTS_TYPE == 2)
-#error Incompatible setting MT32EMU_API_TYPE=1
-#elif MT32EMU_API_TYPE == 2 && (MT32EMU_EXPORTS_TYPE == 0)
-#error Incompatible setting MT32EMU_API_TYPE=2
-#elif MT32EMU_API_TYPE == 3 && (MT32EMU_EXPORTS_TYPE == 0)
-#error Incompatible setting MT32EMU_API_TYPE=3
-#endif
-#else /* #ifdef MT32EMU_API_TYPE */
-#if 0 < MT32EMU_EXPORTS_TYPE && MT32EMU_EXPORTS_TYPE < 3
-#define MT32EMU_API_TYPE MT32EMU_EXPORTS_TYPE
-#else
-#define MT32EMU_API_TYPE 0
-#endif
-#endif /* #ifdef MT32EMU_API_TYPE */
-
-/* MT32EMU_SHARED should be defined when building shared library, especially for Windows platforms. */
-/*
-#define MT32EMU_SHARED
-*/
-
-#include "globals.h"
-
-#if !defined(__cplusplus) || MT32EMU_API_TYPE == 1
-
-#include "c_interface/c_interface.h"
-
-#elif MT32EMU_API_TYPE == 2 || MT32EMU_API_TYPE == 3
-
-#include "c_interface/cpp_interface.h"
-
-#else /* #if !defined(__cplusplus) || MT32EMU_API_TYPE == 1 */
+// Configuration
+
+// 0: Use 16-bit signed samples and refined wave generator based on logarithmic fixed-point computations and LUTs. Maximum emulation accuracy and speed.
+// 1: Use float samples in the wave generator and renderer. Maximum output quality and minimum noise.
+#define MT32EMU_USE_FLOAT_SAMPLES 0
+
+namespace MT32Emu
+{
+// Sample rate to use in mixing. With the progress of development, we've found way too many thing dependent.
+// In order to achieve further advance in emulation accuracy, sample rate made fixed throughout the emulator,
+// except the emulation of analogue path.
+// The output from the synth is supposed to be resampled externally in order to convert to the desired sample rate.
+const unsigned int SAMPLE_RATE = 32000;
+
+// The default value for the maximum number of partials playing simultaneously.
+const unsigned int DEFAULT_MAX_PARTIALS = 32;
+
+// The higher this number, the more memory will be used, but the more samples can be processed in one run -
+// various parts of sample generation can be processed more efficiently in a single run.
+// A run's maximum length is that given to Synth::render(), so giving a value here higher than render() is ever
+// called with will give no gain (but simply waste the memory).
+// Note that this value does *not* in any way impose limitations on the length given to render(), and has no effect
+// on the generated audio.
+// This value must be >= 1.
+const unsigned int MAX_SAMPLES_PER_RUN = 4096;
+
+// The default size of the internal MIDI event queue.
+// It holds the incoming MIDI events before the rendering engine actually processes them.
+// The main goal is to fairly emulate the real hardware behaviour which obviously
+// uses an internal MIDI event queue to gather incoming data as well as the delays
+// introduced by transferring data via the MIDI interface.
+// This also facilitates building of an external rendering loop
+// as the queue stores timestamped MIDI events.
+const unsigned int DEFAULT_MIDI_EVENT_QUEUE_SIZE = 1024;
+}
 
 #include "Types.h"
-#include "File.h"
-#include "FileStream.h"
 #include "ROMInfo.h"
 #include "Synth.h"
-#include "MidiStreamParser.h"
-
-#endif /* #if !defined(__cplusplus) || MT32EMU_API_TYPE == 1 */
 
-#endif /* #ifndef MT32EMU_MT32EMU_H */
+#endif
diff --git a/audio/softsynth/mt32/sha1/sha1.cpp b/audio/softsynth/mt32/sha1/sha1.cpp
deleted file mode 100644
index a0c5e13a36..0000000000
--- a/audio/softsynth/mt32/sha1/sha1.cpp
+++ /dev/null
@@ -1,185 +0,0 @@
-/*
- Copyright (c) 2011, Micael Hildenborg
- All rights reserved.
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are met:
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
-    * Neither the name of Micael Hildenborg nor the
-      names of its contributors may be used to endorse or promote products
-      derived from this software without specific prior written permission.
-
- THIS SOFTWARE IS PROVIDED BY Micael Hildenborg ''AS IS'' AND ANY
- EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- DISCLAIMED. IN NO EVENT SHALL Micael Hildenborg BE LIABLE FOR ANY
- DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-/*
- Contributors:
- Gustav
- Several members in the gamedev.se forum.
- Gregory Petrosyan
- */
-
-#include "sha1.h"
-
-namespace sha1
-{
-    namespace // local
-    {
-        // Rotate an integer value to left.
-        inline unsigned int rol(const unsigned int value,
-                const unsigned int steps)
-        {
-            return ((value << steps) | (value >> (32 - steps)));
-        }
-
-        // Sets the first 16 integers in the buffert to zero.
-        // Used for clearing the W buffert.
-        inline void clearWBuffert(unsigned int* buffert)
-        {
-            for (int pos = 16; --pos >= 0;)
-            {
-                buffert[pos] = 0;
-            }
-        }
-
-        void innerHash(unsigned int* result, unsigned int* w)
-        {
-            unsigned int a = result[0];
-            unsigned int b = result[1];
-            unsigned int c = result[2];
-            unsigned int d = result[3];
-            unsigned int e = result[4];
-
-            int round = 0;
-
-            #define sha1macro(func,val) \
-			{ \
-                const unsigned int t = rol(a, 5) + (func) + e + val + w[round]; \
-				e = d; \
-				d = c; \
-				c = rol(b, 30); \
-				b = a; \
-				a = t; \
-			}
-
-            while (round < 16)
-            {
-                sha1macro((b & c) | (~b & d), 0x5a827999)
-                ++round;
-            }
-            while (round < 20)
-            {
-                w[round] = rol((w[round - 3] ^ w[round - 8] ^ w[round - 14] ^ w[round - 16]), 1);
-                sha1macro((b & c) | (~b & d), 0x5a827999)
-                ++round;
-            }
-            while (round < 40)
-            {
-                w[round] = rol((w[round - 3] ^ w[round - 8] ^ w[round - 14] ^ w[round - 16]), 1);
-                sha1macro(b ^ c ^ d, 0x6ed9eba1)
-                ++round;
-            }
-            while (round < 60)
-            {
-                w[round] = rol((w[round - 3] ^ w[round - 8] ^ w[round - 14] ^ w[round - 16]), 1);
-                sha1macro((b & c) | (b & d) | (c & d), 0x8f1bbcdc)
-                ++round;
-            }
-            while (round < 80)
-            {
-                w[round] = rol((w[round - 3] ^ w[round - 8] ^ w[round - 14] ^ w[round - 16]), 1);
-                sha1macro(b ^ c ^ d, 0xca62c1d6)
-                ++round;
-            }
-
-            #undef sha1macro
-
-            result[0] += a;
-            result[1] += b;
-            result[2] += c;
-            result[3] += d;
-            result[4] += e;
-        }
-    } // namespace
-
-    void calc(const void* src, const int bytelength, unsigned char* hash)
-    {
-        // Init the result array.
-        unsigned int result[5] = { 0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0 };
-
-        // Cast the void src pointer to be the byte array we can work with.
-        const unsigned char* sarray = (const unsigned char*) src;
-
-        // The reusable round buffer
-        unsigned int w[80];
-
-        // Loop through all complete 64byte blocks.
-        const int endOfFullBlocks = bytelength - 64;
-        int endCurrentBlock;
-        int currentBlock = 0;
-
-        while (currentBlock <= endOfFullBlocks)
-        {
-            endCurrentBlock = currentBlock + 64;
-
-            // Init the round buffer with the 64 byte block data.
-            for (int roundPos = 0; currentBlock < endCurrentBlock; currentBlock += 4)
-            {
-                // This line will swap endian on big endian and keep endian on little endian.
-                w[roundPos++] = (unsigned int) sarray[currentBlock + 3]
-                        | (((unsigned int) sarray[currentBlock + 2]) << 8)
-                        | (((unsigned int) sarray[currentBlock + 1]) << 16)
-                        | (((unsigned int) sarray[currentBlock]) << 24);
-            }
-            innerHash(result, w);
-        }
-
-        // Handle the last and not full 64 byte block if existing.
-        endCurrentBlock = bytelength - currentBlock;
-        clearWBuffert(w);
-        int lastBlockBytes = 0;
-        for (;lastBlockBytes < endCurrentBlock; ++lastBlockBytes)
-        {
-            w[lastBlockBytes >> 2] |= (unsigned int) sarray[lastBlockBytes + currentBlock] << ((3 - (lastBlockBytes & 3)) << 3);
-        }
-        w[lastBlockBytes >> 2] |= 0x80 << ((3 - (lastBlockBytes & 3)) << 3);
-        if (endCurrentBlock >= 56)
-        {
-            innerHash(result, w);
-            clearWBuffert(w);
-        }
-        w[15] = bytelength << 3;
-        innerHash(result, w);
-
-        // Store hash in result pointer, and make sure we get in in the correct order on both endian models.
-        for (int hashByte = 20; --hashByte >= 0;)
-        {
-            hash[hashByte] = (result[hashByte >> 2] >> (((3 - hashByte) & 0x3) << 3)) & 0xff;
-        }
-    }
-
-    void toHexString(const unsigned char* hash, char* hexstring)
-    {
-        const char hexDigits[] = { "0123456789abcdef" };
-
-        for (int hashByte = 20; --hashByte >= 0;)
-        {
-            hexstring[hashByte << 1] = hexDigits[(hash[hashByte] >> 4) & 0xf];
-            hexstring[(hashByte << 1) + 1] = hexDigits[hash[hashByte] & 0xf];
-        }
-        hexstring[40] = 0;
-    }
-} // namespace sha1
diff --git a/audio/softsynth/mt32/sha1/sha1.h b/audio/softsynth/mt32/sha1/sha1.h
deleted file mode 100644
index 96d8ce4da6..0000000000
--- a/audio/softsynth/mt32/sha1/sha1.h
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- Copyright (c) 2011, Micael Hildenborg
- All rights reserved.
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are met:
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
-    * Neither the name of Micael Hildenborg nor the
-      names of its contributors may be used to endorse or promote products
-      derived from this software without specific prior written permission.
-
- THIS SOFTWARE IS PROVIDED BY Micael Hildenborg ''AS IS'' AND ANY
- EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- DISCLAIMED. IN NO EVENT SHALL Micael Hildenborg BE LIABLE FOR ANY
- DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef SHA1_DEFINED
-#define SHA1_DEFINED
-
-namespace sha1
-{
-
-    /**
-     @param src points to any kind of data to be hashed.
-     @param bytelength the number of bytes to hash from the src pointer.
-     @param hash should point to a buffer of at least 20 bytes of size for storing the sha1 result in.
-     */
-    void calc(const void* src, const int bytelength, unsigned char* hash);
-
-    /**
-     @param hash is 20 bytes of sha1 hash. This is the same data that is the result from the calc function.
-     @param hexstring should point to a buffer of at least 41 bytes of size for storing the hexadecimal representation of the hash. A zero will be written at position 40, so the buffer will be a valid zero ended string.
-     */
-    void toHexString(const unsigned char* hash, char* hexstring);
-
-} // namespace sha1
-
-#endif // SHA1_DEFINED