common.c

B3g_phase2_C语言_Matlab程序及说明

		for(n_Block=0; n_Block<(INTERP_FACTOR*SUBSLOT_NUM+1); n_Block++)
		{
			p_CurCHEstimate = p_CHEstimate + n_Block*(TxANTENNA_NUM*RxANTENNA_NUM*PATH_NUM);
			p_Cur_h_half    = p_h_half     + (n_slot*(INTERP_FACTOR*SUBSLOT_NUM+1)+n_Block)*(TxANTENNA_NUM*TxANTENNA_NUM*PATH_NUM);
			
			result = vec_self_cov(p_CurCHEstimate, (TxANTENNA_NUM*RxANTENNA_NUM*PATH_NUM), p_Cur_h_half, TxANTENNA_NUM);
		}
	}

	//Free memory
	free(p_FirstCHEst);
	free(p_Rhh);
	free(p_PathGainEst);
	free(p_CombineMtx);
	free(p_CHEstimate);
	free(p_rxSignalPerSubslot);
	
	return 1;
}

int FirstCHEstimate(COMPLEX * p_rxSignal, int n_rxSignalLen, COMPLEX * p_FirstCHEst, COMPLEX * p_Rhh, double * p_PathGainEst, BASEBAND_PARM * p_Baseband_Parm)
{
	int i;
	int n_slot;
	int n_subslot,n_ss;
	int n_TxAntenna;
	int n_RxAntenna;
	int n_Path;
	int result;
	
	int OutLenPerRx = n_rxSignalLen/RxANTENNA_NUM;
	
	//Pointer
	COMPLEX * p_CurFades;
	
	//Memory
	COMPLEX * p_rxPilotPerSubslot;
	p_rxPilotPerSubslot = (COMPLEX *)malloc(RxANTENNA_NUM*PILOT_LENGTH*sizeof(COMPLEX));
	
	//Initialization Rhh and PathGain.
	for(i=0; i<(SUBSLOT_NUM+1)*(SUBSLOT_NUM+1); i++)
	{
		(p_Rhh+i)->real = (p_Rhh+i)->image = 0;
	}
	for(n_Path=0; n_Path<PATH_NUM; n_Path++)
	{
		*(p_PathGainEst+n_Path) = 0;
	}

	//LS channel estimate in one Frame
	for(n_slot=0; n_slot<p_Baseband_Parm->FRAME_SLOTNUM; n_slot++)
	{
		for(n_subslot=0; n_subslot<(SUBSLOT_NUM+1); n_subslot++)
		{
			//Get the received Pilot signal for current subslot.
			for(n_RxAntenna=0; n_RxAntenna<RxANTENNA_NUM; n_RxAntenna++)
			{
				for(i=0; i<PILOT_LENGTH; i++)
				{
					(p_rxPilotPerSubslot+n_RxAntenna*PILOT_LENGTH+i)->real  = (p_rxSignal+n_RxAntenna*OutLenPerRx+n_slot*SLOT_LENGTH+n_subslot*SUBSLOT_LENGTH+GUARD_LENGTH+i)->real;
					(p_rxPilotPerSubslot+n_RxAntenna*PILOT_LENGTH+i)->image = (p_rxSignal+n_RxAntenna*OutLenPerRx+n_slot*SLOT_LENGTH+n_subslot*SUBSLOT_LENGTH+GUARD_LENGTH+i)->image;
				}
			}
			p_CurFades = p_FirstCHEst + (n_slot*(SUBSLOT_NUM+1)+n_subslot)*(RxANTENNA_NUM*TxANTENNA_NUM*PATH_NUM);
			result     = RoughlyChannelEst(p_rxPilotPerSubslot, RxANTENNA_NUM*PILOT_LENGTH, p_CurFades);
		}
	}

	//Rhh estimation in one Frame.
	for(n_slot=0; n_slot<p_Baseband_Parm->FRAME_SLOTNUM; n_slot++)
	{
		p_CurFades = p_FirstCHEst + n_slot*(SUBSLOT_NUM+1)*(RxANTENNA_NUM*TxANTENNA_NUM*PATH_NUM);
		for(n_subslot=0; n_subslot<(SUBSLOT_NUM+1); n_subslot++)
		{
			for(n_ss=0; n_ss<(SUBSLOT_NUM+1); n_ss++)
			{
//				//Here should modified!
//				for(i=0; i<(RxANTENNA_NUM*TxANTENNA_NUM*PATH_NUM); i++)
//				{
//					*(p_Rhh+n_subslot*(SUBSLOT_NUM+1)+n_ss) = add_cmx( *(p_Rhh+n_subslot*(SUBSLOT_NUM+1)+n_ss), 
///											                           mul_cmx( *(p_CurFades+n_subslot*(RxANTENNA_NUM*TxANTENNA_NUM*PATH_NUM)+i),
//				                	                                  conj_cmx( *(p_CurFades+n_ss*(RxANTENNA_NUM*TxANTENNA_NUM*PATH_NUM)+i) ) 
//				                        	                                  )
//				                                	                  );
//				}
				
				//2004-04-22
				for(n_RxAntenna=0; n_RxAntenna<RxANTENNA_NUM; n_RxAntenna++)
				{
					for(n_TxAntenna=0; n_TxAntenna<TxANTENNA_NUM; n_TxAntenna++)
					{
						*(p_Rhh+n_subslot*(SUBSLOT_NUM+1)+n_ss) = add_cmx( *(p_Rhh+n_subslot*(SUBSLOT_NUM+1)+n_ss), 
																		   mul_cmx( *(p_CurFades+(n_subslot*RxANTENNA_NUM+n_RxAntenna)*TxANTENNA_NUM*PATH_NUM+n_TxAntenna),
				                	                                                conj_cmx( *(p_CurFades+(n_ss*RxANTENNA_NUM+n_RxAntenna)*TxANTENNA_NUM*PATH_NUM+n_TxAntenna) ) 
				                        	                                      )
				                                	                     );
					}
				}

			}
		}
	}
	//Get the average value of Rhh (Not including the PATH_NUM!).
	for(i=0; i<(SUBSLOT_NUM+1)*(SUBSLOT_NUM+1); i++)
	{
		*(p_Rhh+i) = div_cmxreal( *(p_Rhh+i), (double)(RxANTENNA_NUM*TxANTENNA_NUM*(p_Baseband_Parm->FRAME_SLOTNUM)) );
	}

		
	//PathGain estimation in one Frame.
	for(i=0; i<RxANTENNA_NUM*(SUBSLOT_NUM+1)*(p_Baseband_Parm->FRAME_SLOTNUM); i++)
	{
		p_CurFades = p_FirstCHEst + i*(TxANTENNA_NUM*PATH_NUM);
		for(n_Path=0; n_Path<PATH_NUM; n_Path++)
		{
			for(n_TxAntenna=0; n_TxAntenna<TxANTENNA_NUM; n_TxAntenna++)
			{
				*(p_PathGainEst+n_Path) += eng_cmx(*(p_CurFades+n_Path*TxANTENNA_NUM+n_TxAntenna));
			}
		}
	}
	//Get the average value of PathGain
	for(n_Path=0; n_Path<PATH_NUM; n_Path++)
	{
		*(p_PathGainEst+n_Path) /= (TxANTENNA_NUM*RxANTENNA_NUM*(SUBSLOT_NUM+1)*(p_Baseband_Parm->FRAME_SLOTNUM));
	}
	
	free(p_rxPilotPerSubslot);
	
	return (i*n_Path*n_TxAntenna);	//The length of p_FirstCHEst.
	
}

