//////////////////////////////////////////////////////////////////////////////////////////
//                                                                                      //
//  FILE:        puncturing_imp.c                                                     	//
//                                                                                      //
//  DESCRIPTION: WIMAX puncturing					     		//
//							                                //
//  Input:	 control_flow_in; data_flow_in                                          //
//                                                                                      //
//  Output:      data_flow_out                                                          //
//                                                                                      //
//June 2009                                                                             //
//////////////////////////////////////////////////////////////////////////////////////////


/** ALOE headers
 */
#include <phal_sw_api.h>
#include <math.h>
#include <swapi_utils.h>

#include "itf_types.h"
#include "inputs.h"
#include "outputs.h"
#include "stats.h"

#include "typetools.h"
#include "puncturing_code.h"


#define BSIZE 8192

/*GLOBAL VARIABLES*/
int data_rcved;		//Data received-->data_rcved=1
			//Data non received-->data_rcved=0
float punct_rateg;
int pseqlength;
int punctseq[MAXPSEQ];
			
#define NUMCHARSBYTE	8

/*PREDEFINED FUNCTIONS*/
void Init_Controlfunction();
int datainflow_bypass(int len);
void Init_puncturing();

//////////////////////////////////////////////////////////////////////////////////////////
//SQUELETON CALLED FUNCTIONS//////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
//CONTROL ////////////////////////////////////////////////////////////////////////CONTROL/
//////////////////////////////////////////////////////////////////////////////////////////
//INPUT///////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////

/*Returns the length(in control in type words) of the expected control flow at each 	*/
/*time-slot										*/
/*Funtion activated if control flow has been received					*/					
/*Check INPUT_MAX_CONTROL								*/
int get_controlin_length(){
int length=1;

	length=control_length();
    	return(length);
}

/*Process the received control flow according to the length returned by 		*/
/*get_controlin_length()								*/
/*"len" indicates the number of control words to be processed				*/
int process_inputcontrol(int len){
	process_control_input(len);

return(1);	/*return 1 if OK; return 0 if error*/
}

//////////////////////////////////////////////////////////////////////////////////////////
//OUTPUT//////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////

/*Returns the length (in control out type words) of the generated control flow at each	*/
/*time-slot										*/
/*Check OUTPUT_MAX_CONTROL								*/
int get_controlout_length(){
int length=1;

    return(length);
}

/*Generate the control word to be send according the length provided by 		*/
/*get_controlout_length()								*/
/*"len" indicates the number of control words to be generated				*/
int generate_outputcontrol(int len){
/*return 1 if OK; return 0 if error*/
return(1);
}



//////////////////////////////////////////////////////////////////////////////////////////
//DATA/////////////////////////////////////////////////////////////////////////////DATA///
//////////////////////////////////////////////////////////////////////////////////////////
//INPUT///////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////

/*Returns the length(in data in type words) of the expected data flow at each time-slot	*/
//Funtion activated only if data flow has been received					*/
/*Check INPUT_MAX_DATA									*/
int get_datain_length()
{
int length=1;

	length=datain_length();
    	return(length);
}
/*Process the received data flow according to the length returned by get_datain_length()*/
/** Run function. return 1 if ok, 0 if error						*/
/*"len" indicates the number of data words to be processed				*/
int process_inputdata(int len)
{
	//printf("puncturing: process_inputdata\n");
	data_rcved=1;	//The execution of this function implies that enough data has 
			//been received
	
	//Testing flows purposes
	if(control_puncturing[0].CExec.status==TEST_FLOW)datainflow_bypass(len);
	//Testing module processing functionality
	if(control_puncturing[0].CExec.status==TEST_PROCESS)test_puncturing();
	//Normal puncturing encoder execution
	if(control_puncturing[0].CExec.status==ACTIVE)process_datainflow(len);
	return 1;	
}


//////////////////////////////////////////////////////////////////////////////////////////
//OUTPUT//////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////

/*Returns the length (in data out type words) of the generated data flow at each	*/
/*time-slot										*/
int get_dataout_length()
{
int length;

	length=0;
	if(data_rcved==0)return(length);
	data_rcved=0;
	//Testing flows purposes
	if(control_puncturing[0].CExec.status==TEST_FLOW)
		length=control_puncturing[0].CData.ninputdata;	//Data send=Data received
	//Testing module processing functionality
	if(control_puncturing[0].CExec.status==TEST_PROCESS)
		length=0;					//No data send
	//Normal execution
	if(control_puncturing[0].CExec.status==ACTIVE)	
		length=dataout_length();
    	return(length);
}


/*Generate the control word to be send according the length provided by 		*/
/*get_controlout_length()								*/
/** Run function. return 1 if ok, 0 if error						*/
/*"len" indicates the number of data words to be generated				*/
int generate_outputdata(int len)
{
	return 1;
}



int InitCustom()
{
    data_rcved=0;
    Init_Controlfunction();
    void Init_puncturing();
    return 1;
}

