/* Example use of Reed-Solomon library 
 *
 * Copyright Henry Minsky (hqm@alum.mit.edu) 1991-2009
 *
 * This software library is licensed under terms of the GNU GENERAL
 * PUBLIC LICENSE
 *
 * RSCODE is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * RSCODE is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Rscode.  If not, see <http://www.gnu.org/licenses/>.

 * Commercial licensing is available under a separate license, please
 * contact author for details.
 *
 * This same code demonstrates the use of the encodier and 
 * decoder/error-correction routines. 
 *
 * We are assuming we have at least four bytes of parity (NPAR >= 4).
 * 
 * This gives us the ability to correct up to two errors, or 
 * four erasures. 
 *
 * In general, with E errors, and K erasures, you will need
 * 2E + K bytes of parity to be able to correct the codeword
 * back to recover the original message data.
 *
 * You could say that each error 'consumes' two bytes of the parity,
 * whereas each erasure 'consumes' one byte.
 *
 * Thus, as demonstrated below, we can inject one error (location unknown)
 * and two erasures (with their locations specified) and the 
 * error-correction routine will be able to correct the codeword
 * back to the original message.
 * */
 
 
#include <stdio.h>
#include <stdlib.h>
//#include "ecc.h"
#include "rsol_code.h"
 
#define ML (K_LENGTH + NPAR)

unsigned char msg0[K_LENGTH] = {0xD4, 0xBA, 0xA1, 0x12, 0xF2, 0x74, 0x96,\
				0x30, 0x27, 0xD4, 0x88, 0x9C, 0x96, 0xE3,\
				0xA9, 0x52, 0xB3, 0x15, 0xAB, 0xFD, 0x92,\
				0x53, 0x07, 0x32, 0xC0, 0x62, 0x48, 0xF0,\
				0x19, 0x22, 0xE0, 0x91, 0x62, 0x1A, 0xC1};
unsigned char msg1[N_LENGTH];			
unsigned char codeword[N_LENGTH], decodedword[N_LENGTH];
 
/* Some debugging routines to introduce errors or erasures
   into a codeword. 
   */

/* Introduce a byte error at LOC */
void
byte_err (int err, int loc, unsigned char *dst)
{
  printf("Adding Error at loc %d, data %#x\n", loc, dst[loc-1]);
  dst[loc-1] ^= err;
}

/* Pass in location of error (first byte position is
   labeled starting at 1, not 0), and the codeword.
*/
void
byte_erasure (int loc, unsigned char dst[], int cwsize, int erasures[]) 
{
  printf("Erasure at loc %d, data %#x\n", loc, dst[loc-1]);
  dst[loc-1] = 0;
}


void fill_prefix(unsigned char msgori[], int data_size, unsigned char msgdst[])
{
	
   int i;
   unsigned char msg1[N_LENGTH];
   
   /*FILL PREFIX WITH 0x00*/
   for(i=0; i<(K_LENGTH-data_size); i++)msg1[i]=0x00;
   for(i=0; i<data_size; i++)msg1[i+(K_LENGTH-data_size)]=msgori[i];
   for(i=0; i<K_LENGTH; i++)msgdst[i]=msg1[i];   	
}

/*Remove prefix and last 12 parity bytes*/ 
void remove_prefix(unsigned char msgrm[], int dat_size, int parityBYTES)
{
	
   int i;
   //unsigned char msg1[N_LENGTH];
   
   /*First de parity bytes*/
   /*Only four parity bytes from sixteen*/
   for(i=0; i<parityBYTES; i++)msgrm[i]=msgrm[K_LENGTH+i];
   for(i=parityBYTES; i<dat_size+parityBYTES; i++)msgrm[i]=msgrm[K_LENGTH-dat_size-parityBYTES+i];
   
   //for(i=0; i<dat_size+parityBYTES; i++)printf("%x ", msgrm[i]);
    	
}


