add SongState::DetectVersion for much less hacky version-detection

driver/amuseconv.cpp

@@ -72,8 +72,9 @@ static bool ExtractAudioGroup(const amuse::SystemString& inPath, const amuse::Sy
         if (fp)
         {
             Log.report(logvisor::Info, _S("Extracting %s"), pair.first.c_str());
-            amuse::SongConverter::Target extractedTarget;
-            std::vector<uint8_t> mid = amuse::SongConverter::SongToMIDI(pair.second.m_data.get(), extractedTarget);
+            int extractedVersion;
+            bool isBig;
+            std::vector<uint8_t> mid = amuse::SongConverter::SongToMIDI(pair.second.m_data.get(), extractedVersion, isBig);
             fwrite(mid.data(), 1, mid.size(), fp);
             fclose(fp);
         }
@@ -82,7 +83,7 @@ static bool ExtractAudioGroup(const amuse::SystemString& inPath, const amuse::Sy
     return true;
 }
 
-static bool BuildSNG(const amuse::SystemString& inPath, const amuse::SystemString& targetPath, amuse::SongConverter::Target target)
+static bool BuildSNG(const amuse::SystemString& inPath, const amuse::SystemString& targetPath, int version, bool big)
 {
     FILE* fp = amuse::FOpen(inPath.c_str(), _S("rb"));
     if (!fp)
@@ -95,7 +96,7 @@ static bool BuildSNG(const amuse::SystemString& inPath, const amuse::SystemStrin
     fread(&data[0], 1, sz, fp);
     fclose(fp);
 
-    std::vector<uint8_t> out = amuse::SongConverter::MIDIToSong(data, target);
+    std::vector<uint8_t> out = amuse::SongConverter::MIDIToSong(data, version, big);
     if (out.empty())
         return false;
 
@@ -119,13 +120,12 @@ static bool ExtractSNG(const amuse::SystemString& inPath, const amuse::SystemStr
     fread(&data[0], 1, sz, fp);
     fclose(fp);
 
-    amuse::SongConverter::Target target;
-    std::vector<uint8_t> out = amuse::SongConverter::SongToMIDI(data.data(), target);
+    int extractedVersion;
+    bool isBig;
+    std::vector<uint8_t> out = amuse::SongConverter::SongToMIDI(data.data(), extractedVersion, isBig);
     if (out.empty())
         return false;
 
-    ReportConvType(ConvType(target));
-
     fp = amuse::FOpen(targetPath.c_str(), _S("wb"));
     fwrite(out.data(), 1, out.size(), fp);
     fclose(fp);
@@ -177,7 +177,7 @@ int main(int argc, const amuse::SystemChar** argv)
                 !amuse::CompareCaseInsensitive(dot, _S(".midi")))
             {
                 ReportConvType(type);
-                good = BuildSNG(barePath, argv[2], amuse::SongConverter::Target(type));
+                good = BuildSNG(barePath, argv[2], 1, true);
             }
             else if (!amuse::CompareCaseInsensitive(dot, _S(".son")) ||
                      !amuse::CompareCaseInsensitive(dot, _S(".sng")))

include/amuse/SongConverter.hpp

@@ -10,14 +10,8 @@ namespace amuse
 class SongConverter
 {
 public:
-    enum class Target
-    {
-        N64,
-        GCN,
-        PC
-    };
-    static std::vector<uint8_t> SongToMIDI(const unsigned char* data, Target& targetOut);
-    static std::vector<uint8_t> MIDIToSong(const std::vector<uint8_t>& data, Target target);
+    static std::vector<uint8_t> SongToMIDI(const unsigned char* data, int& versionOut, bool& isBig);
+    static std::vector<uint8_t> MIDIToSong(const std::vector<uint8_t>& data, int version, bool big);
 };
 
 }

include/amuse/SongState.hpp

@@ -45,7 +45,7 @@ class SongState
         uint16_t m_unk2;
         int16_t m_regionIndex;
         int16_t m_unk3;
-        bool indexValid() const;
+        bool indexValid(bool bigEndian) const;
     };
 
     /** Tempo change entry */
@@ -57,6 +57,7 @@ class SongState
     };
 
     const unsigned char* m_songData = nullptr; /**< Base pointer to active song */
+    int m_sngVersion; /**< Detected song revision, 1 has RLE-compressed delta-times */
     bool m_bigEndian; /**< True if loaded song is big-endian data */
 
     /** State of a single track within arrangement */
@@ -104,8 +105,13 @@ class SongState
     double m_curDt = 0.f; /**< Cumulative dt value for time-remainder tracking */
 
 public:
+    /** Determine SNG version
+     *  @param isBig returns true if big-endian SNG
+     *  @return 0 for initial version, 1 for delta-time revision, -1 for non-SNG */
+    static int DetectVersion(const unsigned char* ptr, bool& isBig);
+
     /** initialize state for Song data at `ptr` */
