encoder.h

Go to the documentation of this file.

/***************************************************************************
                          encoder.h  -  description
                             -------------------
    begin                : Don Mai 16 2002
    copyright            : (C) 2002 by Peter Haase
    email                : mail@p-haase.de
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   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 ENCODER_HEADER
#define ENCODER_HEADER

#include <iostream>
#include <complex>

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

#include "viterbi.h"
#include "puncturing.h"
#include "decoder.h"
#include "interleaver.h"
#include "modulator.h"



class simth::Device;

namespace simthlib
{


class Encoder;


inline std::ostream& operator<<(std::ostream &os, const Encoder &enc);


class Encoder : public simth::Device
{

  public:

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

    virtual ~Encoder(){}

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

    virtual void process();

    void startOfSimulation();

    virtual int getDataLength(int codedLength) const =0;

    virtual int getCodeLength(int rawLength) const =0;

    virtual void Encode(const simth::BitSeq& bits,simth::BitSeq* encBits) const = 0;

    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 = "");

};



class ConvEncoder : public Encoder
{
  private:

    ConvCodeTrellis* usedTrellis;


  public:

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

    ConvEncoder(int deviceID, simth::DeviceSystemIntf* system,
        const simth::PropertyList& pl, 
        int inSymbolsPerStep, 
        const simth::checkedVector<int>& polynomials);

    ConvEncoder(int deviceID, simth::DeviceSystemIntf* system,
        const simth::PropertyList& pl, 
        int inSymbolsPerStep, 
        const simth::checkedVector<int>& polynomials,
                const int recursivePolynomial, bool systematic);

    ConvEncoder(int deviceID, simth::DeviceSystemIntf* system,
        const simth::PropertyList& pl, 
        int inSymbolsPerStep, int bitsPerSymbol, map_type mappMode,
                const simth::checkedVector<int>& polynomials, 
        const int recursivePolynomial = 0, bool systematic=false);


    ConvEncoder(int deviceID, simth::DeviceSystemIntf* system,
        const simth::PropertyList& pl, 
        int inputBitsPerStep, int outputBitsPerStep, map_type mappMode);

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

    virtual ~ConvEncoder(){ delete usedTrellis;}

    virtual int getDataLength(int codedLength) const;

    virtual int getCodeLength(int rawLength) const;


    virtual int numTailbits() const;


    virtual void Encode(const simth::BitSeq &bsin, simth::BitSeq* bsout) const;

    virtual int dataBitsPerStep() const {return usedTrellis->numInbits();}

    virtual int codedBitsPerStep() const {return usedTrellis->numOutbits();}

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

    static simth::checkedVector<int> 
    stdVectorToSimthVector(const simth::Property::vector_int&);
};



inline int ConvEncoder::getCodeLength(int dataLength) const
{
  return usedTrellis->getCodeLength(dataLength);
}

inline int ConvEncoder::getDataLength(int codeLength) const
{
  return usedTrellis->getDataLength(codeLength);
}

inline int ConvEncoder::numTailbits() const
{
  return usedTrellis->numTailbits();
}



class PunctConvEncoder : public ConvEncoder
{
  private:

    Puncturing* usedPuncturing;

  public:

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


    PunctConvEncoder(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);

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


    PunctConvEncoder(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 ~PunctConvEncoder(){ delete usedPuncturing;}

    /* 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 simth::BitSeq* Encode(simth::BitSeq& bits) const;

    // encodes a bit sequence
    virtual void Encode(const simth::BitSeq &bsin, simth::BitSeq* bsout) const;

};





class DapskEncoder : public Encoder
{
    ConvEncoder* amplEncoder;
    ConvEncoder* phaseEncoder;

    mutable int numInSize;
    mutable int numInAmplSize;
    mutable int numInPhaseSize;

    int bitsPerAmpl_;
    int bitsPerPhase_;

    void splitSequence(const simth::BitSeq& inputBits, simth::BitSeq* amplSeq, simth::BitSeq* phaseSeq) const;
    void mergeSequences(const simth::BitSeq& amplSeq, const simth::BitSeq& phaseSeq, simth::BitSeq* outSeq) const;

    void invariante() const;

  protected:
    int bitsPerAmpl() const {return bitsPerAmpl_;}
    int bitsPerPhase() const {return bitsPerPhase_;}

    void computeSplittedSizes(int numInSize,
                              int* amplSize, int* phaseSize) const;

  public:

    DapskEncoder(int deviceID, simth::DeviceSystemIntf* system,
         const simth::PropertyList& pl, 
         int inSymbolsPerStep, int bitsPerSymbol, map_type mappMode,
                 const simth::checkedVector<int>& polynomials, 
         const int recursivePolynomial = 0);


    virtual ~DapskEncoder();

    /* 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 simth::BitSeq* Encode(simth::BitSeq& bits) const;

    // encodes a bit sequence
    virtual void Encode(const simth::BitSeq &bsin, simth::BitSeq* bsout) const;

    virtual int dataBitsPerStep() const {return bitsPerAmpl()+bitsPerPhase();}
    virtual int codedBitsPerStep() const {return (amplEncoder->codedBitsPerStep()+phaseEncoder->codedBitsPerStep());}

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


};


inline void DapskEncoder::invariante() const
{
  if(DEBUG) {
    if(numInAmplSize + numInPhaseSize != numInSize) {
      throw std::logic_error("void DapskEncoder::invariante() const : error 1");
    }
  }
}



} // namespace

#endif

---