//The first channel estimation use LS criterion in one pilot segment.
int RoughlyChannelEst(COMPLEX * p_rxPilot, int n_length, COMPLEX * p_Fades)
{
	int n_RxAntenna;
	int p;
	int i;
	
	for(n_RxAntenna=0; n_RxAntenna<RxANTENNA_NUM; n_RxAntenna++)
	{
		for(i=0; i<TxANTENNA_NUM*PATH_NUM; i++)
		{
			(p_Fades+n_RxAntenna*TxANTENNA_NUM*PATH_NUM+i)->real  = 0;
			(p_Fades+n_RxAntenna*TxANTENNA_NUM*PATH_NUM+i)->image = 0;
			
			for(p=0; p<PILOT_LENGTH; p++)
			{
				*(p_Fades+n_RxAntenna*TxANTENNA_NUM*PATH_NUM+i) = add_cmx( *(p_Fades+n_RxAntenna*TxANTENNA_NUM*PATH_NUM+i), mul_cmx( *(p_rxPilot+n_RxAntenna*PILOT_LENGTH+p), PILOT_MATRIX[p*TxANTENNA_NUM*PATH_NUM+i] ) );
			}
			*(p_Fades+n_RxAntenna*TxANTENNA_NUM*PATH_NUM+i) = div_cmxreal( *(p_Fades+n_RxAntenna*TxANTENNA_NUM*PATH_NUM+i), (double)PILOT_LENGTH );
		}
	}
	
	return (n_RxAntenna*i);
}

