Merge branch 'master' of github.com:Wohlstand/libADLMIDI into stable

9 files changed, 223 insertions, 85 deletions

diff --git a/src/adlmidi.cpp b/src/adlmidi.cpp
index bde8757..12d0e68 100644
--- a/src/adlmidi.cpp
+++ b/src/adlmidi.cpp
@@ -23,14 +23,6 @@
 
 #include "adlmidi_private.hpp"
 
-#ifdef ADLMIDI_HW_OPL
-#define MaxChips 1
-#define MaxChips_STR "1" //Why not just "#MaxCards" ? Watcom fails to pass this with "syntax error" :-P
-#else
-#define MaxChips 100
-#define MaxChips_STR "100"
-#endif
-
 /* Unify MIDI player casting and interface between ADLMIDI and OPNMIDI */
 #define GET_MIDI_PLAYER(device) reinterpret_cast<MIDIplay *>((device)->adl_midiPlayer)
 typedef MIDIplay MidiPlayer;
@@ -68,7 +60,7 @@ ADLMIDI_EXPORT struct ADL_MIDIPlayer *adl_init(long sample_rate)
         return NULL;
     }
     midi_device->adl_midiPlayer = player;
-    adlRefreshNumCards(midi_device);
+    adlCalculateFourOpChannels(player);
     return midi_device;
 }
 
@@ -107,16 +99,31 @@ ADLMIDI_EXPORT int adl_setNumChips(ADL_MIDIPlayer *device, int numChips)
 #else
     play->m_setup.numChips = static_cast<unsigned int>(numChips);
 #endif
-    if(play->m_setup.numChips < 1 || play->m_setup.numChips > MaxChips)
+    if(play->m_setup.numChips < 1 || play->m_setup.numChips > ADL_MAX_CHIPS)
     {
-        play->setErrorString("number of chips may only be 1.." MaxChips_STR ".\n");
+        play->setErrorString("number of chips may only be 1.." ADL_MAX_CHIPS_STR ".\n");
         return -1;
     }
 
-    play->m_synth.m_numChips = play->m_setup.numChips;
-    play->partialReset();
+    int maxFourOps = static_cast<int>(play->m_setup.numChips * 6);
+
+    if(play->m_setup.numFourOps > maxFourOps)
+        play->m_setup.numFourOps = maxFourOps;
+    else if(play->m_setup.numFourOps < -1)
+        play->m_setup.numFourOps = -1;
+
+    if(!play->m_synth.setupLocked())
+    {
+        play->m_synth.m_numChips = play->m_setup.numChips;
+        if(play->m_setup.numFourOps < 0)
+            adlCalculateFourOpChannels(play, true);
+        else
+            play->m_synth.m_numFourOps = static_cast<uint32_t>(play->m_setup.numFourOps);
+        play->partialReset();
+        return 0;
+    }
 
-    return adlRefreshNumCards(device);
+    return 0;
 }
 
 ADLMIDI_EXPORT int adl_getNumChips(struct ADL_MIDIPlayer *device)
@@ -128,6 +135,15 @@ ADLMIDI_EXPORT int adl_getNumChips(struct ADL_MIDIPlayer *device)
     return (int)play->m_setup.numChips;
 }
 
+ADLMIDI_EXPORT int adl_getNumChipsObtained(struct ADL_MIDIPlayer *device)
+{
+    if(device == NULL)
+        return -2;
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
+    assert(play);
+    return (int)play->m_synth.m_numChips;
+}
+
 ADLMIDI_EXPORT int adl_setBank(ADL_MIDIPlayer *device, int bank)
 {
 #ifdef DISABLE_EMBEDDED_BANKS
@@ -159,7 +175,7 @@ ADLMIDI_EXPORT int adl_setBank(ADL_MIDIPlayer *device, int bank)
     play->m_synth.setEmbeddedBank(play->m_setup.bankId);
     play->applySetup();
 
-    return adlRefreshNumCards(device);
+    return 0;
 #endif
 }
 
@@ -357,12 +373,9 @@ ADLMIDI_EXPORT int adl_setNumFourOpsChn(ADL_MIDIPlayer *device, int ops4)
     if(!device)
         return -1;
 
