Some work on old cache

4 files changed, 94 insertions, 32 deletions

diff --git a/utils/gen_adldata/file_formats/load_ea.h b/utils/gen_adldata/file_formats/load_ea.h
index da7d0cc..7d15883 100644
--- a/utils/gen_adldata/file_formats/load_ea.h
+++ b/utils/gen_adldata/file_formats/load_ea.h
@@ -90,7 +90,7 @@ bool BankFormats::LoadEA(BanksDump &db, const char *fn, unsigned bank,
         tmp.data[6] = 0;        // reg 0xE0: modulator, never seems to be set
         tmp.data[7] = 0;        // reg 0xE0: carrier,   never seems to be set
 
-        ins tmp2{};
+        ins tmp2;
         tmp2.notenum   = 0;
         tmp2.pseudo4op = false;
         tmp2.real4op = false;
diff --git a/utils/gen_adldata/measurer.cpp b/utils/gen_adldata/measurer.cpp
index fbae571..2deebc9 100644
--- a/utils/gen_adldata/measurer.cpp
+++ b/utils/gen_adldata/measurer.cpp
@@ -810,14 +810,29 @@ void MeasureThreaded::LoadCache(const char *fileName)
         if(std::fread(&inval, 1, sizeof(uint64_t), in) != sizeof(uint64_t))
             break;
         inst.insno2 = inval;
+        if(std::fread(&inst.instCache1.data, 1, 11, in) != 11)
+            break;
+        if(std::fread(&inst.instCache1.finetune, 1, 1, in) != 1)
+            break;
+        if(std::fread(&inst.instCache1.diff, 1, sizeof(bool), in) != sizeof(bool))
+            break;
+        if(std::fread(&inst.instCache2.data, 1, 11, in) != 11)
+            break;
+        if(std::fread(&inst.instCache2.finetune, 1, 1, in) != 1)
+            break;
+        if(std::fread(&inst.instCache2.diff, 1, sizeof(bool), in) != sizeof(bool))
+            break;
+
         if(std::fread(&inst.notenum, 1, 1, in) != 1)
             break;
         if(std::fread(&inst.real4op, 1, 1, in) != 1)
             break;
         if(std::fread(&inst.pseudo4op, 1, 1, in) != 1)
             break;
-        if(std::fread(&inst.voice2_fine_tune, sizeof(double), 1, in) != 1)
+        int64_t voice2detune = 0;
+        if(std::fread(&voice2detune, sizeof(int64_t), 1, in) != 1)
             break;
+        inst.voice2_fine_tune = static_cast<double>(voice2detune) / 1000000.0;
 
         //Instrument data
         if(fread(found_f, 1, 2 * sizeof(bool), in) != sizeof(bool) * 2)
@@ -896,18 +911,6 @@ void MeasureThreaded::LoadCache(const char *fileName)
         }
 
         //Duration data
-        if(std::fread(&info.peak_amplitude_time, 1, sizeof(uint64_t), in) != sizeof(uint64_t))
-            break;
-        if(std::fread(&info.peak_amplitude_value, 1, sizeof(double), in) != sizeof(double))
-            break;
-        if(std::fread(&info.quarter_amplitude_time, 1, sizeof(double), in) != sizeof(double))
-            break;
-        if(std::fread(&info.begin_amplitude, 1, sizeof(double), in) != sizeof(double))
-            break;
-        if(std::fread(&info.interval, 1, sizeof(double), in) != sizeof(double))
-            break;
-        if(std::fread(&info.keyoff_out_time, 1, sizeof(double), in) != sizeof(double))
-            break;
         if(std::fread(&info.ms_sound_kon, 1, sizeof(int64_t), in) != sizeof(int64_t))
             break;
         if(std::fread(&info.ms_sound_koff, 1, sizeof(int64_t), in) != sizeof(int64_t))
@@ -941,10 +944,17 @@ void MeasureThreaded::SaveCache(const char *fileName)
         fwrite(&outval, 1, sizeof(uint64_t), out);
         outval = in.insno2;
         fwrite(&outval, 1, sizeof(uint64_t), out);
+        fwrite(&in.instCache1.data, 1, 11, out);
+        fwrite(&in.instCache1.finetune, 1, 1, out);
+        fwrite(&in.instCache1.diff, 1, sizeof(bool), out);
+        fwrite(&in.instCache2.data, 1, 11, out);
+        fwrite(&in.instCache2.finetune, 1, 1, out);
+        fwrite(&in.instCache2.diff, 1, sizeof(bool), out);
         fwrite(&in.notenum, 1, 1, out);
         fwrite(&in.real4op, 1, 1, out);
         fwrite(&in.pseudo4op, 1, 1, out);
