OpenCores
URL https://opencores.org/ocsvn/reed_solomon_codec_generator/reed_solomon_codec_generator/trunk

Subversion Repositories reed_solomon_codec_generator

[/] [reed_solomon_codec_generator/] [trunk/] [source/] [RsDecodeChienEmulator.cpp] - Rev 8

Go to most recent revision | Compare with Previous | Blame | View Log

//===================================================================
// Module Name : RsDecodeChienEmulator
// File Name   : RsDecodeChienEmulator.cpp
// Function    : RS decoder chien emulator
// 
// Revision History:
// Date          By           Version    Change Description
//===================================================================
// 2009/02/03  Gael Sapience     1.0       Original
//
//===================================================================
// (C) COPYRIGHT 2009 SYSTEM LSI CO., Ltd.
//
#include <stdio.h>
#include <stdlib.h>
#include <iostream>
void RsGfMultiplier( int*, int*,int*, int, int);
void RsGfInverse( int*, int*, int, int);
 
void RsDecodeChienEmulator(int *numError,int *errorOutTab, int DataSize, int TotalSize, int PrimPoly, int bitSymbol, int *MrefTab, int *PrefTab, int *LambdaInTab, int *OmegaInTab, int *EpsilonInTab, int *ErasureInTab) {
 
 
   //---------------------------------------------------------------
   // C++ variables int
   //---------------------------------------------------------------
   int syndromeLength;
   int aa,bb,ff,ii,jj,kk,tt,zz;
   int tempix;
   int MaxValue;
   int param1;
   int initValue;
   int numErrorReg2 = 0;
   int numErrorReg  = 0;
   int mmTabSize = (bitSymbol*2) -1;
   int idx1;
   int idx2;
   int tempo2;
   int index;
   int Pidx;
   int init;
   int tempNum;
   int lambdaFlag;
 
   //---------------------------------------------------------------
   // syndrome length calculation
   //---------------------------------------------------------------
   syndromeLength = TotalSize - DataSize;
 
 
   //---------------------------------------------------------------
   // C++ variables pointer
   //---------------------------------------------------------------
   int *x1Tab;
   int *x2Tab;
   int *initTab;
 
   int *LambdaRegTab;
   int *LambdaUpTab;
 
   int *LambdaRegTab2;
   int *LambdaUpTab2;
 
 
 
   int *lambdaSum;
   int *lambdaEven;
   int *lambdaOdd;
   int *lambdaSumReg;
   int *lambdaEvenReg;
   int *lambdaEvenReg2;
   int *lambdaEvenReg3;
   int *lambdaOddReg;
   int *lambdaOddReg2;
   int *lambdaOddReg3;
   int *denomE0;
   int *denomE0Reg;
   int *denomE0Inv;
   int *denomE0InvReg;
   int *denomE1;
   int *denomE1Reg;
   int *denomE1Inv;
   int *denomE1InvReg;
   int *bidon;
   int *numeReg;
   int *numeReg2;
   int *errorValueE0;
   int *errorValueE1;
   int *ppTab;
   int *bbTab;
   int *ttTab;
   int *powerTab;
   int *coeffTab;
   int *OmegaRegTab;
   int *OmegaNewTab;
   int *omegaSum;
   int *omegaSumReg;
   int *EpsilonRegTab;
   int *EpsilonNewTab;
   int *epsilonSum;
   int *epsilonSumReg;
   int *epsilonOdd;
   int *epsilonOddReg;
   int *errorOutTabBin;
   int *productTab;
 
 
   //------------------------------------------------------------------------
   // MaxValue calculation
   //------------------------------------------------------------------------
   MaxValue = 2;
   for(ii=0; ii<(bitSymbol-1); ii++){
      MaxValue = MaxValue*2;
   }
 
 
   coeffTab             = new int[MaxValue];
   initTab              = new int[MaxValue];
   lambdaSum            = new int[bitSymbol];
   lambdaEven           = new int[bitSymbol];
   lambdaOdd            = new int[bitSymbol];
   lambdaSumReg         = new int[bitSymbol];
   lambdaEvenReg        = new int[bitSymbol];
   lambdaEvenReg2       = new int[bitSymbol];
   lambdaEvenReg3       = new int[bitSymbol];
   lambdaOddReg         = new int[bitSymbol];
   lambdaOddReg2        = new int[bitSymbol];
   lambdaOddReg3        = new int[bitSymbol];
   x1Tab                = new int[bitSymbol];
   x2Tab                = new int[bitSymbol];
   denomE0              = new int[bitSymbol];
   denomE0Reg           = new int[bitSymbol];
   denomE0Inv           = new int[bitSymbol];
   denomE0InvReg        = new int[bitSymbol];
   denomE1              = new int[bitSymbol];
   denomE1Reg           = new int[bitSymbol];
   denomE1Inv           = new int[bitSymbol];
   denomE1InvReg        = new int[bitSymbol];
   bbTab                = new int[bitSymbol];
   ttTab                = new int[bitSymbol];
   ppTab                = new int[bitSymbol];
   numeReg              = new int[bitSymbol];
   numeReg2             = new int[bitSymbol];
   bidon                = new int[bitSymbol];
   errorValueE0         = new int[bitSymbol];
   errorValueE1         = new int[bitSymbol];
   omegaSum             = new int[bitSymbol];
   omegaSumReg          = new int[bitSymbol];
   epsilonSum           = new int[bitSymbol];
   epsilonSumReg        = new int[bitSymbol];
   epsilonOdd           = new int[bitSymbol];
   epsilonOddReg        = new int[bitSymbol];
   LambdaRegTab         = new int[syndromeLength*bitSymbol];
   LambdaUpTab          = new int[syndromeLength*bitSymbol];
 
   LambdaRegTab2        = new int[syndromeLength*bitSymbol];
   LambdaUpTab2         = new int[syndromeLength*bitSymbol];
 
 
   OmegaRegTab          = new int[syndromeLength*bitSymbol];
   OmegaNewTab          = new int[syndromeLength*bitSymbol];
   EpsilonRegTab        = new int[(syndromeLength+1)*bitSymbol];
   EpsilonNewTab        = new int[(syndromeLength+1)*bitSymbol];
   powerTab             = new int[bitSymbol];
   errorOutTabBin       = new int[bitSymbol];
   productTab           = new int[(syndromeLength+1)*bitSymbol];
 
   //---------------------------------------------------------------
   // initialize lambdaFlag
   //---------------------------------------------------------------
   lambdaFlag = 1;
 
 
   //---------------------------------------------------------------
   //+ initialize powerTab
   //---------------------------------------------------------------
   powerTab[0] = 1;
   for (ii=1; ii<bitSymbol;ii++){
      powerTab[ii] = 2*powerTab[ii-1];
   }
 
 
   //------------------------------------------------------------------------
   //- coeffTab initialize
   //------------------------------------------------------------------------
   coeffTab [0] = 0;
   coeffTab [1] = MaxValue - TotalSize;
   param1 = MaxValue - TotalSize;
 
 
   //------------------------------------------------------------------------
   //- x1Tab initialize
   //------------------------------------------------------------------------
   x1Tab[0] = 1;
   for (ii=1;ii<bitSymbol;ii++){
      x1Tab[ii] = 0;
   }
 
 
   //------------------------------------------------------------------------
   //- x2Tab initialize
   //------------------------------------------------------------------------
   x2Tab[0] = 0;
   x2Tab[1] = 1;
   for (ii=2;ii<bitSymbol;ii++){
      x2Tab[ii] = 0;
   }
 
 
   //------------------------------------------------------------------------
   //- phase 1 : initTab calculation
   //------------------------------------------------------------------------
   for(ii=0;ii<MaxValue;ii++){
 
      //------------------------------------------------------------------------
      //- ppTab = x1Tab * x2Tab
      //------------------------------------------------------------------------
      RsGfMultiplier(ppTab, x1Tab, x2Tab, PrimPoly, bitSymbol);
 
 
      //------------------------------------------------------------------------
      //- reassign x1Tab
      //------------------------------------------------------------------------
      for (zz=0; zz<bitSymbol;zz++){
         x1Tab[zz]	= ppTab[zz];
      }
 
 
      //------------------------------------------------------------------------
      //- Binary To Decimal initValue[dec] = x1Tab[bin]
      //------------------------------------------------------------------------
      initValue = 0;
      for (zz=0; zz<bitSymbol;zz++){
         initValue = initValue + x1Tab[zz] * powerTab[zz];
      }
      initTab[ii] = initValue;
   }
 
 
   //------------------------------------------------------------------------
   //- Decimal To Binary x1Tab[bin] = x2Tab[bin] = tempix[dec]
   //------------------------------------------------------------------------
   tempix = initTab[param1-1];
 
   for (zz =bitSymbol-1; zz>=0;zz--) {
      if (tempix >= powerTab[zz]) {
         tempix = tempix - powerTab[zz];
         x1Tab [zz] = 1;
         x2Tab [zz] = 1;
      }else{
         x1Tab [zz] = 0;
         x2Tab [zz] = 0;
      }
   }
 
 
   //------------------------------------------------------------------------
   //- phase 2
   //------------------------------------------------------------------------
   for (ii = 1;ii<(syndromeLength+1); ii++){
 
      //------------------------------------------------------------------------
      //- ppTab = x1Tab * x2Tab
      //------------------------------------------------------------------------
      RsGfMultiplier(ppTab, x1Tab, x2Tab, PrimPoly, bitSymbol);
 
 
      //------------------------------------------------------------------------
      //- reassign x1Tab
      //------------------------------------------------------------------------
      for (zz=0; zz<bitSymbol;zz++){
         x2Tab[zz]	= ppTab[zz];
      }
 
 
      //------------------------------------------------------------------------
      //- Binary To Decimal initValue[dec] = x2Tab[bin]
      //------------------------------------------------------------------------
      initValue = 0;
      for (zz=0; zz<bitSymbol;zz++){
         initValue = initValue + x2Tab[zz] * powerTab[zz];
      }
      tempo2= initValue;
 
 
      //------------------------------------------------------------------------
      //- index search
      //------------------------------------------------------------------------
      index = 0;
      for (jj=0;jj<MaxValue;jj++){
         if (initTab[jj]==tempo2){
            if (jj == (MaxValue-1)){
               index = 0;
            }else{
               index = jj;
            }
         }
      }
      coeffTab[ii+1] = index+1;
   }
 
 
 
   //---------------------------------------------------------------
   // initialize LambaRegTab
   //---------------------------------------------------------------
   for (ii=0; ii < syndromeLength; ii++) {
      for (zz=0; zz < bitSymbol; zz++) {
         LambdaRegTab[ii*bitSymbol+zz] = 0;
      }
   }
 
   //---------------------------------------------------------------
   // initialize OmegaRegTab
   //---------------------------------------------------------------
   for (ii=0; ii < syndromeLength; ii++) {
      for (zz=0; zz < bitSymbol; zz++) {
         OmegaRegTab[ii*bitSymbol+zz] = 0;
      }
   }
 
 
 
   for (zz=0; zz < bitSymbol; zz++) {
      lambdaSum [zz] = 0;
      lambdaEven [zz] = 0;
      lambdaOdd [zz] = 0;
      omegaSum [zz] = 0;
      epsilonSum [zz] = 0;
      epsilonOdd [zz] = 0;
      lambdaSumReg[zz] = 0;
      lambdaEvenReg3[zz] = 0;
      lambdaEvenReg2[zz] = 0;
      lambdaEvenReg[zz] = 0;
      lambdaOddReg3[zz] = 0;
      lambdaOddReg2[zz] = 0;
      lambdaOddReg[zz] = 0;
      denomE0[zz] = 0;
      denomE1[zz] = 0;
      denomE0Inv[zz] = 0;
      denomE1Inv[zz] = 0;
      denomE0Reg[zz] = 0;
      denomE1Reg[zz] = 0;
      denomE0InvReg[zz] = 0;
      denomE1InvReg[zz] = 0;
      numeReg2[zz] = 0;
      numeReg[zz] = 0;
      omegaSumReg[zz] = 0;
      epsilonSumReg[zz] = 0;
      epsilonOddReg[zz] = 0;
      errorValueE0[zz] = 0;
      errorValueE1[zz] = 0;
   }
 
 
   //---------------------------------------------------------------
   // Chien algorithm loop
   //---------------------------------------------------------------
   for (ii=0; ii < (TotalSize+4); ii++) {
 
 
 
      //---------------------------------------------------------------
      // ii == 0
      //---------------------------------------------------------------
      if (ii ==0){
 
         //---------------------------------------------------------------
         // reset productTab
         //---------------------------------------------------------------
         for (tt=0; tt < syndromeLength*bitSymbol; tt++) {
            productTab [tt] = 0;
         }
 
         //---------------------------------------------------------------
         // update productTab
         //---------------------------------------------------------------
         for (zz=0; zz < syndromeLength; zz++) {
            if (coeffTab[zz] == 0) {
               for (bb = 0; bb <bitSymbol;bb++){
                  productTab[zz*bitSymbol+bb] = LambdaInTab[zz*bitSymbol+bb];
               }
            }else{
               ttTab[0] = 1;
 
               for (kk = 1; kk <bitSymbol;kk++){ ttTab[kk] = 0;}
 
               bbTab[0] = 0;
               bbTab[1] = 1;
 
               for (kk = 2; kk <bitSymbol;kk++){ bbTab[kk] = 0;}
 
               //------------------------------------------------------------------------
               //------------------------------------------------------------------------
               for(ff=1; ff<coeffTab[zz]+1; ff++){
                  //------------------------------------------------------------------------
                  // ppTab = ttTab * bbTab
                  //------------------------------------------------------------------------
                  RsGfMultiplier(ppTab, ttTab, bbTab, PrimPoly, bitSymbol);
 
                  //------------------------------------------------------------------------
                  // reassign ttTab
                  //------------------------------------------------------------------------
                  for (kk = 0; kk <bitSymbol;kk++){
                     ttTab[kk]	= ppTab[kk];
                  }
 
                  //------------------------------------------------------------------------
                  // write P_OUT[0]
                  //------------------------------------------------------------------------
                  if (ff==coeffTab[zz]) {
                     for (Pidx=0; Pidx<bitSymbol; Pidx++){
                        init = 0;
                         for (idx2=0; idx2<bitSymbol;idx2++){bidon [idx2] = 0;}
                         for (idx1=0; idx1<mmTabSize;idx1++){
                            tempNum = PrefTab [Pidx*mmTabSize+idx1];
                            if (tempNum == 1) {
                               //------------------------------------------------------------------------
                               // search
                               //------------------------------------------------------------------------
                               for (idx2=0; idx2<bitSymbol;idx2++){
                                  tempNum = MrefTab[idx1*bitSymbol+idx2];
                                  if ((tempNum > 0) && (ttTab[tempNum-1] == 1)) {
                                     if  (bidon [idx2] == 0) {
                                        bidon [idx2] = 1;
                                     } else {
                                        bidon [idx2] = 0;
                                     }
                                  }
                               }
                            }
                         }
                         //------------------------------------------------------------------------
                         // printf
                         //------------------------------------------------------------------------
                         for (idx2=0; idx2<bitSymbol; idx2++){
                            if (bidon[idx2] == 1) {
                               productTab[zz*bitSymbol+Pidx] = productTab[zz*bitSymbol+Pidx] ^ LambdaInTab[zz*bitSymbol+idx2];
                            }
                         }
                     }
                  }
               }
            }
         }
 
 
         //---------------------------------------------------------------
         // update LambdaRegTab
         //---------------------------------------------------------------
         for (zz=0; zz < syndromeLength; zz++) {
            for (aa=0; aa < bitSymbol; aa++) {
               LambdaRegTab[zz*bitSymbol+aa] = productTab[zz*bitSymbol+aa];
            }
         }
 
 
 
 
         //---------------------------------------------------------------
         // reset productTab
         //---------------------------------------------------------------
         for (tt=0; tt < syndromeLength*bitSymbol; tt++) {
            productTab [tt] = 0;
         }
 
         //---------------------------------------------------------------
         // update productTab
         //---------------------------------------------------------------
         for (zz=0; zz < syndromeLength; zz++) {
            if (coeffTab[zz] == 0) {
               for (bb = 0; bb <bitSymbol;bb++){
                  productTab[zz*bitSymbol+bb] = OmegaInTab[zz*bitSymbol+bb];
               }
            }else{
               ttTab[0] = 1;
 
               for (kk = 1; kk <bitSymbol;kk++){ ttTab[kk] = 0;}
 
               bbTab[0] = 0;
               bbTab[1] = 1;
 
               for (kk = 2; kk <bitSymbol;kk++){ bbTab[kk] = 0;}
 
               //------------------------------------------------------------------------
               //------------------------------------------------------------------------
               for(ff=1; ff<coeffTab[zz]+1; ff++){
                  //------------------------------------------------------------------------
                  // ppTab = ttTab * bbTab
                  //------------------------------------------------------------------------
                  RsGfMultiplier(ppTab, ttTab, bbTab, PrimPoly, bitSymbol);
 
                  //------------------------------------------------------------------------
                  // reassign ttTab
                  //------------------------------------------------------------------------
                  for (kk = 0; kk <bitSymbol;kk++){
                     ttTab[kk]	= ppTab[kk];
                  }
 
                  //------------------------------------------------------------------------
                  // write P_OUT[0]
                  //------------------------------------------------------------------------
                  if (ff==coeffTab[zz]) {
                     for (Pidx=0; Pidx<bitSymbol; Pidx++){
                        init = 0;
                         for (idx2=0; idx2<bitSymbol;idx2++){bidon [idx2] = 0;}
                         for (idx1=0; idx1<mmTabSize;idx1++){
                            tempNum = PrefTab [Pidx*mmTabSize+idx1];
                            if (tempNum == 1) {
                               //------------------------------------------------------------------------
                               // search
                               //------------------------------------------------------------------------
                               for (idx2=0; idx2<bitSymbol;idx2++){
                                  tempNum = MrefTab[idx1*bitSymbol+idx2];
                                  if ((tempNum > 0) && (ttTab[tempNum-1] == 1)) {
                                     if  (bidon [idx2] == 0) {
                                        bidon [idx2] = 1;
                                     } else {
                                        bidon [idx2] = 0;
                                     }
                                  }
                               }
                            }
                         }
                         //------------------------------------------------------------------------
                         // printf
                         //------------------------------------------------------------------------
                         for (idx2=0; idx2<bitSymbol; idx2++){
                            if (bidon[idx2] == 1) {
                               productTab[zz*bitSymbol+Pidx] = productTab[zz*bitSymbol+Pidx] ^ OmegaInTab[zz*bitSymbol+idx2];
                            }
                         }
                     }
                  }
               }
            }
         }
 
 
         //---------------------------------------------------------------
         // update OmegaRegTab
         //---------------------------------------------------------------
         for (zz=0; zz < syndromeLength; zz++) {
            for (aa=0; aa < bitSymbol; aa++) {
               OmegaRegTab[zz*bitSymbol+aa] = productTab[zz*bitSymbol+aa];
            }
         }
 
 
 
         //---------------------------------------------------------------
         // reset productTab
         //---------------------------------------------------------------
         for (tt=0; tt < (syndromeLength+1)*bitSymbol; tt++) {
            productTab [tt] = 0;
         }
 
 
         //---------------------------------------------------------------
         // update productTab
         //---------------------------------------------------------------
         for (zz=0; zz <= syndromeLength; zz++) {
            if (coeffTab[zz] == 0) {
               for (bb = 0; bb <bitSymbol;bb++){
                  productTab[zz*bitSymbol+bb] = EpsilonInTab[zz*bitSymbol+bb];
               }
            }else{
               ttTab[0] = 1;
 
               for (kk = 1; kk <bitSymbol;kk++){ ttTab[kk] = 0;}
 
               bbTab[0] = 0;
               bbTab[1] = 1;
 
               for (kk = 2; kk <bitSymbol;kk++){ bbTab[kk] = 0;}
 
               //------------------------------------------------------------------------
               //------------------------------------------------------------------------
               for(ff=1; ff<coeffTab[zz]+1; ff++){
                  //------------------------------------------------------------------------
                  // ppTab = ttTab * bbTab
                  //------------------------------------------------------------------------
                  RsGfMultiplier(ppTab, ttTab, bbTab, PrimPoly, bitSymbol);
 
                  //------------------------------------------------------------------------
                  // reassign ttTab
                  //------------------------------------------------------------------------
                  for (kk = 0; kk <bitSymbol;kk++){
                     ttTab[kk]	= ppTab[kk];
                  }
 
                  //------------------------------------------------------------------------
                  // write P_OUT[0]
                  //------------------------------------------------------------------------
                  if (ff==coeffTab[zz]) {
                     for (Pidx=0; Pidx<bitSymbol; Pidx++){
                        init = 0;
                         for (idx2=0; idx2<bitSymbol;idx2++){bidon [idx2] = 0;}
                         for (idx1=0; idx1<mmTabSize;idx1++){
                            tempNum = PrefTab [Pidx*mmTabSize+idx1];
                            if (tempNum == 1) {
                               //------------------------------------------------------------------------
                               // search
                               //------------------------------------------------------------------------
                               for (idx2=0; idx2<bitSymbol;idx2++){
                                  tempNum = MrefTab[idx1*bitSymbol+idx2];
                                  if ((tempNum > 0) && (ttTab[tempNum-1] == 1)) {
                                     if  (bidon [idx2] == 0) {
                                        bidon [idx2] = 1;
                                     } else {
                                        bidon [idx2] = 0;
                                     }
                                  }
                               }
                            }
                         }
                         //------------------------------------------------------------------------
                         // printf
                         //------------------------------------------------------------------------
                         for (idx2=0; idx2<bitSymbol; idx2++){
                            if (bidon[idx2] == 1) {
                               productTab[zz*bitSymbol+Pidx] = productTab[zz*bitSymbol+Pidx] ^ EpsilonInTab[zz*bitSymbol+idx2];
                            }
                         }
                     }
                  }
               }
            }
         }
 
 
         //---------------------------------------------------------------
         // update EpsilonRegTab
         //---------------------------------------------------------------
         for (zz=0; zz <= syndromeLength; zz++) {
            for (aa=0; aa < bitSymbol; aa++) {
               EpsilonRegTab[zz*bitSymbol+aa] = productTab[zz*bitSymbol+aa];
            }
         }
 
 
      }else{
 
         //---------------------------------------------------------------
         // reset productTab
         //---------------------------------------------------------------
         for (tt=0; tt < syndromeLength*bitSymbol; tt++) {
            productTab [tt] = 0;
         }
 
 
         //---------------------------------------------------------------
         // update productTab
         //---------------------------------------------------------------
         for (zz=0; zz < syndromeLength; zz++) {
            if (zz == 0) {
               for (bb = 0; bb <bitSymbol;bb++){
                  productTab[zz*bitSymbol+bb] = LambdaRegTab[zz*bitSymbol+bb];
               }
            }else{
               ttTab[0] = 1;
 
               for (kk = 1; kk <bitSymbol;kk++){ ttTab[kk] = 0;}
 
               bbTab[0] = 0;
               bbTab[1] = 1;
 
               for (kk = 2; kk <bitSymbol;kk++){ bbTab[kk] = 0;}
 
               //------------------------------------------------------------------------
               //------------------------------------------------------------------------
               for(ff=1; ff<zz+1; ff++){
                  //------------------------------------------------------------------------
                  // ppTab = ttTab * bbTab
                  //------------------------------------------------------------------------
                  RsGfMultiplier(ppTab, ttTab, bbTab, PrimPoly, bitSymbol);
 
                  //------------------------------------------------------------------------
                  // reassign ttTab
                  //------------------------------------------------------------------------
                  for (kk = 0; kk <bitSymbol;kk++){
                     ttTab[kk]	= ppTab[kk];
                  }
 
                  //------------------------------------------------------------------------
                  // write P_OUT[0]
                  //------------------------------------------------------------------------
                  if (ff==zz) {
                     for (Pidx=0; Pidx<bitSymbol; Pidx++){
                        init = 0;
                         for (idx2=0; idx2<bitSymbol;idx2++){bidon [idx2] = 0;}
                         for (idx1=0; idx1<mmTabSize;idx1++){
                            tempNum = PrefTab [Pidx*mmTabSize+idx1];
                            if (tempNum == 1) {
                               //------------------------------------------------------------------------
                               // search
                               //------------------------------------------------------------------------
                               for (idx2=0; idx2<bitSymbol;idx2++){
                                  tempNum = MrefTab[idx1*bitSymbol+idx2];
                                  if ((tempNum > 0) && (ttTab[tempNum-1] == 1)) {
                                     if  (bidon [idx2] == 0) {
                                        bidon [idx2] = 1;
                                     } else {
                                        bidon [idx2] = 0;
                                     }
                                  }
                               }
                            }
                         }
                         //------------------------------------------------------------------------
                         // printf
                         //------------------------------------------------------------------------
                         for (idx2=0; idx2<bitSymbol; idx2++){
                            if (bidon[idx2] == 1) {
                               productTab[zz*bitSymbol+Pidx] = productTab[zz*bitSymbol+Pidx] ^ LambdaRegTab[zz*bitSymbol+idx2];
                            }
                         }
                     }
                  }
               }
            }
         }
 
 
         //---------------------------------------------------------------
         // calulate LambdaUpTab
         //---------------------------------------------------------------
         for (zz=0; zz < syndromeLength; zz++) {
            for (aa=0; aa < bitSymbol; aa++) {
               LambdaUpTab[zz*bitSymbol+aa] = productTab[zz*bitSymbol+aa];
            }
         }
 
 
         //---------------------------------------------------------------
         // reset productTab
         //---------------------------------------------------------------
         for (tt=0; tt < syndromeLength*bitSymbol; tt++) {
            productTab [tt] = 0;
         }
 
 
         //---------------------------------------------------------------
         // update productTab
         //---------------------------------------------------------------
         for (zz=0; zz < syndromeLength; zz++) {
            if (zz == 0) {
               for (bb = 0; bb <bitSymbol;bb++){
                  productTab[zz*bitSymbol+bb] = OmegaRegTab[zz*bitSymbol+bb];
               }
            }else{
               ttTab[0] = 1;
 
               for (kk = 1; kk <bitSymbol;kk++){ ttTab[kk] = 0;}
 
               bbTab[0] = 0;
               bbTab[1] = 1;
 
               for (kk = 2; kk <bitSymbol;kk++){ bbTab[kk] = 0;}
 
               //------------------------------------------------------------------------
               //------------------------------------------------------------------------
               for(ff=1; ff<zz+1; ff++){
                  //------------------------------------------------------------------------
                  // ppTab = ttTab * bbTab
                  //------------------------------------------------------------------------
                  RsGfMultiplier(ppTab, ttTab, bbTab, PrimPoly, bitSymbol);
 
                  //------------------------------------------------------------------------
                  // reassign ttTab
                  //------------------------------------------------------------------------
                  for (kk = 0; kk <bitSymbol;kk++){
                     ttTab[kk]	= ppTab[kk];
                  }
 
                  //------------------------------------------------------------------------
                  // write P_OUT[0]
                  //------------------------------------------------------------------------
                  if (ff==zz) {
                     for (Pidx=0; Pidx<bitSymbol; Pidx++){
                        init = 0;
                         for (idx2=0; idx2<bitSymbol;idx2++){bidon [idx2] = 0;}
                         for (idx1=0; idx1<mmTabSize;idx1++){
                            tempNum = PrefTab [Pidx*mmTabSize+idx1];
                            if (tempNum == 1) {
                               //------------------------------------------------------------------------
                               // search
                               //------------------------------------------------------------------------
                               for (idx2=0; idx2<bitSymbol;idx2++){
                                  tempNum = MrefTab[idx1*bitSymbol+idx2];
                                  if ((tempNum > 0) && (ttTab[tempNum-1] == 1)) {
                                     if  (bidon [idx2] == 0) {
                                        bidon [idx2] = 1;
                                     } else {
                                        bidon [idx2] = 0;
                                     }
                                  }
                               }
                            }
                         }
                         //------------------------------------------------------------------------
                         // printf
                         //------------------------------------------------------------------------
                         for (idx2=0; idx2<bitSymbol; idx2++){
                            if (bidon[idx2] == 1) {
                               productTab[zz*bitSymbol+Pidx] = productTab[zz*bitSymbol+Pidx] ^ OmegaRegTab[zz*bitSymbol+idx2];
                            }
                         }
                     }
                  }
               }
            }
         }
 
 
         //---------------------------------------------------------------
         // calulate OmegaNewTab
         //---------------------------------------------------------------
         for (zz=0; zz < syndromeLength; zz++) {
            for (aa=0; aa < bitSymbol; aa++) {
               OmegaNewTab[zz*bitSymbol+aa] = productTab[zz*bitSymbol+aa];
            }
         }
 
         //---------------------------------------------------------------
         // reset productTab
         //---------------------------------------------------------------
         for (tt=0; tt < (syndromeLength+1)*bitSymbol; tt++) {
            productTab [tt] = 0;
         }
 
         //---------------------------------------------------------------
         // update productTab
         //---------------------------------------------------------------
         for (zz=0; zz <= syndromeLength; zz++) {
 
 
            if (zz == 0) {
               for (bb = 0; bb <bitSymbol;bb++){
                  productTab[zz*bitSymbol+bb] = EpsilonRegTab[zz*bitSymbol+bb];
               }
            }else{
               ttTab[0] = 1;
 
               for (kk = 1; kk <bitSymbol;kk++){ ttTab[kk] = 0;}
 
               bbTab[0] = 0;
               bbTab[1] = 1;
 
               for (kk = 2; kk <bitSymbol;kk++){ bbTab[kk] = 0;}
 
               //------------------------------------------------------------------------
               //------------------------------------------------------------------------
               for(ff=1; ff<zz+1; ff++){
 
                  //------------------------------------------------------------------------
                  // ppTab = ttTab * bbTab
                  //------------------------------------------------------------------------
                  RsGfMultiplier(ppTab, ttTab, bbTab, PrimPoly, bitSymbol);
 
                  //------------------------------------------------------------------------
                  // reassign ttTab
                  //------------------------------------------------------------------------
                  for (kk = 0; kk <bitSymbol;kk++){
                     ttTab[kk]	= ppTab[kk];
                  }
 
 
                  //------------------------------------------------------------------------
                  // write P_OUT[0]
                  //------------------------------------------------------------------------
                  if (ff==zz) {
                     for (Pidx=0; Pidx<bitSymbol; Pidx++){
                        init = 0;
                         for (idx2=0; idx2<bitSymbol;idx2++){bidon [idx2] = 0;}
                         for (idx1=0; idx1<mmTabSize;idx1++){
                            tempNum = PrefTab [Pidx*mmTabSize+idx1];
                            if (tempNum == 1) {
                               //------------------------------------------------------------------------
                               // search
                               //------------------------------------------------------------------------
                               for (idx2=0; idx2<bitSymbol;idx2++){
                                  tempNum = MrefTab[idx1*bitSymbol+idx2];
                                  if ((tempNum > 0) && (ttTab[tempNum-1] == 1)) {
                                     if  (bidon [idx2] == 0) {
                                        bidon [idx2] = 1;
                                     } else {
                                        bidon [idx2] = 0;
                                     }
                                  }
                               }
                            }
                         }
                         //------------------------------------------------------------------------
                         // printf
                         //------------------------------------------------------------------------
                         for (idx2=0; idx2<bitSymbol; idx2++){
                            if (bidon[idx2] == 1) {
                               productTab[zz*bitSymbol+Pidx] = productTab[zz*bitSymbol+Pidx] ^ EpsilonRegTab[zz*bitSymbol+idx2];
                            }
                         }
                     }
                  }
               }
            }
         }
 
         //---------------------------------------------------------------
         // calulate EpsilonNewTab
         //---------------------------------------------------------------
         for (zz=0; zz <= syndromeLength; zz++) {
            for (aa=0; aa < bitSymbol; aa++) {
               EpsilonNewTab[zz*bitSymbol+aa] = productTab[zz*bitSymbol+aa];
            }
         }
 
         //---------------------------------------------------------------
         // calculate lambdaSum
         //---------------------------------------------------------------
         for (bb=0; bb < bitSymbol; bb++) {
            lambdaSum[bb] = 0;
            for (zz=0; zz < syndromeLength; zz++) {
               lambdaSum[bb] = lambdaSum[bb] ^ LambdaRegTab[zz*bitSymbol+bb];
            }
         }
 
         //---------------------------------------------------------------
         // calculate lambdaEven
         //---------------------------------------------------------------
         for (bb=0; bb < bitSymbol; bb++) {
            lambdaEven[bb] = 0;
            for (zz=0; zz < syndromeLength; zz++) {
               if (zz % 2 == 0){
                  lambdaEven[bb] = lambdaEven[bb] ^ LambdaRegTab[zz*bitSymbol+bb];
               }
            }
         }
 
 
         //---------------------------------------------------------------
         // calculate lambdaOdd
         //---------------------------------------------------------------
         for (bb=0; bb < bitSymbol; bb++) {
            lambdaOdd[bb] = 0;
            for (zz=0; zz < syndromeLength; zz++) {
               if (zz % 2 == 1){
                  lambdaOdd[bb] = lambdaOdd[bb] ^ LambdaRegTab[zz*bitSymbol+bb];
               }
            }
         }
 
         //---------------------------------------------------------------
         // calculate omegaSum
         //---------------------------------------------------------------
         for (bb=0; bb < bitSymbol; bb++) {
            omegaSum[bb] = 0;
            for (zz=0; zz < syndromeLength; zz++) {
               omegaSum[bb] = omegaSum[bb] ^ OmegaRegTab[zz*bitSymbol+bb];
            }
         }
 
 
         //---------------------------------------------------------------
         // calculate epsilonSum
         //---------------------------------------------------------------
         for (bb=0; bb < bitSymbol; bb++) {
            epsilonSum[bb] = 0;
            for (zz=0; zz <= syndromeLength; zz++) {
               epsilonSum[bb] = epsilonSum[bb] ^ EpsilonRegTab[zz*bitSymbol+bb];
            }
         }
 
 
         //---------------------------------------------------------------
         // calculate epsilonOdd
         //---------------------------------------------------------------
         for (bb=0; bb < bitSymbol; bb++) {
            epsilonOdd[bb] = 0;
            for (zz=0; zz <= syndromeLength; zz++) {
               if (zz % 2 == 1){
                  epsilonOdd[bb] = epsilonOdd[bb] ^ EpsilonRegTab[zz*bitSymbol+bb];
               }
            }
         }
 
         //---------------------------------------------------------------
         // calculate denomE0
         //---------------------------------------------------------------
         RsGfMultiplier(denomE0, lambdaOddReg, epsilonSumReg, PrimPoly, bitSymbol);
 
 
         //---------------------------------------------------------------
         // calculate denomE1
         //---------------------------------------------------------------
         RsGfMultiplier(denomE1, lambdaSumReg, epsilonOddReg, PrimPoly, bitSymbol);
 
 
         //---------------------------------------------------------------
         // calculate denomE0Inv
         //---------------------------------------------------------------
         RsGfInverse(denomE0Inv, denomE0Reg, PrimPoly, bitSymbol);
 
 
         //---------------------------------------------------------------
         // calculate denomE1Inv
         //---------------------------------------------------------------
         RsGfInverse(denomE1Inv, denomE1Reg, PrimPoly, bitSymbol);
 
         //---------------------------------------------------------------
         // calculate errorValueE0
         //---------------------------------------------------------------
         RsGfMultiplier(errorValueE0, numeReg2, denomE0InvReg, PrimPoly, bitSymbol);
 
 
         //---------------------------------------------------------------
         // calculate errorValueE1
         //---------------------------------------------------------------
         RsGfMultiplier(errorValueE1, numeReg2, denomE1InvReg, PrimPoly, bitSymbol);
 
         //---------------------------------------------------------------
         // calculate errorOut
         //---------------------------------------------------------------
         if (ii>3) {
            if (ErasureInTab [ii-4] == 1){
               for (bb=0; bb < bitSymbol; bb++) {
                  errorOutTabBin [bb] = errorValueE1[bb];
               }
            }else{
               lambdaFlag = 1;
               for (bb=0; bb < bitSymbol; bb++) {
                  if (lambdaEvenReg3 [bb] != lambdaOddReg3[bb]){
                     lambdaFlag = 0;
                  }
               }
 
               if (lambdaFlag == 1) {
                  for (bb=0; bb < bitSymbol; bb++) {
                     errorOutTabBin [bb] = errorValueE0[bb];
                  }
               }else{
                  for (bb=0; bb < bitSymbol; bb++) {
                     errorOutTabBin [bb] = 0;
                  }
               }
            }
 
            //---------------------------------------------------------------
            // bin to dec
            //---------------------------------------------------------------
            tempNum = 0;
            for(kk=0; kk< bitSymbol; kk++){
               tempNum = tempNum + errorOutTabBin[kk] * powerTab[kk];
            }
            errorOutTab[ii-4] = tempNum;
         }
 
         //---------------------------------------------------------------
         // update numErrorReg2
         //---------------------------------------------------------------
            lambdaFlag = 1;
            for (bb=0; bb < bitSymbol; bb++) {
               if (lambdaEven [bb] != lambdaOdd[bb]){
                  lambdaFlag = 0;
               }
            }
 
         if (ii == (TotalSize)){
            if (lambdaFlag==1) {
               numErrorReg2 = numErrorReg + 1;
            }else{
               numErrorReg2 = numErrorReg;
            }
         }
 
         //---------------------------------------------------------------
         // update numErrorReg
         //---------------------------------------------------------------
         if (ii == 0){
            numErrorReg = 0;
         }else{
            if (lambdaFlag==1) {
               numErrorReg = numErrorReg + 1;
            }
         }
 
 
         //---------------------------------------------------------------
         // update LambdaRegTab
         //---------------------------------------------------------------
         for (zz=0; zz < syndromeLength; zz++) {
            for (bb=0; bb < bitSymbol; bb++) {
               LambdaRegTab[zz*bitSymbol+bb] = LambdaUpTab[zz*bitSymbol+bb];
            }
         }
 
         //---------------------------------------------------------------
         // update OmegaRegTab
         //---------------------------------------------------------------
         for (zz=0; zz < syndromeLength; zz++) {
            for (bb=0; bb < bitSymbol; bb++) {
               OmegaRegTab[zz*bitSymbol+bb] = OmegaNewTab[zz*bitSymbol+bb];
            }
         }
 
 
         //---------------------------------------------------------------
         // update EpsilonRegTab
         //---------------------------------------------------------------
         for (zz=0; zz <= syndromeLength; zz++) {
            for (bb=0; bb < bitSymbol; bb++) {
               EpsilonRegTab[zz*bitSymbol+bb] = EpsilonNewTab[zz*bitSymbol+bb];
            }
         }
 
         //---------------------------------------------------------------
         // update registers
         //---------------------------------------------------------------
         for (bb=0; bb < bitSymbol; bb++) {
            lambdaSumReg   [bb] = lambdaSum[bb];
            lambdaEvenReg3 [bb] = lambdaEvenReg2[bb];
            lambdaEvenReg2 [bb] = lambdaEvenReg [bb];
            lambdaEvenReg  [bb] = lambdaEven    [bb];
            lambdaOddReg3  [bb] = lambdaOddReg2[bb];
            lambdaOddReg2  [bb] = lambdaOddReg [bb];
            lambdaOddReg   [bb] = lambdaOdd    [bb];
            denomE0Reg     [bb] = denomE0 [bb];
            denomE1Reg     [bb] = denomE1 [bb];
            denomE0InvReg  [bb] = denomE0Inv [bb];
            denomE1InvReg  [bb] = denomE1Inv [bb];
            numeReg2       [bb] = numeReg [bb];
            numeReg        [bb] = omegaSumReg [bb];
            omegaSumReg    [bb] = omegaSum [bb];
            epsilonSumReg  [bb] = epsilonSum[bb];
            epsilonOddReg  [bb] = epsilonOdd[bb];
         }
      }
   }
 
 
   //---------------------------------------------------------------
   // assign numError
   //---------------------------------------------------------------
   numError [0] = numErrorReg2;
 
 
   //---------------------------------------------------------------
   // Free memory
   //---------------------------------------------------------------
   delete[] x1Tab;
   delete[] x2Tab;
   delete[] initTab;
   delete[] LambdaRegTab;
   delete[] LambdaUpTab;
   delete[] LambdaRegTab2;
   delete[] LambdaUpTab2;
   delete[] lambdaSum;
   delete[] lambdaEven;
   delete[] lambdaOdd;
   delete[] lambdaSumReg;
   delete[] lambdaEvenReg;
   delete[] lambdaEvenReg2;
   delete[] lambdaEvenReg3;
   delete[] lambdaOddReg;
   delete[] lambdaOddReg2;
   delete[] lambdaOddReg3;
   delete[] denomE0;
   delete[] denomE0Reg;
   delete[] denomE0Inv;
   delete[] denomE0InvReg;
   delete[] denomE1;
   delete[] denomE1Reg;
   delete[] denomE1Inv;
   delete[] denomE1InvReg;
   delete[] bidon;
   delete[] numeReg;
   delete[] numeReg2;
   delete[] errorValueE0;
   delete[] errorValueE1;
   delete[] ppTab;
   delete[] bbTab;
   delete[] ttTab;
   delete[] powerTab;
   delete[] coeffTab;
   delete[] OmegaRegTab;
   delete[] OmegaNewTab;
   delete[] omegaSum;
   delete[] omegaSumReg;
   delete[] EpsilonRegTab;
   delete[] EpsilonNewTab;
   delete[] epsilonSum;
   delete[] epsilonSumReg;
   delete[] epsilonOdd;
   delete[] epsilonOddReg;
   delete[] errorOutTabBin;
   delete[] productTab;
 
 
}
 

Go to most recent revision | Compare with Previous | Blame | View Log

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.