rs_en.c

一份比较有价值的有关ＲＳ编码的文章 欢迎下载

/************************************************************************
 * File:     	RSEnCode.c
 * Title:    	Encoder for RS codes in C
 * Authors:  	lzg
 * Date:     	2003.4
 * Input: 	data,data of Waiting for been encoded 
 * Return: 	Check_Bit,RS encoding checkout bit
 * Note:	Codeword is c(X) = b(X) + data(X)*X^(nn - kk)  
 *************************************************************************/
/************************************************************************************
  FUNCTIONS:
	gen_gf() generates the field GF(2^mm) and the conversion table in the GF(2^mm).
	encode_rs() encode the RS codes in systematic form.
************************************************************************************/

#include <math.h>
#include <stdio.h>
#include <time.h>
//#include <conio.h>
#include "stdlib.h"

#ifndef Gen_GF
#define Gen_GF
//#include "Gen_GF.c"
#endif

#ifndef GFMM_KK_B0
#define GFMM_KK_B0
#define mm		8
#define nn		255
#define kk		243
#define tt		6
#define b0		120
#define nn_short	31
#define kk_short	19
#endif

void encode_rs(const int *data,int *Check_Bit)
/* take the string of symbols in data[i], i=0..(k-1) and encode systematically
   to produce 2*tt parity symbols in bb[0]..bb[2*tt-1]
   data[] is input and bb[] is output in polynomial form.
   Encoding is done by using a feedback shift register with appropriate
   connections specified by the elements of gg[], which was generated above.
   Codeword is   c(X) = data(X)*X**(nn-kk)+ b(X)          */
 {
   register int i,j ;
   int feedback ;
   int *Alpha_to,*Index_of,*gg;
   /*
   int nn;
   nn=pow(2,mm) - 1;
   */
   Alpha_to = (int *) calloc((nn + 1),sizeof(int));
   Index_of = (int *) calloc((nn + 1),sizeof(int));
   gg = (int *) calloc((nn - kk),sizeof(int));

   /*generate GF(2^mm) and conversion table for RS encode*/
   gen_gf(Alpha_to,Index_of,gg);

   for (i=0; i<nn-kk; i++)   *(Check_Bit + i) = 0 ;
   for (i=kk-1; i>=0; i--)
   {
    	feedback = *(Index_of + (*(data + i) ^ *(Check_Bit + nn - kk - 1))) ;
        if (feedback != -1) /* feedback term is non-zero */
        {
          for (j=nn-kk-1; j>0; j--)
          {
            if (gg[j] != -1)
              *(Check_Bit + j) = *(Check_Bit + j - 1) ^ *(Alpha_to + (*(gg + j) + feedback)%nn) ;
            else
              *(Check_Bit + j) = *(Check_Bit + j - 1) ;
          }
          *Check_Bit = *(Alpha_to + (*gg+feedback)%nn) ;
        }
        else /* feedback term is zero. encoder becomes a single-byte shifter */
        {
          for (j=nn-kk-1; j>0; j--)
          	*(Check_Bit + j) = *(Check_Bit + j - 1) ;
          *Check_Bit = 0 ;
        }
    }
    free(Alpha_to);
    free(Index_of);
    free(gg);
 }