int RunCustom()
{
    return 1;
}

//////////////////////////////////////////////////////////////////////////////////////////
//END SQUELETON CALLED FUNCTIONS//////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
//######################################################################################//
//////////////////////////////////////////////////////////////////////////////////////////
//ESPECIFIC MODULE FUNCTIONS//////////////////////////////////////////////////////////////
//CONTROL////////////////////////////////////////////////////////////////////////CONTROL//
//////////////////////////////////////////////////////////////////////////////////////////
void Init_Controlfunction()
{
	control_puncturing[0].CExec.status=NONACTIVE;
	control_puncturing[0].CData.ninputdata=0;
	control_puncturing[0].CData.noutputdata=0;
}

void Init_puncturing(){

   /* Variables Inicialization */

}

int control_length()
{
	return(INPUT_MAX_CONTROL);
}


int process_control_input(int len)
{
    int i;

	if(len==1){
		//CAPTURE CONFIG
			punct_rateg=control_puncturing[0].CData.punct_rate;
		//PRINT CONFIG VALUES
   		printf("O---->PUNCTURING (config):........................................TSLOT%d\n",\
			control_puncturing[0].CExec.timeslot);
		printf("O       STATUS: %d \n",\
                                control_puncturing[0].CExec.status);                     
		printf("O       NumInputdata=%d, NumOutputdata=%d\n",\
				control_puncturing[0].CData.ninputdata,\
				control_puncturing[0].CData.noutputdata);
                pseqlength=control_puncturing[0].CData.pseqlength;
		printf("O       puncturing rate=%4.2f pseqlength=%d\n",\
                                punct_rateg, pseqlength);
                printf("O       Puncturing Sequence=");
                for(i=0; i<pseqlength; i++){
                    punctseq[i]=control_puncturing[0].CData.puncseq[i];
                    printf("%d ",punctseq[i]);
                }
                printf("\n");
	}
}

//////////////////////////////////////////////////////////////////////////////////////////
//DATA//////////////////////////////////////////////////////////////////////////////DATA//
//////////////////////////////////////////////////////////////////////////////////////////
#define OK  1
#define NEVER -1
/*Perfom a bypass input output without any data modification*/
int datainflow_bypass(int len)
{
int i;
static int s=0, one=0;

        one++;
        if(one==NEVER)s=OK;
        else s=0;
        if(s==OK)printf("Puncturing BYPASS: datalength=%d\n", len);
	for(i=1; i<=len; i++){
		output_data[i-1]=input_data[i-1];
                if(s==OK)printf("% d  ", (unsigned char)output_data[i-1]);
                if(s==OK)if(i%16==0)printf("\n");
		}
        if(s==OK)printf("\n");
	return(1);

}



#define DATA_FLOW_LENGTH	0

/*data_length(): Define the data flow length in each time-slot*/
int datain_length()
{
int length=0;

	if(control_puncturing[0].CExec.status==NONACTIVE)length=0;
	if(control_puncturing[0].CExec.status==ACTIVE)length=\
				control_puncturing[0].CData.ninputdata;
	if(control_puncturing[0].CExec.status==TEST_FLOW)length=\
				control_puncturing[0].CData.ninputdata;
	if(control_puncturing[0].CExec.status==TEST_PROCESS)length=\
				control_puncturing[0].CData.ninputdata;

	return(length);
}