-    if(ops4 == -1)
-        return adlRefreshNumCards(device);
-
     MidiPlayer *play = GET_MIDI_PLAYER(device);
     assert(play);
-    if((unsigned int)ops4 > 6 * play->m_setup.numChips)
+    if(ops4 > 6 * static_cast<int>(play->m_setup.numChips))
     {
         char errBuff[250];
         snprintf(errBuff, 250, "number of four-op channels may only be 0..%u when %u OPL3 cards are used.\n", (6 * (play->m_setup.numChips)), play->m_setup.numChips);
@@ -370,9 +383,15 @@ ADLMIDI_EXPORT int adl_setNumFourOpsChn(ADL_MIDIPlayer *device, int ops4)
         return -1;
     }
 
-    play->m_setup.numFourOps = static_cast<unsigned int>(ops4);
-    play->m_synth.m_numFourOps = play->m_setup.numFourOps;
-    play->m_synth.updateChannelCategories();
+    play->m_setup.numFourOps = ops4;
+    if(!play->m_synth.setupLocked())
+    {
+        if(play->m_setup.numFourOps < 0)
+            adlCalculateFourOpChannels(play, true);
+        else
+            play->m_synth.m_numFourOps = static_cast<uint32_t>(play->m_setup.numFourOps);
+        play->m_synth.updateChannelCategories();
+    }
 
     return 0;
 }
@@ -380,22 +399,35 @@ ADLMIDI_EXPORT int adl_setNumFourOpsChn(ADL_MIDIPlayer *device, int ops4)
 ADLMIDI_EXPORT int adl_getNumFourOpsChn(struct ADL_MIDIPlayer *device)
 {
     if(!device)
-        return -1;
+        return -2;
     MidiPlayer *play = GET_MIDI_PLAYER(device);
     assert(play);
-    return (int)play->m_setup.numFourOps;
+    return play->m_setup.numFourOps;
 }
 
+ADLMIDI_EXPORT int adl_getNumFourOpsChnObtained(struct ADL_MIDIPlayer *device)
+{
+    if(!device)
+        return -2;
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
+    assert(play);
+    return (int)play->m_synth.m_numFourOps;
+}
+
+
 ADLMIDI_EXPORT void adl_setPercMode(ADL_MIDIPlayer *device, int percmod)
 {
     if(!device) return;
     MidiPlayer *play = GET_MIDI_PLAYER(device);
     assert(play);
     play->m_setup.rhythmMode = percmod;
-    play->m_synth.m_rhythmMode   = play->m_setup.rhythmMode < 0 ?
-                              (play->m_synth.m_insBankSetup.adLibPercussions) :
-                              (play->m_setup.rhythmMode != 0);
-    play->m_synth.updateChannelCategories();
+    if(!play->m_synth.setupLocked())
+    {
+        play->m_synth.m_rhythmMode   = play->m_setup.rhythmMode < 0 ?
+                                  (play->m_synth.m_insBankSetup.adLibPercussions) :
+                                  (play->m_setup.rhythmMode != 0);
+        play->m_synth.updateChannelCategories();
+    }
 }
 
 ADLMIDI_EXPORT void adl_setHVibrato(ADL_MIDIPlayer *device, int hvibro)
@@ -404,10 +436,13 @@ ADLMIDI_EXPORT void adl_setHVibrato(ADL_MIDIPlayer *device, int hvibro)
     MidiPlayer *play = GET_MIDI_PLAYER(device);
     assert(play);
     play->m_setup.deepVibratoMode = hvibro;
-    play->m_synth.m_deepVibratoMode     = play->m_setup.deepVibratoMode < 0 ?
-                                    play->m_synth.m_insBankSetup.deepVibrato :
-                                    (play->m_setup.deepVibratoMode != 0);
-    play->m_synth.commitDeepFlags();
+    if(!play->m_synth.setupLocked())
+    {
+        play->m_synth.m_deepVibratoMode     = play->m_setup.deepVibratoMode < 0 ?
+                                        play->m_synth.m_insBankSetup.deepVibrato :
+                                        (play->m_setup.deepVibratoMode != 0);
+        play->m_synth.commitDeepFlags();
+    }
 }
 
 ADLMIDI_EXPORT int adl_getHVibrato(struct ADL_MIDIPlayer *device)