-    void initialize(const unsigned char* ptr);
+    bool initialize(const unsigned char* ptr);
 
     /** advances `dt` seconds worth of commands in the Song
      *  @return `true` if END reached

lib/AudioGroupData.cpp

@@ -7,10 +7,10 @@ IntrusiveAudioGroupData::~IntrusiveAudioGroupData()
 {
     if (m_owns)
     {
-        delete m_pool;
-        delete m_proj;
-        delete m_sdir;
-        delete m_samp;
+        delete[] m_pool;
+        delete[] m_proj;
+        delete[] m_sdir;
+        delete[] m_samp;
     }
 }
 
@@ -27,10 +27,10 @@ IntrusiveAudioGroupData& IntrusiveAudioGroupData::operator=(IntrusiveAudioGroupD
 {
     if (m_owns)
     {
-        delete m_pool;
-        delete m_proj;
-        delete m_sdir;
-        delete m_samp;
+        delete[] m_pool;
+        delete[] m_proj;
+        delete[] m_sdir;
+        delete[] m_samp;
     }
 
     m_owns = other.m_owns;

lib/SongConverter.cpp

@@ -42,8 +42,9 @@ struct PitchEvent {};
 struct Event
 {
     bool endEvent = false;
-    bool controlChange = false;
-    bool progChange = false;
+    bool isNote = false;
+    bool isControlChange = false;
+    bool isProgChange = false;
     uint8_t channel;
     uint8_t noteOrCtrl;
     uint8_t velOrVal;
@@ -54,15 +55,16 @@ struct Event
     int pitchBend;
 
     Event(NoteEvent, uint8_t chan, uint8_t note, uint8_t vel, uint16_t len)
-    : controlChange(false), channel(chan), noteOrCtrl(note), velOrVal(vel), length(len) {}
+    : isNote(true), channel(chan), noteOrCtrl(note), velOrVal(vel), length(len) {}
 
     Event(CtrlEvent, uint8_t chan, uint8_t note, uint8_t vel, uint16_t len)
-    : controlChange(true), channel(chan), noteOrCtrl(note), velOrVal(vel), length(len) {}
+    : isControlChange(true), channel(chan), noteOrCtrl(note), velOrVal(vel), length(len) {}
 
     Event(ProgEvent, uint8_t chan, uint8_t prog)
-    : progChange(true), channel(chan), program(prog) {}
+    : isProgChange(true), channel(chan), program(prog) {}
 
-    Event(PitchEvent, uint8_t chan, int pBend) : isPitchBend(true), channel(chan), pitchBend(pBend) {}
+    Event(PitchEvent, uint8_t chan, int pBend)
+    : isPitchBend(true), channel(chan), pitchBend(pBend) {}
 };
 
 class MIDIDecoder
@@ -616,7 +618,7 @@ static void EncodeTimeRLE(std::vector<uint8_t>& vecOut, uint32_t val)
     vecOut.push_back(reinterpret_cast<const uint8_t*>(&lastPart)[1]);
 }
 
-std::vector<uint8_t> SongConverter::SongToMIDI(const unsigned char* data, Target& targetOut)
+std::vector<uint8_t> SongConverter::SongToMIDI(const unsigned char* data, int& versionOut, bool& isBig)
 {
     std::vector<uint8_t> ret = {'M', 'T', 'h', 'd'};
     uint32_t six32 = SBig(uint32_t(6));
@@ -627,17 +629,10 @@ std::vector<uint8_t> SongConverter::SongToMIDI(const unsigned char* data, Target
     ret.push_back(1);
 
     SongState song;
-    song.initialize(data);
-
-    if (song.m_bigEndian)
-    {
-        if (song.m_header.m_trackIdxOff == 0x18 || song.m_header.m_trackIdxOff == 0x58)
-            targetOut = Target::GCN;
-        else
-            targetOut = Target::N64;
-    }
-    else
-        targetOut = Target::PC;
+    if (!song.initialize(data))
+        return {};
+    versionOut = song.m_sngVersion;
+    isBig = song.m_bigEndian;
 
     size_t trkCount = 1;
     for (std::experimental::optional<SongState::Track>& trk : song.m_tracks)
@@ -711,7 +706,7 @@ std::vector<uint8_t> SongConverter::SongToMIDI(const unsigned char* data, Target
             std::multimap<int, Event> allEvents;
 
             /* Iterate all regions */
