Revert "[AT3P] Delay for 1 frame during GHA. Adjust previous frame during."

This reverts commit 0265177f2d64503df609c63238d983d984938fab.

It looks like previous statement about adjusting delayed frame was wrong.
Commit 0265177f2d64503df609c63238d983d984938fab causes some phantom generation.

3 files changed, 45 insertions, 92 deletions

diff --git a/src/atrac/at3p/at3p_gha.cpp b/src/atrac/at3p/at3p_gha.cpp
index 71ab903..96b3eba 100644
--- a/src/atrac/at3p/at3p_gha.cpp
+++ b/src/atrac/at3p/at3p_gha.cpp
@@ -91,41 +91,6 @@ class TGhaProcessor : public IGhaProcessor {
         }
     };
 
-    class TTimeline {
-    public:
-        static void Clear(TAt3PGhaData& p)
-        {
-            for (size_t i = 0; i < p.Waves.size(); i++) {
-                TAt3PGhaData::TWavesChannel& waves = p.Waves[i];
-                waves.WaveParams.clear();
-                waves.WaveSbInfos.clear();
-            }
-            p.NumToneBands = 0;
-            p.SecondIsLeader = false;
-        }
-
-        TTimeline()
-        {
-            P0 = &Buf[0];
-            P1 = &Buf[1];
-
-            Clear(P0->Res);
-            Clear(P1->Res);
-        }
-
-        TAt3PGhaData* Cur()  { return &P1->Res; }
-        TAt3PGhaData* Prev() { return &P0->Res; }
-
-        void Swap() { std::swap(P0, P1); }
-    private:
-        struct TBuf {
-            TAt3PGhaData Res;
-        } Buf[2];
-
-        TBuf* P0;
-        TBuf* P1;
-    };
-
     struct TChannelGhaCbCtx {
         TChannelGhaCbCtx(TChannelData* data, size_t sb)
             : Data(data)
@@ -167,14 +132,13 @@ public:
     }
 
     const TAt3PGhaData* DoAnalize(TBufPtr b1, TBufPtr b2) override;
-    const TAt3PGhaData* Drain() override;
 private:
     static void FillSubbandAth(float* out);
     static TAmpSfTab CreateAmpSfTab();
     static void CheckResuidalAndApply(float* resuidal, size_t size, void* self) noexcept;
     static void GenWaves(const TAt3PGhaData::TWaveParam* param, size_t numWaves, size_t reg_offset, float* out, size_t outLimit);
 
-    void AdjustEnvelope(pair<uint32_t, uint32_t>& envelope, const pair<uint32_t, uint32_t>& src, uint32_t sb, bool folower);
+    void AdjustEnvelope(pair<uint32_t, uint32_t>& envelope, const pair<uint32_t, uint32_t>& src, uint32_t history);
     uint32_t FillFolowerRes(const TGhaInfoMap& lGha, const TChannelData* src, TGhaInfoMap::const_iterator& it, uint32_t leaderSb);
 
     uint32_t AmplitudeToSf(float amp) const;
@@ -185,7 +149,8 @@ private:
     void FillResultBuf(const vector<TChannelData>& data);
 
     gha_ctx_t LibGhaCtx;
-    TTimeline Timeline;
+    TAt3PGhaData ResultBuf;
+    TAt3PGhaData ResultBufHistory;
     const bool Stereo;
 
     static float SubbandAth[SUBBANDS];
@@ -361,14 +326,9 @@ const TAt3PGhaData* TGhaProcessor::DoAnalize(TBufPtr b1, TBufPtr b2)
     }
 
     FillResultBuf(data);
-    Timeline.Swap();
+    ResultBufHistory = ResultBuf;
 
-    return Timeline.Cur();
-}
-
-const TAt3PGhaData* TGhaProcessor::Drain()
-{
-    return Timeline.Prev();
+    return &ResultBuf;
 }
 
 bool TGhaProcessor::CheckNextFrame(const float* nextSrc, const vector<gha_info>& ghaInfos) const