@@ -424,10 +459,13 @@ ADLMIDI_EXPORT void adl_setHTremolo(ADL_MIDIPlayer *device, int htremo)
     MidiPlayer *play = GET_MIDI_PLAYER(device);
     assert(play);
     play->m_setup.deepTremoloMode = htremo;
-    play->m_synth.m_deepTremoloMode     = play->m_setup.deepTremoloMode < 0 ?
-                                    play->m_synth.m_insBankSetup.deepTremolo :
-                                    (play->m_setup.deepTremoloMode != 0);
-    play->m_synth.commitDeepFlags();
+    if(!play->m_synth.setupLocked())
+    {
+        play->m_synth.m_deepTremoloMode     = play->m_setup.deepTremoloMode < 0 ?
+                                        play->m_synth.m_insBankSetup.deepTremolo :
+                                        (play->m_setup.deepTremoloMode != 0);
+        play->m_synth.commitDeepFlags();
+    }
 }
 
 ADLMIDI_EXPORT int adl_getHTremolo(struct ADL_MIDIPlayer *device)
@@ -445,9 +483,12 @@ ADLMIDI_EXPORT void adl_setScaleModulators(ADL_MIDIPlayer *device, int smod)
     MidiPlayer *play = GET_MIDI_PLAYER(device);
     assert(play);
     play->m_setup.scaleModulators = smod;
-    play->m_synth.m_scaleModulators     = play->m_setup.scaleModulators < 0 ?
-                                    play->m_synth.m_insBankSetup.scaleModulators :
-                                    (play->m_setup.scaleModulators != 0);
+    if(!play->m_synth.setupLocked())
+    {
+        play->m_synth.m_scaleModulators     = play->m_setup.scaleModulators < 0 ?
+                                        play->m_synth.m_insBankSetup.scaleModulators :
+                                        (play->m_setup.scaleModulators != 0);
+    }
 }
 
 ADLMIDI_EXPORT void adl_setFullRangeBrightness(struct ADL_MIDIPlayer *device, int fr_brightness)
@@ -489,10 +530,13 @@ ADLMIDI_EXPORT void adl_setLogarithmicVolumes(struct ADL_MIDIPlayer *device, int
     MidiPlayer *play = GET_MIDI_PLAYER(device);
     assert(play);
     play->m_setup.logarithmicVolumes = (logvol != 0);
-    if(play->m_setup.logarithmicVolumes)
-        play->m_synth.setVolumeScaleModel(ADLMIDI_VolumeModel_NativeOPL3);
-    else
-        play->m_synth.setVolumeScaleModel(static_cast<ADLMIDI_VolumeModels>(play->m_synth.m_volumeScale));
+    if(!play->m_synth.setupLocked())
+    {
+        if(play->m_setup.logarithmicVolumes)
+            play->m_synth.setVolumeScaleModel(ADLMIDI_VolumeModel_NativeOPL3);
+        else
+            play->m_synth.setVolumeScaleModel(static_cast<ADLMIDI_VolumeModels>(play->m_synth.m_volumeScale));
+    }
 }
 
 ADLMIDI_EXPORT void adl_setVolumeRangeModel(struct ADL_MIDIPlayer *device, int volumeModel)
@@ -502,10 +546,13 @@ ADLMIDI_EXPORT void adl_setVolumeRangeModel(struct ADL_MIDIPlayer *device, int v
     MidiPlayer *play = GET_MIDI_PLAYER(device);
     assert(play);
     play->m_setup.volumeScaleModel = volumeModel;
-    if(play->m_setup.volumeScaleModel == ADLMIDI_VolumeModel_AUTO)//Use bank default volume model
-        play->m_synth.m_volumeScale = (OPL3::VolumesScale)play->m_synth.m_insBankSetup.volumeModel;
-    else
-        play->m_synth.setVolumeScaleModel(static_cast<ADLMIDI_VolumeModels>(volumeModel));
+    if(!play->m_synth.setupLocked())
+    {
+        if(play->m_setup.volumeScaleModel == ADLMIDI_VolumeModel_AUTO)//Use bank default volume model
+            play->m_synth.m_volumeScale = (OPL3::VolumesScale)play->m_synth.m_insBankSetup.volumeModel;
+        else
+            play->m_synth.setVolumeScaleModel(static_cast<ADLMIDI_VolumeModels>(volumeModel));
+    }
 }
 
 ADLMIDI_EXPORT int adl_getVolumeRangeModel(struct ADL_MIDIPlayer *device)