//Obtain the filter matrix
int GetCombineMtx(COMPLEX * p_Rhh, int n_Len, double * p_PathGainEst, COMPLEX * p_CombineMtx, double * Noise_variance)
{
	int       i,j,k;
	int       result;
	int       n_Path;
	double    Var_Est = 0;
	
	//Pointer
	COMPLEX * p_CurCombineMtx;
	
	//Memory
	double  * p_EigenValue;
	COMPLEX * p_EigenVector;

	//Allocate memory
	p_EigenValue    = (double  *)malloc((SUBSLOT_NUM+1)*sizeof(double));
	p_EigenVector   = (COMPLEX *)malloc((SUBSLOT_NUM+1)*(SUBSLOT_NUM+1)*sizeof(COMPLEX));

	//Solve eigenproblem for Rhh.
	result = GetMtxEigValueVector(p_Rhh, (SUBSLOT_NUM+1), p_EigenValue, p_EigenVector);
	
	for(i=0; i<SUBSLOT_NUM/4; i++)
	{
		Var_Est += *(p_EigenValue+SUBSLOT_NUM-i);
	}
	Var_Est /= i;
//	Var_Est *= 1.1;
	


	*Noise_variance = PILOT_LENGTH*Var_Est*1.2;
	
	for(i=0; i<(SUBSLOT_NUM+1); i++)
	{
		*(p_EigenValue+i) -= Var_Est;
		if( *(p_EigenValue+i)<1e-10 ) *(p_EigenValue+i) = 0;
	}
	for(n_Path=0; n_Path<PATH_NUM; n_Path++)
	{
		*(p_PathGainEst+n_Path) -= Var_Est;
		if( *(p_PathGainEst+n_Path)<1e-10 ) *(p_PathGainEst+n_Path) = 0;
	}

	//Compute Combine matrix for each path.
	for(n_Path=0; n_Path<PATH_NUM; n_Path++)
	{
		p_CurCombineMtx = p_CombineMtx + n_Path*(SUBSLOT_NUM+1)*(SUBSLOT_NUM+1);
		
		for(i=0; i<(SUBSLOT_NUM+1); i++)
		{
			for(j=0; j<(SUBSLOT_NUM+1); j++)
			{
				(p_CurCombineMtx+i*(SUBSLOT_NUM+1)+j)->real = (p_CurCombineMtx+i*(SUBSLOT_NUM+1)+j)->image = 0;
				for(k=0; k<(SUBSLOT_NUM+1); k++)
				{
					*(p_CurCombineMtx+i*(SUBSLOT_NUM+1)+j) = 
			       add_cmx( *(p_CurCombineMtx+i*(SUBSLOT_NUM+1)+j), 
			                mul_cmxreal( mul_cmx( *(p_EigenVector+i*(SUBSLOT_NUM+1)+k), 
			                                      conj_cmx(*(p_EigenVector+j*(SUBSLOT_NUM+1)+k)) ),
			                            (*(p_EigenValue+k))*(*(p_PathGainEst+n_Path))/((*(p_EigenValue+k))*(*(p_PathGainEst+n_Path))+(*(p_PathGainEst))*Var_Est)
			                           ) 
			              );
				}
			}
		}
	}
	
	//Free memory
	free(p_EigenValue);
	free(p_EigenVector);
	
	return (i*j*n_Path);
}

