decoder.h

Go to the documentation of this file.

/***************************************************************************
 *                                                                         *
 *   This library 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.    *
 *                                                                         *
 *   This library 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 this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef DECODER_HEADER
#define DECODER_HEADER

#include <iostream>
#include <string>
#include <complex>
#include <memory>

#include <misc.h>
#include <signals.h>
#include <basicdevice.h>

#include "viterbi.h"
#include "trellis.h"
#include "trellisdecoding.h"



namespace simthlib{ 

class Decoder;
class Encoder;


std::ostream& operator<<(std::ostream &os, const Decoder &cod);


class Decoder : public simth::Device
{
  private:

    simth::SequenceType inputType_;

  protected:

    simth::SequenceType inputType() const {return inputType_;}

  public:
    Decoder(int deviceID, simth::DeviceSystemIntf* system,
        const simth::PropertyList& pl, 
        simth::SequenceType inType);

    virtual ~Decoder(){};

    virtual void decode(const simth::BitSeq &bsin,simth::BitSeq& bsout) = 0;



    virtual void decode(const simth::LlvSeq &llv, simth::BitSeq& bsout) = 0;

    virtual void decode(const simth::LlrSeq &llr, simth::BitSeq& bsout) = 0;

    virtual int getDataLength(int codedLength) const =0;

    virtual int getCodeLength(int rawLength) const =0;

    virtual void process();

    // nicht fuer alle coder: virtual LLRSeq* decode(simth::LlvSeq &llv,
    //sova_type sova=CODER_IN);
    virtual void print(std::ostream &os) const;

    static void init(const std::string& fileName, simth::Device** dev, simth::DeviceSystemIntf* sysPtr, int ID,
                 const std::string& regionQualifier = "");

    void startOfSimulation();
};






class StreamDecoder : public Decoder
{

  public:

    StreamDecoder(int deviceID, simth::DeviceSystemIntf* system,
          const simth::PropertyList& pl, 
          simth::SequenceType inType);

    virtual int dataBitsPerStep() const = 0;
    virtual int codedBitsPerStep() const = 0;

    virtual void process();
  
    virtual void updateInputLengths();
    virtual void updateOutputLengths();

  protected:
    
    //keeps the number of llr values (or the number of hard input bits) that
    //yields when decoding the desired number of output (data) bits.  
    size_t llrInputLength;
};


class TrellisDecoder : public StreamDecoder
{
  private:

    TrellisDecodingAlgorithm* usedAlgorithm;

  protected:

  public:

    TrellisDecoder(int deviceID, simth::DeviceSystemIntf* system,
           const simth::PropertyList& pl, 
           std::auto_ptr<TrellisDecodingAlgorithm> algorithm_ptr,
                   simth::SequenceType inType);
                   
    virtual ~TrellisDecoder();

    // decodes a bit sequence (hard decision decoding)
    virtual void decode(const simth::BitSeq & bsin, simth::BitSeq& bsout);

    /* performs a maximum likelihood sequence estimation of the
    data sequence based on the log-likelihood values of received
    modulation symbols (soft decision decoding) */
    virtual void decode(const simth::LlvSeq &llv, simth::BitSeq& bsout);

    /* performs a maximum likelihood sequence estimation of the
    data sequence based on the log-likelihood ratios of the received
    modulation symbols (soft decision decoding) */
    virtual void decode(const simth::LlrSeq &llr, simth::BitSeq& bsout);


    /* Returns the length of a data bit sequence which can be
    encoded into a coded bit sequence of the given length.

    */
    virtual int getDataLength(int codedLength) const;

    /* Returns the length of the coded bit sequence which the
    coder generates from a data sequence of the given length.
    */
    virtual int getCodeLength(int rawLength) const;

    virtual int dataBitsPerStep() const {return usedAlgorithm->trellis()->numInbits();}
    virtual int codedBitsPerStep() const {return usedAlgorithm->trellis()->numOutbits();}


    /* calculates log-likelihood ratios of the
    data sequence based on the log-likelihood values of received
    modulation symbols (soft in / soft out decoding) */

    virtual void print(std::ostream &os) const;
};

