interleaver.h

Go to the documentation of this file.

/*-*-c++-*-*****************************************************************
                          interleaver.h  -  description
                             -------------------
    begin                : Mit Jun 5 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 INTERLEAVER_HEADER
#define INTERLEAVER_HEADER

#include <string>
#include <stdexcept>
#include <cmath>
#include <memory>

#include <simthetic/signals.h>
#include <simthetic/misc.h>
#include <simthetic/phbib.h>
#include <simthetic/basicdevice.h>
#include <simthetic/basicdevicefactory.h>


namespace simthlib
{

class Interleaving;

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


class Interleaving
{
  private:

    size_t memLen;
    int deinterleavedLength_;

    bool fitMemLengthToInputLength;

    //used in interleave( ) to reduce computational complexity:
    mutable size_t origSize;
    mutable int numParts;
    mutable int dummyBits;
    mutable int remBits;
    mutable size_t intlSize;

    //used in deinterleave( ) to reduce computational complexity:
    mutable int deinterleavingInSize;
    mutable int deinterleavingNumParts;
    mutable int deinterDummyBits;
    mutable int deinterRemBits;


  protected:

    simth::checkedVector<int> interleavingVector;
    simth::checkedVector<int> deinterleavingVector;
  
    // sets the memory length of the interleaver
    //int setMemoryLength(int newMemLen);

  public:
    Interleaving(int memoryLen);


    virtual ~Interleaving(){}

    size_t interleavedLength(size_t inputLength) const;

    void adjustMemoryLength(int newMemLength);

    void setDeinterleavedLength(int deInterLen);

    int deinterleavedLength( ) const;

    template<class Seq> void interleave(const Seq &orig, Seq* inter) const;

    template<class Seq_in, class Seq_out>
    void deinterleave(const Seq_in &inter, Seq_out* deInter) const;

    int interleaveIndex(size_t index) const;

    int deinterleaveIndex(size_t index) const;

    // interleaves an sequence of metric increments (llrSeq)
    //virtual void interleave(const llrSeq &orig, llrSeq* inter) const;

    // deinterleaves a sequence of metric increments (llrSeq)
    //virtual void deinterleave(const llrSeq &inter, llrSeq* deInter) const;

    int memoryLength() const {return memLen;}


    // adjust the size of the memory length to the given new length
    //virtual void adjustMemoryLength(int newLength) = 0;

    virtual void print(std::ostream &os, bool debugInfo = false) const;

    static void init(std::ifstream& is, Interleaving** intlv, 
             const std::string& regionQualifier);

    static std::auto_ptr<simthlib::Interleaving> 
      init(std::ifstream& is,
       const std::string& regionQualifier);

    static std::auto_ptr<simthlib::Interleaving> 
      init(const std::string& type, const simth::PropertyList& pl);

    static void register_init(simth::DeviceFactory& registration);
};



inline void Interleaving::setDeinterleavedLength(int deInterLen)
{
  if(DEBUG) {
    if(deInterLen < 0) {
      throw std::runtime_error("inline int Interleaving::setdeinterleavedLength(int newMemLen) : error 1");
    }
  }
  deinterleavedLength_ = deInterLen;
}

inline int Interleaving::deinterleavedLength( ) const
{
  if(DEBUG) {
    if(deinterleavedLength_ < 0) {
      throw std::runtime_error("inline int Interleaving::deinterleavedLength(int newMemLen) : error 1");
    }
  }
  return deinterleavedLength_;
}



inline int Interleaving::interleaveIndex(size_t index) const
{
  if(DEBUG) {
    if( int(index) >= memoryLength() ) {
      throw std::logic_error("int Interleaving::interleaveIndex(int index) : "
                             " index == " + simth::i2string(index) +
                             " > memoryLength() or < 0");
    }
  }
  return interleavingVector[index];
}

inline int Interleaving::deinterleaveIndex(size_t index) const
{
  if(DEBUG) {
    if( int(index) >= memoryLength() ) {
      throw std::logic_error("int Interleaving::deinterleaveIndex(int index) : "
                             " index == " + simth::i2string(index) +
                             " > memoryLength() or < 0");
    }
  }
  return deinterleavingVector[index];
}



inline size_t Interleaving::interleavedLength(size_t inputLength) const
{
  //compute the number of dummy symbols that are needed to pad the "last" interleaver part:
  size_t remBits = inputLength % memoryLength();
  size_t dummyBits = 0;
  if(remBits != 0) {
    // remBits are always smaller than memoryLength()
    dummyBits = memoryLength() - remBits;
  }
  size_t intlSize = inputLength + dummyBits;
  return intlSize;
}


template<class Seq>
void Interleaving::interleave(const Seq &orig, Seq* inter) const
{
  if(memoryLength()==1) {
    (*inter)=orig;
    return;
  }

  if(DEBUG) {
    if(memoryLength()==0) {
      throw std::logic_error("void Interleaving::interleave(llrSeq &orig, llrSeq& inter) : "
                             "error 1 ");
    }
    if(inter == NULL) {
      throw std::logic_error("void Interleaving::interleave(llrSeq &orig, llrSeq& inter) : "
                             "inter == NULL ");
    }
    if(orig.size() <= 0) {
      throw std::logic_error("void Interleaving::interleave(llrSeq &orig, llrSeq& inter) : "
                             "orig.size() == "+simth::i2string(orig.size()));
    }
  }


  if(origSize != orig.size()) { //adjust;
    origSize = orig.size();

    //compute the number of parts filled completely:
    numParts = origSize / memoryLength();

    //compute the number of dummy symbols that are needed to pad the "last" interleaver part:
    remBits = origSize % memoryLength();
    dummyBits = 0;
    if(remBits != 0) {
      dummyBits = memoryLength() - remBits;
    }
    intlSize = origSize + dummyBits;
  }

  //Gedanklich wird die Sequenz in Teile  (Parts) unterteilt, deren Groesse der Gedaechtnislaenge
  //des Interleavings entspricht. Ist der letzte Teil kleiner wird er mit zusaetzlichen Nullen ausgfuellt.
  //Bsp:
  // (llrSequenz) 100101101010111    (MemLen) 3
  // 101 010 110 101 011 1(00) <- pad the last parts with zeros if the length does not fit
  //  0   1   2   4   5   6       <- partCounter

  //if needed, fit size of output sequence
  if( inter->size() != intlSize) {
    inter->resize(intlSize);
  }


  int partOffset = 0;
  //loop through all parts except the last incomplete one:
  for(int partCounter =0; partCounter < numParts; partCounter++) {

    //loop through all subsequences
    for(int counterInPart=0; counterInPart < memoryLength(); counterInPart++) {

      //Index is transformed to interleavedIndex()
      int helpIndex = interleaveIndex(counterInPart);

      if(DEBUG) {
        if( (helpIndex) >= memoryLength()) {
          throw std::logic_error("void Interleaving::interleave(llrSeq &orig, llrSeq* inter) : "
                                 "helpIndex == "+
                                 simth::i2string(helpIndex)+
                                 " >= memLen");
        }
        if( (partOffset + helpIndex) >= int(intlSize) ) {
          throw std::logic_error("void Interleaving::interleave(llrSeq &orig, llrSeq* inter) : "
                                 "partOffset + helpIndex == "+
                                 simth::i2string(partOffset+helpIndex)+
                                 " >= seqLenOut");
        }
        if( (partOffset + counterInPart) >= int(origSize) ) {
          throw std::logic_error("void Interleaving::interleave(llrSeq &orig, llrSeq* inter) : "
                                 "partOffset + counterInPart == "+
                                 simth::i2string(partOffset+counterInPart)+
                                 " >= seqLenIn");
        }
      }

      (*inter)[partOffset + helpIndex] = orig[partOffset + counterInPart];
    }
    partOffset+=memoryLength();
  }
  //hand the last part (with data and dummy zeros) over to the interleaver:
  if(dummyBits > 0) {
    int lastPartOffset = intlSize - memoryLength();
    int pos = 0;
    for( ; pos < remBits; pos++) {
      int helpIndex = interleaveIndex(pos);
      if(DEBUG) {
        if( (helpIndex) >= memoryLength()) {
          throw std::logic_error("void Interleaving::interleave(llrSeq &orig, llrSeq* inter) : "
                                 "helpIndex == "+
                                 simth::i2string(helpIndex)+
                                 " >= memLen");
        }
        if( (lastPartOffset + helpIndex) >= int(intlSize) ) {
          throw std::logic_error("void Interleaving::interleave(llrSeq &orig, llrSeq* inter) : "
                                 "partOffset + helpIndex == "+
                                 simth::i2string(lastPartOffset+helpIndex)+
                                 " >= seqLenOut");
        }
      }
      (*inter)[lastPartOffset + helpIndex] = orig[lastPartOffset + pos];;
    }
    if(DEBUG) {
      if(pos != remBits) {
        throw std::logic_error("void Interleaving::interleave(llrSeq &orig, llrSeq* inter) : "
                               "error 1");
      }
    }
    for( ; pos < memoryLength(); pos++) {
      int helpIndex = interleaveIndex(pos);
      if(DEBUG) {
        if( (helpIndex) >= memoryLength()) {
          throw std::logic_error("void Interleaving::interleave(llrSeq &orig, llrSeq* inter) : "
                                 "helpIndex == "+
                                 simth::i2string(helpIndex)+
                                 " >= memLen");
        }
        if( (lastPartOffset + helpIndex) >= int(intlSize) ) {
          throw std::logic_error("void Interleaving::interleave(llrSeq &orig, llrSeq* inter) : "
                                 "partOffset + helpIndex == "+
                                 simth::i2string(lastPartOffset+helpIndex)+
                                 " >= seqLenOut");
        }
      }
      typedef typename Seq::value_type T;
      (*inter)[lastPartOffset + helpIndex] = T();
    }
  }
}


template<class Seq_in, class Seq_out>
void Interleaving::deinterleave(const Seq_in &orig, Seq_out* deinter) const
{
  if(memoryLength()==1) {
    (*deinter)=orig;
    return;
  }


  if(SECURITY){
    if(memoryLength()==0) {
      throw std::logic_error("void Interleaving::deinterleave(llrSeq &orig, llrSeq& inter) : "
                             "error 1 ");
    }
    if(deinter == NULL) {
      throw std::logic_error("void Interleaving::deinterleave(llrSeq &orig, llrSeq& inter) : "
                             "deinter == NULL ");
    }
    if(int(orig.size()) < deinterleavedLength() ||
        int(orig.size()) >= deinterleavedLength() + memoryLength()) {
      throw std::logic_error("void Interleaving::deinterleave(llrSeq &orig, llrSeq& deinter) : "
                             "origSize()<deinterleavedLength() || origSize>=deinterleavedLength + memoryLength()"
                             " (orig.size() == "+simth::i2string(orig.size())+"), "
                             " (deinterleavedLength() == "+simth::i2string(deinterleavedLength())+"), "
                             " (memoryLength() == "+simth::i2string(memoryLength())+")");
    }
    if(orig.size() % memoryLength() != 0) {
      throw std::logic_error("void Interleaving::deinterleave(llrSeq &orig, llrSeq& deinter) : "
                             "origSize() %  memoryLength() != 0"
                             " (orig.size() == "+simth::i2string(orig.size())+")");
    }
  }

  //Gedanklich wird die Sequenz in Teile  (Parts) unterteilt, deren Groesse der Gedaechtnislaenge
  //des Interleavings entspricht. Ist der letzte Teil kleiner wird eine Exception ausgeloest.
  //Bsp:
  // (llrSequenz) 100101101010111    (MemLen) 3
  // 101 010 110 101 011 1(00) <- throw an exception if this doesn't fit
  //  0   1   2   4   5   6       <- partCounter

  //if needed, fit size of output sequence
  if( int(deinter->size()) != deinterleavedLength()) {
    deinter->resize(deinterleavedLength());
  }

  if(deinterleavingInSize != int(orig.size()) ) {   //compute new:
    deinterleavingInSize = orig.size();
    deinterleavingNumParts = deinterleavingInSize / memoryLength();

    //compute the number of dummy symbols that are needed to pad the "last" interleaver part:
    deinterDummyBits = deinterleavingInSize - deinterleavedLength();
    if(DEBUG) {
      if(deinterDummyBits < 0 || deinterDummyBits >= memoryLength()) {
        throw std::logic_error("void Interleaving::deinterleave(llrSeq &orig, llrSeq& deinter) : error 1a");
      }
    }
    if(deinterDummyBits != 0) {
      deinterRemBits = memoryLength()-deinterDummyBits;
      deinterleavingNumParts--;
    }
    else {
      deinterRemBits = 0;
    }
    if(DEBUG) {
      if(deinterleavingNumParts < 0) {
        throw std::logic_error("void Interleaving::deinterleave(llrSeq &orig, llrSeq& deinter) : error 1");
      }
      if(deinterDummyBits == 0 && deinterleavingNumParts == 0) {
        throw std::logic_error("void Interleaving::deinterleave(llrSeq &orig, llrSeq& deinter) : error 2");
      }
    }
  }

  int partOffset = 0;
  //loop through all parts
  for(int partCounter =0; partCounter < deinterleavingNumParts; partCounter++) {

    //loop through all subsequences
    for(int counterInPart=0; counterInPart < memoryLength(); counterInPart++) {

      //interleavedIndex is transformed to toInterleavedIndex()
      int helpIndex = deinterleaveIndex(counterInPart);

      if(DEBUG) {
        if( (helpIndex) >= memoryLength()) {
          throw std::logic_error("void Interleaving::deinterleave(llrSeq &orig, llrSeq* deinter) : "
                                 "helpIndex == "+
                                 simth::i2string(helpIndex)+
                                 " >= memLen");
        }
        if( (partOffset + helpIndex) >= deinterleavingInSize) {
          throw std::logic_error("void Interleaving::deinterleave(llrSeq &orig, llrSeq* deinter) : "
                                 "partOffset + helpIndex == "+
                                 simth::i2string(partOffset+helpIndex)+
                                 " >= seqLenOut");
        }
        if( (partOffset + counterInPart) >= deinterleavingInSize) {
          throw std::logic_error("void Interleaving::deinterleave(llrSeq &orig, llrSeq* deinter) : "
                                 "partOffset + counterInPart == "+
                                 simth::i2string(partOffset+counterInPart)+
                                 " >= seqLenIn");
        }
      }
      (*deinter)[partOffset + helpIndex] = orig[partOffset + counterInPart];
    }
    partOffset+=memoryLength();
  }

  //loop through last part:
  for(int counterInPart=0; counterInPart < deinterRemBits; counterInPart++) {

    //interleavedIndex is transformed to InterleavedIndex()
    int interHelpIndex = interleaveIndex(counterInPart);
    if(DEBUG) {
      if( (interHelpIndex) >= memoryLength()) {
        throw std::logic_error("void Interleaving::deinterleave(llrSeq &orig, llrSeq* deinter) : "
                               "helpIndex == "+
                               simth::i2string(interHelpIndex)+
                               " >= memLen");
      }
      if( (partOffset + interHelpIndex) >= deinterleavingInSize) {
        throw std::logic_error("void Interleaving::deinterleave(llrSeq &orig, llrSeq* deinter) : "
                               "partOffset + helpIndex == "+
                               simth::i2string(partOffset+interHelpIndex)+
                               " >= seqLenOut");
      }
      if( (partOffset + counterInPart) >= deinterleavedLength()) {
        throw std::logic_error("void Interleaving::deinterleave(llrSeq &orig, llrSeq* deinter) : "
                               "partOffset + deinterLeavedLength() == "+
                               simth::i2string(partOffset+deinterleavedLength())+
                               " >= seqLenIn");
      }
    }
    (*deinter)[partOffset + counterInPart] = orig[partOffset + interHelpIndex];
  }
}



class NoInterleaving : public Interleaving
{
  protected:

  public:
    NoInterleaving() : Interleaving(1){};
    //virtual void adjustMemoryLength(int newLength){ };
    virtual void print(std::ostream &os, bool debugInfo = false) const;
};



class BlockInterleaving : public Interleaving
{
  private:


  protected:
    void initMappingVectors();

  public:
    BlockInterleaving(int blockLength);

    virtual void print(std::ostream &os, bool debugInfo = false) const;
};

class SymbolInterleaving : public Interleaving
{
  private:

    int blockLength_;
    int symbolLength_;

  protected:
    void initMappingVectors();


  public:
    SymbolInterleaving(int blockLength, int symbolLength, 
               int forcedMemLength_ = -1);

    virtual void print(std::ostream &os, bool debugInfo = false) const;
};


class Interleaving3d : public Interleaving
{
  private:

    int num_columns;

    int num_rows;

    int num_planes;

  protected:
    void initMappingVectors();

  public:
    Interleaving3d(int cols, int rows, int planes);

    virtual void print(std::ostream &os, bool debugInfo = false) const;
};



class Interleaving3dModified : public Interleaving
{
  private:

    int num_columns;

    int num_rows;

    int num_planes;

    bool planeScramble;

    simth::checkedVector<int> bitPosMapping;

    void initBitPositionMapping();

    static bool isPlaneStillFree(int infoInteger, int bitPos);

    int getPlane(int dataBitPos) const;

  protected:
    void initMappingVectors();

  public:
    Interleaving3dModified(int cols, int rows, int planes, bool planeScrambling);

    virtual void print(std::ostream &os, bool debugInfo = false) const;

};


inline int Interleaving3dModified::getPlane(int dataBitPos) const
{
  if(planeScramble == true) {
    return bitPosMapping[dataBitPos];
  }
  else {
    return dataBitPos;
  }
}

inline bool Interleaving3dModified::isPlaneStillFree(int infoValue, int bitPos)
{
  return (infoValue & 1<<bitPos) ? false : true;
}



class PolyphaseInterleaving3d : public Interleaving
{
  private:

    int num_columns;

    int num_rows;

    int num_planes;

  protected:
    void initMappingVectors();

  public:
    PolyphaseInterleaving3d(int cols, int rows, int planes);

    virtual void print(std::ostream &os, bool debugInfo = false) const;
};












class PseudoRandomInterleaving : public Interleaving
{
  private:

    int a;
    int b;

  protected:
    void initMappingVectors();

  public:
    PseudoRandomInterleaving(int N, int a, int b);

    virtual void print(std::ostream &os, bool debugInfo = false) const;
};

class PseudoRandom3dInterleaving : public PseudoRandomInterleaving
{
  private:

    int planes;

  protected:
    void sortMappingVectors();

  public:
    PseudoRandom3dInterleaving(int N, int a, int b, int planes);

    virtual void print(std::ostream &os, bool debugInfo = false) const;
};



class PseudoRandomSymbolInterleaving : public Interleaving
{
  private:

    int symbolLength;
    PseudoRandomInterleaving pseudoIntlv;

  protected:
    void initMappingVectors();

  public:
    PseudoRandomSymbolInterleaving(int N, int a, int b, int symbolLength);

    virtual void print(std::ostream &os, bool debugInfo = false) const;
};


// ////////////////////////////////////////////////////////////


class Interleaver : public simth::Device
{
    friend void initMSDDDecoder(const std::string, simth::Device**, simth::DeviceSystemIntf*, int ID,
                                const std::string& regionQualifier = "");

  protected:

    Interleaving* interl;

  public:
    Interleaver(int deviceID, simth::DeviceSystemIntf* system,
        const simth::PropertyList& pl,
        std::auto_ptr<Interleaving> interl_);
    ~Interleaver();

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

    int memoryLength() const {return interl->memoryLength();}

    void adjustMemoryLength(int newMemLength);

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

    void startOfSimulation();

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

    static simth::Device* 
    init(int ID, 
     simth::DeviceSystemIntf* sysPtr,
     const simth::PropertyList& _pl, 
     const std::string& cpptype);
};



template<class T>
class InterleaverT : public Interleaver
{


  public:
    InterleaverT(int deviceID, simth::DeviceSystemIntf* system,
         const simth::PropertyList& pl,
         std::auto_ptr<Interleaving> interl_);

    virtual void process();
};

template<class T>
InterleaverT<T>::InterleaverT(int deviceID, simth::DeviceSystemIntf* system,
                  const simth::PropertyList& pl,
                  std::auto_ptr<Interleaving> interl_)
    : Interleaver(deviceID, system, pl, interl_)
{
  insertInputInterface<T>();
  insertOutputInterface<T>();
}



template<class T>
void InterleaverT<T>::process()
{

  while(isInputSequence(0)) {
    T* in =  getInputSequence<T>(0);
    T* out = getOutputSequence<T>(0);
    if(out->rAttributes() != in->rAttributes()) {
      out->wAttributes() = in->rAttributes();
    }
    interl->interleave(*in,out);
    flushProcessedSequences();
  }
  //inform the interfaces that the process has been finished:


}


class Deinterleaver : public simth::Device
{
  private:

  protected:

    Interleaving* interl;

  public:

    Deinterleaver(int deviceID, simth::DeviceSystemIntf* system,
          const simth::PropertyList& pl,
          std::auto_ptr<Interleaving> interl_);
    ~Deinterleaver();

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

    int memoryLength() const {return interl->memoryLength();}

    void adjustMemoryLength(int newMemLength);

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

    void startOfSimulation();

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

    static simth::Device* 
    init(int ID, 
     simth::DeviceSystemIntf* sysPtr,
     const simth::PropertyList& _pl, 
     const std::string& cpptype);
};




template<class T>
class DeinterleaverT : public Deinterleaver
{


  public:

    DeinterleaverT(int deviceID, simth::DeviceSystemIntf* system,
           const simth::PropertyList& pl,
           std::auto_ptr<Interleaving> interl_);

    virtual void process();
};

template<class T>
inline DeinterleaverT<T>::DeinterleaverT(int deviceID, simth::DeviceSystemIntf* system,
    const simth::PropertyList& pl,
                     std::auto_ptr<Interleaving> interl_)
    : Deinterleaver(deviceID, system, pl, interl_)
{
  insertInputInterface<T>();
  insertOutputInterface<T>();
}


template<class T>
void DeinterleaverT<T>::process()
{

  while(isInputSequence(0)) {
    interl->deinterleave(*getInputSequence<T>(0),getOutputSequence<T>(0));
    flushProcessedSequences();
  }
  //inform the interfaces that the process has been finished:


}


}

#endif

---