refactoring:

some changes to get possibility to create alternative
compression algorithms and use different containers.

7 files changed, 63 insertions, 32 deletions

diff --git a/src/aea.cpp b/src/aea.cpp
index 93f0431..7432dcc 100644
--- a/src/aea.cpp
+++ b/src/aea.cpp
@@ -106,7 +106,7 @@ void TAea::WriteFrame(std::vector<char> data) {
 int TAea::GetChannelNum() const {
     return Meta.AeaHeader[264];
 }
-uint32_t TAea::GetLengthInSamples() const {
+long long TAea::GetLengthInSamples() const {
     const int fd = fileno(Meta.AeaFile);
     struct stat sb;
     fstat(fd, &sb);
diff --git a/src/aea.h b/src/aea.h
index bbd3f17..0ca1e7a 100644
--- a/src/aea.h
+++ b/src/aea.h
@@ -5,6 +5,7 @@
 #include <array>
 #include <memory>
 
+#include "compressed_io.h"
 
 
 class TAeaIOError : public std::exception {
@@ -25,7 +26,10 @@ public:
 class TAeaFormatError {
 };
 
-class TAea {
+static const int AEA_FRAME_SZ = 212;
+typedef ICompressedIO<AEA_FRAME_SZ> IAtrac1IO;
+
+class TAea : public IAtrac1IO {
     static constexpr uint32_t AeaMetaSize = 2048;
     struct TMeta {
         FILE* AeaFile;
@@ -35,17 +39,15 @@ class TAea {
     static TAea::TMeta CreateMeta(const std::string& filename, const std::string& title, int numChannel, uint32_t numFrames);
     bool FirstWrite = true;
 public:
-        typedef std::array<char, 212> TFrame;
 		TAea(const std::string& filename);
         TAea(const std::string& filename, const std::string& title, int numChannel, uint32_t numFrames);
 		~TAea();
-        std::unique_ptr<TFrame> ReadFrame(); 
-//        void WriteFrame(std::unique_ptr<TAea::TFrame>&& frame);
-        void WriteFrame(std::vector<char> data);
-        std::string GetName() const;
-        int GetChannelNum() const;
-        uint32_t GetLengthInSamples() const;
+        std::unique_ptr<TFrame> ReadFrame() override; 
+        void WriteFrame(std::vector<char> data) override;
+        std::string GetName() const override;
+        int GetChannelNum() const override;
+        long long GetLengthInSamples() const override;
 };
 
-typedef std::unique_ptr<TAea> TAeaPtr;
+typedef std::unique_ptr<IAtrac1IO> TAeaPtr;
 
diff --git a/src/atracdenc.cpp b/src/atracdenc.cpp
index bf27539..092059c 100644
--- a/src/atracdenc.cpp
+++ b/src/atracdenc.cpp
@@ -22,11 +22,10 @@ static vector<double> invertSpectr(double* in) {
     return buf;
 }
 
-TAtrac1Processor::TAtrac1Processor(TAeaPtr&& aea, bool mono)
-    : MixChannel(mono)
-    , Aea(std::move(aea))
+TAtrac1Processor::TAtrac1Processor(TAeaPtr&& aea, TAtrac1EncodeSettings&& settings)
+    : Aea(std::move(aea))
+    , Settings(std::move(settings))
 {
-    (void)MixChannel; //TODO
 }
 
 static void vector_fmul_window(double *dst, const double *src0,
@@ -171,13 +170,17 @@ TPCMEngine<double>::TProcessLambda TAtrac1Processor::GetDecodeLambda() {
 }
 
 
-TPCMEngine<double>::TProcessLambda TAtrac1Processor::GetEncodeLambda(const TAtrac1EncodeSettings& settings) {
+TPCMEngine<double>::TProcessLambda TAtrac1Processor::GetEncodeLambda() {
     const uint32_t srcChannels = Aea->GetChannelNum();
     vector<IAtrac1BitAlloc*> bitAlloc;
-    for (int i = 0; i < srcChannels; i++)
-        bitAlloc.push_back(new TAtrac1SimpleBitAlloc(Aea.get(), settings.GetBfuIdxConst(), settings.GetFastBfuNumSearch()));
+    for (int i = 0; i < srcChannels; i++) {
+        TAea* atrac1container = dynamic_cast<TAea*>(Aea.get());
+        if (atrac1container == nullptr)
+            abort();
+        bitAlloc.push_back(new TAtrac1SimpleBitAlloc(atrac1container, Settings.GetBfuIdxConst(), Settings.GetFastBfuNumSearch()));
+    }
 
-    return [this, srcChannels, bitAlloc, settings](vector<double>* data) {
+    return [this, srcChannels, bitAlloc](vector<double>* data) {
         for (uint32_t channel = 0; channel < srcChannels; channel++) {
             double src[NumSamples];
             vector<double> specs(512);
@@ -188,7 +191,7 @@ TPCMEngine<double>::TProcessLambda TAtrac1Processor::GetEncodeLambda(const TAtra
             SplitFilterBank[channel].Split(&src[0], &PcmBufLow[channel][0], &PcmBufMid[channel][0], &PcmBufHi[channel][0]);
 
             uint32_t windowMask = 0;
-            if (settings.GetWindowMode() == TAtrac1EncodeSettings::EWindowMode::EWM_AUTO) {
+            if (Settings.GetWindowMode() == TAtrac1EncodeSettings::EWindowMode::EWM_AUTO) {
                 windowMask |= (uint32_t)TransientDetectors.GetDetector(channel, 0).Detect(&PcmBufLow[channel][0]);
 
                 const vector<double>& invMid = invertSpectr<128>(&PcmBufMid[channel][0]);
@@ -200,7 +203,7 @@ TPCMEngine<double>::TProcessLambda TAtrac1Processor::GetEncodeLambda(const TAtra
                 //std::cout << "trans: " << windowMask << std::endl;
             } else {
                 //no transient detection, use given mask
-                windowMask = settings.GetWindowMask();
+                windowMask = Settings.GetWindowMask();
             }
             const TBlockSize blockSize(windowMask & 0x1, windowMask & 0x2, windowMask & 0x4); //low, mid, hi
 
diff --git a/src/atracdenc.h b/src/atracdenc.h
index 03e85ea..eb2f670 100644
--- a/src/atracdenc.h
+++ b/src/atracdenc.h
@@ -33,9 +33,9 @@ public:
     {}
 };
 
-class TAtrac1Processor : public TAtrac1MDCT, public virtual TAtrac1Data {
-    bool MixChannel;
+class TAtrac1Processor : public IProcessor<double>, public TAtrac1MDCT, public virtual TAtrac1Data {
     TAeaPtr Aea;
+    const TAtrac1EncodeSettings Settings;
 
     double PcmBufLow[2][256 + 16];
     double PcmBufMid[2][256 + 16];
@@ -79,9 +79,9 @@ class TAtrac1Processor : public TAtrac1MDCT, public virtual TAtrac1Data {
     NAtrac1::TScaler Scaler;
 
 public:
-    TAtrac1Processor(TAeaPtr&& aea, bool mono = false);
-    TPCMEngine<double>::TProcessLambda GetDecodeLambda();
+    TAtrac1Processor(TAeaPtr&& aea, TAtrac1EncodeSettings&& settings);
+    TPCMEngine<double>::TProcessLambda GetDecodeLambda() override;
 
-    TPCMEngine<double>::TProcessLambda GetEncodeLambda(const TAtrac1EncodeSettings& settings);
+    TPCMEngine<double>::TProcessLambda GetEncodeLambda() override;
 };
 }
diff --git a/src/compressed_io.h b/src/compressed_io.h
new file mode 100644
index 0000000..9999f43
--- /dev/null
+++ b/src/compressed_io.h
@@ -0,0 +1,16 @@
+#pragma once
+#include <vector>
+#include <array>
+#include <string>
+
+template<int FRAME_SZ>
+class ICompressedIO {
+public:
+    typedef std::array<char, FRAME_SZ> TFrame;
+    virtual void WriteFrame(std::vector<char> data) = 0;
+    virtual std::unique_ptr<TFrame> ReadFrame() = 0;
+    virtual std::string GetName() const = 0;
+    virtual int GetChannelNum() const = 0;
+    virtual long long GetLengthInSamples() const = 0;
+    virtual ~ICompressedIO() {}
+};
diff --git a/src/main.cpp b/src/main.cpp
index 1706a19..62a42d4 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -134,33 +134,35 @@ int main(int argc, char* const* argv) {
         return 1;
     }
 
-    TWavPtr wavIO;
-    TAeaPtr aeaIO;
     TPCMEngine<double>* pcmEngine = nullptr;
+    IProcessor<double>* atracProcessor;
     uint64_t totalSamples = 0;
+    TWavPtr wavIO;
     if (mode == E_ENCODE) {
         wavIO = TWavPtr(new TWav(inFile));
         const int numChannels = wavIO->GetChannelNum();
         totalSamples = wavIO->GetTotalSamples();
         //TODO: recheck it
-        aeaIO = TAeaPtr(new TAea(outFile, "test", numChannels, numChannels * totalSamples / 512));
+        TAeaPtr aeaIO = TAeaPtr(new TAea(outFile, "test", numChannels, numChannels * totalSamples / 512));
         pcmEngine = new TPCMEngine<double>(4096, numChannels, TPCMEngine<double>::TReaderPtr(wavIO->GetPCMReader<double>()));
         cout << "Input file: " << inFile << "\n Channels: " << numChannels << "\n SampleRate: " << wavIO->GetSampleRate() << "\n TotalSamples: " << totalSamples << endl;
+        atracProcessor = new TAtrac1Processor(move(aeaIO), TAtrac1EncodeSettings(bfuIdxConst, fastBfuNumSearch, windowMode, winMask));
     } else if (mode == E_DECODE) {
-        aeaIO = TAeaPtr(new TAea(inFile));
+        TAeaPtr aeaIO = TAeaPtr(new TAea(inFile));
         totalSamples = aeaIO->GetLengthInSamples();
         uint32_t length = aeaIO->GetLengthInSamples();
         cout << "Name: " << aeaIO->GetName() << "\n Channels: " << aeaIO->GetChannelNum() << "\n Length: " << length << endl;
         wavIO = TWavPtr(new TWav(outFile, aeaIO->GetChannelNum(), 44100));
         pcmEngine = new TPCMEngine<double>(4096, aeaIO->GetChannelNum(), TPCMEngine<double>::TWriterPtr(wavIO->GetPCMWriter<double>()));
+        atracProcessor = new TAtrac1Processor(move(aeaIO), TAtrac1EncodeSettings(bfuIdxConst, fastBfuNumSearch, windowMode, winMask));
     } else {
         cout << "Processing mode was not specified" << endl;
         return 1;
     }
 
-    TAtrac1Processor atrac1Processor(move(aeaIO), mono);
-    auto atracLambda = (mode == E_DECODE) ? atrac1Processor.GetDecodeLambda() :
-        atrac1Processor.GetEncodeLambda(TAtrac1EncodeSettings(bfuIdxConst, fastBfuNumSearch, windowMode, winMask));
+    auto atracLambda = (mode == E_DECODE) ? atracProcessor->GetDecodeLambda() :
+        atracProcessor->GetEncodeLambda();
+
     uint64_t processed = 0;
     try {
         while (totalSamples > (processed = pcmEngine->ApplyProcess(512, atracLambda)))
diff --git a/src/pcmengin.h b/src/pcmengin.h
index 8ea58a6..3395c5c 100644
--- a/src/pcmengin.h
+++ b/src/pcmengin.h
@@ -104,3 +104,11 @@ private:
         }
     }
 };
+
+template<class T>
+class IProcessor {
+public:
+    virtual typename TPCMEngine<T>::TProcessLambda GetDecodeLambda() = 0;
+    virtual typename TPCMEngine<T>::TProcessLambda GetEncodeLambda() = 0;
+    virtual ~IProcessor() {}
+};