/shared/development/google_code/rssoft/libccsoft/lib/CC_Encoding_base.h

Go to the documentation of this file.

/*
 Copyright 2013 Edouard Griffiths <f4exb at free dot fr>

 This file is part of CCSoft. A Convolutional Codes Soft Decoding library

 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 2 of the License, 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; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Boston, MA  02110-1301  USA

 Convolutional encoder class

 */
#ifndef __CC_ENCODING_BASE_H__
#define __CC_ENCODING_BASE_H__

#include "CCSoft_Exception.h"
#include <vector>
#include <iostream>

namespace ccsoft
{

template<typename T_Register>
void print_register(const T_Register& reg, std::ostream& os)
{
    os << std::hex << reg;
    os << std::dec;
}

template<>
void print_register<unsigned char>(const unsigned char& reg, std::ostream& os);

template<typename T_IOSymbol>
void print_symbol(const T_IOSymbol& sym, std::ostream& os)
{
    os << std::dec << sym;
}

template<>
void print_symbol<unsigned char>(const unsigned char& sym, std::ostream& os);

template<typename T_Register, typename T_IOSymbol>
class CC_Encoding_base
{
public:

    //=============================================================================================
    CC_Encoding_base(const std::vector<unsigned int>& _constraints, const std::vector<std::vector<T_Register> >& _genpoly_representations) :
        k(_constraints.size()),
        constraints(_constraints),
        genpoly_representations(_genpoly_representations),
        m(0)
    {
        if (k < 1)
        {
            throw CCSoft_Exception("There must be at least one constraint size");
        }

        if (k > sizeof(T_IOSymbol)*8)
        {
            throw CCSoft_Exception("Number of input bits not supported by I/O symbol type");
        }

        if (genpoly_representations.size() != k)
        {
            throw CCSoft_Exception("Generator polynomial representations size error");
        }

        unsigned int min_nb_outputs = genpoly_representations[0].size();

        for (unsigned int ci=0; ci < constraints.size(); ci++)
        {
            if (constraints[ci] > sizeof(T_Register)*8)
            {
                throw CCSoft_Exception("One constraint size is too large for the size of the registers");
            }

            if (genpoly_representations[ci].size() < min_nb_outputs)
            {
                min_nb_outputs = genpoly_representations[ci].size();
            }

            if (constraints[ci] > m)
            {
                m = constraints[ci];
            }
        }

        n = min_nb_outputs;

        if (n <= k)
        {
            throw CCSoft_Exception("The number of outputs must be larger than the number of inputs");
        }

        if (n > sizeof(T_IOSymbol)*8)
        {
            throw CCSoft_Exception("Number of output bits not supported by I/O symbol type");
        }
    }

    //=============================================================================================
    virtual ~CC_Encoding_base()
    {}
    
    //=============================================================================================
    virtual T_Register& get_register(unsigned int index) = 0;

    //=============================================================================================
    bool encode(const T_IOSymbol& in_symbol, T_IOSymbol& out_symbol, bool no_step = false)
    {
        T_IOSymbol w_in = in_symbol;

        // load registers with new symbol bits
        for (unsigned int ki=0; ki<k; ki++)
        {
            if (no_step)
            {
                get_register(ki) >>= 1; // flush bit
            }
            get_register(ki) <<= 1; // make room for bit
            get_register(ki) += w_in & 1; // insert bit
            w_in >>= 1; // move to next input bit
        }

        out_symbol = 0;
        T_IOSymbol symbol_bit;

        for (unsigned int ni=0; ni<n; ni++)
        {
            symbol_bit = 0;

            for (unsigned int ki=0; ki<k; ki++)
            {
                symbol_bit ^= (xorbits(get_register(ki)&genpoly_representations[ki][ni]) ? 1 : 0);
            }

            out_symbol += symbol_bit << ni;
        }

        return true;
    }

    //=============================================================================================
    void print(std::ostream& os)
    {
        std::cout << "k=" << k << ", n=" << n << ", m=" << m << std::endl;

        for (unsigned int ci=0; ci<k; ci++)
        {
            os << ci << " (" << constraints[ci] << ") : ";

            for (unsigned int gi=0; gi<n; gi++)
            {
                print_register(genpoly_representations[ci][gi], os);
                os << " ";
            }

            os << std::endl;
        }
    }

    unsigned int get_k() const
    {
        return k;
    }

    unsigned int get_n() const
    {
        return n;
    }

    unsigned int get_m() const
    {
        return m;
    }

protected:

    bool xorbits(const T_Register& reg)
    {
        T_Register w_reg = reg;
        unsigned int nb_ones = 0;

        while(w_reg != 0)
        {
            nb_ones += w_reg % 2;
            w_reg /= 2;
        }

        return (nb_ones % 2) == 1;
    }

    unsigned int k; 
    unsigned int n; 
    unsigned int m; 
    std::vector<unsigned int> constraints; 
    std::vector<std::vector<T_Register> > genpoly_representations; 
};

} // namespace ccsoft


#endif // __CC_ENCODING_H__