blockencoder.h

Go to the documentation of this file.

/***************************************************************************
                          blockencoder.h  -  description
                             -------------------
    begin                : Sun Sep 14 2003
    copyright            : (C) 2003 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 BLOCKENCODER_H
#define BLOCKENCODER_H

#include "encoder.h"


namespace simthlib{

class BlockEncoder : public Encoder
{

  public:
    BlockEncoder(int deviceID, simth::DeviceSystemIntf* system,
         const simth::PropertyList& pl);
    virtual ~BlockEncoder() = 0;

};

  

class ReedSol_init
{
  private:
  public:
    ReedSol_init();
    virtual ~ReedSol_init();

    static const int Q=256;
    static const int R=60;

    int *gp,(*mlga)[Q],(*mgp)[ReedSol_init::Q];
    int *g,*lgt,*lga,*qua,*inv;
    void init(int ,int ,int );
    int mult(int, int);
  private:
    void gf(int);
    void mcf(int,int,int  (*mgp)[ReedSol_init::Q]);
    void genpol(int, int, int);


};

class ReedSolomonEncoder : public BlockEncoder
{


  public:
    ReedSolomonEncoder(int deviceID, simth::DeviceSystemIntf* system,
               const simth::PropertyList& pl,
               int bitsPerSymbol, int numCheckSymbol ,int m0_, int input_Length);
    virtual ~ReedSolomonEncoder();
    virtual void Encode(const simth::BitSeq &bsin, simth::BitSeq* bsout) const;
    virtual void updateOutputLengths( );
    virtual void updateInputLengths();

    virtual int getDataLength(int codedLength) const;
    virtual int getCodeLength(int rawLength) const;

  private:
    void invariante() const;
    void coder(int*, int, int) const;
    size_t inp_length;
    size_t out_length;
    int q;
    int inf_code_length;
    int code_length;
    int *gp,(*mgp)[ReedSol_init::Q];
    int ns;
    mutable int temp[ReedSol_init::Q];
    int bits_p_sym, r, m0;
};

inline void ReedSolomonEncoder::invariante() const
{
  if(DEBUG) {
    if(outputLength(0) != out_length) {
      throw std::runtime_error("inline ReedSolomonEncoder:invariante() : error 1");
    }
  }
}


}

#endif

---