[refactoring] Split CompressedIO interface for Read and Write part

13 files changed, 190 insertions, 149 deletions

diff --git a/src/aea.cpp b/src/aea.cpp
index 4589a60..9394677 100644
--- a/src/aea.cpp
+++ b/src/aea.cpp
@@ -21,18 +21,67 @@
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <string.h>
+#include <memory>
 
 using std::string;
 using std::array;
 using std::vector;
 using std::unique_ptr;
 
-TAea::TMeta TAea::ReadMeta(const string& filename) {
+class TAeaCommon {
+protected:
+    static constexpr uint32_t AeaMetaSize = 2048;
+    struct TMeta {
+        FILE* AeaFile;
+        std::array<char, AeaMetaSize> AeaHeader;
+    } Meta;
+public:
+    TAeaCommon(const TMeta& meta)
+        : Meta(meta)
+    {}
+    uint8_t GetChannelNum() const;
+    string GetName() const;
+    virtual ~TAeaCommon();
+};
+
+uint8_t TAeaCommon::GetChannelNum() const {
+    return Meta.AeaHeader[264];
+}
+
+string TAeaCommon::GetName() const {
+    return string(&Meta.AeaHeader[4]);
+}
+
+TAeaCommon::~TAeaCommon() {
+    fclose(Meta.AeaFile);
+}
+
+class TAeaInput : public ICompressedInput, public TAeaCommon {
+    static TAeaCommon::TMeta ReadMeta(const string& filename);
+public:
+    TAeaInput(const string& filename);
+    unique_ptr<TFrame> ReadFrame() override; 
+    uint64_t GetLengthInSamples() const override;
+
+    uint8_t GetChannelNum() const override {
+        return TAeaCommon::GetChannelNum();
+    }
+
+    string GetName() const override {
+        return TAeaCommon::GetName(); 
+    }
+};
+
+TAeaInput::TAeaInput(const string& filename)
+    : TAeaCommon(ReadMeta(filename))
+{}
+
+TAeaCommon::TMeta TAeaInput::ReadMeta(const string& filename) {
     FILE* fp = fopen(filename.c_str(), "rb");
     if (!fp)
         throw TAeaIOError("Can't open file to read", errno);
     array<char, AeaMetaSize> buf;
-    if (fread(&buf[0], TAea::AeaMetaSize, 1, fp) != 1) {
+    if (fread(&buf[0], AeaMetaSize, 1, fp) != 1) {
         const int errnum = errno;
         fclose(fp);
         throw TAeaIOError("Can't read AEA header", errnum);
@@ -42,13 +91,58 @@ TAea::TMeta TAea::ReadMeta(const string& filename) {
         return {fp, buf};
     }
     throw TAeaFormatError();
+}
+
+uint64_t TAeaInput::GetLengthInSamples() const {
+#ifdef PLATFORM_WINDOWS
+    const int fd = _fileno(Meta.AeaFile);
+#else
+    const int fd = fileno(Meta.AeaFile);
+#endif
+    struct stat sb;
+    fstat(fd, &sb);
+    const uint32_t nChannels = Meta.AeaHeader[264] ? Meta.AeaHeader[264] : 1;
+    return (uint64_t)512 * ((sb.st_size - AeaMetaSize) / 212 / nChannels - 5); 
+}
 
+unique_ptr<ICompressedIO::TFrame> TAeaInput::ReadFrame() {
+    unique_ptr<ICompressedIO::TFrame>frame(new TFrame(212));
+    if(fread(frame->Get(), frame->Size(), 1, Meta.AeaFile) != 1) {
+        const int errnum = errno;
+        fclose(Meta.AeaFile);
+        throw TAeaIOError("Can't read AEA frame", errnum);
+    }
+    return frame;
 }
 
-TAea::TMeta TAea::CreateMeta(const string& filename, const string& title, uint8_t channelNum, uint32_t numFrames) {
+class TAeaOutput : public ICompressedOutput, public TAeaCommon {
+    static TAeaCommon::TMeta CreateMeta(const string& filename, const string& title,
+        uint8_t numChannel, uint32_t numFrames);
+
+    bool FirstWrite = true;
+public:
+    TAeaOutput(const string& filename, const string& title, uint8_t numChannel, uint32_t numFrames);
+    void WriteFrame(vector<char> data) override;
+
+    uint8_t GetChannelNum() const override {
+        return TAeaCommon::GetChannelNum();
+    }
+    string GetName() const override {
+        return TAeaCommon::GetName(); 
+    }
+};
+
+TAeaOutput::TAeaOutput(const string& filename, const string& title, uint8_t numChannels, uint32_t numFrames)
+    : TAeaCommon(CreateMeta(filename, title, numChannels, numFrames))
+{}
+
+TAeaCommon::TMeta TAeaOutput::CreateMeta(const string& filename, const string& title,
+    uint8_t channelsNum, uint32_t numFrames)
+{
     FILE* fp = fopen(filename.c_str(), "wb");
     if (!fp)
         throw TAeaIOError("Can't open file to write", errno);
+
     array<char, AeaMetaSize> buf;
     memset(&buf[0], 0, AeaMetaSize);
     buf[0] = 0x00;
@@ -59,63 +153,32 @@ TAea::TMeta TAea::CreateMeta(const string& filename, const string& title, uint8_
     buf[19] = 0;
 //    buf[210] = 0x08;
     *(uint32_t*)&buf[260] = numFrames;
-    buf[264] = (char)channelNum;
-    if (fwrite(&buf[0], TAea::AeaMetaSize, 1, fp) != 1) {
+    buf[264] = (char)channelsNum;
+
+    if (fwrite(&buf[0], AeaMetaSize, 1, fp) != 1) {
         const int errnum = errno;
         fclose(fp);
-        throw TAeaIOError("Can't read AEA header", errnum);
+        throw TAeaIOError("Can't write AEA header", errnum);
     }
+
     static char dummy[212];
     if (fwrite(&dummy[0], 212, 1, fp) != 1) {
         const int errnum = errno;
         fclose(fp);
-        throw TAeaIOError("Can't read AEA header", errnum);
+        throw TAeaIOError("Can't write dummy frame", errnum);
     }
 
     return {fp, buf};
 }
 
-
-TAea::TAea(const string& filename)
-    : Meta(ReadMeta(filename))
-{}
-
-TAea::TAea(const string& filename, const string& title, uint8_t channelNum, uint32_t numFrames)
-    : Meta(CreateMeta(filename, title, channelNum, numFrames))
-{}
-
-TAea::~TAea() {
-    fclose(Meta.AeaFile);
-}
-
-string TAea::GetName() const {
-    return string(&Meta.AeaHeader[4]);
-}
-
-unique_ptr<TAea::TFrame> TAea::ReadFrame() {
-    unique_ptr<TAea::TFrame>frame(new TFrame(212));
-    if(fread(frame->Get(), frame->Size(), 1, Meta.AeaFile) != 1) {
-        const int errnum = errno;
-        fclose(Meta.AeaFile);
-        throw TAeaIOError("Can't read AEA frame", errnum);
-    }
-    return frame;
-}
-/*
-void TAea::WriteFrame(std::unique_ptr<TAea::TFrame>&& frame) {
-    if (fwrite(frame.get(), frame->size(), 1, Meta.AeaFile) != 1) {
-        const int errnum = errno;
-        fclose(Meta.AeaFile);
-        throw TAeaIOError("Can't write AEA frame", errnum);
-    }
-}
-*/
-void TAea::WriteFrame(vector<char> data) {
+void TAeaOutput::WriteFrame(vector<char> data) {
     if (FirstWrite) {
         FirstWrite = false;
         return;
     }
+
     data.resize(212);
+
     if (fwrite(data.data(), data.size(), 1, Meta.AeaFile) != 1) {
         const int errnum = errno;
         fclose(Meta.AeaFile);
@@ -123,18 +186,12 @@ void TAea::WriteFrame(vector<char> data) {
     }
 }
 
-uint8_t TAea::GetChannelNum() const {
-    return Meta.AeaHeader[264];
+TCompressedInputPtr CreateAeaInput(const std::string& filename) {
+    return unique_ptr<TAeaInput>(new TAeaInput(filename));
 }
 
-uint64_t TAea::GetLengthInSamples() const {
-#ifdef PLATFORM_WINDOWS
-    const int fd = _fileno(Meta.AeaFile);
-#else
-    const int fd = fileno(Meta.AeaFile);
-#endif
-    struct stat sb;
-    fstat(fd, &sb);
-    const uint32_t nChannels = Meta.AeaHeader[264] ? Meta.AeaHeader[264] : 1;
-    return (uint64_t)512 * ((sb.st_size - TAea::AeaMetaSize) / 212 / nChannels - 5); 
+TCompressedOutputPtr CreateAeaOutput(const string& filename, const string& title,
+    uint8_t numChannels, uint32_t numFrames)
+{
+    return unique_ptr<TAeaOutput>(new TAeaOutput(filename, title, numChannels, numFrames));
 }
diff --git a/src/aea.h b/src/aea.h
index 2fb216d..50edc9f 100644
--- a/src/aea.h
+++ b/src/aea.h
@@ -17,15 +17,9 @@
  */
 
 #pragma once
-#include <iostream>
-#include <fstream>
-#include <vector>
-#include <array>
-#include <memory>
 
 #include "compressed_io.h"
 
-
 class TAeaIOError : public std::exception {
     const int ErrNum = 0;
     const char* Text;
@@ -44,24 +38,7 @@ public:
 class TAeaFormatError {
 };
 
-typedef ICompressedIO IAtrac1IO;
 
-class TAea : public IAtrac1IO {
-    static constexpr uint32_t AeaMetaSize = 2048;
-    struct TMeta {
-        FILE* AeaFile;
-        std::array<char, AeaMetaSize> AeaHeader;
-    } Meta;
-    static TAea::TMeta ReadMeta(const std::string& filename);
-    static TAea::TMeta CreateMeta(const std::string& filename, const std::string& title, uint8_t numChannel, uint32_t numFrames);
-    bool FirstWrite = true;
-public:
-    TAea(const std::string& filename);
-    TAea(const std::string& filename, const std::string& title, uint8_t numChannel, uint32_t numFrames);
-    ~TAea();
-    std::unique_ptr<TFrame> ReadFrame() override; 
-    void WriteFrame(std::vector<char> data) override;
-    std::string GetName() const override;
-    uint8_t GetChannelNum() const override;
-    uint64_t GetLengthInSamples() const override;
-};
+TCompressedInputPtr CreateAeaInput(const std::string& filename);
+TCompressedOutputPtr CreateAeaOutput(const std::string& filename, const std::string& title,
+    uint8_t numChannel, uint32_t numFrames);
diff --git a/src/atrac/atrac1_bitalloc.cpp b/src/atrac/atrac1_bitalloc.cpp
index ae6ad2f..01bc83c 100644
--- a/src/atrac/atrac1_bitalloc.cpp
+++ b/src/atrac/atrac1_bitalloc.cpp
@@ -218,7 +218,7 @@ uint32_t TAtrac1SimpleBitAlloc::Write(const std::vector<TScaledBlock>& scaledBlo
     return BfuAmountTab[bfuIdx];
 }
 
-TAtrac1BitStreamWriter::TAtrac1BitStreamWriter(TAea* container)
+TAtrac1BitStreamWriter::TAtrac1BitStreamWriter(ICompressedOutput* container)
     : Container(container)
 {
     NEnv::SetRoundFloat();
diff --git a/src/atrac/atrac1_bitalloc.h b/src/atrac/atrac1_bitalloc.h
index 2478ddb..87f317b 100644
--- a/src/atrac/atrac1_bitalloc.h
+++ b/src/atrac/atrac1_bitalloc.h
@@ -47,9 +47,9 @@ public:
 };
 
 class TAtrac1BitStreamWriter : public virtual TAtrac1Data {
-    TAea* Container;
+    ICompressedOutput* Container;
 public:
-    explicit TAtrac1BitStreamWriter(TAea* container);
+    explicit TAtrac1BitStreamWriter(ICompressedOutput* container);
 
     void WriteBitStream(const std::vector<uint32_t>& bitsPerEachBlock, const std::vector<TScaledBlock>& scaledBlocks,
                         uint32_t bfuAmountIdx, const TBlockSize& blockSize);
@@ -63,7 +63,7 @@ class TAtrac1SimpleBitAlloc : public TAtrac1BitStreamWriter, public TBitsBooster
     uint32_t GetMaxUsedBfuId(const std::vector<uint32_t>& bitsPerEachBlock);
     uint32_t CheckBfuUsage(bool* changed, uint32_t curBfuId, const std::vector<uint32_t>& bitsPerEachBlock);
 public:
-    explicit TAtrac1SimpleBitAlloc(TAea* container, uint32_t bfuIdxConst, bool fastBfuNumSearch)
+    explicit TAtrac1SimpleBitAlloc(ICompressedOutput* container, uint32_t bfuIdxConst, bool fastBfuNumSearch)
         : TAtrac1BitStreamWriter(container)
         , BfuIdxConst(bfuIdxConst)
         , FastBfuNumSearch(fastBfuNumSearch)
diff --git a/src/atrac1denc.cpp b/src/atrac1denc.cpp
index e15680b..64e4f48 100644
--- a/src/atrac1denc.cpp
+++ b/src/atrac1denc.cpp
@@ -32,12 +32,17 @@ using namespace NAtrac1;
 using namespace NMDCT;
 using std::vector;
 
-TAtrac1Processor::TAtrac1Processor(TCompressedIOPtr&& aea, TAtrac1EncodeSettings&& settings)
+TAtrac1Encoder::TAtrac1Encoder(TCompressedOutputPtr&& aea, TAtrac1EncodeSettings&& settings)
     : Aea(std::move(aea))
     , Settings(std::move(settings))
 {
 }
 
+TAtrac1Decoder::TAtrac1Decoder(TCompressedInputPtr&& aea)
+    : Aea(std::move(aea))
+{
+}
+
 static void vector_fmul_window(TFloat *dst, const TFloat *src0,
                                 const TFloat *src1, const TFloat *win, int len)
 {
@@ -126,12 +131,12 @@ void TAtrac1MDCT::IMdct(TFloat Specs[512], const TBlockSize& mode, TFloat* low,
     }
 }
 
-TPCMEngine<TFloat>::TProcessLambda TAtrac1Processor::GetDecodeLambda() {
+TPCMEngine<TFloat>::TProcessLambda TAtrac1Decoder::GetLambda() {
     return [this](TFloat* data, const TPCMEngine<TFloat>::ProcessMeta& meta) {
         TFloat sum[512];
         const uint32_t srcChannels = Aea->GetChannelNum();
         for (uint32_t channel = 0; channel < srcChannels; channel++) {
-            std::unique_ptr<TAea::TFrame> frame(Aea->ReadFrame());
+            std::unique_ptr<ICompressedIO::TFrame> frame(Aea->ReadFrame());
 
             TBitStream bitstream(frame->Get(), frame->Size());
 
@@ -157,14 +162,11 @@ TPCMEngine<TFloat>::TProcessLambda TAtrac1Processor::GetDecodeLambda() {
 }
 
 
-TPCMEngine<TFloat>::TProcessLambda TAtrac1Processor::GetEncodeLambda() {
+TPCMEngine<TFloat>::TProcessLambda TAtrac1Encoder::GetLambda() {
     const uint32_t srcChannels = Aea->GetChannelNum();
     vector<IAtrac1BitAlloc*> bitAlloc;
     for (size_t 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()));
+        bitAlloc.push_back(new TAtrac1SimpleBitAlloc(Aea.get(), Settings.GetBfuIdxConst(), Settings.GetFastBfuNumSearch()));
     }
 
     return [this, srcChannels, bitAlloc](TFloat* data, const TPCMEngine<TFloat>::ProcessMeta& meta) {
diff --git a/src/atrac1denc.h b/src/atrac1denc.h
index 8468c74..802978d 100644
--- a/src/atrac1denc.h
+++ b/src/atrac1denc.h
@@ -56,8 +56,8 @@ public:
     {}
 };
 
-class TAtrac1Processor : public IProcessor<TFloat>, public TAtrac1MDCT, public virtual NAtrac1::TAtrac1Data {
-    TCompressedIOPtr Aea;
+class TAtrac1Encoder : public IProcessor<TFloat>, public TAtrac1MDCT, public virtual NAtrac1::TAtrac1Data {
+    TCompressedOutputPtr Aea;
     const NAtrac1::TAtrac1EncodeSettings Settings;
 
     TFloat PcmBufLow[2][256 + 16];
@@ -67,7 +67,6 @@ class TAtrac1Processor : public IProcessor<TFloat>, public TAtrac1MDCT, public v
     int32_t PcmValueMax = 1;
     int32_t PcmValueMin = -1;
 
-    Atrac1SynthesisFilterBank<TFloat> SynthesisFilterBank[2];
     Atrac1SplitFilterBank<TFloat> SplitFilterBank[2];
 
     class TTransientDetectors {
@@ -97,14 +96,30 @@ class TAtrac1Processor : public IProcessor<TFloat>, public TAtrac1MDCT, public v
             }
         }
     };
-    TAtrac1Processor::TTransientDetectors TransientDetectors;
+    TAtrac1Encoder::TTransientDetectors TransientDetectors;
  
     TScaler<TAtrac1Data> Scaler;
 
 public:
-    TAtrac1Processor(TCompressedIOPtr&& aea, NAtrac1::TAtrac1EncodeSettings&& settings);
-    TPCMEngine<TFloat>::TProcessLambda GetDecodeLambda() override;
+    TAtrac1Encoder(TCompressedOutputPtr&& aea, NAtrac1::TAtrac1EncodeSettings&& settings);
+    TPCMEngine<TFloat>::TProcessLambda GetLambda() override;
+};
+
+class TAtrac1Decoder : public IProcessor<TFloat>, public TAtrac1MDCT, public virtual NAtrac1::TAtrac1Data {
+    TCompressedInputPtr Aea;
+    const NAtrac1::TAtrac1EncodeSettings Settings;
+
+    TFloat PcmBufLow[2][256 + 16];
+    TFloat PcmBufMid[2][256 + 16];
+    TFloat PcmBufHi[2][512 + 16];
+
+    int32_t PcmValueMax = 1;
+    int32_t PcmValueMin = -1;
 
-    TPCMEngine<TFloat>::TProcessLambda GetEncodeLambda() override;
+    Atrac1SynthesisFilterBank<TFloat> SynthesisFilterBank[2];
+public:
+    TAtrac1Decoder(TCompressedInputPtr&& aea);
+    TPCMEngine<TFloat>::TProcessLambda GetLambda() override;
 };
+
 }
diff --git a/src/atrac3denc.cpp b/src/atrac3denc.cpp
index 0538b67..1da3641 100644
--- a/src/atrac3denc.cpp
+++ b/src/atrac3denc.cpp
@@ -88,7 +88,7 @@ void TAtrac3MDCT::Midct(TFloat specs[1024], TFloat* bands[4], TGainDemodulatorAr
     }
 }
 
-TAtrac3Processor::TAtrac3Processor(TCompressedIOPtr&& oma, TAtrac3EncoderSettings&& encoderSettings)
+TAtrac3Encoder::TAtrac3Encoder(TCompressedOutputPtr&& oma, TAtrac3EncoderSettings&& encoderSettings)
     : Oma(std::move(oma))
     , Params(std::move(encoderSettings))
     , TransientDetectors(2 * 4, TTransientDetector(8, 256)) //2 - channels, 4 - bands
@@ -96,7 +96,7 @@ TAtrac3Processor::TAtrac3Processor(TCompressedIOPtr&& oma, TAtrac3EncoderSetting
     , TransientParamsHistory(Params.SourceChannels, std::vector<TTransientParam>(4))
 {}
 
-TAtrac3Processor::~TAtrac3Processor()
+TAtrac3Encoder::~TAtrac3Encoder()
 {}
 
 TAtrac3MDCT::TGainModulatorArray TAtrac3MDCT::MakeGainModulatorArray(const TAtrac3Data::SubbandInfo& si)
@@ -129,27 +129,27 @@ TAtrac3MDCT::TGainModulatorArray TAtrac3MDCT::MakeGainModulatorArray(const TAtra
     }
 }
 
-TFloat TAtrac3Processor::LimitRel(TFloat x)
+TFloat TAtrac3Encoder::LimitRel(TFloat x)
 {
     return std::min(std::max(x, GainLevel[15]), GainLevel[0]);
 }
 
-void TAtrac3Processor::ResetTransientParamsHistory(int channel, int band)
+void TAtrac3Encoder::ResetTransientParamsHistory(int channel, int band)
 {
     TransientParamsHistory[channel][band] = {-1 , 1, -1, 1, -1, 1};
 }
 
-void TAtrac3Processor::SetTransientParamsHistory(int channel, int band, const TTransientParam& params)
+void TAtrac3Encoder::SetTransientParamsHistory(int channel, int band, const TTransientParam& params)
 {
     TransientParamsHistory[channel][band] = params;
 }
 
-const TAtrac3Processor::TTransientParam& TAtrac3Processor::GetTransientParamsHistory(int channel, int band) const
+const TAtrac3Encoder::TTransientParam& TAtrac3Encoder::GetTransientParamsHistory(int channel, int band) const
 {
     return TransientParamsHistory[channel][band];
 }
 
-TAtrac3Processor::TTransientParam TAtrac3Processor::CalcTransientParam(const std::vector<TFloat>& gain, const TFloat lastMax)
+TAtrac3Encoder::TTransientParam TAtrac3Encoder::CalcTransientParam(const std::vector<TFloat>& gain, const TFloat lastMax)
 {
     int32_t attack0Location = -1; // position where gain is risen up, -1 - no attack
     TFloat attack0Relation = 1;
@@ -207,7 +207,7 @@ TAtrac3Processor::TTransientParam TAtrac3Processor::CalcTransientParam(const std
     return {attack0Location, attack0Relation, attack1Location, attack1Relation, releaseLocation, releaseRelation};
 }
 
-void TAtrac3Processor::CreateSubbandInfo(TFloat* in[4],
+void TAtrac3Encoder::CreateSubbandInfo(TFloat* in[4],
                                          uint32_t channel,
                                          TTransientDetector* transientDetector,
                                          TAtrac3Data::SubbandInfo* subbandInfo)
@@ -274,7 +274,7 @@ void TAtrac3Processor::CreateSubbandInfo(TFloat* in[4],
     }
 }
 
-void TAtrac3Processor::Matrixing()
+void TAtrac3Encoder::Matrixing()
 {
     for (uint32_t subband = 0; subband < 4; subband++) {
         TFloat* pair[2] = {PcmBuffer.GetSecond(subband * 2), PcmBuffer.GetSecond(subband * 2 + 1)};
@@ -288,7 +288,7 @@ void TAtrac3Processor::Matrixing()
     }
 }
 
-TPCMEngine<TFloat>::TProcessLambda TAtrac3Processor::GetEncodeLambda()
+TPCMEngine<TFloat>::TProcessLambda TAtrac3Encoder::GetLambda()
 {
     TOma* omaptr = dynamic_cast<TOma*>(Oma.get());
     if (!omaptr) {
@@ -353,10 +353,4 @@ TPCMEngine<TFloat>::TProcessLambda TAtrac3Processor::GetEncodeLambda()
     };
 }
 
-TPCMEngine<TFloat>::TProcessLambda TAtrac3Processor::GetDecodeLambda()
-{
-    abort();
-    return {};
-}
-
-}//namespace NAtracDEnc
+} //namespace NAtracDEnc
diff --git a/src/atrac3denc.h b/src/atrac3denc.h
index 163ecfd..3d373a2 100644
--- a/src/atrac3denc.h
+++ b/src/atrac3denc.h
@@ -79,8 +79,8 @@ protected:
     TAtrac3MDCT::TGainModulatorArray MakeGainModulatorArray(const TAtrac3Data::SubbandInfo& si);
 };
 
-class TAtrac3Processor : public IProcessor<TFloat>, public TAtrac3MDCT {
-    TCompressedIOPtr Oma;
+class TAtrac3Encoder : public IProcessor<TFloat>, public TAtrac3MDCT {
+    TCompressedOutputPtr Oma;
     const NAtrac3::TAtrac3EncoderSettings Params;
     TDelayBuffer<TFloat, 8, 256> PcmBuffer; //8 = 2 channels * 4 bands
 
@@ -115,9 +115,8 @@ public:
     void Matrixing();
 
 public:
-    TAtrac3Processor(TCompressedIOPtr&& oma, NAtrac3::TAtrac3EncoderSettings&& encoderSettings);
-    ~TAtrac3Processor();
-    TPCMEngine<TFloat>::TProcessLambda GetDecodeLambda() override;
-    TPCMEngine<TFloat>::TProcessLambda GetEncodeLambda() override;
+    TAtrac3Encoder(TCompressedOutputPtr&& oma, NAtrac3::TAtrac3EncoderSettings&& encoderSettings);
+    ~TAtrac3Encoder();
+    TPCMEngine<TFloat>::TProcessLambda GetLambda() override;
 };
 }
diff --git a/src/compressed_io.h b/src/compressed_io.h
index 090ddf4..511860e 100644
--- a/src/compressed_io.h
+++ b/src/compressed_io.h
@@ -41,12 +41,22 @@ public:
         size_t Size() const { return Sz; }
         char* Get() { return Data; }
     };
-    virtual void WriteFrame(std::vector<char> data) = 0;
-    virtual std::unique_ptr<TFrame> ReadFrame() = 0;
     virtual std::string GetName() const = 0;
     virtual uint8_t GetChannelNum() const = 0;
-    virtual uint64_t GetLengthInSamples() const = 0;
     virtual ~ICompressedIO() {}
 };
 
-typedef std::unique_ptr<ICompressedIO> TCompressedIOPtr;
+class ICompressedInput : public ICompressedIO {
+public:
+    virtual std::unique_ptr<TFrame> ReadFrame() = 0;
+    virtual uint64_t GetLengthInSamples() const = 0;
+};
+
+class ICompressedOutput : public ICompressedIO {
+public:
+    virtual void WriteFrame(std::vector<char> data) = 0;
+};
+
+typedef std::unique_ptr<ICompressedInput> TCompressedInputPtr;
+typedef std::unique_ptr<ICompressedOutput> TCompressedOutputPtr;
+
diff --git a/src/main.cpp b/src/main.cpp
index 9cd8b40..9256799 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -147,7 +147,7 @@ static void PrepareAtrac1Encoder(const string& inFile,
         std::cerr << "Number of input samples exceeds output format limitation,"
             "the result will be incorrect" << std::endl;
     }
-    TCompressedIOPtr aeaIO = TCompressedIOPtr(new TAea(outFile, "test", numChannels, (uint32_t)numFrames));
+    TCompressedOutputPtr aeaIO = CreateAeaOutput(outFile, "test", numChannels, (uint32_t)numFrames);
     pcmEngine->reset(new TPCMEngine<TFloat>(4096,
                                             numChannels,
                                             TPCMEngine<TFloat>::TReaderPtr((*wavIO)->GetPCMReader<TFloat>())));
@@ -157,7 +157,7 @@ static void PrepareAtrac1Encoder(const string& inFile,
              << "\n SampleRate: " << (*wavIO)->GetSampleRate()
              << "\n TotalSamples: " << totalSamples
              << endl;
-    atracProcessor->reset(new TAtrac1Processor(std::move(aeaIO), std::move(encoderSettings)));
+    atracProcessor->reset(new TAtrac1Encoder(std::move(aeaIO), std::move(encoderSettings)));
 }
 
 static void PrepareAtrac1Decoder(const string& inFile,
@@ -168,7 +168,7 @@ static void PrepareAtrac1Decoder(const string& inFile,
                                  TPcmEnginePtr* pcmEngine,
                                  TAtracProcessorPtr* atracProcessor)
 {
-    TCompressedIOPtr aeaIO = TCompressedIOPtr(new TAea(inFile));
+    TCompressedInputPtr aeaIO = CreateAeaInput(inFile);
     *totalSamples = aeaIO->GetLengthInSamples();
     uint64_t length = aeaIO->GetLengthInSamples();
     if (!noStdOut)
@@ -180,7 +180,7 @@ static void PrepareAtrac1Decoder(const string& inFile,
     pcmEngine->reset(new TPCMEngine<TFloat>(4096,
                                             aeaIO->GetChannelNum(),
                                             TPCMEngine<TFloat>::TWriterPtr((*wavIO)->GetPCMWriter<TFloat>())));
-    atracProcessor->reset(new TAtrac1Processor(std::move(aeaIO), NAtrac1::TAtrac1EncodeSettings()));
+    atracProcessor->reset(new TAtrac1Decoder(std::move(aeaIO)));
 }
 
 static void PrepareAtrac3Encoder(const string& inFile,
@@ -202,7 +202,7 @@ static void PrepareAtrac3Encoder(const string& inFile,
         std::cerr << "Number of input samples exceeds output format limitation,"
             "the result will be incorrect" << std::endl;
     }
-    TCompressedIOPtr omaIO = TCompressedIOPtr(new TOma(outFile,
+    TCompressedOutputPtr omaIO = TCompressedOutputPtr(new TOma(outFile,
                                                        "test",
                                                        numChannels,
                                                        (int32_t)numFrames, OMAC_ID_ATRAC3,
@@ -211,7 +211,7 @@ static void PrepareAtrac3Encoder(const string& inFile,
     pcmEngine->reset(new TPCMEngine<TFloat>(4096,
                                             numChannels,
                                             TPCMEngine<TFloat>::TReaderPtr(wavIO->GetPCMReader<TFloat>())));
-    atracProcessor->reset(new TAtrac3Processor(std::move(omaIO), std::move(encoderSettings)));
+    atracProcessor->reset(new TAtrac3Encoder(std::move(omaIO), std::move(encoderSettings)));
 }
 
 int main_(int argc, char* const* argv)
@@ -373,8 +373,7 @@ int main_(int argc, char* const* argv)
         return 1;
     }
 
-    auto atracLambda = (mode == E_DECODE) ? atracProcessor->GetDecodeLambda() :
-        atracProcessor->GetEncodeLambda();
+    auto atracLambda = atracProcessor->GetLambda();
 
     uint64_t processed = 0;
     try {
diff --git a/src/oma.cpp b/src/oma.cpp
index 2f55173..b0bc7bf 100644
--- a/src/oma.cpp
+++ b/src/oma.cpp
@@ -40,11 +40,6 @@ TOma::~TOma() {
     oma_close(File);
 }
 
-unique_ptr<ICompressedIO::TFrame> TOma::ReadFrame() {
-    abort();
-    return nullptr;
-}
-
 void TOma::WriteFrame(vector<char> data) {
     if (oma_write(File, &data[0], 1) == -1) {
         fprintf(stderr, "write error\n");
@@ -60,7 +55,3 @@ string TOma::GetName() const {
 uint8_t TOma::GetChannelNum() const {
     return 2; //for ATRAC3
 }
-uint64_t TOma::GetLengthInSamples() const {
-    abort();
-    return 0;
-}
diff --git a/src/oma.h b/src/oma.h
index 396464a..58fcfd2 100644
--- a/src/oma.h
+++ b/src/oma.h
@@ -22,15 +22,13 @@
 
 #include "oma/liboma/include/oma.h"
 
-class TOma : public ICompressedIO {
+class TOma : public ICompressedOutput {
     OMAFILE* File;
 public:
     TOma(const std::string& filename, const std::string& title, uint8_t numChannel,
         uint32_t numFrames, int cid, uint32_t framesize, bool jointStereo);
     ~TOma();
-    std::unique_ptr<TFrame> ReadFrame() override;
     void WriteFrame(std::vector<char> data) override;
     std::string GetName() const override;
     uint8_t GetChannelNum() const override;
-    uint64_t GetLengthInSamples() const override;
 };
diff --git a/src/pcmengin.h b/src/pcmengin.h
index 915fc7c..b2523ca 100644
--- a/src/pcmengin.h
+++ b/src/pcmengin.h
@@ -160,7 +160,6 @@ public:
 template<class T>
 class IProcessor {
 public:
-    virtual typename TPCMEngine<T>::TProcessLambda GetDecodeLambda() = 0;
-    virtual typename TPCMEngine<T>::TProcessLambda GetEncodeLambda() = 0;
+    virtual typename TPCMEngine<T>::TProcessLambda GetLambda() = 0;
     virtual ~IProcessor() {}
 };