mCoder.hpp

Go to the documentation of this file.

// Copyright (c) 2013 Michael D. Adams
// All rights reserved.

// __START_OF_LICENSE__
// 
// Copyright (c) 2015 Michael D. Adams
// All rights reserved.
// 
// This file is part of the Signal Processing Library (SPL).
// 
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License as
// published by the Free Software Foundation; either version 3,
// or (at your option) any later version.
// 
// This program 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 General Public License for more details.
// 
// You should have received a copy of the GNU General Public
// License along with this program; see the file LICENSE.  If not,
// see <http://www.gnu.org/licenses/>.
// 
// __END_OF_LICENSE__

// Defining this symbol will cause all symbols to be processed in
// bypass mode.
// This symbol is intended for testing purposes only and SHOULD NOT
// normally be defined.
//#define SPL_MCoder_BypassAll

#ifndef SPL_mCoder_hpp
#define SPL_mCoder_hpp

// Header files

#include <SPL/config.hpp>
#include <vector>
#include <iostream>
#include <SPL/bitStream.hpp>

//

namespace SPL {

// M-Coder:  Common Encoder/Decoder Information Class

class MCoder
{
protected:

        struct Context;

        // Various lookup tables.
        static const unsigned char rangeTabLPS[64][4];
        static const unsigned char transIdxLPS[64];
        static const unsigned char transIdxMPS[64];
};

// Per-context state information
struct MCoder::Context {
        // The most probable symbol (MPS).
        unsigned char valMPS_;

        // The state index.
        unsigned char pStateIdx_;
};

// M-Coder Encoder Class

class MEncoder : public MCoder
{
public:

        // Constructors and destructor

        MEncoder(int numContexts = 0, OutputBitStream* out = 0);

        ~MEncoder();

        // Set and get various state

        void setNumContexts(int numContexts);

        int getNumContexts() const;

        void clearContexts();

        void setOutput(OutputBitStream* out);

        OutputBitStream* getOutput() const;

        long getSymCount() const;

        long getBitCount() const;

        // Encoding

        void start();

        int terminate();

        int encodeRegular(int contextId, int binVal);

        int encodeBypass(int binVal);

        // Debugging

        static void setDebugLevel(int debugLevel);

        static void setDebugStream(std::ostream& debugStream);

        static std::ostream& getDebugStream();

        void dump(std::ostream& out) const;

private:

        static int debugLevel_;
        static std::ostream* debugStream_;

        int encodeTerminate(int binVal);
        int renormE();
        int putBit(int b);
        int encodeFlush();
        int writeBits(int v, int n);

        // The copy constructor is declared but not defined in order to
        // prevent copying.
        MEncoder(const MEncoder&);

        // The copy assignment operator is declared but not defined in order to
        // prevent copy assignment.
        MEncoder& operator=(const MEncoder&);

        // The bit stream for output.
        OutputBitStream* out_;

        // The per-context state information.
        std::vector<Context> contexts_;

        // Have any bits been coded yet?
        unsigned char firstBitFlag_;

        // Lower bound of current interval.
        unsigned short codILow_;

        // Size of current interval.
        unsigned short codIRange_;

        // The number of bits to follow the next bit of output.
        unsigned long bitsOutstanding_;

        // The number of symbols output.
        long symCount_;

        // The number of bits output so far.
        long bitCount_;

        // Has a code word been started?
        bool initialized_;

};

inline long MEncoder::getSymCount() const
{
        return symCount_;
}

inline long MEncoder::getBitCount() const
{
        return bitCount_ + bitsOutstanding_;
}

inline int MEncoder::getNumContexts() const {
        return contexts_.size();
}

inline OutputBitStream* MEncoder::getOutput() const {
        return out_;
}

inline void MEncoder::setOutput(OutputBitStream* out) {
        out_ = out;
}

// M-Coder Decoder Class

class MDecoder : public MCoder {
public:

        // Constructors and destructor

        MDecoder(int numContexts = 0, InputBitStream* in = 0);

        ~MDecoder();

        // Set and get various state

        void setNumContexts(int numContexts);

        int getNumContexts() const;

        void setInput(InputBitStream* in);

        InputBitStream* getInput() const;

        void clearContexts();

        long getBitCount() const;

        long getSymCount() const;

        // Decoding

        int start();

        int terminate();

        int decodeRegular(int contextId);

        int decodeBypass();

        // Debugging

        void dump(std::ostream& out) const;

        static void setDebugLevel(int debugLevel);

        static void setDebugStream(std::ostream& debugStream);

        static std::ostream& getDebugStream();

private:

        static int debugLevel_;
        static std::ostream* debugStream_;
        int decodeTerminate();
        int readBits(int n);
        int renormD();

        // The copy constructor is declared but not defined in order to
        // prevent copying.
        MDecoder(const MDecoder&);

        // The copy assignment operator is declared but not defined in order to
        // prevent copy assignment.
        MDecoder& operator=(const MDecoder&);

        // The bit stream for input.
        InputBitStream* in_;

        // The current code range.
        unsigned short codIRange_;

        // The current code offset.
        unsigned short codIOffset_;

        // The per-context state information.
        std::vector<Context> contexts_;

        // The number of bits read so far.
        unsigned long bitCount_;

        // The number of symbols decoded so far.
        unsigned long symCount_;

        // Has a code word been started?
        bool initialized_;

};

inline long MDecoder::getBitCount() const {
        return bitCount_;
}

inline long MDecoder::getSymCount() const {
        return symCount_;
}

inline int MDecoder::getNumContexts() const {
        return contexts_.size();
}

inline InputBitStream* MDecoder::getInput() const {
        return in_;
}

inline void MDecoder::setInput(InputBitStream* in) {
        in_ = in;
}

//

}

#endif