commit 2f29fdee73d7171cbd075b5a8b281f0b58c26b0c Author: sergm Date: Mon Dec 1 21:20:05 2014 +0200 mt32emu patch diff --git a/src/Makefile.am b/src/Makefile.am index 184469e..286638d 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -17,4 +17,4 @@ dosbox_LDADD = cpu/libcpu.a debug/libdebug.a dos/libdos.a fpu/libfpu.a hardware EXTRA_DIST = winres.rc dosbox.ico - +LIBS += -lmt32emu diff --git a/src/dosbox.cpp b/src/dosbox.cpp index a4bf564..6d7f1e8 100644 --- a/src/dosbox.cpp +++ b/src/dosbox.cpp @@ -467,7 +467,7 @@ void DOSBOX_Init(void) { const char* mputypes[] = { "intelligent", "uart", "none",0}; // FIXME: add some way to offer the actually available choices. - const char *devices[] = { "default", "win32", "alsa", "oss", "coreaudio", "coremidi","none", 0}; + const char *devices[] = { "default", "win32", "alsa", "oss", "coreaudio", "coremidi", "mt32", "none", 0}; Pstring = secprop->Add_string("mpu401",Property::Changeable::WhenIdle,"intelligent"); Pstring->Set_values(mputypes); Pstring->Set_help("Type of MPU-401 to emulate."); @@ -480,6 +480,88 @@ void DOSBOX_Init(void) { Pstring->Set_help("Special configuration options for the device driver. This is usually the id of the device you want to use.\n" " See the README/Manual for more details."); + Pstring = secprop->Add_string("mt32.romdir",Property::Changeable::WhenIdle,""); + Pstring->Set_help("Name of the directory where MT-32 Control and PCM ROM files can be found. Emulation requires these files to work.\n" + " Accepted file names are as follows:\n" + " MT32_CONTROL.ROM or CM32L_CONTROL.ROM - control ROM file.\n" + " MT32_PCM.ROM or CM32L_PCM.ROM - PCM ROM file.\n"); + + const char *mt32ReverseStereo[] = {"off", "on",0}; + Pstring = secprop->Add_string("mt32.reverse.stereo",Property::Changeable::WhenIdle,"off"); + Pstring->Set_values(mt32ReverseStereo); + Pstring->Set_help("Reverse stereo channels for MT-32 output"); + + const char *mt32log[] = {"off", "on",0}; + Pstring = secprop->Add_string("mt32.verbose",Property::Changeable::WhenIdle,"off"); + Pstring->Set_values(mt32log); + Pstring->Set_help("MT-32 debug logging"); + + const char *mt32thread[] = {"off", "on",0}; + Pstring = secprop->Add_string("mt32.thread",Property::Changeable::WhenIdle,"off"); + Pstring->Set_values(mt32thread); + Pstring->Set_help("MT-32 rendering in separate thread"); + + const char *mt32DACModes[] = {"0", "1", "2", "3", "auto",0}; + Pstring = secprop->Add_string("mt32.dac",Property::Changeable::WhenIdle,"auto"); + Pstring->Set_values(mt32DACModes); + Pstring->Set_help("MT-32 DAC input emulation mode\n" + "Nice = 0 - default\n" + "Produces samples at double the volume, without tricks.\n" + "Higher quality than the real devices\n\n" + + "Pure = 1\n" + "Produces samples that exactly match the bits output from the emulated LA32.\n" + "Nicer overdrive characteristics than the DAC hacks (it simply clips samples within range)\n" + "Much less likely to overdrive than any other mode.\n" + "Half the volume of any of the other modes.\n" + "Perfect for developers while debugging :)\n\n" + + "GENERATION1 = 2\n" + "Re-orders the LA32 output bits as in early generation MT-32s (according to Wikipedia).\n" + "Bit order at DAC (where each number represents the original LA32 output bit number, and XX means the bit is always low):\n" + "15 13 12 11 10 09 08 07 06 05 04 03 02 01 00 XX\n\n" + + "GENERATION2 = 3\n" + "Re-orders the LA32 output bits as in later generations (personally confirmed on my CM-32L - KG).\n" + "Bit order at DAC (where each number represents the original LA32 output bit number):\n" + "15 13 12 11 10 09 08 07 06 05 04 03 02 01 00 14\n"); + + const char *mt32analogModes[] = {"0", "1", "2", "3", "auto",0}; + Pstring = secprop->Add_string("mt32.analog",Property::Changeable::WhenIdle,"auto"); + Pstring->Set_values(mt32analogModes); + Pstring->Set_help("MT-32 analogue output emulation mode\n" + "Digital = 0\n" + "Only digital path is emulated. The output samples correspond to the digital output signal appeared at the DAC entrance.\n" + "Fastest mode.\n\n" + + "Coarse = 1\n" + "Coarse emulation of LPF circuit. High frequencies are boosted, sample rate remains unchanged.\n" + "A bit better sounding but also a bit slower.\n\n" + + "Accurate = 2 - default\n" + "Finer emulation of LPF circuit. Output signal is upsampled to 48 kHz to allow emulation of audible mirror spectra above 16 kHz,\n" + "which is passed through the LPF circuit without significant attenuation.\n" + "Sounding is closer to the analog output from real hardware but also slower than the modes 0 and 1.\n\n" + + "Oversampled = 3\n" + "Same as the default mode 2 but the output signal is 2x oversampled, i.e. the output sample rate is 96 kHz.\n" + "Even slower than all the other modes but better retains highest frequencies while further resampled in DOSBox mixer.\n"); + + const char *mt32reverbModes[] = {"0", "1", "2", "3", "auto",0}; + Pstring = secprop->Add_string("mt32.reverb.mode",Property::Changeable::WhenIdle,"auto"); + Pstring->Set_values(mt32reverbModes); + Pstring->Set_help("MT-32 reverb mode"); + + const char *mt32reverbTimes[] = {"0", "1", "2", "3", "4", "5", "6", "7",0}; + Pint = secprop->Add_int("mt32.reverb.time",Property::Changeable::WhenIdle,5); + Pint->Set_values(mt32reverbTimes); + Pint->Set_help("MT-32 reverb decaying time"); + + const char *mt32reverbLevels[] = {"0", "1", "2", "3", "4", "5", "6", "7",0}; + Pint = secprop->Add_int("mt32.reverb.level",Property::Changeable::WhenIdle,3); + Pint->Set_values(mt32reverbLevels); + Pint->Set_help("MT-32 reverb level"); + #if C_DEBUG secprop=control->AddSection_prop("debug",&DEBUG_Init); #endif diff --git a/src/gui/Makefile.am b/src/gui/Makefile.am index 3fed5e6..d4aeabc 100644 --- a/src/gui/Makefile.am +++ b/src/gui/Makefile.am @@ -7,5 +7,5 @@ libgui_a_SOURCES = sdlmain.cpp sdl_mapper.cpp dosbox_logo.h \ render_templates_sai.h render_templates_hq.h \ render_templates_hq2x.h render_templates_hq3x.h \ midi.cpp midi_win32.h midi_oss.h midi_coreaudio.h midi_alsa.h \ - midi_coremidi.h sdl_gui.cpp dosbox_splash.h + midi_coremidi.h midi_mt32.h sdl_gui.cpp dosbox_splash.h diff --git a/src/gui/midi.cpp b/src/gui/midi.cpp index 61d15e5..0ec8ebc 100644 --- a/src/gui/midi.cpp +++ b/src/gui/midi.cpp @@ -98,6 +98,11 @@ MidiHandler Midi_none; #endif +#define DOSBOX_MIDI_H +#include "midi_mt32.cpp" +static MidiHandler_mt32 &Midi_mt32 = MidiHandler_mt32::GetInstance(); +#undef DOSBOX_MIDI_H + static struct { Bitu status; Bitu cmd_len; diff --git a/src/gui/midi_mt32.cpp b/src/gui/midi_mt32.cpp new file mode 100644 index 0000000..ce71157 --- /dev/null +++ b/src/gui/midi_mt32.cpp @@ -0,0 +1,248 @@ +#include +#include +#include +#include "control.h" + +#ifndef DOSBOX_MIDI_H +#include "midi.h" +#endif + +#include "midi_mt32.h" + +static const Bitu MILLIS_PER_SECOND = 1000; +static const Bitu MINIMUM_RENDER_MILLIS = 16; +static const Bitu AUDIO_LATENCY_MILLIS = 2 * MINIMUM_RENDER_MILLIS; + +MidiHandler_mt32 &MidiHandler_mt32::GetInstance() { + static MidiHandler_mt32 midiHandler_mt32; + return midiHandler_mt32; +} + +MidiHandler_mt32::MidiHandler_mt32() : open(false), chan(NULL), synth(NULL), thread(NULL) { +} + +MidiHandler_mt32::~MidiHandler_mt32() { + Close(); +} + +const char *MidiHandler_mt32::GetName(void) { + return "mt32"; +} + +void MidiHandler_mt32::makeROMPathName(char pathName[], const char romDir[], const char fileName[], bool addPathSeparator) { + strcpy(pathName, romDir); + if (addPathSeparator) { + strcat(pathName, "/"); + } + strcat(pathName, fileName); +} + +bool MidiHandler_mt32::Open(const char *conf) { + Section_prop *section = static_cast(control->GetSection("midi")); + const char *romDir = section->Get_string("mt32.romdir"); + if (romDir == NULL) romDir = "./"; // Paranoid NULL-check, should never happen + size_t romDirLen = strlen(romDir); + bool addPathSeparator = false; + if (romDirLen < 1) { + romDir = "./"; + } else if (4080 < romDirLen) { + LOG_MSG("MT32: mt32.romdir is too long, using the current dir."); + romDir = "./"; + } else { + char lastChar = romDir[strlen(romDir) - 1]; + addPathSeparator = lastChar != '/' && lastChar != '\\'; + } + + char pathName[4096]; + MT32Emu::FileStream controlROMFile; + MT32Emu::FileStream pcmROMFile; + + makeROMPathName(pathName, romDir, "CM32L_CONTROL.ROM", addPathSeparator); + if (!controlROMFile.open(pathName)) { + makeROMPathName(pathName, romDir, "MT32_CONTROL.ROM", addPathSeparator); + if (!controlROMFile.open(pathName)) { + LOG_MSG("MT32: Control ROM file not found"); + return false; + } + } + makeROMPathName(pathName, romDir, "CM32L_PCM.ROM", addPathSeparator); + if (!pcmROMFile.open(pathName)) { + makeROMPathName(pathName, romDir, "MT32_PCM.ROM", addPathSeparator); + if (!pcmROMFile.open(pathName)) { + LOG_MSG("MT32: PCM ROM file not found"); + return false; + } + } + const MT32Emu::ROMImage *controlROMImage = MT32Emu::ROMImage::makeROMImage(&controlROMFile); + const MT32Emu::ROMImage *pcmROMImage = MT32Emu::ROMImage::makeROMImage(&pcmROMFile); + + MT32Emu::AnalogOutputMode analogOutputMode = MT32Emu::AnalogOutputMode_ACCURATE; + if (strcmp(section->Get_string("mt32.analog"), "auto") != 0) { + analogOutputMode = (MT32Emu::AnalogOutputMode)atoi(section->Get_string("mt32.analog")); + } + + synth = new MT32Emu::Synth(&reportHandler); + if (!synth->open(*controlROMImage, *pcmROMImage, analogOutputMode)) { + LOG_MSG("MT32: Error initialising emulation"); + return false; + } + MT32Emu::ROMImage::freeROMImage(controlROMImage); + MT32Emu::ROMImage::freeROMImage(pcmROMImage); + + if (strcmp(section->Get_string("mt32.reverb.mode"), "auto") != 0) { + Bit8u reverbsysex[] = {0x10, 0x00, 0x01, 0x00, 0x05, 0x03}; + reverbsysex[3] = (Bit8u)atoi(section->Get_string("mt32.reverb.mode")); + reverbsysex[4] = (Bit8u)section->Get_int("mt32.reverb.time"); + reverbsysex[5] = (Bit8u)section->Get_int("mt32.reverb.level"); + synth->writeSysex(16, reverbsysex, 6); + synth->setReverbOverridden(true); + } + + if (strcmp(section->Get_string("mt32.dac"), "auto") != 0) { + synth->setDACInputMode((MT32Emu::DACInputMode)atoi(section->Get_string("mt32.dac"))); + } + + synth->setReversedStereoEnabled(strcmp(section->Get_string("mt32.reverse.stereo"), "on") == 0); + noise = strcmp(section->Get_string("mt32.verbose"), "on") == 0; + renderInThread = strcmp(section->Get_string("mt32.thread"), "on") == 0; + + if (noise) LOG_MSG("MT32: Adding mixer channel at sample rate %d", synth->getStereoOutputSampleRate()); + chan = MIXER_AddChannel(mixerCallBack, synth->getStereoOutputSampleRate(), "MT32"); + if (renderInThread) { + stopProcessing = false; + renderPos = 0; + playPos = 0; + sampleRateRatio = MT32Emu::SAMPLE_RATE / (double)synth->getStereoOutputSampleRate(); + minimumRenderFrames = (MINIMUM_RENDER_MILLIS * synth->getStereoOutputSampleRate()) / MILLIS_PER_SECOND; + framesPerAudioBuffer = (AUDIO_LATENCY_MILLIS * synth->getStereoOutputSampleRate()) / MILLIS_PER_SECOND; + audioBufferSize = framesPerAudioBuffer << 1; + audioBuffer = new Bit16s[audioBufferSize]; + render(framesPerAudioBuffer - 1, audioBuffer); + playedBuffers = 1; + thread = SDL_CreateThread(processingThread, NULL); + } + chan->Enable(true); + + open = true; + return true; +} + +void MidiHandler_mt32::Close(void) { + if (!open) return; + chan->Enable(false); + if (renderInThread) { + stopProcessing = true; + SDL_WaitThread(thread, NULL); + thread = NULL; + delete[] audioBuffer; + audioBuffer = NULL; + } + MIXER_DelChannel(chan); + chan = NULL; + synth->close(); + delete synth; + synth = NULL; + open = false; +} + +void MidiHandler_mt32::PlayMsg(Bit8u *msg) { + if (renderInThread) { + synth->playMsg(SDL_SwapLE32(*(Bit32u *)msg), getMidiEventTimestamp()); + } else { + synth->playMsg(SDL_SwapLE32(*(Bit32u *)msg)); + } +} + +void MidiHandler_mt32::PlaySysex(Bit8u *sysex, Bitu len) { + if (renderInThread) { + synth->playSysex(sysex, len, getMidiEventTimestamp()); + } else { + synth->playSysex(sysex, len); + } +} + +void MidiHandler_mt32::render(const Bitu len, Bit16s *buf) { + Bit16s *revBuf = &buf[renderPos]; + synth->render(revBuf, len); + renderPos = (renderPos + (len << 1)) % audioBufferSize; +} + +void MidiHandler_mt32::mixerCallBack(Bitu len) { + MidiHandler_mt32 &midiHandler_mt32 = MidiHandler_mt32::GetInstance(); + if (midiHandler_mt32.renderInThread) { + while (midiHandler_mt32.renderPos == midiHandler_mt32.playPos) { + SDL_Delay(1); + } + Bitu renderPos = midiHandler_mt32.renderPos; + Bitu playPos = midiHandler_mt32.playPos; + Bitu samplesReady; + if (renderPos < playPos) { + samplesReady = midiHandler_mt32.audioBufferSize - playPos; + } else { + samplesReady = renderPos - playPos; + } + if (len > (samplesReady >> 1)) { + len = samplesReady >> 1; + } + midiHandler_mt32.chan->AddSamples_s16(len, &midiHandler_mt32.audioBuffer[playPos]); + playPos += (len << 1); + while (midiHandler_mt32.audioBufferSize <= playPos) { + playPos -= midiHandler_mt32.audioBufferSize; + midiHandler_mt32.playedBuffers++; + } + midiHandler_mt32.playPos = playPos; + } else { + midiHandler_mt32.renderPos = 0; + midiHandler_mt32.render(len, (Bit16s *)MixTemp); + midiHandler_mt32.chan->AddSamples_s16(len, (Bit16s *)MixTemp); + } +} + +int MidiHandler_mt32::processingThread(void *) { + MidiHandler_mt32 &midiHandler_mt32 = MidiHandler_mt32::GetInstance(); + while (!midiHandler_mt32.stopProcessing) { + Bitu renderPos = midiHandler_mt32.renderPos; + Bitu playPos = midiHandler_mt32.playPos; + Bitu framesToRender; + if (renderPos < playPos) { + framesToRender = (playPos - renderPos - 2) >> 1; + if (framesToRender < midiHandler_mt32.minimumRenderFrames) { + SDL_Delay(1 + (MILLIS_PER_SECOND * (midiHandler_mt32.minimumRenderFrames - framesToRender)) / midiHandler_mt32.synth->getStereoOutputSampleRate()); + continue; + } + } else { + framesToRender = (midiHandler_mt32.audioBufferSize - renderPos) >> 1; + if (playPos == 0) { + framesToRender--; + if (framesToRender == 0) { + SDL_Delay(1 + (MILLIS_PER_SECOND * midiHandler_mt32.minimumRenderFrames) / midiHandler_mt32.synth->getStereoOutputSampleRate()); + continue; + } + } + } + midiHandler_mt32.render(framesToRender, midiHandler_mt32.audioBuffer); + } + return 0; +} + +void MidiHandler_mt32::MT32ReportHandler::onErrorControlROM() { + LOG_MSG("MT32: Couldn't open Control ROM file"); +} + +void MidiHandler_mt32::MT32ReportHandler::onErrorPCMROM() { + LOG_MSG("MT32: Couldn't open PCM ROM file"); +} + +void MidiHandler_mt32::MT32ReportHandler::showLCDMessage(const char *message) { + LOG_MSG("MT32: LCD-Message: %s", message); +} + +void MidiHandler_mt32::MT32ReportHandler::printDebug(const char *fmt, va_list list) { + MidiHandler_mt32 &midiHandler_mt32 = MidiHandler_mt32::GetInstance(); + if (midiHandler_mt32.noise) { + char s[1024]; + strcpy(s, "MT32: "); + vsnprintf(s + 6, 1017, fmt, list); + LOG_MSG(s); + } +} diff --git a/src/gui/midi_mt32.h b/src/gui/midi_mt32.h new file mode 100644 index 0000000..45b20cd --- /dev/null +++ b/src/gui/midi_mt32.h @@ -0,0 +1,54 @@ +#ifndef DOSBOX_MIDI_MT32_H +#define DOSBOX_MIDI_MT32_H + +#include "mixer.h" +#include + +struct SDL_Thread; + +class MidiHandler_mt32 : public MidiHandler { +public: + static MidiHandler_mt32 &GetInstance(void); + + const char *GetName(void); + bool Open(const char *conf); + void Close(void); + void PlayMsg(Bit8u *msg); + void PlaySysex(Bit8u *sysex, Bitu len); + +private: + MixerChannel *chan; + MT32Emu::Synth *synth; + SDL_Thread *thread; + Bit16s *audioBuffer; + Bitu audioBufferSize; + Bitu framesPerAudioBuffer; + Bitu minimumRenderFrames; + double sampleRateRatio; + volatile Bitu renderPos, playPos, playedBuffers; + volatile bool stopProcessing; + bool open, noise, renderInThread; + + class MT32ReportHandler : public MT32Emu::ReportHandler { + protected: + virtual void onErrorControlROM(); + virtual void onErrorPCMROM(); + virtual void showLCDMessage(const char *message); + virtual void printDebug(const char *fmt, va_list list); + } reportHandler; + + static void mixerCallBack(Bitu len); + static int processingThread(void *); + static void makeROMPathName(char pathName[], const char romDir[], const char fileName[], bool addPathSeparator); + + MidiHandler_mt32(); + ~MidiHandler_mt32(); + + void render(const Bitu len, Bit16s *buf); + + Bit32u inline getMidiEventTimestamp() { + return Bit32u((playedBuffers * framesPerAudioBuffer + (playPos >> 1)) * sampleRateRatio); + } +}; + +#endif /* DOSBOX_MIDI_MT32_H */