/////////////////////////////////////////////////////////////////
void rs802_11e_encoder(unsigned char msgrs[],\
				int datasize,\
				unsigned char codewrs[],\
				int PARITYbytes)
{
  int i;
  unsigned char msg1[N_LENGTH];
  
  /* Initialization the ECC library */
   initialize_ecc ();
 
/*   printf("DADES: datasize=%d\n", datasize);
   for(i=0; i<datasize; i++)printf("%x ", msgrs[i]);	
   printf("\n");
*/
   fill_prefix(msgrs, datasize, msg1);  
   
/* printf("IN___: ");
   for(i=0; i<K_LENGTH; i++)printf("%x ", msg1[i]);	
   printf("\n");
*/
  // Encode data into codeword, adding NPAR parity bytes 
   encode_data(msg1, K_LENGTH, codewrs);  

/*   printf("CODED: ");
   for(i=0; i<N_LENGTH; i++)printf("%x ", codewrs[i]);	
   printf("\n");
*/
   remove_prefix(codewrs, datasize, PARITYbytes);

/*   printf("CWORD: ");
   for(i=0; i<datasize+PARITYbytes; i++)printf("%x ", codewrs[i]);	
   printf("\n");
*/
}

/*Function build received codeword to reed solomon format*/
void build_reccodeword(unsigned char msgh[], int dat_size, int parityBYTES)
{
   int i;
   
      for(i=parityBYTES; i<parityBYTES+dat_size; i++)msgh[K_LENGTH-dat_size-parityBYTES+i]=msgh[i];
      for(i=0; i<parityBYTES; i++)msgh[K_LENGTH+i]=msgh[i];
      for(i=0; i<K_LENGTH-dat_size; i++)msgh[i]=0;
      for(i=K_LENGTH+parityBYTES; i<N_LENGTH; i++)msgh[i]=0;

   printf("BUILD: ");
   for(i=0; i<N_LENGTH; i++)printf("%x ", msgh[i]);	
   printf("\n");      
      
}


/*Function format output decoder*/
void formatDecodOutput(unsigned char msgdo[], int dat_size, int parityBYTES)
{
   int i;

	/*ONLY OUTPUT DECODED DATA */
	printf("POINTER: dat_size%d \n",  dat_size );
	for(i=0; i<dat_size; i++)msgdo[i]=msgdo[K_LENGTH-dat_size+i];
}



void rs802_11e_decoder(unsigned char codewdrs[],\
					int datasize,\
					int PARITYbytes)
{
  int i;
  int erasures[16];
  int nerasures = 0;

  /* Initialization the ECC library */
   initialize_ecc ();

     build_reccodeword(codewdrs, datasize, PARITYbytes);
     
  /*We need to indicate the position of the erasures.  Eraseure
    positions are indexed (1 based) from the end of the message... */
    
    for(i=0; i<(N_LENGTH-K_LENGTH-PARITYbytes); i++){
    	erasures[nerasures++] = ML-(K_LENGTH+PARITYbytes+1+i);
	//printf("K_LENGTH+PARITYbytes+1+i=%d \n", K_LENGTH+PARITYbytes+1+i);
    }
/*
     erasures[nerasures++] = ML-244;
     erasures[nerasures++] = ML-245;
     erasures[nerasures++] = ML-246;
     erasures[nerasures++] = ML-247;
     erasures[nerasures++] = ML-248;
     erasures[nerasures++] = ML-249;
     erasures[nerasures++] = ML-250;
     erasures[nerasures++] = ML-251;  
     erasures[nerasures++] = ML-252;
     erasures[nerasures++] = ML-253;    
     erasures[nerasures++] = ML-254;
     erasures[nerasures++] = ML-255;   
*/
  /* Now decode -- encoded codeword size must be passed */
     decode_data(codewdrs, ML);

  /* check if syndrome is all zeros */
     if (check_syndrome () != 0) {
         correct_errors_erasures (codewdrs, 
			     ML,
			     nerasures, 
			     erasures);
 
     //printf("Corrected codeword: \"%s\"\n", codeword);
     }
   printf("DECOD: ");
   for(i=0; i<N_LENGTH; i++)printf("%x ", codewdrs[i]);	
   printf("\n");    
   
   formatDecodOutput(codewdrs, datasize, PARITYbytes);
    

}