Subversion Repositories reed_solomon_codec_generator

//===================================================================
// Module Name : RsDecodeInv
// File Name   : RsDecodeInv.cpp
// Function    : RTL Decoder Inverter Module generation
// 
// 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>
#include<windows.h>
#include<fstream>
#include <string.h>
using namespace std;
 
FILE  *OutFileDecodeInv;
void RsGfMultiplier( int*, int*,int*, int, int);
 
void RsDecodeInv(int PrimPoly, int bitSymbol, int pathFlag, int lengthPath, char *rootFolderPath) {
 
 
   //---------------------------------------------------------------
   // C++ variables
   //---------------------------------------------------------------
   int ii,zz;
   int tempix;
   int magicInv;
   int MaxValue;
   int *x1Tab;
   int *powerTab;
   int *y2Tab;
   int *y3Tab;
   int *y6Tab;
   int *y12Tab;
   int *y15Tab;
   int *y30Tab;
   int *y60Tab;
   int *y120Tab;
   int *y240Tab;
   int *y14Tab;
   int *y254Tab;
   int *y508Tab;
   int *y510Tab;
   int *y1020Tab;
   int *y1022Tab;
   int *y62Tab;
   int *y126Tab;
   int *y2044Tab;
   int *y2046Tab;
   int *y4092Tab;
   int *y4094Tab;
   int *yFinalTab;
   char *strRsDecodeInv;
 
   x1Tab    = new int[bitSymbol];
   powerTab = new int[bitSymbol];
   y2Tab    = new int[bitSymbol];
   y3Tab    = new int[bitSymbol];
   y6Tab    = new int[bitSymbol];
   y12Tab   = new int[bitSymbol];
   y15Tab   = new int[bitSymbol];
   y30Tab   = new int[bitSymbol];
   y60Tab   = new int[bitSymbol];
   y120Tab  = new int[bitSymbol];
   y240Tab  = new int[bitSymbol];
   y14Tab   = new int[bitSymbol];
   y254Tab  = new int[bitSymbol];
   y508Tab  = new int[bitSymbol];
   y510Tab  = new int[bitSymbol];
   y1020Tab = new int[bitSymbol];
   y1022Tab = new int[bitSymbol];
   y62Tab   = new int[bitSymbol];
   y126Tab  = new int[bitSymbol];
   y2044Tab = new int[bitSymbol];
   y2046Tab = new int[bitSymbol];
   y4092Tab = new int[bitSymbol];
   y4094Tab = new int[bitSymbol];
   yFinalTab= new int[bitSymbol];
 
 
   //---------------------------------------------------------------
   // open file
   //---------------------------------------------------------------
   strRsDecodeInv = (char *)calloc(lengthPath + 19,  sizeof(char));
   if (pathFlag == 0) { 
        strRsDecodeInv[0] = '.';
   }else{
      for(ii=0; ii<lengthPath; ii++){
         strRsDecodeInv[ii] = rootFolderPath[ii];
      }
   }
   strcat(strRsDecodeInv, "/rtl/RsDecodeInv.v");
 
   OutFileDecodeInv = fopen(strRsDecodeInv,"w");
 
 
 
   //---------------------------------------------------------------
   // write File Header
   //---------------------------------------------------------------
   fprintf(OutFileDecodeInv, "//===================================================================\n");
   fprintf(OutFileDecodeInv, "// Module Name : RsDecodeInv\n");
   fprintf(OutFileDecodeInv, "// File Name   : RsDecodeInv.v\n");
   fprintf(OutFileDecodeInv, "// Function    : Rs Decoder Inverse calculation Module\n");
   fprintf(OutFileDecodeInv, "// \n");
   fprintf(OutFileDecodeInv, "// Revision History:\n");
   fprintf(OutFileDecodeInv, "// Date          By           Version    Change Description\n");
   fprintf(OutFileDecodeInv, "//===================================================================\n");
   fprintf(OutFileDecodeInv, "// 2009/02/03  Gael Sapience     1.0       Original\n");
   fprintf(OutFileDecodeInv, "//\n");
   fprintf(OutFileDecodeInv, "//===================================================================\n");
   fprintf(OutFileDecodeInv, "// (C) COPYRIGHT 2009 SYSTEM LSI CO., Ltd.\n");
   fprintf(OutFileDecodeInv, "//\n\n\n");
 
   //---------------------------------------------------------------
   // Ports Declaration
   //---------------------------------------------------------------
   fprintf(OutFileDecodeInv, "module RsDecodeInv(\n");
   fprintf(OutFileDecodeInv, "   B,   // data in\n");
   fprintf(OutFileDecodeInv, "   R    // data out\n");
   fprintf(OutFileDecodeInv, " );\n\n\n");
   fprintf(OutFileDecodeInv, "   input  [%d:0]   B; // data in\n", bitSymbol-1);
   fprintf(OutFileDecodeInv, "   output [%d:0]   R; // data out\n\n\n", bitSymbol-1);
 
 
   //---------------------------------------------------------------
   // R register
   //---------------------------------------------------------------
   fprintf(OutFileDecodeInv, "   reg [%d:0]   R;\n\n\n", bitSymbol-1);
   fprintf(OutFileDecodeInv, "   always @(B) begin\n");
   fprintf(OutFileDecodeInv, "      case (B)\n");
   fprintf(OutFileDecodeInv, "         %d'd0: begin\n", bitSymbol);
   fprintf(OutFileDecodeInv, "            R = %d'd0;\n", bitSymbol);
   fprintf(OutFileDecodeInv, "         end\n");
 
 
   //---------------------------------------------------------------
   // MaxValue calculation (2^bitSymbol)
   //---------------------------------------------------------------
   MaxValue = 2;
   for(ii=0; ii<(bitSymbol-1); ii++){
      MaxValue = MaxValue*2;
   }
 
 
   //---------------------------------------------------------------
   // initialize powerTab
   //---------------------------------------------------------------
   powerTab[0] = 1;
   for (ii=1; ii<bitSymbol;ii++){
      powerTab[ii] = 2*powerTab[ii-1];
   }
 
 
   for (ii = 1;ii<MaxValue;ii++){
      //---------------------------------------------------------------
      // Decimal To binary x1Tab[bin] = ii[dec]
      //---------------------------------------------------------------
      tempix = ii;
      for (zz =(bitSymbol-1); zz>=0;zz--) {
         if (tempix >= powerTab[zz]) {
            tempix = tempix - powerTab[zz];
            x1Tab [zz] = 1;
         }else{
            x1Tab [zz] = 0;
         }
      }
 
 
      //---------------------------------------------------------------
      // Galois multiplier: Y^2 = x1*x1
      //---------------------------------------------------------------
      RsGfMultiplier(y2Tab, x1Tab, x1Tab, PrimPoly, bitSymbol);
 
 
      //---------------------------------------------------------------
      // Galois multiplier: Y^3 = Y^2 *x1
      //---------------------------------------------------------------
      RsGfMultiplier(y3Tab, y2Tab, x1Tab, PrimPoly, bitSymbol);
 
 
      //---------------------------------------------------------------
      // Galois multiplier: Y^6 = Y^3 *Y^3
      //---------------------------------------------------------------
      RsGfMultiplier(y6Tab, y3Tab, y3Tab, PrimPoly, bitSymbol);
 
 
      //---------------------------------------------------------------
      // Galois multiplier: Y^12 = Y^6 *Y^6
      //---------------------------------------------------------------
      RsGfMultiplier(y12Tab, y6Tab, y6Tab, PrimPoly, bitSymbol);
 
 
      //---------------------------------------------------------------
      // Galois multiplier: Y^15 = Y^12 *Y^3
      //---------------------------------------------------------------
      RsGfMultiplier(y15Tab, y12Tab, y3Tab, PrimPoly, bitSymbol);
 
 
      //---------------------------------------------------------------
      // Galois multiplier: Y^30 = Y^15 *Y^15
      //---------------------------------------------------------------
      RsGfMultiplier(y30Tab, y15Tab, y15Tab, PrimPoly, bitSymbol);
 
 
      //---------------------------------------------------------------
      // Galois multiplier: Y^60 = Y^30 *Y^30
      //---------------------------------------------------------------
      RsGfMultiplier(y60Tab, y30Tab, y30Tab, PrimPoly, bitSymbol);
 
 
      //---------------------------------------------------------------
      // Galois multiplier: Y^62 = Y^60 *Y^2
      //---------------------------------------------------------------
      RsGfMultiplier(y62Tab, y60Tab, y2Tab, PrimPoly, bitSymbol);
 
 
      //---------------------------------------------------------------
      // Galois multiplier: Y^120 = Y^60 *Y^60
      //---------------------------------------------------------------
      RsGfMultiplier(y120Tab, y60Tab, y60Tab, PrimPoly, bitSymbol);
 
 
      //---------------------------------------------------------------
      // Galois multiplier: Y^126 = Y^120 *Y^6
      //---------------------------------------------------------------
      RsGfMultiplier(y126Tab, y120Tab, y6Tab, PrimPoly, bitSymbol);
 
 
      //---------------------------------------------------------------
      // Galois multiplier: Y^240 = Y^120 *Y^120
      //---------------------------------------------------------------
      RsGfMultiplier(y240Tab, y120Tab, y120Tab, PrimPoly, bitSymbol);
 
 
      //---------------------------------------------------------------
      // Galois multiplier: Y^14 = Y^12 *Y^2
      //---------------------------------------------------------------
      RsGfMultiplier(y14Tab, y12Tab, y2Tab, PrimPoly, bitSymbol);
 
 
      //---------------------------------------------------------------
      // Galois multiplier: Y^254 = Y^240 *Y^14
      //---------------------------------------------------------------
      RsGfMultiplier(y254Tab, y240Tab, y14Tab, PrimPoly, bitSymbol);
 
 
      //---------------------------------------------------------------
      // Galois multiplier: Y^508 = Y^254 *Y^254
      //---------------------------------------------------------------
      RsGfMultiplier(y508Tab, y254Tab, y254Tab, PrimPoly, bitSymbol);
 
 
      //---------------------------------------------------------------
      // Galois multiplier: Y^510 = Y^508 *Y^2
      //---------------------------------------------------------------
      RsGfMultiplier(y510Tab, y508Tab, y2Tab, PrimPoly, bitSymbol);
 
 
      //---------------------------------------------------------------
      // Galois multiplier: Y^1020 = Y^510 *Y^510
      //---------------------------------------------------------------
      RsGfMultiplier(y1020Tab, y510Tab, y510Tab, PrimPoly, bitSymbol);
 
 
      //---------------------------------------------------------------
      // Galois multiplier: Y^1022 = Y^1020 *Y^2
      //---------------------------------------------------------------
      RsGfMultiplier(y1022Tab, y1020Tab, y2Tab, PrimPoly, bitSymbol);
 
 
      //---------------------------------------------------------------
      // Galois multiplier: Y^2044 = Y^1022 *Y^1022
      //---------------------------------------------------------------
      RsGfMultiplier(y2044Tab, y1022Tab, y1022Tab, PrimPoly, bitSymbol);
 
 
      //---------------------------------------------------------------
      // Galois multiplier: Y^2044 = Y^2044 *Y^2
      //---------------------------------------------------------------
      RsGfMultiplier(y2046Tab, y2044Tab, y2Tab, PrimPoly, bitSymbol);
 
 
      //---------------------------------------------------------------
      // Galois multiplier: Y^4092 = Y^2046 *Y^2046
      //---------------------------------------------------------------
      RsGfMultiplier(y4092Tab, y2046Tab, y2046Tab, PrimPoly, bitSymbol);
 
 
      //---------------------------------------------------------------
      // Galois multiplier: Y^4094 = Y^4092 *Y^2
      //---------------------------------------------------------------
      RsGfMultiplier(y4094Tab, y4092Tab, y2Tab, PrimPoly, bitSymbol);
 
 
      //---------------------------------------------------------------
      // Result assignment 2^8=y^254, 2^9=y^510, 2^10=y^1022
      //---------------------------------------------------------------
      switch(bitSymbol){
         case (3):
            for (zz=0; zz<bitSymbol;zz++){
               yFinalTab [zz] = y6Tab[zz];
            }
         break;
         case (4):
            for (zz=0; zz<bitSymbol;zz++){
               yFinalTab [zz] = y14Tab[zz];
            }
         break;
         case (5):
            for (zz=0; zz<bitSymbol;zz++){
               yFinalTab [zz] = y30Tab[zz];
            }
         break;
         case (6):
            for (zz=0; zz<bitSymbol;zz++){
               yFinalTab [zz] = y62Tab[zz];
            }
         break;
         case (7):
            for (zz=0; zz<bitSymbol;zz++){
               yFinalTab [zz] = y126Tab[zz];
            }
         break;
         case (8):
            for (zz=0; zz<bitSymbol;zz++){
               yFinalTab [zz] = y254Tab[zz];
            }
         break;
         case (9):
            for (zz=0; zz<bitSymbol;zz++){
               yFinalTab [zz] = y510Tab[zz];
            }
         break;
         case (10):
            for (zz=0; zz<bitSymbol;zz++){
               yFinalTab [zz] = y1022Tab[zz];
            }
         break;
         case (11):
            for (zz=0; zz<bitSymbol;zz++){
               yFinalTab [zz] = y2046Tab[zz];
            }
         break;
         case (12):
            for (zz=0; zz<bitSymbol;zz++){
               yFinalTab [zz] = y4094Tab[zz];
            }
         break;
         default:
            yFinalTab [0] = 0;
         break;
      }
 
 
      //---------------------------------------------------------------
      // Binary To Decimal magicInv[dec] = yFinalTab[bin]
      //---------------------------------------------------------------
      magicInv = 0;
      for (zz=0; zz<bitSymbol;zz++){
         magicInv = magicInv + yFinalTab[zz] * powerTab[zz];
      }
 
//      fprintf(OutFileDecodeInv, "         %d'd%d: begin\n", bitSymbol, ii);
      if (ii == MaxValue -1){
         fprintf(OutFileDecodeInv, "         default: begin\n");
      }else{
         fprintf(OutFileDecodeInv, "         %d'd%d: begin\n", bitSymbol, ii);
      }
 
 
      fprintf(OutFileDecodeInv, "            R = %d'd%d;\n", bitSymbol, magicInv);
      fprintf(OutFileDecodeInv, "         end\n");
   }
   fprintf(OutFileDecodeInv, "      endcase\n");
   fprintf(OutFileDecodeInv, "   end\n");
   fprintf(OutFileDecodeInv, "endmodule\n");
 
 
   //---------------------------------------------------------------
   // close file
   //---------------------------------------------------------------
   fclose(OutFileDecodeInv);
 
 
   //---------------------------------------------------------------
   // Free memory
   //---------------------------------------------------------------
   delete[] x1Tab;
   delete[] powerTab;
   delete[] y2Tab;
   delete[] y3Tab;
   delete[] y6Tab;
   delete[] y12Tab;
   delete[] y15Tab;
   delete[] y30Tab;
   delete[] y60Tab;
   delete[] y120Tab;
   delete[] y240Tab;
   delete[] y14Tab;
   delete[] y254Tab;
   delete[] y508Tab;
   delete[] y510Tab;
   delete[] y1020Tab;
   delete[] y1022Tab;
   delete[] yFinalTab;
   delete[] y62Tab;
   delete[] y126Tab;
   delete[] y2044Tab;
   delete[] y2046Tab;
   delete[] y4092Tab;
   delete[] y4094Tab;
 
 
   //---------------------------------------------------------------
   // automatically convert Dos mode To Unix mode
   //---------------------------------------------------------------
	char ch;
	char temp[MAX_PATH]="\0";
 
	//Open the file for reading in binarymode.
	ifstream fp_read(strRsDecodeInv, ios_base::in | ios_base::binary);
	sprintf(temp, "%s.temp", strRsDecodeInv);
	//Create a temporary file for writing in the binary mode. This
	//file will be created in the same directory as the input file.
	ofstream fp_write(temp, ios_base::out | ios_base::trunc | ios_base::binary);
 
	while(fp_read.eof() != true)
	{
		fp_read.get(ch);
		//Check for CR (carriage return)
		if((int)ch == 0x0D)
			continue;
		if (!fp_read.eof())fp_write.put(ch);
	}
 
	fp_read.close();
	fp_write.close();
	//Delete the existing input file.
	remove(strRsDecodeInv);
	//Rename the temporary file to the input file.
	rename(temp, strRsDecodeInv);
	//Delete the temporary file.
	remove(temp);
 
 
   //---------------------------------------------------------------
   // clean string
   //---------------------------------------------------------------
   free(strRsDecodeInv);
 
 
}