@@ -564,19 +524,11 @@ bool TGhaProcessor::PsyPreCheck(size_t sb, const struct gha_info& gha, const TCh
     return false;
 }
 
-void TGhaProcessor::AdjustEnvelope(pair<uint32_t, uint32_t>& envelope, const pair<uint32_t, uint32_t>& src, uint32_t sb, bool folower)
+void TGhaProcessor::AdjustEnvelope(pair<uint32_t, uint32_t>& envelope, const pair<uint32_t, uint32_t>& src, uint32_t history)
 {
-    uint32_t history = TAt3PGhaData::INIT;
-    if (Timeline.Prev()->Waves[folower].WaveSbInfos.size() > sb) {
-        history = Timeline.Prev()->Waves[folower].WaveSbInfos[sb].Envelope.second;
-    }
-
     if (src.first == 0 && history == TAt3PGhaData::EMPTY_POINT) {
         envelope.first = TAt3PGhaData::EMPTY_POINT;
     } else {
-        if (history == TAt3PGhaData::EMPTY_POINT) {
-            Timeline.Prev()->Waves[folower].WaveSbInfos[sb].Envelope.second = 31;
-        }
         if (src.first == TAt3PGhaData::EMPTY_POINT) {
             abort(); //impossible right now
             envelope.first = TAt3PGhaData::EMPTY_POINT;
@@ -623,16 +575,15 @@ void TGhaProcessor::FillResultBuf(const vector<TChannelData>& data)
     std::vector<TWavesChannel> history;
     history.reserve(data.size());
 
-    auto resultBuf = Timeline.Cur();
-    history.push_back(resultBuf->Waves[0]);
+    history.push_back(ResultBuf.Waves[0]);
 
-    resultBuf->SecondIsLeader = leader;
-    resultBuf->NumToneBands = usedContiguousSb[leader];
+    ResultBuf.SecondIsLeader = leader;
+    ResultBuf.NumToneBands = usedContiguousSb[leader];
 
     TGhaInfoMap::const_iterator leaderStartIt;
     TGhaInfoMap::const_iterator folowerIt;
     if (data.size() == 2) {
-        TWavesChannel& fWaves = resultBuf->Waves[1];
+        TWavesChannel& fWaves = ResultBuf.Waves[1];
 
         history.push_back(fWaves);
 
@@ -645,7 +596,7 @@ void TGhaProcessor::FillResultBuf(const vector<TChannelData>& data)
     }
 
     const auto& ghaInfos = data[leader].GhaInfos;
-    TWavesChannel& waves = resultBuf->Waves[0];
+    TWavesChannel& waves = ResultBuf.Waves[0];
     waves.WaveParams.clear();
     waves.WaveSbInfos.clear();
     waves.WaveSbInfos.resize(usedContiguousSb[leader]);
@@ -669,7 +620,11 @@ void TGhaProcessor::FillResultBuf(const vector<TChannelData>& data)
 
         waves.WaveSbInfos[sb].WaveNums++;
         if (sb != prevSb) {
-            AdjustEnvelope(waves.WaveSbInfos[prevSb].Envelope, data[leader].Envelopes[prevSb], prevSb, 0);
+            uint32_t histStop = TAt3PGhaData::INIT;
+            if (ResultBufHistory.Waves[0].WaveSbInfos.size() > prevSb) {
+                histStop = ResultBufHistory.Waves[0].WaveSbInfos[prevSb].Envelope.second;
+            }
+            AdjustEnvelope(waves.WaveSbInfos[prevSb].Envelope, data[leader].Envelopes[prevSb], histStop);
 
             // update index sb -> wave position index
             waves.WaveSbInfos[sb].WaveIndex = index;
@@ -687,7 +642,12 @@ void TGhaProcessor::FillResultBuf(const vector<TChannelData>& data)
         index++;
     }
 
-    TGhaProcessor::AdjustEnvelope(waves.WaveSbInfos[prevSb].Envelope, data[leader].Envelopes[prevSb], prevSb, 0);
+    uint32_t histStop = (uint32_t)-2;
+    if (ResultBufHistory.Waves[0].WaveSbInfos.size() > prevSb) {
+        histStop = ResultBufHistory.Waves[0].WaveSbInfos[prevSb].Envelope.second;
+    }
+
+    TGhaProcessor::AdjustEnvelope(waves.WaveSbInfos[prevSb].Envelope, data[leader].Envelopes[prevSb], histStop);
 
     if (data.size() == 2) {
         FillFolowerRes(data[leader].GhaInfos, &data[!leader], folowerIt, prevSb);
@@ -696,9 +656,14 @@ void TGhaProcessor::FillResultBuf(const vector<TChannelData>& data)
 
 uint32_t TGhaProcessor::FillFolowerRes(const TGhaInfoMap& lGhaInfos, const TChannelData* src, TGhaInfoMap::const_iterator& it, const uint32_t curSb)
 {
+    uint32_t histStop = (uint32_t)-2;
+    if (ResultBufHistory.Waves[1].WaveSbInfos.size() > curSb) {
+        histStop = ResultBufHistory.Waves[1].WaveSbInfos[curSb].Envelope.second;
+    }
+
     const TGhaInfoMap& fGhaInfos = src->GhaInfos;
 
-    TWavesChannel& waves = Timeline.Cur()->Waves[1];
+    TWavesChannel& waves = ResultBuf.Waves[1];
 
     uint32_t folowerSbMode = 0; // 0 - no tones, 1 - sharing band, 2 - own tones set
     uint32_t nextSb = 0;
@@ -726,18 +691,18 @@ uint32_t TGhaProcessor::FillFolowerRes(const TGhaInfoMap& lGhaInfos, const TChan
 
     switch (folowerSbMode) {
         case 0:
-            Timeline.Cur()->ToneSharing[curSb] = false;
+            ResultBuf.ToneSharing[curSb] = false;
             waves.WaveSbInfos[curSb].WaveNums = 0;
             break;
         case 1:
-            Timeline.Cur()->ToneSharing[curSb] = true;
+            ResultBuf.ToneSharing[curSb] = true;
             waves.WaveParams.resize(waves.WaveParams.size() - added);
             break;
         default:
-            Timeline.Cur()->ToneSharing[curSb] = false;
+            ResultBuf.ToneSharing[curSb] = false;
             waves.WaveSbInfos[curSb].WaveIndex = waves.WaveParams.size() - added;
             waves.WaveSbInfos[curSb].WaveNums = added;
-            AdjustEnvelope(waves.WaveSbInfos[curSb].Envelope, src->Envelopes[curSb], curSb, 1);
+            AdjustEnvelope(waves.WaveSbInfos[curSb].Envelope, src->Envelopes[curSb], histStop);
     }
     return nextSb;
 }
diff --git a/src/atrac/at3p/at3p_gha.h b/src/atrac/at3p/at3p_gha.h
index b14e8d9..45f3cbc 100644
--- a/src/atrac/at3p/at3p_gha.h
+++ b/src/atrac/at3p/at3p_gha.h
@@ -69,7 +69,6 @@ public:
     using TBufPtr = std::array<const float*, 2>;
     virtual ~IGhaProcessor() {}
     virtual const TAt3PGhaData* DoAnalize(TBufPtr b1, TBufPtr b2) = 0;
-    virtual const TAt3PGhaData* Drain() = 0;
 };
 
 std::unique_ptr<IGhaProcessor> MakeGhaProcessor0(bool stereo);
diff --git a/src/atrac/at3p/at3p_gha_ut.cpp b/src/atrac/at3p/at3p_gha_ut.cpp
index e152ae3..fcf5095 100644
--- a/src/atrac/at3p/at3p_gha_ut.cpp
+++ b/src/atrac/at3p/at3p_gha_ut.cpp
@@ -51,8 +51,7 @@ static const TAt3PGhaData __attribute__ ((noinline)) GenAndRunGha(vector<TTestPa
     const float* b1 = buf1.data();
     const float* b2 = buf2.empty() ? nullptr : buf2.data();
 
-    processor->DoAnalize({b1, b1 + 2048}, {b2, b2 + 2048});
-    return *processor->Drain();
+    return *(processor->DoAnalize({b1, b1 + 2048}, {b2, b2 + 2048}));
 }
 
 static class TDumper {
@@ -470,9 +469,8 @@ TEST(AT3PGHA, 100hz__two_frames_mono) {
     std::vector<TAt3PGhaData> resBuf;
     auto processor = MakeGhaProcessor0(false);
 
-    processor->DoAnalize({&buf[0], &buf[2048]}, {nullptr, nullptr});
     {
-        const auto& res = *processor->DoAnalize({&buf[2048], &buf[0]}, {nullptr, nullptr});
+        const auto& res = *processor->DoAnalize({&buf[0], &buf[2048]}, {nullptr, nullptr});
 
         EXPECT_EQ(res.NumToneBands, 1);
         EXPECT_EQ(res.Waves[0].WaveParams.size(), 1);
@@ -488,7 +486,7 @@ TEST(AT3PGHA, 100hz__two_frames_mono) {
 
     {
         memset(&buf[0], 0, sizeof(float) * 128);
-        const auto& res = *processor->Drain();
+        const auto& res = *processor->DoAnalize({&buf[2048], &buf[0]}, {nullptr, nullptr});
 
         EXPECT_EQ(res.NumToneBands, 1);
         EXPECT_EQ(res.Waves[0].WaveParams.size(), 1);
@@ -516,10 +514,9 @@ TEST(AT3PGHA, 100hz_than_500hz_than_100hz__3_frames_mono) {
     std::vector<TAt3PGhaData> resBuf;
     auto processor = MakeGhaProcessor0(false);
 
-    processor->DoAnalize({&buf[0], &buf[2048]}, {nullptr, nullptr});
     {
+        const auto& res = *processor->DoAnalize({&buf[0], &buf[2048]}, {nullptr, nullptr});
 
-        const auto& res = *processor->DoAnalize({&buf[2048], &buf[0]}, {nullptr, nullptr});
         EXPECT_EQ(res.NumToneBands, 1);
         EXPECT_EQ(res.Waves[0].WaveParams.size(), 1);
         EXPECT_EQ(res.Waves[0].WaveSbInfos.size(), 1);
@@ -535,7 +532,7 @@ TEST(AT3PGHA, 100hz_than_500hz_than_100hz__3_frames_mono) {
     {
         memset(&buf[0], 0, sizeof(float) * 128);
         Gen({100.0f, 0, 32768, 0, 128}, buf);
-        const auto& res = *processor->DoAnalize({&buf[0], &buf[2048]}, {nullptr, nullptr});
+        const auto& res = *processor->DoAnalize({&buf[2048], &buf[0]}, {nullptr, nullptr});
 
         EXPECT_EQ(res.NumToneBands, 1);
         EXPECT_EQ(res.Waves[0].WaveParams.size(), 1);
@@ -550,8 +547,7 @@ TEST(AT3PGHA, 100hz_than_500hz_than_100hz__3_frames_mono) {
     }
     {
         memset(&buf[2048], 0, sizeof(float) * 128);
-
-        const auto& res = *processor->Drain();
+        const auto& res = *processor->DoAnalize({&buf[0], &buf[2048]}, {nullptr, nullptr});
 
         EXPECT_EQ(res.NumToneBands, 1);
         EXPECT_EQ(res.Waves[0].WaveParams.size(), 1);
@@ -578,8 +574,7 @@ TEST(AT3PGHA, 100hz__phase_two_frames_mono) {
     memset(&buf[128], 0, sizeof(float) * 128);
 
     auto processor = MakeGhaProcessor0(false);
-    processor->DoAnalize({&buf[0], &buf[2048]}, {nullptr, nullptr});
-    const auto& res = *processor->Drain();
+    const auto& res = *processor->DoAnalize({&buf[0], &buf[2048]}, {nullptr, nullptr});
 
     EXPECT_EQ(res.NumToneBands, 1);
     EXPECT_EQ(res.Waves[0].WaveParams.size(), 1);
@@ -601,8 +596,7 @@ TEST(AT3PGHA, 689hz0625__two_frames_mono) {
     memset(&buf[128], 0, sizeof(float) * 128);
 
     auto processor = MakeGhaProcessor0(false);
-    processor->DoAnalize({&buf[0], &buf[2048]}, {nullptr, nullptr});
-    const auto& res = *processor->Drain();
+    const auto& res = *processor->DoAnalize({&buf[0], &buf[2048]}, {nullptr, nullptr});
 
     EXPECT_EQ(res.NumToneBands, 1);
     EXPECT_EQ(res.Waves[0].WaveParams.size(), 1);
@@ -623,8 +617,7 @@ TEST(AT3PGHA, 689hz0625_1000hz__two_frames_mono) {
     memset(&buf[128], 0, sizeof(float) * 128);
 
     auto processor = MakeGhaProcessor0(false);
-    processor->DoAnalize({&buf[0], &buf[2048]}, {nullptr, nullptr});
-    const auto& res = *processor->Drain();
+    const auto& res = *processor->DoAnalize({&buf[0], &buf[2048]}, {nullptr, nullptr});
 
     EXPECT_EQ(res.NumToneBands, 1);
     EXPECT_EQ(res.Waves[0].WaveParams.size(), 2);
@@ -647,8 +640,7 @@ TEST(AT3PGHA, 500hz_1000hz__two_frames_mono) {
     memset(&buf[128], 0, sizeof(float) * 128);
 
     auto processor = MakeGhaProcessor0(false);
-    processor->DoAnalize({&buf[0], &buf[2048]}, {nullptr, nullptr});
-    const auto& res = *processor->Drain();
+    const auto& res = *processor->DoAnalize({&buf[0], &buf[2048]}, {nullptr, nullptr});
 
     EXPECT_EQ(res.NumToneBands, 1);
     EXPECT_EQ(res.Waves[0].WaveParams.size(), 2);
@@ -671,8 +663,7 @@ TEST(AT3PGHA, 500hz_1000hz__phase_two_frames_mono) {
     memset(&buf[128], 0, sizeof(float) * 128);
 
     auto processor = MakeGhaProcessor0(false);
-    processor->DoAnalize({&buf[0], &buf[2048]}, {nullptr, nullptr});
-    const auto& res = *processor->Drain();
+    const auto& res = *processor->DoAnalize({&buf[0], &buf[2048]}, {nullptr, nullptr});
 
     EXPECT_EQ(res.NumToneBands, 1);
     EXPECT_EQ(res.Waves[0].WaveParams.size(), 2);
@@ -698,8 +689,7 @@ TEST(AT3PGHA, 250hz_500hz_1000hz__two_frames_mono) {
     memset(&buf[128], 0, sizeof(float) * 128);
 
     auto processor = MakeGhaProcessor0(false);
-    processor->DoAnalize({&buf[0], &buf[2048]}, {nullptr, nullptr});
-    const auto& res = *processor->Drain();
+    const auto& res = *processor->DoAnalize({&buf[0], &buf[2048]}, {nullptr, nullptr});
 
     EXPECT_EQ(res.NumToneBands, 1);
     EXPECT_EQ(res.Waves[0].WaveParams.size(), 3);
@@ -726,8 +716,7 @@ TEST(AT3PGHA, 250hz_500hz_1000hz_1200hz__two_frames_mono) {
     memset(&buf[128], 0, sizeof(float) * 128);
 
     auto processor = MakeGhaProcessor0(false);
-    processor->DoAnalize({&buf[0], &buf[2048]}, {nullptr, nullptr});
-    const auto& res = *processor->Drain();
+    const auto& res = *processor->DoAnalize({&buf[0], &buf[2048]}, {nullptr, nullptr});
 
     EXPECT_EQ(res.NumToneBands, 1);
     EXPECT_EQ(res.Waves[0].WaveParams.size(), 4);