int process_datainflow(int length)
{
int i, numofbits,j, NPARITYBYTES, DATASIZE;
unsigned char info_A[BSIZE];
int info_B[BSIZE];
int info_C[BSIZE];
int inlength_bits;

int msg2[35] = {0, 1, 2, 3, 4, 5, 6,\
			7, 8, 9, 10, 11, 12, 13,\
			14, 15, 16, 17, 18, 19, 20,\
			21, 22, 23, 24, 25, 26, 27,\
			28, 29, 30, 31, 32, 33, 34};

//static int punct_rate;


	if(length==0)return(-1);
	//printf("PUNCTURING: proces_data[]: input length=%d\n", length);
	//printf("PUNCTURING: proces_data[]: punct_rateg=%f\n", punct_rateg);
	//printf("puncturing: proces_data: output length=%d\n", control_puncturing[0].CData.noutputdata);
	//punct_rate=control_puncturing[0].CData.punct_rate;
	if (length>0){
	
		//READ INPUT BUFFER	
//		printf("puncturing input\n");
		for(i=1; i<=length; i++){
			info_A[i-1]=input_data[i-1];
//			printf("  %d", (int)input_data[i-1]);
//			if(i%16 == 0)printf("\n");
		}
//		printf("\n");

//		for(i=0; i<length; i++)info_A[i]=0xFF;

		
		//------FROM CHAR TO BITS
		inlength_bits=MSBfirstchar2bin (info_A, info_B, length);
 /*               for(i=0; i<inlength_bits; i++)info_B[i]=1;
                info_B[7]=0;
                info_B[511]=0;
                info_B[503]=0;
                info_B[502]=0;
                info_B[501]=0;
                info_B[500]=0;
                info_B[499]=0;
 */
		//printf("PUNCTURING: proces_data(): inlength1=%d\n", inlength_bits);

                //printf("PUNCTURING: puncturing input inlength_bits=%d\n", inlength_bits);
		
		
		
		
		
/*		printf("PUNCTURING INPUT: puncturing inlength_bits=%d: \n", inlength_bits);
                for(i=1; i<=inlength_bits; i++){
                    printf("%d ", info_B[i-1]);
                    if(i%32 == 0)printf("\n");
                }
                printf("\n");
*/		
		

		//------PUNCTURING
		//printf("PUNCTURING: proces_data[]: punct_rateg2=%f\n", punct_rateg);
                inlength_bits=puncturing(punctseq, pseqlength, inlength_bits, info_B, info_C);

                //printf("PUNCTURING: puncturing output inlength_bits=%d\n", inlength_bits);


		//BITs TO CHARs
		length=MSBfirstbin2char (info_C, output_data, inlength_bits);

 /*               printf("PUNCTURING OUTPUT BYTES: length=%d\n", length);
                for(i=1; i<=length; i++){
                    printf("%d ", output_data[i-1]);
                    if(i%8 == 0)printf("\n");
                }
                printf("\n");
*/

                if(length != control_puncturing[0].CData.noutputdata){
                    printf("ERROR: puncturing_imp: process_datainflow()\n");
                    printf("length= %d!=  noutputdata=%d\n",\
                            length, control_puncturing[0].CData.noutputdata);

                }

		
/*		printf("puncturing output\n");
		for(i=0; i<length; i++){
			printf("  %d", output_data[i]);
			if(i%32 == 0)printf("\n");
		}
		printf("\n");
*/		
	//printf("PUNCTURING: proces_data(): output length=%d\n", length);
	}
}

int dataout_length()
{
int length;

	length=control_puncturing[0].CData.noutputdata;
	//printf("PUNCTURING: dataout_length(): length=%d\n", length);
	return(length);
}

int generate_dataflow(int len)
{
int i;

	return(1);
}


#define TESTLENGTH   	35
#define BSIZE2		500

int test_puncturing(int length){
int i;
int m;
int msg_length, outlength;
                 
int encoded2[500]; 
int sdvdout[BSIZE2];
float splusn[BSIZE2], splusn1[BSIZE2];                   /* noisy data array */


			
int msg2[TESTLENGTH] = {0, 1, 2, 3, 4, 5, 6,\
			7, 8, 9, 10, 11, 12, 13,\
			14, 15, 16, 17, 18, 19, 20,\
			21, 22, 23, 24, 25, 26, 27,\
			28, 29, 30, 31, 32, 33, 34};

int rate1R1[2]={1,1};			//Punturing matrix for rate 1/2
int rate4R3[4]={1,1,0,1};		//Puncturing matrix for rate 2/3
int rate3R2[6]={1,1,0,1,1,0};		//Puncturing matrix for rate 3/4
int rate5R3[10]={1,1,0,1,1,0,0,1,1,0};	//Puncturing matrix for rate 5/6

static float punc_rate;

//CHECK PUNCTURING-DEPUNCTURING	
	
	    msg_length = TESTLENGTH;
            outlength = TESTLENGTH;
	    punc_rate=control_puncturing[0].CData.punct_rate;
            punc_rate=RATE5R3;
            punc_rate=punct_rateg;
	    
	    printf("PUNCTURING INPUT: puncturing TEST PROCESS: \n");
   	    for(i=0; i<msg_length; i++)printf("%d ", msg2[i]);	
   	    printf("\n");
	    
            //msg_length=puncturing(rate5R3, 10, msg_length, msg2, encoded2);
            msg_length=puncturing(punctseq, pseqlength, msg_length, msg2, encoded2);

            printf("PUNCTURING OUTPUT: puncturing TEST PROCESS: \n");
   	    for(i=0; i<msg_length; i++)printf("%d ", encoded2[i]);
   	    printf("\n");
 
	    for(i=0; i<msg_length; i++)*(splusn+i)=(float)*(encoded2+i);

 	    //msg_length=depuncturing(rate5R3, 10, msg_length, outlength,\
            //                                        splusn, splusn1);
            msg_length=depuncturing(punctseq,  pseqlength, msg_length, outlength,\
                                                    splusn, splusn1);
 
	    printf("DEPUNCTURING OUTPUT: puncturing TEST PROCESS\n");
   	    for(i=0; i<msg_length; i++)printf("%d ", (int)*(splusn1+i));	
   	    printf("\n");


}



//////////////////////////////////////////////////////////////////////////////////////////
//END OF ESPECIFIC MODULE FUNCTIONS///////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////


void ConfigInterfaces() {}