//The second channel estimation use the MMSE criterion in one slot.
int SecondCHEstimate(COMPLEX * p_FirstCHEst, int n_InLen, COMPLEX * p_CombineMtx, COMPLEX * p_CHEstimate, int n_InterpFactor)
{
	int       result;
	int       n_Path;
	int       n_TxAntenna;
	int       n_RxAntenna;
	int       n_subslot,n_ss;
	int       n_Block;
	
	//Pointer
	COMPLEX * p_CurCombineMtx;
	
	//Memory
	COMPLEX * p_OriginalFades;
	COMPLEX * p_FilteredFades;
	COMPLEX * p_InterpedFades;
	
	//Allocate memory
	p_OriginalFades = (COMPLEX *)malloc((SUBSLOT_NUM+1)*sizeof(COMPLEX));
	p_FilteredFades = (COMPLEX *)malloc((SUBSLOT_NUM+1)*sizeof(COMPLEX));
	p_InterpedFades = (COMPLEX *)malloc((n_InterpFactor*SUBSLOT_NUM+1)*sizeof(COMPLEX));
	
	
	//Filter the orginal fades for a special path.
	for(n_Path=0; n_Path<PATH_NUM; n_Path++)
	{
		p_CurCombineMtx = p_CombineMtx + n_Path*(SUBSLOT_NUM+1)*(SUBSLOT_NUM+1);
		
		for(n_TxAntenna=0; n_TxAntenna<TxANTENNA_NUM; n_TxAntenna++)
		{
			for(n_RxAntenna=0; n_RxAntenna<RxANTENNA_NUM; n_RxAntenna++)
			{
				//Get Data
				for(n_subslot=0; n_subslot<(SUBSLOT_NUM+1); n_subslot++)
				{
					(p_OriginalFades+n_subslot)->real  = (p_FirstCHEst+(n_subslot*RxANTENNA_NUM+n_RxAntenna)*TxANTENNA_NUM*PATH_NUM+n_Path*TxANTENNA_NUM+n_TxAntenna)->real;
					(p_OriginalFades+n_subslot)->image = (p_FirstCHEst+(n_subslot*RxANTENNA_NUM+n_RxAntenna)*TxANTENNA_NUM*PATH_NUM+n_Path*TxANTENNA_NUM+n_TxAntenna)->image;
				}
				
				//Filter Data
				for(n_subslot=0; n_subslot<(SUBSLOT_NUM+1); n_subslot++)
				{
					(p_FilteredFades+n_subslot)->real = (p_FilteredFades+n_subslot)->image = 0;
					
					for(n_ss=0; n_ss<(SUBSLOT_NUM+1); n_ss++)
					{
						*(p_FilteredFades+n_subslot) = add_cmx( *(p_FilteredFades+n_subslot), mul_cmx( *(p_CurCombineMtx+n_subslot*(SUBSLOT_NUM+1)+n_ss), *(p_OriginalFades+n_ss) ) );
					}
				}
				
				//Interpolate Data
				result = cmx_spline(p_FilteredFades, (SUBSLOT_NUM+1), p_InterpedFades, n_InterpFactor);
				
				//Save Data
				for(n_Block=0; n_Block<result; n_Block++)	//result = n_InterpFactor*SUBSLOT_NUM+1
				{
					(p_CHEstimate+((n_Block*RxANTENNA_NUM+n_RxAntenna)*PATH_NUM+n_Path)*TxANTENNA_NUM+n_TxAntenna)->real  = (p_InterpedFades+n_Block)->real;
					(p_CHEstimate+((n_Block*RxANTENNA_NUM+n_RxAntenna)*PATH_NUM+n_Path)*TxANTENNA_NUM+n_TxAntenna)->image = (p_InterpedFades+n_Block)->image;
				}
			}
		}
	}
	
	//Free memory
	free(p_OriginalFades);
	free(p_FilteredFades);
	free(p_InterpedFades);
	
	return (n_Block*n_RxAntenna*n_Path*n_TxAntenna);	
}

/* END _RAKE_CHEST_C_ */