@@ -531,7 +578,8 @@ ADLMIDI_EXPORT int adl_openBankFile(struct ADL_MIDIPlayer *device, const char *f
                 play->setErrorString("ADL MIDI: Can't load file");
             return -1;
         }
-        else return adlRefreshNumCards(device);
+        else
+            return adlCalculateFourOpChannels(play, true);
     }
 
     ADLMIDI_ErrorString = "Can't load file: ADLMIDI is not initialized";
@@ -552,7 +600,8 @@ ADLMIDI_EXPORT int adl_openBankData(struct ADL_MIDIPlayer *device, const void *m
                 play->setErrorString("ADL MIDI: Can't load data from memory");
             return -1;
         }
-        else return adlRefreshNumCards(device);
+        else
+            return adlCalculateFourOpChannels(play, true);
     }
 
     ADLMIDI_ErrorString = "Can't load file: ADL MIDI is not initialized";
@@ -660,7 +709,8 @@ ADLMIDI_EXPORT int adl_setRunAtPcmRate(ADL_MIDIPlayer *device, int enabled)
         MidiPlayer *play = GET_MIDI_PLAYER(device);
         assert(play);
         play->m_setup.runAtPcmRate = (enabled != 0);
-        play->partialReset();
+        if(!play->m_synth.setupLocked())
+            play->partialReset();
         return 0;
     }
     return -1;
