#include <malloc.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
//#include "mex.h"

#define CHIP_LENGTH 38400


void GenWCDMAUplinkSignal(double *CurrentInphaseChips,double *CurrentQuadratureChips,
						  double *PastInphaseChips,double *PastQuadratureChips,
						  double *FutureInphaseChips,double *FutureQuadratureChips,
						  unsigned NumChips,double *PulseShape,unsigned PulseLength,
						  unsigned SamplesPerChip,double *InphaseSignal,
						  double *QuadratureSignal,unsigned NumSamples)
/*************************************************************************************************
/void GenWCDMAUplinkSignal(double *InphaseChips,double *QuadratureChips,unsigned NumChips,
/						   double *PulseShape,unsigned PulseLength,unsigned SamplesPerChip,
/						   double *InphaseSignal,double *QuadratureSignal,unsigned NumSamples)
/
/
/Takes the Inphase and Quadrature Data Stream along with the pulse shape and generates
/the baseband representation of the transmitted signal
/
/Parameters
/   Input
/      InphaseChips        double *   Pointer to array of length NumChips that stores 
/                                     the inphase Chip values
/      QuadratureChips     double *   Pointer to array of length NumChips that stores 
/                                     the quadrature Chip values
/      NumChips            unsigned   Length of Chip arrays
/      PulseShape          double *   Pointer to array of length PulseLength that stores
/                                     the pulse shape
/      PulseLength         unsigned   Length of the PulseShape array
/      SamplesPerChip      unsighed   Number of samples per Chip (oversampling factor)
/
/   Output
/      InPhaseSignal       double *   Pointer to array of length NumSamples that stores 
/                                     the inphase signal values
/      QuadratureSignal    double *   Pointer to array of length NumSamples that stores 
/                                     the quadrature signal values
/      NumSamples          unsigned   Length of signal arrays
/
/*************************************************************************************************/
{
	unsigned k0,k1;
	unsigned TempChipArrayLength;	//number of chips used in the singal computation
									//Equals the length of the frame plus the length of the pulse -1
	unsigned PulseLengthInChips;	//Length of Tx Pulse in terms of chip duration
	unsigned Overlap;				//Number of signal samples required from previous and next frame
	unsigned Start,Finish;			//used to determine the start and finish of certain loops
	double *InphaseChipArray,*InphaseChipsTemp;	//Pointer and temporary pointer that contains the 
												//chips that are needed to compute the inphase signal 
												//associated with the current frame
	double *QuadChipArray,*QuadratureChipsTemp;	//Pointer and temporary pointer that contains the 
												//chips that are needed to compute the quadrature signal 
												//associated with the current frame
	double *PulseShapeTemp,*TempPulseTemp;	//Temporary pointer for *PuseShape
	double *InphaseSignalTemp,*QuadratureSignalTemp;	//Temporary pointers for inphase and quadrature signals
	double *TempInphaseTemp,*TempQuadratureTemp;		//Temporary pointers for inphase and quadrature signals
	
	//Determine the lenght of the pulse in terms of chips
	PulseLengthInChips = (int) (PulseLength / SamplesPerChip);

	//Determine size of output array
	NumSamples = PulseLength + (SamplesPerChip*(NumChips-1));

	//Determine the size of temporary chip array
	TempChipArrayLength = CHIP_LENGTH + PulseLengthInChips;

	//Allocate temporary chip array
	InphaseChipArray = (double *) calloc(TempChipArrayLength,sizeof(double));
	if (InphaseChipArray == NULL) 
	{
		printf("\nArray could not be allocated\n");
		return;
	}
	QuadChipArray = (double *) calloc(TempChipArrayLength,sizeof(double));
	if (QuadChipArray == NULL) 
	{
		printf("\nArray could not be allocated\n");
		return;
	}

	//Load temporary chip array
	InphaseChipsTemp = InphaseChipArray;
	QuadratureChipsTemp = QuadChipArray;

		//Load contribution from previous frame
	Overlap = PulseLengthInChips/2;
	TempInphaseTemp = PastInphaseChips + CHIP_LENGTH - Overlap;
	TempQuadratureTemp = PastQuadratureChips + CHIP_LENGTH - Overlap;
	for (k0=0; k0<Overlap; k0++)
	{
		*InphaseChipsTemp++ = *TempInphaseTemp++;
		*QuadratureChipsTemp++ = *TempQuadratureTemp++;
	}

		//Load contribution from current frame
	TempInphaseTemp = CurrentInphaseChips;
	TempQuadratureTemp = CurrentQuadratureChips;
	for (k0=0; k0<CHIP_LENGTH; k0++)
	{
		*InphaseChipsTemp++ = *TempInphaseTemp++;
		*QuadratureChipsTemp++ = *TempQuadratureTemp++;
	}

		//Load contribution from next frame
	TempInphaseTemp = FutureInphaseChips;
	TempQuadratureTemp = FutureQuadratureChips;
	for (k0=0; k0<Overlap; k0++)
	{
		*InphaseChipsTemp++ = *TempInphaseTemp++;
		*QuadratureChipsTemp++ = *TempQuadratureTemp++;
	}
	//TemporaryChipArrayLoaded

	//Perform filtering
	InphaseSignalTemp = InphaseSignal;
	QuadratureSignalTemp = QuadratureSignal;
	InphaseChipsTemp = InphaseChipArray;
	QuadratureChipsTemp = QuadChipArray;
	PulseShapeTemp = PulseShape + Overlap*SamplesPerChip;
	Start = (Overlap + 1) * SamplesPerChip;
	for (k0=0; k0<Overlap;k0++)
	{
		TempInphaseTemp = InphaseSignalTemp;
		TempQuadratureTemp = QuadratureSignalTemp;
		TempPulseTemp=PulseShapeTemp;
		Start -= SamplesPerChip;
		for (k1=Start; k1<PulseLength;k1++)
		{
			*TempInphaseTemp++ += *InphaseChipsTemp * *TempPulseTemp;
			*TempQuadratureTemp++ += *QuadratureChipsTemp * *TempPulseTemp++;
		}
		InphaseChipsTemp++;
		QuadratureChipsTemp++;
		PulseShapeTemp -= SamplesPerChip;
	} 

	
	for (k0=0;k0<CHIP_LENGTH;k0++)
	{
		TempInphaseTemp = InphaseSignalTemp;
		TempQuadratureTemp = QuadratureSignalTemp;
		PulseShapeTemp = PulseShape;
		for (k1=0;k1<PulseLength;k1++)
		{
			*TempInphaseTemp++ += *InphaseChipsTemp * *PulseShapeTemp;
			*TempQuadratureTemp++ += *QuadratureChipsTemp * *PulseShapeTemp++;
		}
		InphaseSignalTemp += SamplesPerChip;
		QuadratureSignalTemp += SamplesPerChip;
		InphaseChipsTemp++;
		QuadratureChipsTemp++;
	}

	Finish=PulseLength;
	for (k0=0; k0<Overlap; k0++)
	{
		TempInphaseTemp = InphaseSignalTemp;
		TempQuadratureTemp = QuadratureSignalTemp;
		PulseShapeTemp = PulseShape;
		Finish -= SamplesPerChip;
		for (k1=0;k1<Finish;k1++)
		{
			*TempInphaseTemp++ += *InphaseChipsTemp * *PulseShapeTemp;
			*TempQuadratureTemp++ += *QuadratureChipsTemp * *PulseShapeTemp++;
		}
		InphaseSignalTemp += SamplesPerChip;
		QuadratureSignalTemp += SamplesPerChip;
		InphaseChipsTemp++;
		QuadratureChipsTemp++;
	}
	
	free(InphaseChipArray);
	free(QuadChipArray);
}