-        fwrite(&in.voice2_fine_tune, sizeof(double), 1, out);
+        int64_t voice2detune = static_cast<int64_t>(in.voice2_fine_tune * 1000000.0);
+        fwrite(&voice2detune, sizeof(int64_t), 1, out);
 
         for(InstrumentDataTab::const_iterator j = insdatatab.begin(); j != insdatatab.end(); ++j)
         {
@@ -970,12 +980,6 @@ void MeasureThreaded::SaveCache(const char *fileName)
             fwrite(&id[i].diff, 1, sizeof(bool), out);
         }
 
-        fwrite(&it->second.peak_amplitude_time, 1, sizeof(uint64_t), out);
-        fwrite(&it->second.peak_amplitude_value, 1, sizeof(double), out);
-        fwrite(&it->second.quarter_amplitude_time, 1, sizeof(double), out);
-        fwrite(&it->second.begin_amplitude, 1, sizeof(double), out);
-        fwrite(&it->second.interval, 1, sizeof(double), out);
-        fwrite(&it->second.keyoff_out_time, 1, sizeof(double), out);
         fwrite(&it->second.ms_sound_kon, 1, sizeof(int64_t), out);
         fwrite(&it->second.ms_sound_koff, 1, sizeof(int64_t), out);
         fwrite(&it->second.nosound, 1, sizeof(bool), out);
@@ -1026,7 +1030,7 @@ void MeasureThreaded::LoadCacheX(const char *fileName)
         return;
     }
 
-    itemsCount = static_cast<int_fast32_t>(toSint32LE(itemsCountA));
+    itemsCount = static_cast<uint_fast32_t>(toUint32LE(itemsCountA));
 
     while(!std::feof(in) && itemsCount > 0)
     {
@@ -1240,8 +1244,12 @@ void MeasureThreaded::destData::callback(void *myself)
                            static_cast<int_fast32_t>(s->bd_ins->percussionKeyNumber),
                            static_cast<int_fast32_t>(s->bd_ins->instFlags),
                            static_cast<int_fast32_t>(s->bd_ins->secondVoiceDetune)};
+        s->myself->m_durationInfo_mx.lock();
         DurationInfoCacheX::iterator cachedEntry = s->myself->m_durationInfoX.find(ok);
-        if(cachedEntry != s->myself->m_durationInfoX.end())
+        bool atEnd = cachedEntry == s->myself->m_durationInfoX.end();
+        s->myself->m_durationInfo_mx.unlock();
+
+        if(!atEnd)
         {
             const DurationInfo &di = cachedEntry->second;
             s->bd_ins->delay_on_ms = di.ms_sound_kon;
@@ -1258,17 +1266,21 @@ void MeasureThreaded::destData::callback(void *myself)
     }
     else
     {
-        DurationInfoCache::iterator cachedEntry = s->myself->m_durationInfo.find(s->i->first);
+        const ins &ok = s->i->first;
+        s->myself->m_durationInfo_mx.lock();
+        DurationInfoCache::iterator cachedEntry = s->myself->m_durationInfo.find(ok);
+        bool atEnd = cachedEntry == s->myself->m_durationInfo.end();
+        s->myself->m_durationInfo_mx.unlock();
 
-        if(cachedEntry != s->myself->m_durationInfo.end())
+        if(!atEnd)
         {
             s->myself->m_cache_matches++;
             goto endWork;
         }
 
-        info = MeasureDurations(s->i->first, &dosbox);
+        info = MeasureDurations(ok, &dosbox);
         s->myself->m_durationInfo_mx.lock();
-        s->myself->m_durationInfo.insert({s->i->first, info});
+        s->myself->m_durationInfo.insert({ok, info});
         s->myself->m_durationInfo_mx.unlock();
     }
 
diff --git a/utils/gen_adldata/progs_cache.cpp b/utils/gen_adldata/progs_cache.cpp
index 9de0759..2225f74 100644
--- a/utils/gen_adldata/progs_cache.cpp
+++ b/utils/gen_adldata/progs_cache.cpp
@@ -66,10 +66,14 @@ size_t InsertIns(
         }
 
         in.insno1 = insno;
+        in.instCache1 = id;
     }
 
     if(oneVoice || (id == id2))