diff --git a/src/adlmidi_load.cpp b/src/adlmidi_load.cpp
index 915b587..07ad875 100644
--- a/src/adlmidi_load.cpp
+++ b/src/adlmidi_load.cpp
@@ -1,4 +1,4 @@
-/*
+/*
  * libADLMIDI is a free MIDI to WAV conversion library with OPL3 emulation
  *
  * Original ADLMIDI code: Copyright (c) 2010-2014 Joel Yliluoma <bisqwit@iki.fi>
@@ -203,7 +203,7 @@ bool MIDIplay::LoadMIDI_post()
             adlins.adl[0] = adl;
             adlins.adl[1] = adl;
             adlins.ms_sound_kon  = 1000;
-            adlins.ms_sound_koff = 0;
+            adlins.ms_sound_koff = 500;
             adlins.tone  = 0;
             adlins.flags = 0;
             adlins.voice2_fine_tune = 0.0;
@@ -214,20 +214,36 @@ bool MIDIplay::LoadMIDI_post()
         m_synth.m_rhythmMode = true;
         m_synth.m_musicMode = OPL3::MODE_CMF;
         m_synth.m_volumeScale = OPL3::VOLUME_NATIVE;
+
+        m_synth.m_numChips = 1;
+        m_synth.m_numFourOps = 0;
     }
     else if(format == MidiSequencer::Format_RSXX)
     {
         //opl.CartoonersVolumes = true;
         m_synth.m_musicMode     = OPL3::MODE_RSXX;
         m_synth.m_volumeScale   = OPL3::VOLUME_NATIVE;
+
+        m_synth.m_numChips = 1;
+        m_synth.m_numFourOps = 0;
     }
     else if(format == MidiSequencer::Format_IMF)
     {
         //std::fprintf(stderr, "Done reading IMF file\n");
         m_synth.m_numFourOps  = 0; //Don't use 4-operator channels for IMF playing!
         m_synth.m_musicMode = OPL3::MODE_IMF;
+
+        m_synth.m_numChips = 1;
+        m_synth.m_numFourOps = 0;
+    }
+    else
+    {
+        m_synth.m_numChips = m_setup.numChips;
+        if(m_setup.numFourOps < 0)
+            adlCalculateFourOpChannels(this, true);
     }
 
+    m_setup.tick_skip_samples_delay = 0;
     m_synth.reset(m_setup.emulator, m_setup.PCM_RATE, this); // Reset OPL3 chip
     //opl.Reset(); // ...twice (just in case someone misprogrammed OPL3 previously)
     m_chipChannels.clear();
diff --git a/src/adlmidi_midiplay.cpp b/src/adlmidi_midiplay.cpp
index 42b5b01..1e1da07 100644
--- a/src/adlmidi_midiplay.cpp
+++ b/src/adlmidi_midiplay.cpp
@@ -104,7 +104,11 @@ void MIDIplay::AdlChannel::addAge(int64_t us)
 {
     const int64_t neg = 1000 * static_cast<int64_t>(-0x1FFFFFFFll);
     if(users_empty())
+    {
         koff_time_until_neglible_us = std::max(koff_time_until_neglible_us - us, neg);
+        if(koff_time_until_neglible_us < 0)
+            koff_time_until_neglible_us = 0;
+    }
     else
     {
         koff_time_until_neglible_us = 0;
@@ -137,7 +141,7 @@ MIDIplay::MIDIplay(unsigned long sampleRate):
     m_setup.maxdelay = 512.0 / (double)m_setup.PCM_RATE;
 
     m_setup.bankId    = 0;
-    m_setup.numFourOps = 7;
+    m_setup.numFourOps = -1;
     m_setup.numChips   = 2;
     m_setup.deepTremoloMode     = -1;
     m_setup.deepVibratoMode     = -1;
@@ -194,9 +198,13 @@ void MIDIplay::applySetup()
         m_synth.m_volumeScale = (OPL3::VolumesScale)m_synth.m_insBankSetup.volumeModel;
 
     m_synth.m_numChips    = m_setup.numChips;
-    m_synth.m_numFourOps  = m_setup.numFourOps;
     m_cmfPercussionMode = false;
 
+    if(m_setup.numFourOps >= 0)
+        m_synth.m_numFourOps  = m_setup.numFourOps;
+    else
+        adlCalculateFourOpChannels(this, true);
+
     m_synth.reset(m_setup.emulator, m_setup.PCM_RATE, this);
     m_chipChannels.clear();
     m_chipChannels.resize(m_synth.m_numChannels);
@@ -584,6 +592,7 @@ bool MIDIplay::realTime_NoteOn(uint8_t channel, uint8_t note, uint8_t velocity)
         int32_t c = adlchannel[ccount];
         if(c < 0)
             continue;
+        m_chipChannels[c].recent_ins = voices[ccount];
         m_chipChannels[c].addAge(0);
     }
 
@@ -1161,7 +1170,7 @@ void MIDIplay::noteUpdate(size_t midCh,
                     }
                     else
                     {
-                        m_chipChannels[c].koff_time_until_neglible_us = 1000 * ains.ms_sound_koff;
+                        m_chipChannels[c].koff_time_until_neglible_us = 1000 * int64_t(ains.ms_sound_koff);
                     }
                 }
             }
@@ -1331,14 +1340,24 @@ void MIDIplay::setErrorString(const std::string &err)
 
 int64_t MIDIplay::calculateChipChannelGoodness(size_t c, const MIDIchannel::NoteInfo::Phys &ins) const
 {
-    int64_t koff_ms = m_chipChannels[c].koff_time_until_neglible_us / 1000;
-    int64_t s = (m_synth.m_musicMode != OPL3::MODE_CMF) ? -koff_ms : 0;
+    const AdlChannel &chan = m_chipChannels[c];
+    int64_t koff_ms = chan.koff_time_until_neglible_us / 1000;
+    int64_t s = -koff_ms;
+
+    // Rate channel with a releasing note
+    if(s < 0 && chan.users_empty())
+    {
+        s -= 40000;
+        // If it's same instrument, better chance to get it when no free channels
+        if(chan.recent_ins == ins)
+            s = (m_synth.m_musicMode == OPL3::MODE_CMF) ? 0 : -koff_ms;
+        return s;
+    }
 
     // Same midi-instrument = some stability
-    //if(c == MidCh) s += 4;
-    for(AdlChannel::LocationData *j = m_chipChannels[c].users_first; j; j = j->next)
+    for(AdlChannel::LocationData *j = chan.users_first; j; j = j->next)
     {
-        s -= 4000;
+        s -= 4000000;
 
         int64_t kon_ms = j->kon_time_until_neglible_us / 1000;
         s -= (j->sustained == AdlChannel::LocationData::Sustain_None) ?
@@ -1356,7 +1375,7 @@ int64_t MIDIplay::calculateChipChannelGoodness(size_t c, const MIDIchannel::Note
                 // Arpeggio candidate = even better
                 if(j->vibdelay_us < 70000
                    || j->kon_time_until_neglible_us > 20000000)
-                    s += 0;
+                    s += 10;
             }
 
             // Percussion is inferior to melody
@@ -1446,6 +1465,8 @@ void MIDIplay::killOrEvacuate(size_t from_channel,
                               AdlChannel::LocationData *j,
                               MIDIplay::MIDIchannel::activenoteiterator i)
 {
+    uint32_t maxChannels = ADL_MAX_CHIPS * 18;
+
     // Before killing the note, check if it can be
     // evacuated to another channel as an arpeggio
     // instrument. This helps if e.g. all channels
@@ -1455,7 +1476,7 @@ void MIDIplay::killOrEvacuate(size_t from_channel,
     {
         uint16_t cs = static_cast<uint16_t>(c);
 
-        if(c > std::numeric_limits<uint32_t>::max())
+        if(c >= maxChannels)
             break;
         if(c == from_channel)
             continue;
diff --git a/src/adlmidi_opl3.cpp b/src/adlmidi_opl3.cpp
index e486dd6..f3672d3 100644
--- a/src/adlmidi_opl3.cpp
+++ b/src/adlmidi_opl3.cpp
@@ -181,6 +181,13 @@ OPL3::OPL3() :
 #endif
 }
 
+bool OPL3::setupLocked()
+{
+    return (m_musicMode == MODE_CMF ||
+            m_musicMode == MODE_IMF ||
+            m_musicMode == MODE_RSXX);
+}
+
 void OPL3::setEmbeddedBank(uint32_t bank)
 {
 #ifndef DISABLE_EMBEDDED_BANKS
@@ -487,6 +494,7 @@ void OPL3::setPan(size_t c, uint8_t value)
             int panning = 0;
             if(value  < 64 + 32) panning |= OPL_PANNING_LEFT;
             if(value >= 64 - 32) panning |= OPL_PANNING_RIGHT;
+            writePan(chip, g_channelsMap[cc], 64);
             writeRegI(chip, 0xC0 + g_channelsMap[cc], m_insCache[c].feedconn | panning);
 #ifndef ADLMIDI_HW_OPL
         }
diff --git a/src/adlmidi_private.cpp b/src/adlmidi_private.cpp
index 43fe8de..4e8e488 100644
--- a/src/adlmidi_private.cpp
+++ b/src/adlmidi_private.cpp
@@ -34,10 +34,9 @@ void adl_audioTickHandler(void *instance, uint32_t chipId, uint32_t rate)
 }
 #endif
 
-int adlRefreshNumCards(ADL_MIDIPlayer *device)
+int adlCalculateFourOpChannels(MIDIplay *play, bool silent)
 {
     size_t n_fourop[2] = {0, 0}, n_total[2] = {0, 0};
-    MIDIplay *play = reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
 
     //Automatically calculate how much 4-operator channels is necessary
 #ifndef DISABLE_EMBEDDED_BANKS
@@ -100,9 +99,10 @@ int adlRefreshNumCards(ADL_MIDIPlayer *device)
         : (play->m_setup.NumCards == 1 ? 1 : play->m_setup.NumCards * 4);
 */
 
