Merge branch 'at3plus-dev'

It looks like we are able to encode ATRAC3PLUS compatible bitstream so we can merge at3p development branch in to the main branch.
Current limitation for AT3P mode:
- Only 352 Kbps (proper bit allocation and some psychoacoustic must be implemented)
- GHA sometime works with error (but huge bitrate hide it)
- No VLC, VQ, delta encoding
- No noise substitution
- No gain control
- No window shape switching

3 files changed, 433 insertions, 0 deletions

diff --git a/src/lib/bs_encode/encode.cpp b/src/lib/bs_encode/encode.cpp
new file mode 100644
index 0000000..230ae0f
--- /dev/null
+++ b/src/lib/bs_encode/encode.cpp
@@ -0,0 +1,184 @@
+/*
+ * This file is part of AtracDEnc.
+ *
+ * AtracDEnc is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * AtracDEnc is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with AtracDEnc; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "encode.h"
+
+#include <iostream>
+
+namespace NAtracDEnc {
+
+using NBitStream::TBitStream;
+
+class TBitStreamEncoder::TImpl : public TBitAllocHandler {
+public:
+    explicit TImpl(std::vector<IBitStreamPartEncoder::TPtr>&& encoders);
+    void DoStart(size_t targetBits, float minLambda, float maxLambda) noexcept;
+    float DoContinue() noexcept;
+    void DoSubmit(size_t gotBits) noexcept;
+    bool DoCheck(size_t gotBits) const noexcept;
+    void DoRun(void* frameData, TBitStream& bs);
+    uint32_t DoGetCurGlobalConsumption() const noexcept;
+private:
+    std::vector<IBitStreamPartEncoder::TPtr> Encoders;
+    size_t CurEncPos;
+    size_t RepeatEncPos;
+
+    size_t TargetBits;
+    float MinLambda;
+    float MaxLambda;
+    float CurLambda;
+    float LastLambda;
+
+    bool NeedRepeat = false;
+};
+
+TBitStreamEncoder::TImpl::TImpl(std::vector<IBitStreamPartEncoder::TPtr>&& encoders)
+    : Encoders(std::move(encoders))
+    , CurEncPos(0)
+    , RepeatEncPos(0)
+{
+}
+
+void TBitStreamEncoder::TImpl::DoStart(size_t targetBits, float minLambda, float maxLambda) noexcept
+{
+    TargetBits = targetBits;
+    MinLambda = minLambda;
+    MaxLambda = maxLambda;
+}
+
+float TBitStreamEncoder::TImpl::DoContinue() noexcept
+{
+    if (MaxLambda <= MinLambda) {
+        return LastLambda;
+    }
+
+    CurLambda = (MaxLambda + MinLambda) / 2.0;
+    RepeatEncPos = CurEncPos;
+    return CurLambda;
+}
+
+void TBitStreamEncoder::TImpl::DoSubmit(size_t gotBits) noexcept
+{
+    if  (MaxLambda <= MinLambda) {
+        NeedRepeat = false;
+    } else {
+        if (gotBits < TargetBits) {
+            LastLambda = CurLambda;
+            MaxLambda = CurLambda - 0.01f;
+            NeedRepeat = true;
+        } else if (gotBits > TargetBits) {
+            MinLambda = CurLambda + 0.01f;
+            NeedRepeat = true;
+        } else {
+            NeedRepeat = false;
+        }
+    }
+}
+
+bool TBitStreamEncoder::TImpl::DoCheck(size_t gotBits) const noexcept
+{
+    return gotBits < TargetBits;
+}
+
+void TBitStreamEncoder::TImpl::DoRun(void* frameData, TBitStream& bs)
+{
+    bool cont = false;
+    do {
+        for (CurEncPos = RepeatEncPos; CurEncPos < Encoders.size(); CurEncPos++) {
+            auto status = Encoders[CurEncPos]->Encode(frameData, *this);
+            if (NeedRepeat) {
+                NeedRepeat = false;
+                cont = true;
+                break;
+            } else {
+                cont = false;
+            }
+            if (status == IBitStreamPartEncoder::EStatus::Repeat) {
+                cont = true;
+                for (size_t i = 0; i < CurEncPos; i++) {
+                    Encoders[i]->Reset();
+                }
+                RepeatEncPos = 0;
+                break;
+            }
+        }
+    } while (cont);
+
+    for (size_t i = 0; i < Encoders.size(); i++) {
+        Encoders[i]->Dump(bs);
+    }
+}
+
+uint32_t TBitStreamEncoder::TImpl::DoGetCurGlobalConsumption() const noexcept
+{
+    uint32_t consumption = 0;
+    for (size_t i = 0; i < CurEncPos; i++) {
+        consumption += Encoders[i]->GetConsumption();
+    }
+    return consumption;
+}
+
+/////
+
+TBitStreamEncoder::TBitStreamEncoder(std::vector<IBitStreamPartEncoder::TPtr>&& encoders)
+    : Impl(new TBitStreamEncoder::TImpl(std::move(encoders)))
+{}
+
+TBitStreamEncoder::~TBitStreamEncoder()
+{
+    delete Impl;
+}
+
+void TBitStreamEncoder::Do(void* frameData, TBitStream& bs)
+{
+    Impl->DoRun(frameData, bs);
+}
+
+/////
+
+void TBitAllocHandler::Start(size_t targetBits, float minLambda, float maxLambda) noexcept
+{
+    TBitStreamEncoder::TImpl* self = static_cast<TBitStreamEncoder::TImpl*>(this);
+    self->DoStart(targetBits, minLambda, maxLambda);
+}
+
+float TBitAllocHandler::Continue() noexcept
+{
+    TBitStreamEncoder::TImpl* self = static_cast<TBitStreamEncoder::TImpl*>(this);
+    return self->DoContinue();
+}
+
+void TBitAllocHandler::Submit(size_t gotBits) noexcept
+{
+    TBitStreamEncoder::TImpl* self = static_cast<TBitStreamEncoder::TImpl*>(this);
+    self->DoSubmit(gotBits);
+}
+
+bool TBitAllocHandler::Check(size_t gotBits) const noexcept
+{
+    const TBitStreamEncoder::TImpl* self = static_cast<const TBitStreamEncoder::TImpl*>(this);
+    return self->DoCheck(gotBits);
+}
+
+uint32_t TBitAllocHandler::GetCurGlobalConsumption() const noexcept
+{
+    const TBitStreamEncoder::TImpl* self = static_cast<const TBitStreamEncoder::TImpl*>(this);
+    return self->DoGetCurGlobalConsumption();
+}
+
+}
diff --git a/src/lib/bs_encode/encode.h b/src/lib/bs_encode/encode.h
new file mode 100644
index 0000000..3302d10
--- /dev/null
+++ b/src/lib/bs_encode/encode.h
@@ -0,0 +1,71 @@
+/*
+ * This file is part of AtracDEnc.
+ *
+ * AtracDEnc is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * AtracDEnc is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with AtracDEnc; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#pragma once
+
+#include <memory>
+#include <vector>
+#include <functional>
+
+namespace NBitStream {
+class TBitStream;
+}
+
+namespace NAtracDEnc {
+
+class TBitAllocHandler {
+public:
+    void Start(size_t targetBits, float minLambda, float maxLambda) noexcept;
+    float Continue() noexcept;
+    bool Check(size_t gitBits) const noexcept;
+    void Submit(size_t gotBits) noexcept;
+
+    // Returns consumption of all previous encoded parts (except part from this method called)
+    uint32_t GetCurGlobalConsumption() const noexcept;
+};
+
+class IBitStreamPartEncoder {
+public:
+    using TPtr = std::unique_ptr<IBitStreamPartEncoder>;
+    enum class EStatus {
+        Ok, // Ok, go to the next stage
+        Repeat, // Repeat from first stage
+    };
+
+    virtual ~IBitStreamPartEncoder() = default;
+    virtual EStatus Encode(void* frameData, TBitAllocHandler& ba) = 0;
+    virtual void Dump(NBitStream::TBitStream& bs) = 0;
+    virtual void Reset() noexcept {};
+    virtual uint32_t GetConsumption() const noexcept = 0;
+};
+
+class TBitStreamEncoder {
+public:
+    class TImpl;
+    explicit TBitStreamEncoder(std::vector<IBitStreamPartEncoder::TPtr>&& encoders);
+    ~TBitStreamEncoder();
+
+    void Do(void* frameData, NBitStream::TBitStream& bs);
+    TBitStreamEncoder(const TBitStreamEncoder&) = delete;
+    TBitStreamEncoder& operator=(const TBitStreamEncoder&) = delete;
+private:
+    std::vector<IBitStreamPartEncoder::TPtr> Encoders;
+    TImpl* Impl;
+};
+
+}
diff --git a/src/lib/bs_encode/encode_ut.cpp b/src/lib/bs_encode/encode_ut.cpp
new file mode 100644
index 0000000..39f0ff1
--- /dev/null
+++ b/src/lib/bs_encode/encode_ut.cpp
@@ -0,0 +1,178 @@
+/*
+ * This file is part of AtracDEnc.
+ *
+ * AtracDEnc is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * AtracDEnc is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with AtracDEnc; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "encode.h"
+#include <gtest/gtest.h>
+#include <cmath>
+#include <memory>
+#include <bitstream/bitstream.h>
+
+using namespace NAtracDEnc;
+
+static size_t SomeBitFn1(float lambda) {
+    return sqrt(lambda * (-1.0f)) * 300;
+}
+
+static size_t SomeBitFn2(float lambda) {
+    return 1 + (SomeBitFn1(lambda) & (~(size_t)7));
+}
+
+class TPartEncoder1 : public IBitStreamPartEncoder {
+public:
+    explicit TPartEncoder1(size_t expCalls)
+        : ExpCalls(expCalls)
+    {}
+
+    EStatus Encode(void* frameData, TBitAllocHandler& ba) override {
+        EncCalls++;
+        ba.Start(1000, -15, -1);
+        return EStatus::Ok;
+    }
+
+    void Dump(NBitStream::TBitStream& bs) override {
+         EXPECT_EQ(EncCalls, ExpCalls);
+    }
+
+    uint32_t GetConsumption() const noexcept override {
+        return 0;
+    }
+private:
+    const size_t ExpCalls;
+    size_t EncCalls = 0;
+};
+
+template<size_t (*F)(float)>
+class TPartEncoder2 : public IBitStreamPartEncoder {
+public:
+    explicit TPartEncoder2(size_t expCalls)
+        : ExpCalls(expCalls)
+    {}
+
+    EStatus Encode(void* frameData, TBitAllocHandler& ba) override {
+        EncCalls++;
+        auto lambda = ba.Continue();
+        auto bits = F(lambda);
+        ba.Submit(bits);
+        Bits = bits;
+        return EStatus::Ok;
+    }
+
+    void Dump(NBitStream::TBitStream& bs) override {
+         EXPECT_EQ(EncCalls, ExpCalls);
+         for (size_t i = 0; i < Bits; i++) {
+             bs.Write(1, 1);
+         }
+    }
+
+    uint32_t GetConsumption() const noexcept override {
+        return 1 * Bits;
+    }
+private:
+    const size_t ExpCalls;
+    size_t EncCalls = 0;
+    size_t Bits = 0;
+};
+
+class TPartEncoder3 : public IBitStreamPartEncoder {
+public:
+    explicit TPartEncoder3(size_t expCalls)
+        : ExpCalls(expCalls)
+    {}
+
+    EStatus Encode(void* frameData, TBitAllocHandler& ba) override {
+        EncCalls++;
+        return EStatus::Ok;
+    }
+
+    void Dump(NBitStream::TBitStream& bs) override {
+         EXPECT_EQ(EncCalls, ExpCalls);
+    }
+
+    uint32_t GetConsumption() const noexcept override {
+        return 0;
+    }
+private:
+    const size_t ExpCalls;
+    size_t EncCalls = 0;
+};
+
+class TPartEncoder4 : public IBitStreamPartEncoder {
+public:
+    TPartEncoder4() = default;
+
+    EStatus Encode(void* frameData, TBitAllocHandler& ba) override {
+        if (EncCalls == 0) {
+            EncCalls++;
+            return EStatus::Repeat;
+        }
+
+        return EStatus::Ok;
+    }
+
+    void Dump(NBitStream::TBitStream& bs) override {
+         EXPECT_EQ(EncCalls, 1);
+    }
+
+    uint32_t GetConsumption() const noexcept override {
+        return 0;
+    }
+private:
+    size_t EncCalls = 0;
+};
+
+TEST(BsEncode, SimpleAlloc) {
+    std::vector<IBitStreamPartEncoder::TPtr> encoders;
+    encoders.emplace_back(std::make_unique<TPartEncoder1>(1));
+    encoders.emplace_back(std::make_unique<TPartEncoder2<SomeBitFn1>>(8));
+    encoders.emplace_back(std::make_unique<TPartEncoder3>(1));
+
+    NBitStream::TBitStream bs;
+    TBitStreamEncoder encoder(std::move(encoders));
+    encoder.Do(nullptr, bs);
+
+    EXPECT_EQ(bs.GetSizeInBits(), 1000);
+}
+
+TEST(BsEncode, AllocWithRepeat) {
+    std::vector<IBitStreamPartEncoder::TPtr> encoders;
+    encoders.emplace_back(std::make_unique<TPartEncoder1>(2));
+    encoders.emplace_back(std::make_unique<TPartEncoder2<SomeBitFn1>>(16));
+    encoders.emplace_back(std::make_unique<TPartEncoder3>(2));
+    encoders.emplace_back(std::make_unique<TPartEncoder4>());
+
+    NBitStream::TBitStream bs;
+    TBitStreamEncoder encoder(std::move(encoders));
+    encoder.Do(nullptr, bs);
+
+    EXPECT_EQ(bs.GetSizeInBits(), 1000);
+}
+
+TEST(BsEncode, NotExactAlloc) {
+    std::vector<IBitStreamPartEncoder::TPtr> encoders;
+    encoders.emplace_back(std::make_unique<TPartEncoder1>(1));
+    encoders.emplace_back(std::make_unique<TPartEncoder2<SomeBitFn2>>(11));
+    encoders.emplace_back(std::make_unique<TPartEncoder3>(1));
+
+    NBitStream::TBitStream bs;
+    TBitStreamEncoder encoder(std::move(encoders));
+    encoder.Do(nullptr, bs);
+
+    EXPECT_EQ(bs.GetSizeInBits(), 993);
+}
+
+