///////////////////////////////////////////////////////////
/* ABSTRACT MODULE */
int Transmitter(short * p_InfoBit, int n_InfoBitLength, COMPLEX * p_txSignal, BASEBAND_PARM * p_Baseband_Parm, CODE_PARAMETER * p_code_parm, int * p_CodeInlvTable, int * p_OuterInlvTable)
{
	int i;
	int result;
	int n_slot;
	int n_subslot;
	int n_TxAntenna;

	int n_CodePacket;	
	int n_CodePacket_Num = TxANTENNA_NUM*p_Baseband_Parm->FRAME_SLOTNUM/CODE_SLOTNUM;
	
	short   * p_CurInfoBit;
	int     * p_CurCodedBit;

	int 	* p_CodedBit;
	COMPLEX * p_ModedSym;
	COMPLEX * p_CurTxSym;
	COMPLEX * p_CurTxSignal;
	p_CodedBit = (int *)malloc(TxANTENNA_NUM*p_Baseband_Parm->FRAME_SLOTNUM*p_Baseband_Parm->n_CodedBitPerSlot*sizeof(int));
	p_ModedSym = (COMPLEX *)malloc(TxANTENNA_NUM*p_Baseband_Parm->FRAME_SLOTNUM*SYMBOL_SLOT*sizeof(COMPLEX));
	p_CurTxSym = (COMPLEX *)malloc(p_Baseband_Parm->FRAME_SLOTNUM*SYMBOL_SLOT*sizeof(COMPLEX));
	

	//Encode
	for(n_CodePacket=0; n_CodePacket<n_CodePacket_Num; n_CodePacket++)
	{
		p_CurInfoBit  = p_InfoBit  + n_CodePacket*p_code_parm->n_InfoBit_length;
		p_CurCodedBit = p_CodedBit + n_CodePacket*(CODE_SLOTNUM*p_Baseband_Parm->n_CodedBitPerSlot);
		
		result        = TurboEncoder(p_CurInfoBit, p_CurCodedBit, p_code_parm, p_CodeInlvTable);
	}
	
	//Outer Interleave
	s_interleave_int(p_CodedBit, TxANTENNA_NUM*p_Baseband_Parm->FRAME_SLOTNUM*p_Baseband_Parm->n_CodedBitPerSlot, p_OuterInlvTable);
	
	//Modulate
	result = GrayMapQAM(p_CodedBit, TxANTENNA_NUM*p_Baseband_Parm->FRAME_SLOTNUM*p_Baseband_Parm->n_CodedBitPerSlot, p_ModedSym, p_Baseband_Parm->MODULATOR_STYLE);

	//Assemble Frame for each Tx.
	for(n_TxAntenna=0; n_TxAntenna<TxANTENNA_NUM; n_TxAntenna++)
	{
		p_CurTxSignal = p_txSignal + n_TxAntenna*p_Baseband_Parm->FRAME_SLOTNUM*SLOT_LENGTH;
		
		//Get current Tx's symbols for all slot.
		for(n_slot=0; n_slot<p_Baseband_Parm->FRAME_SLOTNUM; n_slot++)
		{
			for(n_subslot=0; n_subslot<SUBSLOT_NUM; n_subslot++)
			{
				for(i=0; i<SUBSLOTDATA_LENGTH; i++)
				{
					(p_CurTxSym+(n_slot*SUBSLOT_NUM+n_subslot)*SUBSLOTDATA_LENGTH+i)->real  = (p_ModedSym+((n_slot*SUBSLOT_NUM+n_subslot)*TxANTENNA_NUM+n_TxAntenna)*SUBSLOTDATA_LENGTH+i)->real;
					(p_CurTxSym+(n_slot*SUBSLOT_NUM+n_subslot)*SUBSLOTDATA_LENGTH+i)->image = (p_ModedSym+((n_slot*SUBSLOT_NUM+n_subslot)*TxANTENNA_NUM+n_TxAntenna)*SUBSLOTDATA_LENGTH+i)->image;
				}
			}
		}
		
		result = AssembleFrame(p_CurTxSym, p_CurTxSignal, p_Baseband_Parm, n_TxAntenna);
	}
	
	//Free memory
	free(p_CodedBit);
	free(p_ModedSym);
	free(p_CurTxSym);
	
	return n_TxAntenna*result;
	
}
int tmpTurboReceiver
(short   * p_InfoBit,    int n_InfoBitLength,
 COMPLEX * p_rakeSignal, int n_SignalLength,
 COMPLEX * p_h_half,     int n_FadeLength,
 short   * p_DecodedBit,
 int     * p_OuterInlvTable,
 int     * p_CodeInlvTable,
 BASEBAND_PARM  * p_Baseband_Parm,
 CODE_PARAMETER * p_code_parm,
 double    Noise_variance,
 int       n_DetectIterNum)
{
	int i;
	int result;
	int n_Iter;
	int n_DecIter;
	int n_slot;
	int n_subslot;
	int n_CodePacket;
	
	int n_CodePacket_Num      = TxANTENNA_NUM*p_Baseband_Parm->FRAME_SLOTNUM/CODE_SLOTNUM;
	int n_SignalLenPerSubslot = n_SignalLength/(p_Baseband_Parm->FRAME_SLOTNUM)/SUBSLOT_NUM;
	int n_LLRLenPerSubslot    = TxANTENNA_NUM*SUBSLOTDATA_LENGTH*(p_Baseband_Parm->MODULATOR_STYLE);

	//Just in one Block!
	int n_FadeLen             = TxANTENNA_NUM*TxANTENNA_NUM*PATH_NUM;
	int n_MaskLen             = TxANTENNA_NUM*TxANTENNA_NUM*(2*PATH_NUM-1);
	
	//Test
	int n_error = 0;

	//Pointer
	COMPLEX * p_CurSignal;
	COMPLEX * p_CurFades;
	
	short   * p_CurDecodedBit;
	double  * p_CurCodedBitLLR;
	double  * p_CurInfoBitLLR;
	
	//Memory
	double  * p_Rou;
	COMPLEX * p_Mask;
		
	COMPLEX * p_x_mean0;
	double  * p_x_variance0;
	
	double  * p_CodedBitLLR;
	double  * p_InfoBitLLR;
	
	COMPLEX * p_x_Intf;
	double  * p_x_Sigma;
	

	//Allocate memory
	p_Rou         = (double  *)malloc((INTERP_FACTOR+1)*TxANTENNA_NUM*sizeof(double));
	p_Mask        = (COMPLEX *)malloc((INTERP_FACTOR+1)*n_MaskLen*sizeof(COMPLEX));
	
	p_x_mean0     = (COMPLEX *)malloc(TxANTENNA_NUM*SUBSLOTDATA_LENGTH*sizeof(COMPLEX));
	p_x_variance0 = (double  *)malloc(TxANTENNA_NUM*SUBSLOTDATA_LENGTH*sizeof(double));
	
	p_CodedBitLLR = (double  *)malloc(p_Baseband_Parm->FRAME_SLOTNUM*SUBSLOT_NUM*n_LLRLenPerSubslot*sizeof(double));
	p_InfoBitLLR  = (double  *)malloc(n_CodePacket_Num*(p_code_parm->n_InfoBit_length+p_code_parm->n_CodeMemLength)*sizeof(double));
	
	p_x_Intf      = (COMPLEX *)malloc(n_SignalLenPerSubslot*sizeof(COMPLEX));
	p_x_Sigma     = (double  *)malloc(n_SignalLenPerSubslot*sizeof(double));
	
	//Initialization
	for(i=0; i<p_Baseband_Parm->FRAME_SLOTNUM*SUBSLOT_NUM*n_LLRLenPerSubslot; i++)
	{
		*(p_CodedBitLLR+i) = 0;
	}
	for(i=0; i<n_CodePacket_Num*(p_code_parm->n_InfoBit_length+p_code_parm->n_CodeMemLength); i++)
	{
		*(p_InfoBitLLR+i) = 0;
	}
	
	//Turbo Detection/Decoding
	for(n_Iter=0; n_Iter<n_DetectIterNum; n_Iter++)
	{
		for(n_slot=0; n_slot<p_Baseband_Parm->FRAME_SLOTNUM; n_slot++)
		{
			for(n_subslot=0; n_subslot<SUBSLOT_NUM; n_subslot++)
			{
				p_CurSignal      =  p_rakeSignal  + (n_slot*SUBSLOT_NUM+n_subslot)*n_SignalLenPerSubslot;
				p_CurFades       =  p_h_half      + (n_slot*(INTERP_FACTOR*SUBSLOT_NUM+1)+n_subslot*INTERP_FACTOR)*n_FadeLen;
				p_CurCodedBitLLR =  p_CodedBitLLR + (n_slot*SUBSLOT_NUM+n_subslot)*n_LLRLenPerSubslot;
				
				result = NewRouMask(p_CurFades, p_Mask, p_Rou, INTERP_FACTOR);
				
				if(n_Iter==0)
				{
					for(i=0; i<TxANTENNA_NUM*SUBSLOTDATA_LENGTH; i++)
					{
						(p_x_mean0+i)->real = (p_x_mean0+i)->image = 0;
						*(p_x_variance0+i)  = 1 ;
					}
					
					result = Turbo_IC(p_CurSignal, n_SignalLenPerSubslot, p_Rou, p_Mask, n_MaskLen*MAXS