-    play->m_synth.m_numFourOps = play->m_setup.numFourOps = static_cast<unsigned>(numFourOps * play->m_setup.numChips);
+    play->m_synth.m_numFourOps = static_cast<unsigned>(numFourOps * play->m_synth.m_numChips);
     // Update channel categories and set up four-operator channels
-    play->m_synth.updateChannelCategories();
+    if(!silent)
+        play->m_synth.updateChannelCategories();
 
     return 0;
 }
diff --git a/src/adlmidi_private.hpp b/src/adlmidi_private.hpp
index c5b70ee..59ba555 100644
--- a/src/adlmidi_private.hpp
+++ b/src/adlmidi_private.hpp
@@ -161,6 +161,14 @@ typedef BW_MidiSequencer MidiSequencer;
 #define OPL_PANNING_RIGHT   0x20
 #define OPL_PANNING_BOTH    0x30
 
+#ifdef ADLMIDI_HW_OPL
+#define ADL_MAX_CHIPS 1
+#define ADL_MAX_CHIPS_STR "1" //Why not just "#MaxCards" ? Watcom fails to pass this with "syntax error" :-P
+#else
+#define ADL_MAX_CHIPS 100
+#define ADL_MAX_CHIPS_STR "100"
+#endif
+
 extern std::string ADLMIDI_ErrorString;
 
 /*
@@ -211,6 +219,7 @@ inline int32_t adl_cvtU32(int32_t x)
 }
 
 struct ADL_MIDIPlayer;
+class  MIDIplay;
 /**
  * @brief OPL3 Chip management class
  */