-            while (trk->m_nextRegion->indexValid())
+            while (trk->m_nextRegion->indexValid(song.m_bigEndian))
             {
                 std::multimap<int, Event> events;
                 trk->advanceRegion(nullptr);
@@ -766,9 +761,9 @@ std::vector<uint8_t> SongConverter::SongToMIDI(const unsigned char* data, Target
                 }
 
                 /* Loop through as many commands as we can for this time period */
-                if (song.m_header.m_trackIdxOff == 0x18 || song.m_header.m_trackIdxOff == 0x58)
+                if (song.m_sngVersion == 1)
                 {
-                    /* GameCube */
+                    /* Revision */
                     while (true)
                     {
                         /* Load next command */
@@ -810,31 +805,16 @@ std::vector<uint8_t> SongConverter::SongToMIDI(const unsigned char* data, Target
                 }
                 else
                 {
-                    /* N64 */
+                    /* Legacy */
                     while (true)
                     {
                         /* Load next command */
-                        if (*reinterpret_cast<const uint32_t*>(trk->m_data) == 0xffff0000)
+                        if (*reinterpret_cast<const uint16_t*>(&trk->m_data[2]) == 0xffff)
                         {
                             /* End of channel */
                             trk->m_data = nullptr;
                             break;
                         }
-                        else if (trk->m_data[0] & 0x80 && trk->m_data[1] & 0x80)
-                        {
-                            /* Control change */
-                            uint8_t val = trk->m_data[0] & 0x7f;
-                            uint8_t ctrl = trk->m_data[1] & 0x7f;
-                            events.emplace(regStart + trk->m_eventWaitCountdown, Event{CtrlEvent{}, trk->m_midiChan, ctrl, val, 0});
-                            trk->m_data += 2;
-                        }
-                        else if (trk->m_data[0] & 0x80)
-                        {
-                            /* Program change */
-                            uint8_t prog = trk->m_data[0] & 0x7f;
-                            events.emplace(regStart + trk->m_eventWaitCountdown, Event{ProgEvent{}, trk->m_midiChan, prog});
-                            trk->m_data += 2;
-                        }
                         else
                         {
                             if ((trk->m_data[2] & 0x80) != 0x80)
@@ -877,7 +857,7 @@ std::vector<uint8_t> SongConverter::SongToMIDI(const unsigned char* data, Target
                 /* Resolve key-off events */
                 for (auto& pair : events)
                 {
-                    if (!pair.second.controlChange)
+                    if (pair.second.isNote)
                     {
                         auto it = allEvents.emplace(pair.first + pair.second.length, pair.second);
                         it->second.endEvent = true;
@@ -892,11 +872,11 @@ std::vector<uint8_t> SongConverter::SongToMIDI(const unsigned char* data, Target
                 encoder._sendContinuedValue(pair.first - lastTime);
                 lastTime = pair.first;
 
-                if (pair.second.controlChange)
+                if (pair.second.isControlChange)
                 {
                     encoder.controlChange(pair.second.channel, pair.second.noteOrCtrl, pair.second.velOrVal);
                 }
-                else if (pair.second.progChange)
+                else if (pair.second.isProgChange)
                 {
                     encoder.programChange(trk->m_midiChan, pair.second.program);
                 }
@@ -904,7 +884,7 @@ std::vector<uint8_t> SongConverter::SongToMIDI(const unsigned char* data, Target
                 {
                     encoder.pitchBend(trk->m_midiChan, pair.second.pitchBend);
                 }
-                else
+                else if (pair.second.isNote)
                 {
                     if (pair.second.endEvent)
                         encoder.noteOff(pair.second.channel, pair.second.noteOrCtrl, pair.second.velOrVal);
@@ -933,11 +913,10 @@ std::vector<uint8_t> SongConverter::SongToMIDI(const unsigned char* data, Target
     return ret;
 }
 
-std::vector<uint8_t> SongConverter::MIDIToSong(const std::vector<uint8_t>& data, Target target)
+std::vector<uint8_t> SongConverter::MIDIToSong(const std::vector<uint8_t>& data, int version, bool big)
 {
     std::vector<uint8_t> ret;
     std::vector<uint8_t>::const_iterator it = data.cbegin();
-    bool bigEndian = (target == Target::GCN || target == Target::N64);
 
     struct MIDIHeader
     {
@@ -984,6 +963,7 @@ std::vector<uint8_t> SongConverter::MIDIToSong(const std::vector<uint8_t>& data,
         std::vector<uint8_t> eventBuf;
         std::vector<uint8_t> pitchBuf;
         std::vector<uint8_t> modBuf;
+        int padding = 0;
 
         bool operator==(const Region& other) const
         {
@@ -1035,7 +1015,7 @@ std::vector<uint8_t> SongConverter::MIDIToSong(const std::vector<uint8_t>& data,
                 ++it;
                 for (auto& pair : tempos)
                 {
-                    if (bigEndian)
+                    if (big)
                         tempoBuf.emplace_back(SBig(uint32_t(pair.first * 384 / header.div)), SBig(uint32_t(pair.second)));
                     else
                         tempoBuf.emplace_back(pair.first * 384 / header.div, pair.second);
@@ -1092,7 +1072,7 @@ std::vector<uint8_t> SongConverter::MIDIToSong(const std::vector<uint8_t>& data,
                             lastModVal = 0;
                         }
 
-                        if (event.second.controlChange)
+                        if (event.second.isControlChange)
                         {
                             if (event.second.noteOrCtrl == 1)
                             {
@@ -1104,55 +1084,61 @@ std::vector<uint8_t> SongConverter::MIDIToSong(const std::vector<uint8_t>& data,
                             }
                             else
                             {
-                                if (target == Target::GCN)
+                                if (version == 1)
                                 {
                                     EncodeTimeRLE(region.eventBuf, uint32_t(eventTick - lastEventTick));
                                     lastEventTick = eventTick;
                                     region.eventBuf.push_back(0x80 | event.second.velOrVal);
                                     region.eventBuf.push_back(0x80 | event.second.noteOrCtrl);
                                 }
-                                else if (target == Target::N64)
+                                else
                                 {
-                                    uint32_t tickBig = SBig(uint32_t(eventTick - startTick));
-                                    for (int i=0 ; i<4 ; ++i)
-                                        region.eventBuf.push_back(reinterpret_cast<const uint8_t*>(&tickBig)[i]);
-                                    region.eventBuf.push_back(0x80 | event.second.velOrVal);
-                                    region.eventBuf.push_back(0x80 | event.second.noteOrCtrl);
-                                }
-                                else if (target == Target::PC)
-                                {
-                                    uint32_t tick = uint32_t(eventTick - startTick);
-                                    for (int i=0 ; i<4 ; ++i)
-                                        region.eventBuf.push_back(reinterpret_cast<const uint8_t*>(&tick)[i]);
-                                    region.eventBuf.push_back(0x80 | event.second.velOrVal);
-                                    region.eventBuf.push_back(0x80 | event.second.noteOrCtrl);
+                                    if (big)
+                                    {
+                                        uint32_t tickBig = SBig(uint32_t(eventTick - startTick));
+                                        for (int i=0 ; i<4 ; ++i)
+                                            region.eventBuf.push_back(reinterpret_cast<const uint8_t*>(&tickBig)[i]);
+                                        region.eventBuf.push_back(0x80 | event.second.velOrVal);
+                                        region.eventBuf.push_back(0x80 | event.second.noteOrCtrl);
+                                    }
+                                    else
+                                    {
+                                        uint32_t tick = uint32_t(eventTick - startTick);
+                                        for (int i=0 ; i<4 ; ++i)
+                                            region.eventBuf.push_back(reinterpret_cast<const uint8_t*>(&tick)[i]);
+                                        region.eventBuf.push_back(0x80 | event.second.velOrVal);
+                                        region.eventBuf.push_back(0x80 | event.second.noteOrCtrl);
+                                    }
                                 }
                             }
                         }
-                        else if (event.second.progChange)
+                        else if (event.second.isProgChange)
                         {
-                            if (target == Target::GCN)
+                            if (version == 1)
                             {
                                 EncodeTimeRLE(region.eventBuf, uint32_t(eventTick - lastEventTick));
                                 lastEventTick = eventTick;
                                 region.eventBuf.push_back(0x80 | event.second.program);
                                 region.eventBuf.push_back(0);
                             }
-                            else if (target == Target::N64)
+                            else
                             {
-                                uint32_t tickBig = SBig(uint32_t(eventTick - startTick));
-                                for (int i=0 ; i<4 ; ++i)
-                                    region.eventBuf.push_back(reinterpret_cast<const uint8_t*>(&tickBig)[i]);
-                                region.eventBuf.push_back(0x80 | event.second.program);
-                                region.eventBuf.push_back(0);
-                            }
-                            else if (target == Target::PC)
-                            {
-                                uint32_t tick = uint32_t(eventTick - startTick);
-                                for (int i=0 ; i<4 ; ++i)
-                                    region.eventBuf.push_back(reinterpret_cast<const uint8_t*>(&tick)[i]);
-                                region.eventBuf.push_back(0x80 | event.second.program);
-                                region.eventBuf.push_back(0);
+                                if (big)
+                                {
+                                    uint32_t tickBig = SBig(uint32_t(eventTick - startTick));
+                                    for (int i=0 ; i<4 ; ++i)
+                                        region.eventBuf.push_back(reinterpret_cast<const uint8_t*>(&tickBig)[i]);
+                                    region.eventBuf.push_back(0x80 | event.second.program);
+                                    region.eventBuf.push_back(0);
+                                }
+                                else
+                                {
+                                    uint32_t tick = uint32_t(eventTick - startTick);
+                                    for (int i=0 ; i<4 ; ++i)
+                                        region.eventBuf.push_back(reinterpret_cast<const uint8_t*>(&tick)[i]);
+                                    region.eventBuf.push_back(0x80 | event.second.program);
+                                    region.eventBuf.push_back(0);
+                                }
                             }
                         }
                         else if (event.second.isPitchBend)
@@ -1163,9 +1149,9 @@ std::vector<uint8_t> SongConverter::MIDIToSong(const std::vector<uint8_t>& data,
                             EncodeContinuousRLE(region.pitchBuf, newPitch - lastPitchVal);
                             lastPitchVal = newPitch;
                         }
-                        else
+                        else if (event.second.isNote)
                         {
-                            if (target == Target::GCN)
+                            if (version == 1)
                             {
                                 EncodeTimeRLE(region.eventBuf, uint32_t(eventTick - lastEventTick));
                                 lastEventTick = eventTick;
@@ -1175,27 +1161,30 @@ std::vector<uint8_t> SongConverter::MIDIToSong(const std::vector<uint8_t>& data,
                                 region.eventBuf.push_back(reinterpret_cast<const uint8_t*>(&lenBig)[0]);
                                 region.eventBuf.push_back(reinterpret_cast<const uint8_t*>(&lenBig)[1]);
                             }
-                            else if (target == Target::N64)
+                            else
                             {
-                                uint32_t tickBig = SBig(uint32_t(eventTick - startTick));
-                                for (int i=0 ; i<4 ; ++i)
-                                    region.eventBuf.push_back(reinterpret_cast<const uint8_t*>(&tickBig)[i]);
-                                uint16_t lenBig = SBig(uint16_t(event.second.length));
-                                region.eventBuf.push_back(reinterpret_cast<const uint8_t*>(&lenBig)[0]);
-                                region.eventBuf.push_back(reinterpret_cast<const uint8_t*>(&lenBig)[1]);
-                                region.eventBuf.push_back(event.second.noteOrCtrl);
-                                region.eventBuf.push_back(event.second.velOrVal);
-                            }
-                            else if (target == Target::PC)
-                            {
-                                uint32_t tick = uint32_t(eventTick - startTick);
-                                for (int i=0 ; i<4 ; ++i)
-                                    region.eventBuf.push_back(reinterpret_cast<const uint8_t*>(&tick)[i]);
-                                uint16_t len = uint16_t(event.second.length);
-                                region.eventBuf.push_back(reinterpret_cast<const uint8_t*>(&len)[0]);
-                                region.eventBuf.push_back(reinterpret_cast<const uint8_t*>(&len)[1]);
-                                region.eventBuf.push_back(event.second.noteOrCtrl);
-                                region.eventBuf.push_back(event.second.velOrVal);
+                                if (big)
+                                {
+                                    uint32_t tickBig = SBig(uint32_t(eventTick - startTick));
+                                    for (int i=0 ; i<4 ; ++i)
+                                        region.eventBuf.push_back(reinterpret_cast<const uint8_t*>(&tickBig)[i]);
+                                    uint16_t lenBig = SBig(uint16_t(event.second.length));
+                                    region.eventBuf.push_back(reinterpret_cast<const uint8_t*>(&lenBig)[0]);
+                                    region.eventBuf.push_back(reinterpret_cast<const uint8_t*>(&lenBig)[1]);
+                                    region.eventBuf.push_back(event.second.noteOrCtrl);
+                                    region.eventBuf.push_back(event.second.velOrVal);
+                                }
+                                else
+                                {
+                                    uint32_t tick = uint32_t(eventTick - startTick);
+                                    for (int i=0 ; i<4 ; ++i)
+                                        region.eventBuf.push_back(reinterpret_cast<const uint8_t*>(&tick)[i]);
+                                    uint16_t len = uint16_t(event.second.length);
+                                    region.eventBuf.push_back(reinterpret_cast<const uint8_t*>(&len)[0]);
+                                    region.eventBuf.push_back(reinterpret_cast<const uint8_t*>(&len)[1]);
+                                    region.eventBuf.push_back(event.second.noteOrCtrl);
+                                    region.eventBuf.push_back(event.second.velOrVal);
+                                }
                             }
                         }
                     }
@@ -1213,7 +1202,7 @@ std::vector<uint8_t> SongConverter::MIDIToSong(const std::vector<uint8_t>& data,
                     }
 
                     /* Terminate region */
-                    if (target == Target::GCN)
+                    if (version == 1)
                     {
                         size_t pitchDelta = 0;
                         size_t modDelta = 0;
@@ -1226,31 +1215,34 @@ std::vector<uint8_t> SongConverter::MIDIToSong(const std::vector<uint8_t>& data,
                         region.eventBuf.push_back(0xff);
                         region.eventBuf.push_back(0xff);
                     }
-                    else if (target == Target::N64)
+                    else
                     {
-                        uint32_t selTick = std::max(std::max(lastEventTick - startTick,
-                                                             lastPitchTick - startTick),
-                                                             lastModTick - startTick);
-                        uint32_t tickBig = SBig(uint32_t(selTick));
-                        for (int i=0 ; i<4 ; ++i)
-                            region.eventBuf.push_back(reinterpret_cast<const uint8_t*>(&tickBig)[i]);
-                        region.eventBuf.push_back(0);
-                        region.eventBuf.push_back(0);
-                        region.eventBuf.push_back(0xff);
-                        region.eventBuf.push_back(0xff);
-                    }
-                    else if (target == Target::PC)
-                    {
-                        uint32_t selTick = std::max(std::max(lastEventTick - startTick,
-                                                             lastPitchTick - startTick),
-                                                             lastModTick - startTick);
-                        uint32_t tick = uint32_t(selTick);
-                        for (int i=0 ; i<4 ; ++i)
-                            region.eventBuf.push_back(reinterpret_cast<const uint8_t*>(&tick)[i]);
-                        region.eventBuf.push_back(0);
-                        region.eventBuf.push_back(0);
-                        region.eventBuf.push_back(0xff);
-                        region.eventBuf.push_back(0xff);
+                        if (big)
+                        {
+                            uint32_t selTick = std::max(std::max(lastEventTick - startTick,
+                                                                 lastPitchTick - startTick),
+                                                                 lastModTick - startTick);
+                            uint32_t tickBig = SBig(uint32_t(selTick));
+                            for (int i=0 ; i<4 ; ++i)
+                                region.eventBuf.push_back(reinterpret_cast<const uint8_t*>(&tickBig)[i]);
+                            region.eventBuf.push_back(0);
+                            region.eventBuf.push_back(0);
+                            region.eventBuf.push_back(0xff);
+                            region.eventBuf.push_back(0xff);
+                        }
+                        else
+                        {
+                            uint32_t selTick = std::max(std::max(lastEventTick - startTick,
+                                                                 lastPitchTick - startTick),
+                                                                 lastModTick - startTick);
+                            uint32_t tick = uint32_t(selTick);
+                            for (int i=0 ; i<4 ; ++i)
+                                region.eventBuf.push_back(reinterpret_cast<const uint8_t*>(&tick)[i]);
+                            region.eventBuf.push_back(0);
+                            region.eventBuf.push_back(0);
+                            region.eventBuf.push_back(0xff);
+                            region.eventBuf.push_back(0xff);
+                        }
                     }
 
                     if (region.pitchBuf.size())
@@ -1277,13 +1269,15 @@ std::vector<uint8_t> SongConverter::MIDIToSong(const std::vector<uint8_t>& data,
                     {
                         regionDataIdxArr.push_back(curRegionOff);
                         curRegionOff += 12 + region.eventBuf.size() + region.pitchBuf.size() + region.modBuf.size();
+                        int paddedRegOff = ((curRegionOff + 3) & ~3);
+                        region.padding = paddedRegOff - curRegionOff;
                         regions.push_back(std::move(region));
                     }
 
                     /* Region header */
                     regionBuf.emplace_back();
                     SongState::TrackRegion& reg = regionBuf.back();
-                    if (bigEndian)
+                    if (big)
                     {
                         reg.m_startTick = SBig(uint32_t(startTick));
                         reg.m_progNum = 0xff;
@@ -1309,7 +1303,7 @@ std::vector<uint8_t> SongConverter::MIDIToSong(const std::vector<uint8_t>& data,
                 /* Terminating region header */
                 regionBuf.emplace_back();
                 SongState::TrackRegion& reg = regionBuf.back();
-                if (bigEndian)
+                if (big)
                 {
                     reg.m_startTick = SBig(uint32_t(lastTrackStartTick));
                     reg.m_progNum = 0xff;
@@ -1331,7 +1325,7 @@ std::vector<uint8_t> SongConverter::MIDIToSong(const std::vector<uint8_t>& data,
         }
     }
 
-    if (target == Target::GCN)
+    if (version == 1)
     {
         SongState::Header head;
         head.m_trackIdxOff = 0x18;
@@ -1342,7 +1336,8 @@ std::vector<uint8_t> SongConverter::MIDIToSong(const std::vector<uint8_t>& data,
         head.m_unkOff = 0;
 
         uint32_t regIdxOff = head.m_regionIdxOff;
-        head.swapBig();
+        if (big)
+            head.swapBig();
         *reinterpret_cast<SongState::Header*>(&*ret.insert(ret.cend(), 0x18, 0)) = head;
 
         for (int i=0 ; i<64 ; ++i)
@@ -1354,7 +1349,8 @@ std::vector<uint8_t> SongConverter::MIDIToSong(const std::vector<uint8_t>& data,
             }
 
             uint32_t idx = trackRegionIdxArr[i];
-            *reinterpret_cast<uint32_t*>(&*ret.insert(ret.cend(), 4, 0)) = SBig(uint32_t(0x18 + 4 * 64 + idx * 12));
+            *reinterpret_cast<uint32_t*>(&*ret.insert(ret.cend(), 4, 0)) = big ? SBig(uint32_t(0x18 + 4 * 64 + idx * 12)) :
+                                                                                      uint32_t(0x18 + 4 * 64 + idx * 12);
         }
 
         for (SongState::TrackRegion& reg : regionBuf)
@@ -1362,22 +1358,25 @@ std::vector<uint8_t> SongConverter::MIDIToSong(const std::vector<uint8_t>& data,
 
         uint32_t regBase = regIdxOff + 4 * regionDataIdxArr.size();
         for (uint32_t regOff : regionDataIdxArr)
-            *reinterpret_cast<uint32_t*>(&*ret.insert(ret.cend(), 4, 0)) = SBig(uint32_t(regBase + regOff));
+            *reinterpret_cast<uint32_t*>(&*ret.insert(ret.cend(), 4, 0)) = big ? SBig(uint32_t(regBase + regOff)) :
+                                                                                      uint32_t(regBase + regOff);
 
         uint32_t curOffset = regBase;
         for (Region& reg : regions)
         {
-            *reinterpret_cast<uint32_t*>(&*ret.insert(ret.cend(), 4, 0)) = SBig(uint32_t(8));
+            *reinterpret_cast<uint32_t*>(&*ret.insert(ret.cend(), 4, 0)) = big ? SBig(uint32_t(8)) : 8;
 
             if (reg.pitchBuf.size())
                 *reinterpret_cast<uint32_t*>(&*ret.insert(ret.cend(), 4, 0)) =
-                    SBig(uint32_t(curOffset + 12 + reg.eventBuf.size()));
+                    big ? SBig(uint32_t(curOffset + 12 + reg.eventBuf.size())) :
+                               uint32_t(curOffset + 12 + reg.eventBuf.size());
             else
                 ret.insert(ret.cend(), 4, 0);
 
             if (reg.modBuf.size())
                 *reinterpret_cast<uint32_t*>(&*ret.insert(ret.cend(), 4, 0)) =
-                    SBig(uint32_t(curOffset + 12 + reg.eventBuf.size() + reg.pitchBuf.size()));
+                    big ? SBig(uint32_t(curOffset + 12 + reg.eventBuf.size() + reg.pitchBuf.size())) :
+                               uint32_t(curOffset + 12 + reg.eventBuf.size() + reg.pitchBuf.size());
             else
                 ret.insert(ret.cend(), 4, 0);
 
@@ -1390,7 +1389,9 @@ std::vector<uint8_t> SongConverter::MIDIToSong(const std::vector<uint8_t>& data,
             if (reg.modBuf.size())
                 memmove(&*ret.insert(ret.cend(), reg.modBuf.size(), 0), reg.modBuf.data(), reg.modBuf.size());
 
-            curOffset += 12 + reg.eventBuf.size() + reg.pitchBuf.size() + reg.modBuf.size();
+            ret.insert(ret.cend(), reg.padding, 0);
+
+            curOffset += 12 + reg.eventBuf.size() + reg.pitchBuf.size() + reg.modBuf.size() + reg.padding;
         }
 
         memmove(&*ret.insert(ret.cend(), 64, 0), chanMap.data(), 64);
@@ -1400,7 +1401,7 @@ std::vector<uint8_t> SongConverter::MIDIToSong(const std::vector<uint8_t>& data,
 
         *reinterpret_cast<uint32_t*>(&*ret.insert(ret.cend(), 4, 0)) = uint32_t(0xffffffff);
     }
-    else if (target == Target::N64)
+    else
     {
         SongState::Header head;
         head.m_trackIdxOff = 0x18 + regionBuf.size() * 12;
@@ -1411,7 +1412,8 @@ std::vector<uint8_t> SongConverter::MIDIToSong(const std::vector<uint8_t>& data,
         head.m_unkOff = 0;
 
         uint32_t chanMapOff = head.m_chanMapOff;
-        head.swapBig();
+        if (big)
+            head.swapBig();
         *reinterpret_cast<SongState::Header*>(&*ret.insert(ret.cend(), 0x18, 0)) = head;
 
         for (SongState::TrackRegion& reg : regionBuf)
@@ -1426,7 +1428,8 @@ std::vector<uint8_t> SongConverter::MIDIToSong(const std::vector<uint8_t>& data,
             }
 
             uint32_t idx = trackRegionIdxArr[i];
-            *reinterpret_cast<uint32_t*>(&*ret.insert(ret.cend(), 4, 0)) = SBig(uint32_t(0x18 + 4 * 64 + idx * 12));
+            *reinterpret_cast<uint32_t*>(&*ret.insert(ret.cend(), 4, 0)) = big ? SBig(uint32_t(0x18 + 4 * 64 + idx * 12)) :
+                                                                                      uint32_t(0x18 + 4 * 64 + idx * 12);
         }
 
         memmove(&*ret.insert(ret.cend(), 64, 0), chanMap.data(), 64);
@@ -1435,17 +1438,19 @@ std::vector<uint8_t> SongConverter::MIDIToSong(const std::vector<uint8_t>& data,
         uint32_t curOffset = regBase;
         for (Region& reg : regions)
         {
-            *reinterpret_cast<uint32_t*>(&*ret.insert(ret.cend(), 4, 0)) = SBig(uint32_t(8));
+            *reinterpret_cast<uint32_t*>(&*ret.insert(ret.cend(), 4, 0)) = big ? SBig(uint32_t(8)) : 8;
 
             if (reg.pitchBuf.size())
                 *reinterpret_cast<uint32_t*>(&*ret.insert(ret.cend(), 4, 0)) =
-                    SBig(uint32_t(curOffset + 12 + reg.eventBuf.size()));
+                    big ? SBig(uint32_t(curOffset + 12 + reg.eventBuf.size())) :
+                               uint32_t(curOffset + 12 + reg.eventBuf.size());
             else
                 ret.insert(ret.cend(), 4, 0);
 
             if (reg.modBuf.size())
                 *reinterpret_cast<uint32_t*>(&*ret.insert(ret.cend(), 4, 0)) =
-                    SBig(uint32_t(curOffset + 12 + reg.eventBuf.size() + reg.pitchBuf.size()));
+                    big ? SBig(uint32_t(curOffset + 12 + reg.eventBuf.size() + reg.pitchBuf.size())) :
+                               uint32_t(curOffset + 12 + reg.eventBuf.size() + reg.pitchBuf.size());
             else
                 ret.insert(ret.cend(), 4, 0);
 
@@ -1458,78 +1463,14 @@ std::vector<uint8_t> SongConverter::MIDIToSong(const std::vector<uint8_t>& data,
             if (reg.modBuf.size())
                 memmove(&*ret.insert(ret.cend(), reg.modBuf.size(), 0), reg.modBuf.data(), reg.modBuf.size());
 
-            curOffset += 12 + reg.eventBuf.size() + reg.pitchBuf.size() + reg.modBuf.size();
-        }
-
-        for (uint32_t regOff : regionDataIdxArr)
-            *reinterpret_cast<uint32_t*>(&*ret.insert(ret.cend(), 4, 0)) = SBig(uint32_t(regBase + regOff));
-
-        if (tempoBuf.size())
-            memmove(&*ret.insert(ret.cend(), tempoBuf.size() * 8, 0), tempoBuf.data(), tempoBuf.size() * 8);
-
-        *reinterpret_cast<uint32_t*>(&*ret.insert(ret.cend(), 4, 0)) = uint32_t(0xffffffff);
-    }
-    else if (target == Target::PC)
-    {
-        SongState::Header head;
-        head.m_trackIdxOff = 0x18 + regionBuf.size() * 12;
-        head.m_regionIdxOff = head.m_trackIdxOff + 4 * 64 + 64 + curRegionOff;
-        head.m_chanMapOff = head.m_trackIdxOff + 4 * 64;
-        head.m_tempoTableOff = tempoBuf.size() ? head.m_regionIdxOff + 4 * regionDataIdxArr.size() : 0;
-        head.m_initialTempo = initTempo;
-        head.m_unkOff = 0;
-
-        *reinterpret_cast<SongState::Header*>(&*ret.insert(ret.cend(), 0x18, 0)) = head;
-
-        for (SongState::TrackRegion& reg : regionBuf)
-            *reinterpret_cast<SongState::TrackRegion*>(&*ret.insert(ret.cend(), 12, 0)) = reg;
-
-        for (int i=0 ; i<64 ; ++i)
-        {
-            if (i >= trackRegionIdxArr.size())
-            {
-                ret.insert(ret.cend(), 4, 0);
-                continue;
-            }
-
-            uint32_t idx = trackRegionIdxArr[i];
-            *reinterpret_cast<uint32_t*>(&*ret.insert(ret.cend(), 4, 0)) = uint32_t(0x18 + 4 * 64 + idx * 12);
-        }
-
-        memmove(&*ret.insert(ret.cend(), 64, 0), chanMap.data(), 64);
-
-        uint32_t regBase = head.m_chanMapOff + 64;
-        uint32_t curOffset = regBase;
-        for (Region& reg : regions)
-        {
-            *reinterpret_cast<uint32_t*>(&*ret.insert(ret.cend(), 4, 0)) = uint32_t(8);
-
-            if (reg.pitchBuf.size())
-                *reinterpret_cast<uint32_t*>(&*ret.insert(ret.cend(), 4, 0)) =
-                    uint32_t(curOffset + 12 + reg.eventBuf.size());
-            else
-                ret.insert(ret.cend(), 4, 0);
-
-            if (reg.modBuf.size())
-                *reinterpret_cast<uint32_t*>(&*ret.insert(ret.cend(), 4, 0)) =
-                    uint32_t(curOffset + 12 + reg.eventBuf.size() + reg.pitchBuf.size());
-            else
-                ret.insert(ret.cend(), 4, 0);
-
-            if (reg.eventBuf.size())
-                memmove(&*ret.insert(ret.cend(), reg.eventBuf.size(), 0), reg.eventBuf.data(), reg.eventBuf.size());
-
-            if (reg.pitchBuf.size())
-                memmove(&*ret.insert(ret.cend(), reg.pitchBuf.size(), 0), reg.pitchBuf.data(), reg.pitchBuf.size());
-
-            if (reg.modBuf.size())
-                memmove(&*ret.insert(ret.cend(), reg.modBuf.size(), 0), reg.modBuf.data(), reg.modBuf.size());
+            ret.insert(ret.cend(), reg.padding, 0);
 
             curOffset += 12 + reg.eventBuf.size() + reg.pitchBuf.size() + reg.modBuf.size();
         }
 
         for (uint32_t regOff : regionDataIdxArr)
-            *reinterpret_cast<uint32_t*>(&*ret.insert(ret.cend(), 4, 0)) = uint32_t(regBase + regOff);
+            *reinterpret_cast<uint32_t*>(&*ret.insert(ret.cend(), 4, 0)) = big ? SBig(uint32_t(regBase + regOff)) :
+                                                                                      uint32_t(regBase + regOff);
 
         if (tempoBuf.size())
             memmove(&*ret.insert(ret.cend(), tempoBuf.size() * 8, 0), tempoBuf.data(), tempoBuf.size() * 8);

lib/SongState.cpp

@@ -18,7 +18,10 @@ static uint32_t DecodeRLE(const unsigned char*& data)
             ++data;
             thisPart = thisPart * 256 + *data;
             if (thisPart == 0)
+            {
+                ++data;
                 return -1;
+            }
         }
 
         if (thisPart == 32767)
@@ -76,9 +79,9 @@ void SongState::Header::swapBig()
     m_unkOff = SBig(m_unkOff);
 }
 
-bool SongState::TrackRegion::indexValid() const
+bool SongState::TrackRegion::indexValid(bool bigEndian) const
 {
-    return SBig(m_regionIndex) >= 0;
+    return (bigEndian ? SBig(m_regionIndex) : m_regionIndex) >= 0;
 }
 
 void SongState::TempoChange::swapBig()
@@ -131,7 +134,7 @@ void SongState::Track::setRegion(Sequencer* seq, const TrackRegion* region)
         seq->setPitchWheel(m_midiChan, clamp(-1.f, m_lastPitchVal / 32768.f, 1.f));
         seq->setCtrlValue(m_midiChan, 1, clamp(0, m_lastModVal * 128 / 16384, 127));
     }
-    if (m_parent.m_header.m_trackIdxOff == 0x18 || m_parent.m_header.m_trackIdxOff == 0x58)
+    if (m_parent.m_sngVersion == 1)
         m_eventWaitCountdown = int32_t(DecodeTimeRLE(m_data));
     else
     {
@@ -148,9 +151,183 @@ void SongState::Track::advanceRegion(Sequencer* seq)
     setRegion(seq, m_nextRegion);
 }
 
-void SongState::initialize(const unsigned char* ptr)
+int SongState::DetectVersion(const unsigned char* ptr, bool& isBig)
 {
-    m_bigEndian = ptr[0] == 0;
+    isBig = ptr[0] == 0;
+    Header header = *reinterpret_cast<const Header*>(ptr);
+    if (isBig)
+        header.swapBig();
+    const uint32_t* trackIdx = reinterpret_cast<const uint32_t*>(ptr + header.m_trackIdxOff);
+    const uint32_t* regionIdxTable = reinterpret_cast<const uint32_t*>(ptr + header.m_regionIdxOff);
+
+    /* First determine maximum index of MIDI regions across all tracks */
+    uint32_t maxRegionIdx = 0;
+    for (int i=0 ; i<64 ; ++i)
+    {
+        if (trackIdx[i])
+        {
+            const TrackRegion* region = nullptr;
+            const TrackRegion* nextRegion = reinterpret_cast<const TrackRegion*>(ptr + (isBig ? SBig(trackIdx[i]) : trackIdx[i]));
+
+            /* Iterate all regions */
+            while (nextRegion->indexValid(isBig))
+            {
+                region = nextRegion;
+                uint32_t regionIdx = (isBig ? SBig(region->m_regionIndex) :
+                                                   region->m_regionIndex);
+                maxRegionIdx = std::max(maxRegionIdx, regionIdx);
+                nextRegion = &region[1];
+            }
+        }
+    }
+
+    /* Perform 2 trials, first assuming revised format (more likely) */
+    int v=1;
+    for (; v>=0 ; --v)
+    {
+        bool bad = false;
+
+        /* Validate all tracks */
+        for (int i=0 ; i<64 ; ++i)
+        {
+            if (trackIdx[i])
+            {
+                const TrackRegion* region = nullptr;
+                const TrackRegion* nextRegion = reinterpret_cast<const TrackRegion*>(ptr + (isBig ? SBig(trackIdx[i]) : trackIdx[i]));
+
+                /* Iterate all regions */
+                while (nextRegion->indexValid(isBig))
+                {
+                    region = nextRegion;
+                    uint32_t regionIdx = (isBig ? SBig(region->m_regionIndex) :
+                                                       region->m_regionIndex);
+                    nextRegion = &region[1];
+
+                    const unsigned char* data = ptr + (isBig ? SBig(regionIdxTable[regionIdx]) :
+                                                                    regionIdxTable[regionIdx]);
+
+                    /* Can't reliably validate final region */
+                    if (regionIdx == maxRegionIdx)
+                        continue;
+
+                    /* Expected end pointer (next region) */
+                    const unsigned char* expectedEnd = ptr + (isBig ? SBig(regionIdxTable[regionIdx+1]) :
+                                                                           regionIdxTable[regionIdx+1]);
+
+                    Track::Header header = *reinterpret_cast<const Track::Header*>(data);
+                    if (isBig)
+                        header.swapBig();
+                    data += 12;
+
+                    /* continuous pitch data */
+                    if (header.m_pitchOff)
+                    {
+                        const unsigned char* dptr = ptr + header.m_pitchOff;
+                        while (DecodeRLE(dptr) != 0xffffffff) {DecodeContinuousRLE(dptr);}
+                        if (dptr >= (expectedEnd - 4) && (dptr <= expectedEnd))
+                            continue;
+                    }
+
+                    /* continuous modulation data */
+                    if (header.m_modOff)
+                    {
+                        const unsigned char* dptr = ptr + header.m_modOff;
+                        while (DecodeRLE(dptr) != 0xffffffff) {DecodeContinuousRLE(dptr);}
+                        if (dptr >= (expectedEnd - 4) && (dptr <= expectedEnd))
+                            continue;
+                    }
+
+                    /* Loop through as many commands as we can for this time period */
+                    if (v == 1)
+                    {
+                        /* Revised */
+                        while (true)
+                        {
+                            /* Delta time */
+                            DecodeTimeRLE(data);
+
+                            /* Load next command */
+                            if (*reinterpret_cast<const uint16_t*>(data) == 0xffff)
+                            {
+                                /* End of channel */
+                                data += 2;
+                                break;
+                            }
+                            else if (data[0] & 0x80 && data[1] & 0x80)
+                            {
+                                /* Control change */
+                                data += 2;
+                            }
+                            else if (data[0] & 0x80)
+                            {
+                                /* Program change */
+                                data += 2;
+                            }
+                            else
+                            {
+                                /* Note */
+                                data += 4;
+                            }
+                        }
+                    }
+                    else
+                    {
+                        /* Legacy */
+                        while (true)
+                        {
+                            /* Delta-time */
+                            data += 4;
+
+                            /* Load next command */
+                            if (*reinterpret_cast<const uint16_t*>(&data[2]) == 0xffff)
+                            {
+                                /* End of channel */
+                                data += 4;
+                                break;
+                            }
+                            else
+                            {
+                                if ((data[2] & 0x80) != 0x80)
+                                {
+                                    /* Note */
+                                }
+                                else if (data[2] & 0x80 && data[3] & 0x80)
+                                {
+                                    /* Control change */
+                                }
+                                else if (data[2] & 0x80)
+                                {
+                                    /* Program change */
+                                }
+                                data += 4;
+                            }
+                        }
+                    }
+
+                    if (data < (expectedEnd - 4) || (data > expectedEnd))
+                    {
+                        bad = true;
+                        break;
+                    }
+                }
+                if (bad)
+                    break;
+            }
+        }
+        if (bad)
+            continue;
+        break;
+    }
+
+    return v;
+}
+
+bool SongState::initialize(const unsigned char* ptr)
+{
+    m_sngVersion = DetectVersion(ptr, m_bigEndian);
+    if (m_sngVersion < 0)
+        return false;
+
     m_songData = ptr;
     m_header = *reinterpret_cast<const Header*>(ptr);
     if (m_bigEndian)
@@ -180,6 +357,8 @@ void SongState::initialize(const unsigned char* ptr)
     m_tempo = m_header.m_initialTempo;
     m_curTick = 0;
     m_songState = SongPlayState::Playing;
+
+    return true;
 }
 
 bool SongState::Track::advance(Sequencer& seq, int32_t ticks)
@@ -187,7 +366,7 @@ bool SongState::Track::advance(Sequencer& seq, int32_t ticks)
     int32_t endTick = m_parent.m_curTick + ticks;
 
     /* Advance region if needed */
-    while (m_nextRegion->indexValid())
+    while (m_nextRegion->indexValid(m_parent.m_bigEndian))
     {
         uint32_t nextRegTick = (m_parent.m_bigEndian ? SBig(m_nextRegion->m_startTick) :
                                                             m_nextRegion->m_startTick);
@@ -212,7 +391,7 @@ bool SongState::Track::advance(Sequencer& seq, int32_t ticks)
     }
 
     if (!m_data)
-        return !m_nextRegion->indexValid();
+        return !m_nextRegion->indexValid(m_parent.m_bigEndian);
 
     /* Update continuous pitch data */
     if (m_pitchWheelData)
@@ -281,9 +460,9 @@ bool SongState::Track::advance(Sequencer& seq, int32_t ticks)
     }
 
     /* Loop through as many commands as we can for this time period */
-    if (m_parent.m_header.m_trackIdxOff == 0x18 || m_parent.m_header.m_trackIdxOff == 0x58)
+    if (m_parent.m_sngVersion == 1)
     {
-        /* GameCube */
+        /* Revision */
         while (true)
         {
             /* Advance wait timer if active, returning if waiting */
@@ -300,7 +479,7 @@ bool SongState::Track::advance(Sequencer& seq, int32_t ticks)
             {
                 /* End of channel */
                 m_data = nullptr;
-                return !m_nextRegion->indexValid();
+                return !m_nextRegion->indexValid(m_parent.m_bigEndian);
             }
             else if (m_data[0] & 0x80 && m_data[1] & 0x80)
             {
@@ -335,7 +514,7 @@ bool SongState::Track::advance(Sequencer& seq, int32_t ticks)
     }
     else
     {
-        /* N64 */
+        /* Legacy */
         while (true)
         {
             /* Advance wait timer if active, returning if waiting */
@@ -348,26 +527,11 @@ bool SongState::Track::advance(Sequencer& seq, int32_t ticks)
             }
 
             /* Load next command */
-            if (*reinterpret_cast<const uint32_t*>(m_data) == 0xffff0000)
+            if (*reinterpret_cast<const uint16_t*>(&m_data[2]) == 0xffff)
             {
                 /* End of channel */
                 m_data = nullptr;
-                return !m_nextRegion->indexValid();
-            }
-            else if (m_data[0] & 0x80 && m_data[1] & 0x80)
-            {
-                /* Control change */
-                uint8_t val = m_data[0] & 0x7f;
-                uint8_t ctrl = m_data[1] & 0x7f;
-                seq.setCtrlValue(m_midiChan, ctrl, val);
-                m_data += 2;
-            }
-            else if (m_data[0] & 0x80)
-            {
-                /* Program change */
-                uint8_t prog = m_data[0] & 0x7f;
-                seq.setChanProgram(m_midiChan, prog);
-                m_data += 2;
+                return !m_nextRegion->indexValid(m_parent.m_bigEndian);
             }
             else
             {