inline int TrellisDecoder::getCodeLength(int rawLength) const
{
  return usedAlgorithm->trellis()->getCodeLength(rawLength);
}


inline int TrellisDecoder::getDataLength(int codeLength) const
{
  return usedAlgorithm->trellis()->getDataLength(codeLength);
}



class ConvDecoder : public TrellisDecoder
{

   public:
      
      ConvDecoder(int deviceID, simth::DeviceSystemIntf* system,
          const simth::PropertyList& pl, 
          int mem, int inbits, int outbits, 
          simth::SequenceType inType,
          trellisdecoding::DecodingAlgorithmMode decodingMode);

      ConvDecoder(int deviceID, simth::DeviceSystemIntf* system,
          const simth::PropertyList& pl, 
          int inSymbolsPerStep, 
          const simth::checkedVector<int>& polynomials, 
          simth::SequenceType inType,
          trellisdecoding::DecodingAlgorithmMode decodingMode);

      ConvDecoder(int deviceID, simth::DeviceSystemIntf* system,
          const simth::PropertyList& pl, 
          int inSymbolsPerStep, 
          const simth::checkedVector<int>& polynomials, 
          int recursivePolynomial, bool systematic,
          simth::SequenceType inType, 
          trellisdecoding::DecodingAlgorithmMode decodingMode);

      ConvDecoder(int deviceID, simth::DeviceSystemIntf* system,
          const simth::PropertyList& pl);
                
      ConvDecoder(int deviceID, simth::DeviceSystemIntf* system,
          const simth::PropertyList& pl, 
          int inSymbolsPerStep, int bitsPerSymbol, 
          ConvCodeTrellis::StartingMode startingMode, 
          map_type mappMode, 
          const simth::checkedVector<int>& polynomials, 
          int recursivePolynomial, bool systematic,
          simth::SequenceType inType,
          trellisdecoding::DecodingAlgorithmMode decodingMode);
                
};


class Puncturing;

class PunctConvDecoder : public TrellisDecoder
{
  private:

  protected:
  
    Puncturing* usedPuncturing;

  public:

    PunctConvDecoder(int deviceID, simth::DeviceSystemIntf* system,
             const simth::PropertyList& pl, 
             int codeRateNumerator,
             int codeRateDenumerator, 
             int mem, 
             int inbits, 
             int outbits);


    PunctConvDecoder(int deviceID, simth::DeviceSystemIntf* system,
             const simth::PropertyList& pl, 
             int codeRateNumerator, 
             int codeRateDenumerator, int inbitsPerStep,
                     const simth::checkedVector<int>& polynomials,
                     const int recursivePolynomial, bool systematic);

    PunctConvDecoder(int deviceID, simth::DeviceSystemIntf* system,
             const simth::PropertyList& pl);

    PunctConvDecoder(int deviceID, simth::DeviceSystemIntf* system,
             const simth::PropertyList& pl, 
             const std::string& puncturingPattern, int inbitsPerStep,
                     const simth::checkedVector<int>& polynomials,
                     const int recursivePolynomial, bool systematic);

    virtual ~PunctConvDecoder();


    virtual void updateInputLengths();
    virtual void updateOutputLengths();


    /* Returns the length of a data bit sequence which can be
       encoded into a coded bit sequence of the given length.
    */
    virtual int getDataLength(int codedLength) const;

    /* Returns the length of the coded bit sequence the
        coder generates from a data sequence of the given length.
    */
    virtual int getCodeLength(int rawLength) const;

    virtual void decode(const simth::LlrSeq &llr, simth::BitSeq& bsout);

    // not implemented -> throws an error
    virtual void decode(const simth::BitSeq & bsin, simth::BitSeq& bsout);

    // not implemented -> throws an error
    virtual void decode(const simth::LlvSeq &llv, simth::BitSeq& bsout);

    void setPuncturing(const std::string& newPuncturePattern);
};


}

#endif

---