Merge branch 'master' into stable

1 files changed, 354 insertions, 181 deletions

diff --git a/src/adlmidi.cpp b/src/adlmidi.cpp
index 9210b5b..f627ce3 100644
--- a/src/adlmidi.cpp
+++ b/src/adlmidi.cpp
@@ -31,6 +31,10 @@
 #define MaxCards_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;
+
 static ADL_Version adl_version = {
     ADLMIDI_VERSION_MAJOR,
     ADLMIDI_VERSION_MINOR,
@@ -68,12 +72,23 @@ ADLMIDI_EXPORT struct ADL_MIDIPlayer *adl_init(long sample_rate)
     return midi_device;
 }
 
+ADLMIDI_EXPORT int adl_setDeviceIdentifier(ADL_MIDIPlayer *device, unsigned id)
+{
+    if(!device || id > 0x0f)
+        return -1;
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
+    if(!play)
+        return -1;
+    play->setDeviceId(id);
+    return 0;
+}
+
 ADLMIDI_EXPORT int adl_setNumChips(ADL_MIDIPlayer *device, int numCards)
 {
     if(device == NULL)
         return -2;
 
-    MIDIplay *play = reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
 #ifdef ADLMIDI_HW_OPL
     (void)numCards;
     play->m_setup.NumCards = 1;
@@ -96,7 +111,7 @@ ADLMIDI_EXPORT int adl_getNumChips(struct ADL_MIDIPlayer *device)
 {
     if(device == NULL)
         return -2;
-    MIDIplay *play = reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
     if(play)
         return (int)play->m_setup.NumCards;
     return -2;
@@ -104,19 +119,19 @@ ADLMIDI_EXPORT int adl_getNumChips(struct ADL_MIDIPlayer *device)
 
 ADLMIDI_EXPORT int adl_setBank(ADL_MIDIPlayer *device, int bank)
 {
-    #ifdef DISABLE_EMBEDDED_BANKS
+#ifdef DISABLE_EMBEDDED_BANKS
     ADL_UNUSED(device);
     ADL_UNUSED(bank);
     ADLMIDI_ErrorString = "This build of libADLMIDI has no embedded banks. Please load bank by using of adl_openBankFile() or adl_openBankData() functions instead of adl_setBank()";
     return -1;
-    #else
+#else
     const uint32_t NumBanks = static_cast<uint32_t>(maxAdlBanks());
     int32_t bankno = bank;
 
     if(bankno < 0)
         bankno = 0;
 
-    MIDIplay *play = reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
     if(static_cast<uint32_t>(bankno) >= NumBanks)
     {
         char errBuf[150];
@@ -130,7 +145,7 @@ ADLMIDI_EXPORT int adl_setBank(ADL_MIDIPlayer *device, int bank)
     play->applySetup();
 
     return adlRefreshNumCards(device);
-    #endif
+#endif
 }
 
 ADLMIDI_EXPORT int adl_getBanksCount()
@@ -147,7 +162,7 @@ ADLMIDI_EXPORT int adl_reserveBanks(ADL_MIDIPlayer *device, unsigned banks)
 {
     if(!device)
         return -1;
-    MIDIplay *play = reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
     OPL3::BankMap &map = play->opl.dynamic_banks;
     map.reserve(banks);
     return (int)map.capacity();
@@ -163,7 +178,7 @@ ADLMIDI_EXPORT int adl_getBank(ADL_MIDIPlayer *device, const ADL_BankId *idp, in
         return -1;
     unsigned idnumber = (id.msb << 8) | id.lsb | (id.percussive ? OPL3::PercussionTag : 0);
 
-    MIDIplay *play = reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
     OPL3::BankMap &map = play->opl.dynamic_banks;
 
     OPL3::BankMap::iterator it;
@@ -215,7 +230,7 @@ ADLMIDI_EXPORT int adl_removeBank(ADL_MIDIPlayer *device, ADL_Bank *bank)
     if(!device || !bank)
         return -1;
 
-    MIDIplay *play = reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
     OPL3::BankMap &map = play->opl.dynamic_banks;
     OPL3::BankMap::iterator it = OPL3::BankMap::iterator::from_ptrs(bank->pointer);
     size_t size = map.size();
@@ -228,7 +243,7 @@ ADLMIDI_EXPORT int adl_getFirstBank(ADL_MIDIPlayer *device, ADL_Bank *bank)
     if(!device)
         return -1;
 
-    MIDIplay *play = reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
     OPL3::BankMap &map = play->opl.dynamic_banks;
 
     OPL3::BankMap::iterator it = map.begin();
@@ -244,7 +259,7 @@ ADLMIDI_EXPORT int adl_getNextBank(ADL_MIDIPlayer *device, ADL_Bank *bank)
     if(!device)
         return -1;
 
-    MIDIplay *play = reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
     OPL3::BankMap &map = play->opl.dynamic_banks;
 
     OPL3::BankMap::iterator it = OPL3::BankMap::iterator::from_ptrs(bank->pointer);
@@ -283,7 +298,7 @@ ADLMIDI_EXPORT int adl_setNumFourOpsChn(ADL_MIDIPlayer *device, int ops4)
 {
     if(!device)
         return -1;
-    MIDIplay *play = reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
     if((unsigned int)ops4 > 6 * play->m_setup.NumCards)
     {
         char errBuff[250];
@@ -302,7 +317,7 @@ ADLMIDI_EXPORT int adl_getNumFourOpsChn(struct ADL_MIDIPlayer *device)
 {
     if(!device)
         return -1;
-    MIDIplay *play = reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
     if(play)
         return (int)play->m_setup.NumFourOps;
     return -1;
@@ -311,7 +326,7 @@ ADLMIDI_EXPORT int adl_getNumFourOpsChn(struct ADL_MIDIPlayer *device)
 ADLMIDI_EXPORT void adl_setPercMode(ADL_MIDIPlayer *device, int percmod)
 {
     if(!device) return;
-    MIDIplay *play = reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
     play->m_setup.AdlPercussionMode = percmod;
     play->opl.AdlPercussionMode     = play->m_setup.AdlPercussionMode < 0 ?
                                       play->opl.dynamic_bank_setup.adLibPercussions :
@@ -322,7 +337,7 @@ ADLMIDI_EXPORT void adl_setPercMode(ADL_MIDIPlayer *device, int percmod)
 ADLMIDI_EXPORT void adl_setHVibrato(ADL_MIDIPlayer *device, int hvibro)
 {
     if(!device) return;
-    MIDIplay *play = reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
     play->m_setup.HighVibratoMode = hvibro;
     play->opl.HighVibratoMode     = play->m_setup.HighVibratoMode < 0 ?
                                     play->opl.dynamic_bank_setup.deepVibrato :
@@ -333,7 +348,7 @@ ADLMIDI_EXPORT void adl_setHVibrato(ADL_MIDIPlayer *device, int hvibro)
 ADLMIDI_EXPORT void adl_setHTremolo(ADL_MIDIPlayer *device, int htremo)
 {
     if(!device) return;
-    MIDIplay *play = reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
     play->m_setup.HighTremoloMode = htremo;
     play->opl.HighTremoloMode     = play->m_setup.HighTremoloMode < 0 ?
                                     play->opl.dynamic_bank_setup.deepTremolo :
@@ -343,8 +358,11 @@ ADLMIDI_EXPORT void adl_setHTremolo(ADL_MIDIPlayer *device, int htremo)
 
 ADLMIDI_EXPORT void adl_setScaleModulators(ADL_MIDIPlayer *device, int smod)
 {
-    if(!device) return;
-    MIDIplay *play = reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
+    if(!device)
+        return;
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
+    if(!play)
+        return;
     play->m_setup.ScaleModulators = smod;
     play->opl.ScaleModulators     = play->m_setup.ScaleModulators < 0 ?
                                     play->opl.dynamic_bank_setup.scaleModulators :
@@ -353,23 +371,36 @@ ADLMIDI_EXPORT void adl_setScaleModulators(ADL_MIDIPlayer *device, int smod)
 
 ADLMIDI_EXPORT void adl_setFullRangeBrightness(struct ADL_MIDIPlayer *device, int fr_brightness)
 {
-    if(!device) return;
-    MIDIplay *play = reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
+    if(!device)
+        return;
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
+    if(!play)
+        return;
     play->m_setup.fullRangeBrightnessCC74 = (fr_brightness != 0);
 }
 
 ADLMIDI_EXPORT void adl_setLoopEnabled(ADL_MIDIPlayer *device, int loopEn)
 {
-    if(!device) return;
-    MIDIplay *play = reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
-    play->m_setup.loopingIsEnabled = (loopEn != 0);
+    if(!device)
+        return;
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
+    if(!play)
+        return;
+#ifndef ADLMIDI_DISABLE_MIDI_SEQUENCER
+    play->m_sequencer.setLoopEnabled(loopEn != 0);
+#else
+    ADL_UNUSED(loopEn);
+#endif
 }
 
 /* !!!DEPRECATED!!! */
 ADLMIDI_EXPORT void adl_setLogarithmicVolumes(struct ADL_MIDIPlayer *device, int logvol)
 {
-    if(!device) return;
-    MIDIplay *play = reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
+    if(!device)
+        return;
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
+    if(!play)
+        return;
     play->m_setup.LogarithmicVolumes = (logvol != 0);
     if(play->m_setup.LogarithmicVolumes)
         play->opl.ChangeVolumeRangesModel(ADLMIDI_VolumeModel_NativeOPL3);
@@ -379,8 +410,11 @@ ADLMIDI_EXPORT void adl_setLogarithmicVolumes(struct ADL_MIDIPlayer *device, int
 
 ADLMIDI_EXPORT void adl_setVolumeRangeModel(struct ADL_MIDIPlayer *device, int volumeModel)
 {
-    if(!device) return;
-    MIDIplay *play = reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
+    if(!device)
+        return;
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
+    if(!play)
+        return;
     play->m_setup.VolumeModel = volumeModel;
     if(play->m_setup.VolumeModel == ADLMIDI_VolumeModel_AUTO)//Use bank default volume model
         play->opl.m_volumeScale = (OPL3::VolumesScale)play->opl.dynamic_bank_setup.volumeModel;
@@ -392,7 +426,7 @@ ADLMIDI_EXPORT int adl_openBankFile(struct ADL_MIDIPlayer *device, const char *f
 {
     if(device && device->adl_midiPlayer)
     {
-        MIDIplay *play = reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
+        MidiPlayer *play = GET_MIDI_PLAYER(device);
         play->m_setup.tick_skip_samples_delay = 0;
         if(!play->LoadBank(filePath))
         {
@@ -412,7 +446,9 @@ ADLMIDI_EXPORT int adl_openBankData(struct ADL_MIDIPlayer *device, const void *m
 {
     if(device && device->adl_midiPlayer)
     {
-        MIDIplay *play = reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
+        MidiPlayer *play = GET_MIDI_PLAYER(device);
+        if(!play)
+            return -1;
         play->m_setup.tick_skip_samples_delay = 0;
         if(!play->LoadBank(mem, static_cast<size_t>(size)))
         {
@@ -432,7 +468,9 @@ ADLMIDI_EXPORT int adl_openFile(ADL_MIDIPlayer *device, const char *filePath)
 {
     if(device && device->adl_midiPlayer)
     {
-        MIDIplay *play = reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
+        MidiPlayer *play = GET_MIDI_PLAYER(device);
+        if(!play)
+            return -1;
 #ifndef ADLMIDI_DISABLE_MIDI_SEQUENCER
         play->m_setup.tick_skip_samples_delay = 0;
         if(!play->LoadMIDI(filePath))
@@ -444,7 +482,7 @@ ADLMIDI_EXPORT int adl_openFile(ADL_MIDIPlayer *device, const char *filePath)
         }
         else return 0;
 #else
-        (void)filePath;
+        ADL_UNUSED(filePath);
         play->setErrorString("ADLMIDI: MIDI Sequencer is not supported in this build of library!");
         return -1;
 #endif //ADLMIDI_DISABLE_MIDI_SEQUENCER
@@ -458,7 +496,9 @@ ADLMIDI_EXPORT int adl_openData(ADL_MIDIPlayer *device, const void *mem, unsigne
 {
     if(device && device->adl_midiPlayer)
     {
-        MIDIplay *play = reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
+        MidiPlayer *play = GET_MIDI_PLAYER(device);
+        if(!play)
+            return -1;
 #ifndef ADLMIDI_DISABLE_MIDI_SEQUENCER
         play->m_setup.tick_skip_samples_delay = 0;
         if(!play->LoadMIDI(mem, static_cast<size_t>(size)))
@@ -470,7 +510,8 @@ ADLMIDI_EXPORT int adl_openData(ADL_MIDIPlayer *device, const void *mem, unsigne
         }
         else return 0;
 #else
-        (void)mem;(void)size;
+        ADL_UNUSED(mem);
+        ADL_UNUSED(size);
         play->setErrorString("ADLMIDI: MIDI Sequencer is not supported in this build of library!");
         return -1;
 #endif //ADLMIDI_DISABLE_MIDI_SEQUENCER
@@ -489,13 +530,13 @@ ADLMIDI_EXPORT const char *adl_chipEmulatorName(struct ADL_MIDIPlayer *device)
 {
     if(device)
     {
-        #ifndef ADLMIDI_HW_OPL
-        MIDIplay *play = reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
+#ifndef ADLMIDI_HW_OPL
+        MidiPlayer *play = GET_MIDI_PLAYER(device);
         if(play && !play->opl.cardsOP2.empty())
             return play->opl.cardsOP2[0]->emulatorName();
         #else
         return "Hardware OPL3 chip on 0x330";
-        #endif
+#endif
     }
     return "Unknown";
 }
@@ -504,8 +545,11 @@ ADLMIDI_EXPORT int adl_switchEmulator(struct ADL_MIDIPlayer *device, int emulato
 {
     if(device)
     {
-        MIDIplay *play = reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
-        if(play && (emulator >= 0) && (emulator < ADLMIDI_EMU_end))
+        MidiPlayer *play = GET_MIDI_PLAYER(device);
+        assert(play);
+        if(!play)
+            return -1;
+        if((emulator >= 0) && (emulator < ADLMIDI_EMU_end))
         {
             play->m_setup.emulator = emulator;
             adl_reset(device);
@@ -521,7 +565,7 @@ ADLMIDI_EXPORT int adl_setRunAtPcmRate(ADL_MIDIPlayer *device, int enabled)
 {
     if(device)
     {
-        MIDIplay *play = reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
+        MidiPlayer *play = GET_MIDI_PLAYER(device);
         if(play)
         {
             play->m_setup.runAtPcmRate = (enabled != 0);
@@ -556,7 +600,7 @@ ADLMIDI_EXPORT const char *adl_errorInfo(struct ADL_MIDIPlayer *device)
 {
     if(!device)
         return adl_errorString();
-    MIDIplay *play = reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
     if(!play)
         return adl_errorString();
     return play->getErrorString().c_str();
@@ -564,22 +608,16 @@ ADLMIDI_EXPORT const char *adl_errorInfo(struct ADL_MIDIPlayer *device)
 
 ADLMIDI_EXPORT const char *adl_getMusicTitle(struct ADL_MIDIPlayer *device)
 {
-    if(!device)
-        return "";
-    MIDIplay *play = reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
-    if(!play)
-        return "";
-    #ifndef ADLMIDI_DISABLE_MIDI_SEQUENCER
-    return play->musTitle.c_str();
-    #else
-    return "";
-    #endif
+    return adl_metaMusicTitle(device);
 }
 
 ADLMIDI_EXPORT void adl_close(struct ADL_MIDIPlayer *device)
 {
-    if(device->adl_midiPlayer)
-        delete reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
+    if(!device)
+        return;
+    MIDIplay * play = reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
+    if(play)
+        delete play;
     device->adl_midiPlayer = NULL;
     free(device);
     device = NULL;
@@ -589,7 +627,7 @@ ADLMIDI_EXPORT void adl_reset(struct ADL_MIDIPlayer *device)
 {
     if(!device)
         return;
-    MIDIplay *play = reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
     play->m_setup.tick_skip_samples_delay = 0;
     play->opl.runAtPcmRate = play->m_setup.runAtPcmRate;
     play->opl.Reset(play->m_setup.emulator, play->m_setup.PCM_RATE, play);
@@ -599,121 +637,173 @@ ADLMIDI_EXPORT void adl_reset(struct ADL_MIDIPlayer *device)
 
 ADLMIDI_EXPORT double adl_totalTimeLength(struct ADL_MIDIPlayer *device)
 {
+#ifndef ADLMIDI_DISABLE_MIDI_SEQUENCER
     if(!device)
         return -1.0;
-    #ifndef ADLMIDI_DISABLE_MIDI_SEQUENCER
-    return reinterpret_cast<MIDIplay *>(device->adl_midiPlayer)->timeLength();
-    #else
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
+    if(!play)
+        return -1.0;
+    return play->m_sequencer.timeLength();
+#else
+    ADL_UNUSED(device);
     return -1.0;
-    #endif
+#endif
 }
 
 ADLMIDI_EXPORT double adl_loopStartTime(struct ADL_MIDIPlayer *device)
 {
+#ifndef ADLMIDI_DISABLE_MIDI_SEQUENCER
     if(!device)
         return -1.0;
-    #ifndef ADLMIDI_DISABLE_MIDI_SEQUENCER
-    return reinterpret_cast<MIDIplay *>(device->adl_midiPlayer)->getLoopStart();
-    #else
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
+    if(!play)
+        return -1.0;
+    return play->m_sequencer.getLoopStart();
+#else
+    ADL_UNUSED(device);
     return -1.0;
-    #endif
+#endif
 }
 
 ADLMIDI_EXPORT double adl_loopEndTime(struct ADL_MIDIPlayer *device)
 {
+#ifndef ADLMIDI_DISABLE_MIDI_SEQUENCER
     if(!device)
         return -1.0;
-    #ifndef ADLMIDI_DISABLE_MIDI_SEQUENCER
-    return reinterpret_cast<MIDIplay *>(device->adl_midiPlayer)->getLoopEnd();
-    #else
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
+    if(!play)
+        return -1.0;
+    return play->m_sequencer.getLoopEnd();
+#else
+    ADL_UNUSED(device);
     return -1.0;
-    #endif
+#endif
 }
 
 ADLMIDI_EXPORT double adl_positionTell(struct ADL_MIDIPlayer *device)
 {
+#ifndef ADLMIDI_DISABLE_MIDI_SEQUENCER
     if(!device)
         return -1.0;
-    #ifndef ADLMIDI_DISABLE_MIDI_SEQUENCER
-    return reinterpret_cast<MIDIplay *>(device->adl_midiPlayer)->tell();
-    #else
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
+    if(!play)
+        return -1.0;
+    return play->m_sequencer.tell();
+#else
+    ADL_UNUSED(device);
     return -1.0;
-    #endif
+#endif
 }
 
 ADLMIDI_EXPORT void adl_positionSeek(struct ADL_MIDIPlayer *device, double seconds)
 {
+#ifndef ADLMIDI_DISABLE_MIDI_SEQUENCER
+    if(seconds < 0.0)
+        return;//Seeking negative position is forbidden! :-P
     if(!device)
         return;
-    #ifndef ADLMIDI_DISABLE_MIDI_SEQUENCER
-    reinterpret_cast<MIDIplay *>(device->adl_midiPlayer)->seek(seconds);
-    #endif
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
+    if(!play)
+        return;
+    play->realTime_panic();
+    play->m_setup.delay = play->m_sequencer.seek(seconds, play->m_setup.mindelay);
+    play->m_setup.carry = 0.0;
+#else
+    ADL_UNUSED(device);
+    ADL_UNUSED(seconds);
+#endif
 }
 
 ADLMIDI_EXPORT void adl_positionRewind(struct ADL_MIDIPlayer *device)
 {
+#ifndef ADLMIDI_DISABLE_MIDI_SEQUENCER
     if(!device)
         return;
-    #ifndef ADLMIDI_DISABLE_MIDI_SEQUENCER
-    reinterpret_cast<MIDIplay *>(device->adl_midiPlayer)->rewind();
-    #endif
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
+    if(!play)
+        return;
+    play->realTime_panic();
+    play->m_sequencer.rewind();
+#else
+    ADL_UNUSED(device);
+#endif
 }
 
 ADLMIDI_EXPORT void adl_setTempo(struct ADL_MIDIPlayer *device, double tempo)
 {
+#ifndef ADLMIDI_DISABLE_MIDI_SEQUENCER
     if(!device || (tempo <= 0.0))
         return;
-    #ifndef ADLMIDI_DISABLE_MIDI_SEQUENCER
-    reinterpret_cast<MIDIplay *>(device->adl_midiPlayer)->setTempo(tempo);
-    #endif
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
+    if(!play)
+        return;
+    play->m_sequencer.setTempo(tempo);
+#else
+    ADL_UNUSED(device);
+    ADL_UNUSED(tempo);
+#endif
 }
 
 
 ADLMIDI_EXPORT const char *adl_metaMusicTitle(struct ADL_MIDIPlayer *device)
 {
+#ifndef ADLMIDI_DISABLE_MIDI_SEQUENCER
     if(!device)
         return "";
-    #ifndef ADLMIDI_DISABLE_MIDI_SEQUENCER
-    return reinterpret_cast<MIDIplay *>(device->adl_midiPlayer)->musTitle.c_str();
-    #else
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
+    if(!play)
+        return "";
+    return play->m_sequencer.getMusicTitle().c_str();
+#else
+    ADL_UNUSED(device);
     return "";
-    #endif
+#endif
 }
 
 
 ADLMIDI_EXPORT const char *adl_metaMusicCopyright(struct ADL_MIDIPlayer *device)
 {
+#ifndef ADLMIDI_DISABLE_MIDI_SEQUENCER
     if(!device)
         return "";
-    #ifndef ADLMIDI_DISABLE_MIDI_SEQUENCER
-    return reinterpret_cast<MIDIplay *>(device->adl_midiPlayer)->musCopyright.c_str();
-    #else
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
+    if(!play)
+        return "";
+    return play->m_sequencer.getMusicCopyright().c_str();
+#else
+    ADL_UNUSED(device);
     return "";
-    #endif
+#endif
 }
 
 ADLMIDI_EXPORT size_t adl_metaTrackTitleCount(struct ADL_MIDIPlayer *device)
 {
+#ifndef ADLMIDI_DISABLE_MIDI_SEQUENCER
     if(!device)
         return 0;
-#ifndef ADLMIDI_DISABLE_MIDI_SEQUENCER
-    return reinterpret_cast<MIDIplay *>(device->adl_midiPlayer)->musTrackTitles.size();
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
+    if(!play)
+        return 0;
+    return play->m_sequencer.getTrackTitles().size();
 #else
+    ADL_UNUSED(device);
     return 0;
 #endif
 }
 
 ADLMIDI_EXPORT const char *adl_metaTrackTitle(struct ADL_MIDIPlayer *device, size_t index)
 {
-    if(!device)
-        return 0;
 #ifndef ADLMIDI_DISABLE_MIDI_SEQUENCER
-    MIDIplay *play = reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
-    if(index >= play->musTrackTitles.size())
+    if(!device)
+        return "";
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
+    const std::vector<std::string> &titles = play->m_sequencer.getTrackTitles();
+    if(index >= titles.size())
         return "INVALID";
-    return play->musTrackTitles[index].c_str();
+    return titles[index].c_str();
 #else
-    (void)device; (void)index;
+    ADL_UNUSED(device);
+    ADL_UNUSED(index);
     return "NOT SUPPORTED";
 #endif
 }
@@ -721,11 +811,15 @@ ADLMIDI_EXPORT const char *adl_metaTrackTitle(struct ADL_MIDIPlayer *device, siz
 
 ADLMIDI_EXPORT size_t adl_metaMarkerCount(struct ADL_MIDIPlayer *device)
 {
+#ifndef ADLMIDI_DISABLE_MIDI_SEQUENCER
     if(!device)
         return 0;
-#ifndef ADLMIDI_DISABLE_MIDI_SEQUENCER
-    return reinterpret_cast<MIDIplay *>(device->adl_midiPlayer)->musMarkers.size();
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
+    if(!play)
+        return 0;
+    return play->m_sequencer.getMarkers().size();
 #else
+    ADL_UNUSED(device);
     return 0;
 #endif
 }
@@ -733,9 +827,10 @@ ADLMIDI_EXPORT size_t adl_metaMarkerCount(struct ADL_MIDIPlayer *device)
 ADLMIDI_EXPORT Adl_MarkerEntry adl_metaMarker(struct ADL_MIDIPlayer *device, size_t index)
 {
     struct Adl_MarkerEntry marker;
-    #ifndef ADLMIDI_DISABLE_MIDI_SEQUENCER
-    MIDIplay *play = reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
-    if(!device || !play || (index >= play->musMarkers.size()))
+#ifndef ADLMIDI_DISABLE_MIDI_SEQUENCER
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
+    const std::vector<MidiSequencer::MIDI_MarkerEntry> &markers = play->m_sequencer.getMarkers();
+    if(!device || !play || (index >= markers.size()))
     {
         marker.label = "INVALID";
         marker.pos_time = 0.0;
@@ -744,27 +839,34 @@ ADLMIDI_EXPORT Adl_MarkerEntry adl_metaMarker(struct ADL_MIDIPlayer *device, siz
     }
     else
     {
-        MIDIplay::MIDI_MarkerEntry &mk = play->musMarkers[index];
+        const MidiSequencer::MIDI_MarkerEntry &mk = markers[index];
         marker.label = mk.label.c_str();
         marker.pos_time = mk.pos_time;
         marker.pos_ticks = (unsigned long)mk.pos_ticks;
     }
-    #else
-    (void)device; (void)index;
+#else
+    ADL_UNUSED(device);
+    ADL_UNUSED(index);
     marker.label = "NOT SUPPORTED";
     marker.pos_time = 0.0;
     marker.pos_ticks = 0;
-    #endif
+#endif
     return marker;
 }
 
 ADLMIDI_EXPORT void adl_setRawEventHook(struct ADL_MIDIPlayer *device, ADL_RawEventHook rawEventHook, void *userData)
 {
+#ifndef ADLMIDI_DISABLE_MIDI_SEQUENCER
     if(!device)
         return;
-    MIDIplay *play = reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
-    play->hooks.onEvent = rawEventHook;
-    play->hooks.onEvent_userData = userData;
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
+    play->m_sequencerInterface.onEvent = rawEventHook;
+    play->m_sequencerInterface.onEvent_userData = userData;
+#else
+    ADL_UNUSED(device);
+    ADL_UNUSED(rawEventHook);
+    ADL_UNUSED(userData);
+#endif
 }
 
 /* Set note hook */
@@ -772,7 +874,7 @@ ADLMIDI_EXPORT void adl_setNoteHook(struct ADL_MIDIPlayer *device, ADL_NoteHook
 {
     if(!device)
         return;
-    MIDIplay *play = reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
     play->hooks.onNote = noteHook;
     play->hooks.onNote_userData = userData;
 }
@@ -782,12 +884,18 @@ ADLMIDI_EXPORT void adl_setDebugMessageHook(struct ADL_MIDIPlayer *device, ADL_D
 {
     if(!device)
         return;
-    MIDIplay *play = reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
     play->hooks.onDebugMessage = debugMessageHook;
     play->hooks.onDebugMessage_userData = userData;
+#ifndef ADLMIDI_DISABLE_MIDI_SEQUENCER
+    play->m_sequencerInterface.onDebugMessage = debugMessageHook;
+    play->m_sequencerInterface.onDebugMessage_userData = userData;
+#endif
 }
 
 #ifndef ADLMIDI_HW_OPL
+
+#   ifndef __WATCOMC__
 template <class Dst>
 static void CopySamplesRaw(ADL_UInt8 *dstLeft, ADL_UInt8 *dstRight, const int32_t *src,
                            size_t frameCount, unsigned sampleOffset)
@@ -919,7 +1027,61 @@ static int SendStereoAudio(int        samples_requested,
 
     return 0;
 }
-#endif
+#   else // __WATCOMC__
+
+/*
+    Workaround for OpenWattcom where templates are declared above are causing compiler to be crashed
+*/
+static void CopySamplesTransformed(ADL_UInt8 *dstLeft, ADL_UInt8 *dstRight, const int32_t *src,
+                                   size_t frameCount, unsigned sampleOffset,
+                                   int32_t(&transform)(int32_t))
+{
+    for(size_t i = 0; i < frameCount; ++i) {
+        *(int16_t *)(dstLeft + (i * sampleOffset)) = (int16_t)transform(src[2 * i]);
+        *(int16_t *)(dstRight + (i * sampleOffset)) = (int16_t)transform(src[(2 * i) + 1]);
+    }
+}
+
+static int SendStereoAudio(int        samples_requested,
+                           ssize_t    in_size,
+                           int32_t   *_in,
+                           ssize_t    out_pos,
+                           ADL_UInt8 *left,
+                           ADL_UInt8 *right,
+                           const ADLMIDI_AudioFormat *format)
+{
+    if(!in_size)
+        return 0;
+    size_t outputOffset = static_cast<size_t>(out_pos);
+    size_t inSamples    = static_cast<size_t>(in_size * 2);
+    size_t maxSamples   = static_cast<size_t>(samples_requested) - outputOffset;
+    size_t toCopy       = std::min(maxSamples, inSamples);
+
+    ADLMIDI_SampleType sampleType = format->type;
+    const unsigned containerSize = format->containerSize;
+    const unsigned sampleOffset = format->sampleOffset;
+
+    left  += (outputOffset / 2) * sampleOffset;
+    right += (outputOffset / 2) * sampleOffset;
+
+    if(sampleType == ADLMIDI_SampleType_U16)
+    {
+        switch(containerSize) {
+        case sizeof(int16_t):
+            CopySamplesTransformed(left, right, _in, toCopy / 2, sampleOffset, adl_cvtS16);
+            break;
+        default:
+            return -1;
+        }
+    }
+    else
+        return -1;
+    return 0;
+}
+#   endif // __WATCOM__
+
+#endif // ADLMIDI_HW_OPL
+
 
 ADLMIDI_EXPORT int adl_play(struct ADL_MIDIPlayer *device, int sampleCount, short *out)
 {
@@ -930,23 +1092,24 @@ ADLMIDI_EXPORT int adl_playFormat(ADL_MIDIPlayer *device, int sampleCount,
                                   ADL_UInt8 *out_left, ADL_UInt8 *out_right,
                                   const ADLMIDI_AudioFormat *format)
 {
-    #ifndef ADLMIDI_DISABLE_MIDI_SEQUENCER
-    #ifdef ADLMIDI_HW_OPL
-    (void)device;
-    (void)sampleCount;
-    (void)out_left;
-    (void)out_right;
-    (void)format;
+#if defined(ADLMIDI_DISABLE_MIDI_SEQUENCER) || defined(ADLMIDI_HW_OPL)
+    ADL_UNUSED(device);
+    ADL_UNUSED(sampleCount);
+    ADL_UNUSED(out_left);
+    ADL_UNUSED(out_right);
+    ADL_UNUSED(format);
     return 0;
-    #else
+#endif
+
+#if !defined(ADLMIDI_DISABLE_MIDI_SEQUENCER) && !defined(ADLMIDI_HW_OPL)
     sampleCount -= sampleCount % 2; //Avoid even sample requests
     if(sampleCount < 0)
         return 0;
     if(!device)
         return 0;
 
-    MIDIplay *player = reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
-    MIDIplay::Setup &setup = player->m_setup;
+    MidiPlayer *player = GET_MIDI_PLAYER(device);
+    MidiPlayer::Setup &setup = player->m_setup;
 
     ssize_t gotten_len = 0;
     ssize_t n_periodCountStereo = 512;
@@ -975,7 +1138,7 @@ ADLMIDI_EXPORT int adl_playFormat(ADL_MIDIPlayer *device, int sampleCount,
             //    setup.SkipForward -= 1;
             //else
             {
-                if((player->atEnd) && (setup.delay <= 0.0))
+                if((player->m_sequencer.positionAtEnd()) && (setup.delay <= 0.0))
                     break;//Stop to fetch samples at reaching the song end with disabled loop
 
                 ssize_t leftSamples = left / 2;
@@ -1024,10 +1187,7 @@ ADLMIDI_EXPORT int adl_playFormat(ADL_MIDIPlayer *device, int sampleCount,
     }
 
     return static_cast<int>(gotten_len);
-    #endif
-    #else
-    return 0;
-    #endif //ADLMIDI_DISABLE_MIDI_SEQUENCER
+#endif //ADLMIDI_DISABLE_MIDI_SEQUENCER
 }
 
 
@@ -1040,22 +1200,22 @@ ADLMIDI_EXPORT int adl_generateFormat(struct ADL_MIDIPlayer *device, int sampleC
                                       ADL_UInt8 *out_left, ADL_UInt8 *out_right,
                                       const ADLMIDI_AudioFormat *format)
 {
-    #ifdef ADLMIDI_HW_OPL
-    (void)device;
-    (void)sampleCount;
-    (void)out_left;
-    (void)out_right;
-    (void)format;
+#ifdef ADLMIDI_HW_OPL
+    ADL_UNUSED(device);
+    ADL_UNUSED(sampleCount);
+    ADL_UNUSED(out_left);
+    ADL_UNUSED(out_right);
+    ADL_UNUSED(format);
     return 0;
-    #else
+#else
     sampleCount -= sampleCount % 2; //Avoid even sample requests
     if(sampleCount < 0)
         return 0;
     if(!device)
         return 0;
 
-    MIDIplay *player = reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
-    MIDIplay::Setup &setup = player->m_setup;
+    MidiPlayer *player = GET_MIDI_PLAYER(device);
+    MidiPlayer::Setup &setup = player->m_setup;
 
     ssize_t gotten_len = 0;
     ssize_t n_periodCountStereo = 512;
@@ -1101,12 +1261,12 @@ ADLMIDI_EXPORT int adl_generateFormat(struct ADL_MIDIPlayer *device, int sampleC
                 gotten_len += (in_generatedPhys) /* - setup.stored_samples*/;
             }
 
-            player->TickIteratos(eat_delay);
+            player->TickIterators(eat_delay);
         }//...
     }
 
     return static_cast<int>(gotten_len);
-    #endif
+#endif
 }
 
 ADLMIDI_EXPORT double adl_tickEvents(struct ADL_MIDIPlayer *device, double seconds, double granuality)
@@ -1114,12 +1274,14 @@ ADLMIDI_EXPORT double adl_tickEvents(struct ADL_MIDIPlayer *device, double secon
 #ifndef ADLMIDI_DISABLE_MIDI_SEQUENCER
     if(!device)
         return -1.0;
-    MIDIplay *player = reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
-    if(!player)
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
+    if(!play)
         return -1.0;
-    return player->Tick(seconds, granuality);
+    return play->Tick(seconds, granuality);
 #else
-    (void)seconds; (void)granuality;
+    ADL_UNUSED(device);
+    ADL_UNUSED(seconds);
+    ADL_UNUSED(granuality);
     return -1.0;
 #endif
 }
@@ -1129,11 +1291,12 @@ ADLMIDI_EXPORT int adl_atEnd(struct ADL_MIDIPlayer *device)
 #ifndef ADLMIDI_DISABLE_MIDI_SEQUENCER
     if(!device)
         return 1;
-    MIDIplay *player = reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
-    if(!player)
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
+    if(!play)
         return 1;
-    return (int)player->atEnd;
+    return (int)play->m_sequencer.positionAtEnd();
 #else
+    ADL_UNUSED(device);
     return 1;
 #endif
 }
@@ -1142,128 +1305,138 @@ ADLMIDI_EXPORT void adl_panic(struct ADL_MIDIPlayer *device)
 {
     if(!device)
         return;
-    MIDIplay *player = reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
-    if(!player)
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
+    if(!play)
         return;
-    player->realTime_panic();
+    play->realTime_panic();
 }
 
 ADLMIDI_EXPORT void adl_rt_resetState(struct ADL_MIDIPlayer *device)
 {
     if(!device)
         return;
-    MIDIplay *player = reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
-    if(!player)
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
+    if(!play)
         return;
-    player->realTime_ResetState();
+    play->realTime_ResetState();
 }
 
 ADLMIDI_EXPORT int adl_rt_noteOn(struct ADL_MIDIPlayer *device, ADL_UInt8 channel, ADL_UInt8 note, ADL_UInt8 velocity)
 {
     if(!device)
         return 0;
-    MIDIplay *player = reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
-    if(!player)
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
+    if(!play)
         return 0;
-    return (int)player->realTime_NoteOn(channel, note, velocity);
+    return (int)play->realTime_NoteOn(channel, note, velocity);
 }
 
 ADLMIDI_EXPORT void adl_rt_noteOff(struct ADL_MIDIPlayer *device, ADL_UInt8 channel, ADL_UInt8 note)
 {
     if(!device)
         return;
-    MIDIplay *player = reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
-    if(!player)
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
+    if(!play)
         return;
-    player->realTime_NoteOff(channel, note);
+    play->realTime_NoteOff(channel, note);
 }
 
 ADLMIDI_EXPORT void adl_rt_noteAfterTouch(struct ADL_MIDIPlayer *device, ADL_UInt8 channel, ADL_UInt8 note, ADL_UInt8 atVal)
 {
     if(!device)
         return;
-    MIDIplay *player = reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
-    if(!player)
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
+    if(!play)
         return;
-    player->realTime_NoteAfterTouch(channel, note, atVal);
+    play->realTime_NoteAfterTouch(channel, note, atVal);
 }
 
 ADLMIDI_EXPORT void adl_rt_channelAfterTouch(struct ADL_MIDIPlayer *device, ADL_UInt8 channel, ADL_UInt8 atVal)
 {
     if(!device)
         return;
-    MIDIplay *player = reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
-    if(!player)
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
+    if(!play)
         return;
-    player->realTime_ChannelAfterTouch(channel, atVal);
+    play->realTime_ChannelAfterTouch(channel, atVal);
 }
 
 ADLMIDI_EXPORT void adl_rt_controllerChange(struct ADL_MIDIPlayer *device, ADL_UInt8 channel, ADL_UInt8 type, ADL_UInt8 value)
 {
     if(!device)
         return;
-    MIDIplay *player = reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
-    if(!player)
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
+    if(!play)
         return;
-    player->realTime_Controller(channel, type, value);
+    play->realTime_Controller(channel, type, value);
 }
 
 ADLMIDI_EXPORT void adl_rt_patchChange(struct ADL_MIDIPlayer *device, ADL_UInt8 channel, ADL_UInt8 patch)
 {
     if(!device)
         return;
-    MIDIplay *player = reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
-    if(!player)
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
+    if(!play)
         return;
-    player->realTime_PatchChange(channel, patch);
+    play->realTime_PatchChange(channel, patch);
 }
 
 ADLMIDI_EXPORT void adl_rt_pitchBend(struct ADL_MIDIPlayer *device, ADL_UInt8 channel, ADL_UInt16 pitch)
 {
     if(!device)
         return;
-    MIDIplay *player = reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
-    if(!player)
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
+    if(!play)
         return;
-    player->realTime_PitchBend(channel, pitch);
+    play->realTime_PitchBend(channel, pitch);
 }
 
 ADLMIDI_EXPORT void adl_rt_pitchBendML(struct ADL_MIDIPlayer *device, ADL_UInt8 channel, ADL_UInt8 msb, ADL_UInt8 lsb)
 {
     if(!device)
         return;
-    MIDIplay *player = reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
-    if(!player)
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
+    if(!play)
         return;
-    player->realTime_PitchBend(channel, msb, lsb);
+    play->realTime_PitchBend(channel, msb, lsb);
 }
 
 ADLMIDI_EXPORT void adl_rt_bankChangeLSB(struct ADL_MIDIPlayer *device, ADL_UInt8 channel, ADL_UInt8 lsb)
 {
     if(!device)
         return;
-    MIDIplay *player = reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
-    if(!player)
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
+    if(!play)
         return;
-    player->realTime_BankChangeLSB(channel, lsb);
+    play->realTime_BankChangeLSB(channel, lsb);
 }
 
 ADLMIDI_EXPORT void adl_rt_bankChangeMSB(struct ADL_MIDIPlayer *device, ADL_UInt8 channel, ADL_UInt8 msb)
 {
     if(!device)
         return;
-    MIDIplay *player = reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
-    if(!player)
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
+    if(!play)
         return;
-    player->realTime_BankChangeMSB(channel, msb);
+    play->realTime_BankChangeMSB(channel, msb);
 }
 
 ADLMIDI_EXPORT void adl_rt_bankChange(struct ADL_MIDIPlayer *device, ADL_UInt8 channel, ADL_SInt16 bank)
 {
     if(!device)
         return;
-    MIDIplay *player = reinterpret_cast<MIDIplay *>(device->adl_midiPlayer);
-    if(!player)
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
+    if(!play)
         return;
-    player->realTime_BankChange(channel, (uint16_t)bank);
+    play->realTime_BankChange(channel, (uint16_t)bank);
+}
+
+ADLMIDI_EXPORT int adl_rt_systemExclusive(struct ADL_MIDIPlayer *device, const ADL_UInt8 *msg, size_t size)
+{
+    if(!device)
+        return -1;
+    MidiPlayer *play = GET_MIDI_PLAYER(device);
+    if(!play)
+        return -1;
+    return play->realTime_SysEx(msg, size);
 }