Subversion Repositories reed_solomon_codec_generator

//===================================================================

// Module Name : RsDecodeSyndromeEmulator

// File Name   : RsDecodeSyndromeEmulator.cpp

// Function    : RS Decoder syndrome 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 RsDecodeSyndromeEmulator(int *regSyndrome, int DataSize, int TotalSize, int PrimPoly, int bitSymbol, int *MrefTab, int *PrefTab, int *DataIn) {

   //---------------------------------------------------------------

   // C++ variables

   //---------------------------------------------------------------

   int aa, bb, kk, ii,ff, zz, tt;

   int syndromeLength;

   int tempix;

   int LoopSize;

   int Pidx;

   int init;

   int idx1;

   int idx2;

   int tempNum;

   int mmTabSize = (bitSymbol*2) -1;

   //---------------------------------------------------------------

   // calculate syndrome polynom length

   //---------------------------------------------------------------

   syndromeLength = TotalSize - DataSize;

   int *powerTab;

   int *DataInBin;

   int *productTab;

   int *bbTab;

   int *ppTab;

   int *ttTab;

   int *bidon;

   powerTab        = new int[bitSymbol];

   DataInBin       = new int[bitSymbol];

   productTab      = new int[syndromeLength*bitSymbol];

   bbTab           = new int[bitSymbol];

   ppTab           = new int[bitSymbol];

   ttTab           = new int[bitSymbol];

   bidon           = new int[bitSymbol];

   //---------------------------------------------------------------

   //+ initialize powerTab

   //---------------------------------------------------------------

   powerTab[0] = 1;

   for (ii=1; ii<bitSymbol;ii++){

      powerTab[ii] = 2*powerTab[ii-1];

   }

   //---------------------------------------------------------------

   // Dec2Bin Datain[0]

   //---------------------------------------------------------------

   tempix = DataIn[0];

   for (zz =bitSymbol-1; zz>=0;zz=zz-1) {

      if (tempix >= powerTab[zz]) {

         tempix = tempix - powerTab[zz];

         DataInBin [zz] = 1;

      }else{

         DataInBin [zz] = 0;

      }

   }

   //---------------------------------------------------------------

   // assign regSyndrome

   //---------------------------------------------------------------

   for (ii=0; ii < syndromeLength; ii++) {

      for (zz=0; zz < bitSymbol; zz++) {

         regSyndrome[ii*bitSymbol+zz] = DataInBin [zz];

      }

   }

   //---------------------------------------------------------------

   // calculate regSyndrome

   //---------------------------------------------------------------

   for (ii=1; ii < TotalSize; ii++) {

      //---------------------------------------------------------------

      // 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] = regSyndrome[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] ^ regSyndrome[zz*bitSymbol+idx2];

                     }

                  }

               }

            }

         }

      }

      }

      //---------------------------------------------------------------

      // Dec2Bin Datain[0]

      //---------------------------------------------------------------

      tempix = DataIn[ii];

      for (zz =bitSymbol-1; zz>=0;zz=zz-1) {

         if (tempix >= powerTab[zz]) {

            tempix = tempix - powerTab[zz];

            DataInBin [zz] = 1;

         }else{

            DataInBin [zz] = 0;

         }

      }

      //---------------------------------------------------------------

      // assign regSyndrome

      //---------------------------------------------------------------

      for (aa=0; aa < syndromeLength; aa++) {

         for (zz=0; zz < bitSymbol; zz++) {

            regSyndrome[aa*bitSymbol+zz] = DataInBin [zz] ^ productTab[aa*bitSymbol+zz];

         }

      }

   }

   //---------------------------------------------------------------

   // Free memory

   //---------------------------------------------------------------

   delete[] powerTab;

   delete[] DataInBin;

   delete[] productTab;

   delete[] bbTab;

   delete[] ppTab;

   delete[] ttTab;

   delete[] bidon;

}