+    {
         in.insno2 = in.insno1;
+        in.instCache2 = in.instCache1;
+    }
     else
     {
         InstrumentDataTab::iterator i = insdatatab.lower_bound(id2);
@@ -92,6 +96,7 @@ size_t InsertIns(
             insno2 = i->second.first;
         }
         in.insno2 = insno2;
+        in.instCache2 = id2;
     }
 
     {
@@ -123,13 +128,18 @@ size_t InsertNoSoundIns()
 {
     // { 0x0F70700,0x0F70710, 0xFF,0xFF, 0x0,+0 },
     insdata tmp1 = MakeNoSoundIns();
-    struct ins tmp2 = { 0, 0, 0, false, false, 0u, 0.0, 0};
+    struct ins tmp2;
     return InsertIns(tmp1, tmp1, tmp2, "nosound", "");
 }
 
 insdata MakeNoSoundIns()
 {
-    return { {0x00, 0x10, 0x07, 0x07, 0xF7, 0xF7, 0x00, 0x00, 0xFF, 0xFF, 0x00}, 0, false};
+    insdata nosnd;
+    uint8_t d[] = {0x00, 0x10, 0x07, 0x07, 0xF7, 0xF7, 0x00, 0x00, 0xFF, 0xFF, 0x00};
+    std::memcpy(nosnd.data, d, 11);
+    nosnd.finetune = 0;
+    nosnd.diff = false;
+    return nosnd;
 }
 
 
diff --git a/utils/gen_adldata/progs_cache.h b/utils/gen_adldata/progs_cache.h
index 239187b..0f25a5d 100644
--- a/utils/gen_adldata/progs_cache.h
+++ b/utils/gen_adldata/progs_cache.h
@@ -22,6 +22,18 @@ struct insdata
     uint8_t         data[11];
     int8_t          finetune;
     bool            diff;
+    explicit insdata()
+    {
+        std::memset(data, 0, 11);
+        finetune = 0;
+        diff = false;
+    }
+    insdata(const insdata &b)
+    {
+        std::memcpy(data, b.data, 11);
+        finetune = b.finetune;
+        diff = b.diff;
+    }
     bool operator==(const insdata &b) const
     {
         return (std::memcmp(data, b.data, 11) == 0) && (finetune == b.finetune) && (diff == b.diff);
@@ -46,9 +58,9 @@ struct insdata
 
 inline bool equal_approx(double const a, double const b)
 {
-    double const epsilon(std::numeric_limits<double>::epsilon() * 100);
-    double const scale(1.0);
-    return std::fabs(a - b) < epsilon * (scale + (std::max)(std::fabs(a), std::fabs(b)));
+    int_fast64_t ai = static_cast<int_fast64_t>(a * 1000000.0);
+    int_fast64_t bi = static_cast<int_fast64_t>(b * 1000000.0);
+    return ai == bi;
 }
 
 struct ins
@@ -59,18 +71,44 @@ struct ins
            Flag_RM_Cymbal = 0x20, Flag_RM_HiHat = 0x28, Mask_RhythmMode = 0x38 };
 
     size_t insno1, insno2;
+    insdata instCache1, instCache2;
     unsigned char notenum;
     bool pseudo4op;
     bool real4op;
     uint32_t rhythmModeDrum;
     double voice2_fine_tune;
     int8_t midi_velocity_offset;
+    explicit ins() :
+        insno1(0),
+        insno2(0),
+        notenum(0),
+        pseudo4op(false),
+        real4op(false),
+        rhythmModeDrum(false),
+        voice2_fine_tune(0.0),
+        midi_velocity_offset(0)
+    {}
+
+    ins(const ins &o) :
+        insno1(o.insno1),
+        insno2(o.insno2),
+        instCache1(o.instCache1),
+        instCache2(o.instCache2),
+        notenum(o.notenum),
+        pseudo4op(o.pseudo4op),
+        real4op(o.real4op),
+        rhythmModeDrum(o.rhythmModeDrum),
+        voice2_fine_tune(o.voice2_fine_tune),
+        midi_velocity_offset(o.midi_velocity_offset)
+    {}
 
     bool operator==(const ins &b) const
     {
         return notenum == b.notenum
                && insno1 == b.insno1
                && insno2 == b.insno2
+               && instCache1 == b.instCache2
+               && instCache2 == b.instCache2
                && pseudo4op == b.pseudo4op
                && real4op == b.real4op
                && rhythmModeDrum == b.rhythmModeDrum
@@ -81,6 +119,8 @@ struct ins
     {
         if(insno1 != b.insno1) return insno1 < b.insno1;
         if(insno2 != b.insno2) return insno2 < b.insno2;
+        if(instCache1 != b.instCache1) return instCache1 < b.instCache1;
+        if(instCache2 != b.instCache2) return instCache2 < b.instCache2;
         if(notenum != b.notenum) return notenum < b.notenum;
         if(pseudo4op != b.pseudo4op) return pseudo4op < b.pseudo4op;
         if(real4op != b.real4op) return real4op < b.real4op;