reedsolomonencoder.h

心电图小波零树压缩演算法的研究

/*
  *********************************************************************
  *                                                                   *
  *        Galois Field Arithmetic Library (version 0.0.1)            *
  *                                                                   *
  * Class: Reed-Solomon Encoder                                       *
  * Version: 0.0.1                                                    *
  * Author: Arash Partow - 2000                                       *
  * URL: http://www.partow.net/projects/galois/index.html             *
  *                                                                   *
  * Copyright Notice:                                                 *
  * Free use of this library is permitted under the guidelines and    *
  * in accordance with the most current version of the Common Public  *
  * License.                                                          *
  * http://www.opensource.org/licenses/cpl.php                        *
  *                                                                   *
  *********************************************************************
*/


#ifndef INCLUDE_REEDSOLOMONENCODER_H
#define INCLUDE_REEDSOLOMONENCODER_H


#include <string>
#include "GaloisField.h"
#include "GaloisFieldElement.h"
#include "GaloisFieldPolynomial.h"
#include "ReedSolomonBlock.h"


using namespace galois;

namespace reedsolomon
{

   class ReedSolomonEncoder
   {

      public:

       ReedSolomonEncoder(GaloisField* _gf, const GaloisFieldPolynomial _gen, const unsigned int _code_length, const unsigned int _fec_length)
       {
          gf          = _gf;
          generator   = _gen;
          code_length = _code_length;
          fec_length  = _fec_length;
          data_length = code_length - fec_length;
          bit_length  = data_length * gf->pwr();
       }

      ~ReedSolomonEncoder(){}


       inline bool encode(ReedSolomonBlock& rsblock)
       {

          if ((rsblock.bitsize > bit_length) || (rsblock.bitsize == 0))
            return false;


          std::string data = rsblock.data;

          // apply necessary temporary padding
          if (rsblock.bitsize < bit_length)
          {
             data = rsblock.data + std::string((bit_length - rsblock.bitsize) / gf->pwr(),0x0);
          }
          else
             data = rsblock.data;

          GaloisFieldPolynomial message(gf,code_length);

          for(unsigned int i = fec_length; i < code_length; i++)
          {
             message[i] = data[code_length - i - 1];
          }

          GaloisFieldPolynomial parities = message % generator;

          rsblock.fec = std::string(fec_length,0x0);

          for(unsigned i = 0; i < fec_length; i++)
          {
             rsblock.fec[i] = static_cast<char>(parities[fec_length - i - 1].poly());
          }

          return true;
       }


       inline bool encode(const std::string data, ReedSolomonBlock& rsblock)
       {
          rsblock.bitsize = static_cast<unsigned int>(data.length() * gf->pwr());
          rsblock.data    = data;
          return encode(rsblock);
       }

      private:

       GaloisField*          gf;
       GaloisFieldPolynomial generator;
       unsigned int          code_length;
       unsigned int          fec_length;
       unsigned int          data_length;
       unsigned int          bit_length; // data length in bits

   };

}

#endif