@@ -218,7 +227,7 @@ class OPL3
 {
     friend class MIDIplay;
     friend class AdlInstrumentTester;
-    friend int adlRefreshNumCards(ADL_MIDIPlayer *device);
+    friend int adlCalculateFourOpChannels(MIDIplay *play, bool silent);
 public:
     enum
     {
@@ -363,6 +372,12 @@ public:
     OPL3();
 
     /**
+     * @brief Checks are setup locked to be changed on the fly or not
+     * @return true when setup on the fly is locked
+     */
+    bool setupLocked();
+
+    /**
      * @brief Choose one of embedded banks
      * @param bank ID of the bank
      */
@@ -880,6 +895,9 @@ public:
         //! Time left until sounding will be muted after key off
         int64_t koff_time_until_neglible_us;
 
+        //! Recently passed instrument, improves a goodness of released but busy channel when matching
+        MIDIchannel::NoteInfo::Phys recent_ins;
+
         enum { users_max = 128 };
         LocationData *users_first, *users_free_cells;
         LocationData users_cells[users_max];
@@ -898,6 +916,7 @@ public:
         AdlChannel(): koff_time_until_neglible_us(0)
         {
             users_clear();
+            std::memset(&recent_ins, 0, sizeof(MIDIchannel::NoteInfo::Phys));
         }
 
         AdlChannel(const AdlChannel &oth): koff_time_until_neglible_us(oth.koff_time_until_neglible_us)
@@ -947,7 +966,7 @@ public:
         int          emulator;
         bool         runAtPcmRate;
         unsigned int bankId;
-        unsigned int numFourOps;
+        int          numFourOps;
         unsigned int numChips;
         int     deepTremoloMode;
         int     deepVibratoMode;
@@ -1481,9 +1500,10 @@ extern void adl_audioTickHandler(void *instance, uint32_t chipId, uint32_t rate)
 /**
  * @brief Automatically calculate and enable necessary count of 4-op channels on emulated chips
  * @param device Library context
+ * @param silent Don't re-count channel categories
  * @return Always 0
  */
-extern int adlRefreshNumCards(ADL_MIDIPlayer *device);
+extern int adlCalculateFourOpChannels(MIDIplay *play, bool silent = false);
 
 /**
  * @brief Check emulator availability
diff --git a/src/adlmidi_sequencer.cpp b/src/adlmidi_sequencer.cpp
index 3c18cad..66b9b9a 100644
--- a/src/adlmidi_sequencer.cpp
+++ b/src/adlmidi_sequencer.cpp
@@ -137,7 +137,7 @@ double MIDIplay::Tick(double s, double granularity)
 
     s *= m_sequencer.getTempoMultiplier();
     for(uint16_t c = 0; c < m_synth.m_numChannels; ++c)
-        m_chipChannels[c].addAge(static_cast<int64_t>(s * 1000.0));
+        m_chipChannels[c].addAge(static_cast<int64_t>(s * 1e6));
 
     updateVibrato(s);
     updateArpeggio(s);
diff --git a/src/chips/dosbox/dbopl.cpp b/src/chips/dosbox/dbopl.cpp
index 2d31708..1931203 100644
--- a/src/chips/dosbox/dbopl.cpp
+++ b/src/chips/dosbox/dbopl.cpp
@@ -38,6 +38,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <vector>
+#include <memory>
 #include "dbopl.h"
 
 #if defined(__GNUC__) && __GNUC__ > 3
@@ -80,7 +81,8 @@ private:
 #if !defined(_WIN32)
 #include <pthread.h>
 struct Mutex : NoCopy {
-	Mutex() : m(PTHREAD_MUTEX_INITIALIZER) {}
+	Mutex() { pthread_mutex_init(&m, NULL);}
+	~Mutex() { pthread_mutex_destroy(&m); }
 	void lock() { pthread_mutex_lock(&m); }
 	void unlock() { pthread_mutex_unlock(&m); }
 	pthread_mutex_t m;
@@ -1331,14 +1333,26 @@ struct CacheEntry {
 	Bit32u linearRates[76];
 	Bit32u attackRates[76];
 };
-static std::vector<CacheEntry> cache;
-static Mutex cacheMutex;
+struct Cache : NoCopy {
+    ~Cache();
+    Mutex mutex;
+    std::vector<CacheEntry *> entries;
+};
+
+static Cache cache;
+
+Cache::~Cache()
+{
+	for ( size_t i = 0, n = entries.size(); i < n; ++i )
+		delete entries[i];
+}
 
 static const CacheEntry *CacheLookupRateDependent( Bit32u rate )
 {
-	for ( size_t i = 0, n = cache.size(); i < n; ++i ) {
-		if (cache[i].rate == rate)
-			return &cache[i];
+	for ( size_t i = 0, n = cache.entries.size(); i < n; ++i ) {
+		const CacheEntry *entry = cache.entries[i];
+		if (entry->rate == rate)
+			return entry;
 	}
 	return NULL;
 }
@@ -1346,7 +1360,7 @@ static const CacheEntry *CacheLookupRateDependent( Bit32u rate )
 static const CacheEntry &ComputeRateDependent( Bit32u rate )
 {
 	{
-		MutexHolder lock( cacheMutex );
+		MutexHolder lock( cache.mutex );
 		if (const CacheEntry *entry = CacheLookupRateDependent( rate ))
 			return *entry;
 	}
@@ -1354,11 +1368,15 @@ static const CacheEntry &ComputeRateDependent( Bit32u rate )
 	double original = OPLRATE;
 	double scale = original / (double)rate;
 
-	CacheEntry entry;
-	entry.rate = rate;
-	Bit32u *freqMul = entry.freqMul;
-	Bit32u *linearRates = entry.linearRates;
-	Bit32u *attackRates = entry.attackRates;
+#if __cplusplus >= 201103L
+	std::unique_ptr<CacheEntry> entry(new CacheEntry);
+#else
+	std::auto_ptr<CacheEntry> entry(new CacheEntry);
+#endif
+	entry->rate = rate;
+	Bit32u *freqMul = entry->freqMul;
+	Bit32u *linearRates = entry->linearRates;
+	Bit32u *attackRates = entry->attackRates;
 
 	//With higher octave this gets shifted up
 	//-1 since the freqCreateTable = *2
@@ -1434,12 +1452,12 @@ static const CacheEntry &ComputeRateDependent( Bit32u rate )
 		attackRates[i] = 8 << RATE_SH;
 	}
 
-	MutexHolder lock( cacheMutex );
+	MutexHolder lock( cache.mutex );
 	if (const CacheEntry *entry = CacheLookupRateDependent( rate ))
 		return *entry;
 
-	cache.push_back(entry);
-	return cache.back();
+	cache.entries.push_back(entry.get());
+	return *entry.release();
 }
 
 void Chip::Setup( Bit32u rate ) {
diff --git a/src/midi_sequencer_impl.hpp b/src/midi_sequencer_impl.hpp
index 6d6b2d8..c2654b2 100644
--- a/src/midi_sequencer_impl.hpp
+++ b/src/midi_sequencer_impl.hpp
@@ -414,6 +414,9 @@ void BW_MidiSequencer::buildSmfSetupReset(size_t trackCount)
     m_loop.reset();
     m_loop.invalidLoop = false;
 
+    m_currentPosition.began = false;
+    m_currentPosition.absTimePosition = 0.0;
+    m_currentPosition.wait = 0.0;
     m_currentPosition.track.clear();
     m_currentPosition.track.resize(trackCount);
 }
@@ -1996,6 +1999,8 @@ bool BW_MidiSequencer::loadMIDI(FileAndMemReader &fr)
     m_format = Format_MIDI;
     m_smfFormat = 0;
 
+    m_cmfInstruments.clear();
+
     const size_t headerSize = 4 + 4 + 2 + 2 + 2; // 14
     char headerBuf[headerSize] = "";