Subversion Repositories reed_solomon_codec_generator

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

// Module Name : main

// File Name   : RsIpEngine.cpp

// Function    : main

// 

// Revision History:

// Date          By           Version    Change Description

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

// 2009/02/03  Gael Sapience     1.0       Original

//

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

// (C) COPYRIGHT 2009 SYSTEM LSI CO., Ltd.

//

#include <cstdio>

#include <cstdlib>

#include <ctime>

#include <iostream>

#include<windows.h>

#include<fstream>

#include <stdio.h>

#include <stdlib.h>

using namespace std;

#include <io.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <string.h>

FILE  *OutFileIPSpecs;

void RsEncode(int, int, int, int, int, int, int, int*, int*, int*, int, int, int, int, int, int, int, int, int, int, char*);

void RsGfMultiplier(int*, int*,int*, int, int);

void RsDecode(int, int, int, int, int, int, int, int,int,int,int,int,int, int*, int*, int*,int,int, int, int, char*);

void RsSimBench(int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, char*);

void RsMrefTab(int*, int);

void RsPrefTab(int*, int, int);

int main(int argc, char *argv[])

{

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

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

   //- Get Parameters from C# program

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

   int DataSize, TotalSize, PrimPoly, ErasureOption;

   int BlockAmount, ErrorRate;

   int bitSymbol;

   int syndromeLength;

   int syndromeMod2;

   int ii,jj,zz;

   int tempix;

   int symbolMax;

   int DecNumber;

   int index;

   int errorStats;

   int passFailFlag;

   int delayDataIn;

   int encDecMode;

   int encBlockAmount;

   int ipCustomerKey;

   int PowerErrorRate;

   int ErasureRate;

   int PowerErasureRate;

   int cppCoreInternalKey;

   int pathFlag;

   int lengthPath;

   char *rootFolderPath;

   char *strsimReedSolomon;

   char *strrtl;

   char *strsim;

   char *strRsEncIn;

   char *strRsEncOut;

   char *strRsDecIn;

   char *strRsDecOut;

   char *strRsEncodeTop;

   char *strRsDecodeTop;

   char *strRsDecodeSyndrome;

   char *strRsDecodeShiftOmega;

   char *strRsDecodePolymul;

   char *strRsDecodeMult;

   char *strRsDecodeInv;

   char *strRsDecodeEuclide;

   char *strRsDecodeErasure;

   char *strRsDecodeDpRam;

   char *strRsDecodeDelay;

   char *strRsDecodeDegree;

   char *strRsDecodeChien;

   char *strIPSpecs;

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

   // cpp core internal ip key

   //- It is the only line to change before release

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

   cppCoreInternalKey = 27;

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

   // convert parameters to Int

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

   DataSize         = atoi(argv[1]);  // Data Size

   TotalSize        = atoi(argv[2]);  // Total Size

   PrimPoly         = atoi(argv[3]);  // Primitve Polynom

   ErasureOption    = atoi(argv[4]);  // Erasure Decoding ( 0: No, 1:Yes)

   BlockAmount      = atoi(argv[5]);  // RS Decoder Block Amount for Sim

   ErrorRate        = atoi(argv[6]);  // Error rate

   PowerErrorRate   = atoi(argv[7]);  // 0: 1, 1: 10^-1, 4: 10^-4

   ErasureRate      = atoi(argv[8]);  // Erasure rate

   PowerErasureRate = atoi(argv[9]);  // 0: 1, 1: 10^-1, 4: 10^-4

   bitSymbol        = atoi(argv[10]); // range = [3..12]

   errorStats       = atoi(argv[11]); //( 0: No, 1:Yes)

   passFailFlag     = atoi(argv[12]); //( 0: No, 1:Yes)

   delayDataIn      = atoi(argv[13]); //( 0: No, 1:Yes)

   encDecMode       = atoi(argv[14]); //(1: enc only, 2:dec only, 3: enc & dec)

   encBlockAmount   = atoi(argv[15]); // encoder block amount

   ipCustomerKey    = atoi(argv[16]); // IP Key

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

   // check parameter amount if not 17 or 18 -> escape code

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

   if ((argc < 17) || (argc > 18)){

      exit(1);

   }

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

   // get Root folder path if specified

   // apthFlag= 1 if Path specified, 0 if not specified

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

   if (argc == 18) {

      pathFlag = 1;

      lengthPath = strlen(argv[17]);

   }else{

      pathFlag = 0;

      lengthPath = 1;

   }

   rootFolderPath = (char *)calloc(lengthPath,  sizeof(char));

   if (pathFlag == 1) {

      rootFolderPath   = argv[17]; // Root Folder Path

      for(ii=0; ii<lengthPath; ii++){ // unify markers

         if (rootFolderPath[ii] == '\\'  ) {

            rootFolderPath[ii] = '/';

         }

      }

   }else{

      rootFolderPath = "Z";

   }

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

   // make path file strings

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

   strsimReedSolomon = (char *)calloc(lengthPath + 22,  sizeof(char));

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

      strsimReedSolomon[ii] = rootFolderPath[ii];

   }

   strcat(strsimReedSolomon, "/sim/simReedSolomon.v");

   strRsEncIn = (char *)calloc(lengthPath + 17,  sizeof(char));

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

      strRsEncIn[ii] = rootFolderPath[ii];

   }

   strcat(strRsEncIn, "/sim/RsEncIn.hex");

   strRsEncOut = (char *)calloc(lengthPath + 18,  sizeof(char));

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

      strRsEncOut[ii] = rootFolderPath[ii];

   }

   strcat(strRsEncOut, "/sim/RsEncOut.hex");

   strRsDecIn = (char *)calloc(lengthPath + 17,  sizeof(char));

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

      strRsDecIn[ii] = rootFolderPath[ii];

   }

   strcat(strRsDecIn, "/sim/RsDecIn.hex");

   strRsDecOut = (char *)calloc(lengthPath + 18,  sizeof(char));

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

      strRsDecOut[ii] = rootFolderPath[ii];

   }

   strcat(strRsDecOut, "/sim/RsDecOut.hex");

   strRsEncodeTop = (char *)calloc(lengthPath + 19,  sizeof(char));

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

      strRsEncodeTop[ii] = rootFolderPath[ii];

   }

   strcat(strRsEncodeTop, "/rtl/RsEncodeTop.v");

   strRsDecodeTop = (char *)calloc(lengthPath + 19,  sizeof(char));

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

      strRsDecodeTop[ii] = rootFolderPath[ii];

   }

   strcat(strRsDecodeTop, "/rtl/RsDecodeTop.v");

   strRsDecodeSyndrome = (char *)calloc(lengthPath + 24,  sizeof(char));

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

      strRsDecodeSyndrome[ii] = rootFolderPath[ii];

   }

   strcat(strRsDecodeSyndrome, "/rtl/RsDecodeSyndrome.v");

   strRsDecodeShiftOmega = (char *)calloc(lengthPath + 26,  sizeof(char));

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

      strRsDecodeShiftOmega[ii] = rootFolderPath[ii];

   }

   strcat(strRsDecodeShiftOmega, "/rtl/RsDecodeShiftOmega.v");

   strRsDecodePolymul = (char *)calloc(lengthPath + 23,  sizeof(char));

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

      strRsDecodePolymul[ii] = rootFolderPath[ii];

   }

   strcat(strRsDecodePolymul, "/rtl/RsDecodePolymul.v");

   strRsDecodeMult = (char *)calloc(lengthPath + 20,  sizeof(char));

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

      strRsDecodeMult[ii] = rootFolderPath[ii];

   }

   strcat(strRsDecodeMult, "/rtl/RsDecodeMult.v");

   strRsDecodeInv = (char *)calloc(lengthPath + 19,  sizeof(char));

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

      strRsDecodeInv[ii] = rootFolderPath[ii];

   }

   strcat(strRsDecodeInv, "/rtl/RsDecodeInv.v");

   strRsDecodeEuclide = (char *)calloc(lengthPath + 23,  sizeof(char));

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

      strRsDecodeEuclide[ii] = rootFolderPath[ii];

   }

   strcat(strRsDecodeEuclide, "/rtl/RsDecodeEuclide.v");

   strRsDecodeErasure = (char *)calloc(lengthPath + 23,  sizeof(char));

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

      strRsDecodeErasure[ii] = rootFolderPath[ii];

   }

   strcat(strRsDecodeErasure, "/rtl/RsDecodeErasure.v");

   strRsDecodeDpRam = (char *)calloc(lengthPath + 21,  sizeof(char));

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

      strRsDecodeDpRam[ii] = rootFolderPath[ii];

   }

   strcat(strRsDecodeDpRam, "/rtl/RsDecodeDpRam.v");

   strRsDecodeDelay = (char *)calloc(lengthPath + 21,  sizeof(char));

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

      strRsDecodeDelay[ii] = rootFolderPath[ii];

   }

   strcat(strRsDecodeDelay, "/rtl/RsDecodeDelay.v");

   strRsDecodeDegree = (char *)calloc(lengthPath + 22,  sizeof(char));

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

      strRsDecodeDegree[ii] = rootFolderPath[ii];

   }

   strcat(strRsDecodeDegree, "/rtl/RsDecodeDegree.v");

   strRsDecodeChien = (char *)calloc(lengthPath + 21,  sizeof(char));

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

      strRsDecodeChien[ii] = rootFolderPath[ii];

   }

   strcat(strRsDecodeChien, "/rtl/RsDecodeChien.v");

   strrtl = (char *)calloc(lengthPath + 5,  sizeof(char));

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

      strrtl[ii] = rootFolderPath[ii];

   }

   strcat(strrtl, "/rtl");

   strsim = (char *)calloc(lengthPath + 5,  sizeof(char));

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

      strsim[ii] = rootFolderPath[ii];

   }

   strcat(strsim, "/sim");

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

   // syndrome Polynom calculation

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

   syndromeLength = TotalSize - DataSize;

   syndromeMod2   = syndromeLength %2;

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

   // symbolMax calculation

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

   symbolMax = 1;

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

      symbolMax= 2* symbolMax;

   }

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

   //- c++ variables

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

   int mmTabSize = (bitSymbol*2) -1;

   int *PrefTab;

   int *MrefTab;

   int *x1Tab;

   int *x2Tab;

   int *ppTab;

   int *aTab;

   int *checkTab;

   int *powerTab;

   int *GenPoly;

   int *convPoly;

   int *xPoly;

   int *coeffPoly;

   int *aPoly;

   int *coeffTab;

   PrefTab   = new int[mmTabSize*bitSymbol];

   MrefTab   = new int[mmTabSize*bitSymbol];

   x1Tab     = new int[bitSymbol];

   x2Tab     = new int[bitSymbol];

   ppTab     = new int[bitSymbol];

   checkTab  = new int[symbolMax-1];

   aTab      = new int[syndromeLength+1];

   powerTab  = new int[bitSymbol];

   GenPoly   = new int[syndromeLength+1];

   convPoly  = new int[syndromeLength+1];

   xPoly     = new int[syndromeLength+1];

   coeffPoly = new int[syndromeLength+1];

   aPoly     = new int[syndromeLength+1];

   coeffTab  = new int[symbolMax];

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

   // MrefTab Construction

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

   RsMrefTab(MrefTab, bitSymbol);

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

   // PrefTab Construction

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

   RsPrefTab(PrefTab, PrimPoly, bitSymbol);

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

   // initialize x1Tab

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

   x1Tab[0] = 1;

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

      x1Tab[ii] = 0;

   }

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

   // initialize x2Tab

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

   x2Tab[0] = 0;

   x2Tab[1] = 1;

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

      x2Tab[ii] = 0;

   }

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

   // initialize powerTab

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

   powerTab[0] = 1;

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

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

   }

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

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

   for(ii=0; ii<symbolMax-1; ii++){

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

      // ppTab = x1Tab * x2Tab

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

      RsGfMultiplier(ppTab, x1Tab, x2Tab, PrimPoly, bitSymbol);

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

      // Binary To Decimal DecNumber [dec] = ppTab [bin]

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

      DecNumber = 0;

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

         DecNumber = DecNumber + ppTab[jj] * powerTab[jj];

      }

      checkTab[ii] = DecNumber;

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

      // Reassign x1Tab

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

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

         x1Tab[jj] = ppTab [jj];

      }

   }

   aTab[0] = 1;

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

   // initialize x1Tab

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

   x1Tab[0] = 1;

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

      x1Tab[ii] = 0;

   }

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

   // initialize x2Tab

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

   x2Tab[0] = 0;

   x2Tab[1] = 1;

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

      x2Tab[ii] = 0;

   }

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

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

      // ppTab = x1Tab * x2Tab

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

      RsGfMultiplier(ppTab, x1Tab, x2Tab, PrimPoly, bitSymbol);

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

      // Binary To Decimal DecNumber [dec] = ppTab [bin]

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

      DecNumber = 0;

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

          DecNumber = DecNumber + ppTab[jj] * powerTab[jj];

      }

      aTab[ii] = DecNumber;

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

      // Reassign x1Tab

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

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

         x1Tab[jj] = ppTab [jj];

      }

   }

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

   // initialize GenPoly, aPoly, convPoly, xPoly, coeffPoly

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

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

      GenPoly   [ii] = 0;

      aPoly     [ii] = 0;

      convPoly  [ii] = 0;

      xPoly     [ii] = 0;

      coeffPoly [ii] = 0;

   }

   GenPoly [0] = 1;

   GenPoly [1] = 1;

   aPoly   [1] = 1;

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

      aPoly   [0] = aTab[ii+1];

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

      // assign xPoly

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

      for (jj=1; jj< (syndromeLength+1); jj++){

         xPoly [jj] = GenPoly[jj-1];

      }

      for (jj=0; jj< (syndromeLength+1); jj++){

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

         // Decimal To Binary x1Tab [bin] = GenPoly[jj][dec]

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

         tempix = GenPoly[jj];

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

            if (tempix >= powerTab[zz]) {

               tempix = tempix - powerTab[zz];

               x1Tab [zz] = 1;

            }else{

               x1Tab [zz] = 0;

            }

         }

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

         // Decimal To Binary x2Tab [bin] = aPoly[0][dec]

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

         tempix = aPoly   [0];

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

            if (tempix >= powerTab[zz]) {

               tempix = tempix -powerTab[zz];

               x2Tab [zz] = 1;

            }else{

               x2Tab [zz] = 0;

            }

         }

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

         // ppTab = x1Tab * x2Tab

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

           RsGfMultiplier(ppTab, x1Tab, x2Tab, PrimPoly, bitSymbol);

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

         // Binary To Decimal coeffPoly[jj] [dec] = ppTab[zz] [bin]

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

         coeffPoly[jj] = 0;

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

            coeffPoly[jj] = coeffPoly[jj] + ppTab[zz] *powerTab[zz];

         }

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

         // compute GenPoly (convolution function)

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

         GenPoly [jj] = coeffPoly[jj] ^ xPoly[jj];

      }

   }

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

  // coeffTab calculation

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

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

      index = 0;

      for (jj= 0; jj<symbolMax-2; jj++){

         if (checkTab[jj] == GenPoly [ii]) {

            index = jj+1;

         }

      }

      coeffTab[ii] = index;

   }

  if (ipCustomerKey == cppCoreInternalKey) {

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

     // remove Files if they already exists

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

     if (pathFlag == 0) { // no path folder specified

        DeleteFile ("./sim/simReedSolomon.v");

        DeleteFile ("./sim/RsEncIn.hex");

        DeleteFile ("./sim/RsEncOut.hex");

        DeleteFile ("./sim/RsDecIn.hex");

        DeleteFile ("./sim/RsDecOut.hex");

        DeleteFile ("./rtl/RsEncodeTop.v");

        DeleteFile ("./rtl/RsDecodeTop.v");

        DeleteFile ("./rtl/RsDecodeSyndrome.v");

        DeleteFile ("./rtl/RsDecodeShiftOmega.v");

        DeleteFile ("./rtl/RsDecodePolymul.v");

        DeleteFile ("./rtl/RsDecodeMult.v");

        DeleteFile ("./rtl/RsDecodeInv.v");

        DeleteFile ("./rtl/RsDecodeEuclide.v");

        DeleteFile ("./rtl/RsDecodeErasure.v");

        DeleteFile ("./rtl/RsDecodeDpRam.v");

        DeleteFile ("./rtl/RsDecodeDelay.v");

        DeleteFile ("./rtl/RsDecodeDegree.v");

        DeleteFile ("./rtl/RsDecodeChien.v");

     }else{ // a path folder has been specified

        DeleteFile (strsimReedSolomon);

        DeleteFile (strRsEncIn);

        DeleteFile (strRsEncOut);

        DeleteFile (strRsDecIn);

        DeleteFile (strRsDecOut);

        DeleteFile (strRsEncodeTop);

        DeleteFile (strRsDecodeTop);

        DeleteFile (strRsDecodeSyndrome);

        DeleteFile (strRsDecodeShiftOmega);

        DeleteFile (strRsDecodePolymul);

        DeleteFile (strRsDecodeMult);

        DeleteFile (strRsDecodeInv);

        DeleteFile (strRsDecodeEuclide);

        DeleteFile (strRsDecodeErasure);

        DeleteFile (strRsDecodeDpRam);

        DeleteFile (strRsDecodeDelay);

        DeleteFile (strRsDecodeDegree);

        DeleteFile (strRsDecodeChien);

     }

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

     // create source and sim folders if they do not already exists

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

     if (pathFlag == 0) { // no path folder specified

        CreateDirectory ("rtl", NULL);

        CreateDirectory ("sim", NULL);

     }else{ // a path folder has been specified

        CreateDirectory (strrtl, NULL);

        CreateDirectory (strsim, NULL);

     }

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

     // RS DECODE

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

     if ((encDecMode == 2) || (encDecMode == 3)){

        RsDecode(DataSize, TotalSize, PrimPoly, bitSymbol, errorStats, passFailFlag, delayDataIn, ErasureOption, BlockAmount, ErrorRate, PowerErrorRate, ErasureRate, PowerErasureRate, MrefTab, PrefTab, coeffTab, encDecMode, encBlockAmount, pathFlag, lengthPath, rootFolderPath);

     }

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

     // RS ENCODE

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