common.c

B3g_phase2_C语言_Matlab程序及说明

	
	return	xor;
}

void trel_gen(int	g0, 
			  int	g1, 
			  int	Mem, 
	          int*	output_matrix, 
	          int*	nextstate_matrix,
	          int*	laststate_matrix,
	          int*	tail_bit)
{
	int		state_num;

	int		i,input,tmp_s,r;
	
	state_num = (1<<Mem);

	for(i=0; i<state_num; i++)
	{
		for(input=0; input<2; input++)
		{
			tmp_s	= (input<<Mem) + i;
			r	= dot(g0, tmp_s, Mem+1);
			tmp_s	= (r<<Mem) + i;
			nextstate_matrix[i*2+input] = (tmp_s>>1);
			r	= dot(g1, tmp_s, Mem+1);
			output_matrix[i*2+input] = r;
		}
		tail_bit[i] = dot(g0, i, Mem);
	}
	for(i=0; i<state_num; i++)
	{
		for(input=0; input<2; input++)
		{
			laststate_matrix[nextstate_matrix[2*i+input]*2+input] = i;
		}
	}
}

void interleave(int* imsg, int* msg, int N, int* interleave_table)
{
	int		i;
	
	for(i=0; i<N; i++)
	{
		imsg[i] = msg[interleave_table[i]];
	}

}

double maximum(double a, double b)
{
	return ( a>b ? a : b );
}

double g(double a, double b)
{
//	return ( a>b ? a : b ) + log(1.0 + exp(-(fabs(a-b))));
	
	double result;
	double diff;
	
	result = (a>b) ? a : b;
	diff   = fabs(a-b);
	
	if(diff>=5.08)
	{
		return result;
	}
	else
	{
		return (result+OFFSET[(int)(diff*128/5.08)]);
	}
}

void deinterleave(int *imsg, int* msg, int N, int* interleave_table)
{
	int		i;
	
	for(i=0; i<N; i++)
	{
		imsg[interleave_table[i]] = msg[i];
	}

}

void interleave_double(double* imsg, double* msg, int N, int* interleave_table)
{
	int			i;

	for(i=0; i<N; i++)
	{
		imsg[i] = msg[interleave_table[i]];
	}

}

void deinterleave_double(double* imsg, double* msg, int N, int* interleave_table)
{
	int			i;

	for(i=0; i<N; i++)
	{
		imsg[interleave_table[i]] = msg[i];
	}

}



void rsc_encode(int* msg, int* parity, int size, int termination, int g0, int g1, int Mem)
{
	int		i;
	int		state = 0;

	int*	output_matrix;
	int*	nextstate_matrix;
	int*	laststate_matrix;
	int*	tail_bit;
	int		num_state;

	num_state = (1<<Mem);

	output_matrix		=	(int*) malloc(num_state*2*sizeof(int));
	nextstate_matrix	=	(int*) malloc(num_state*2*sizeof(int));
	laststate_matrix	=	(int*) malloc(num_state*2*sizeof(int));
	tail_bit			=	(int*) malloc(num_state*sizeof(int));

	trel_gen(g0, g1, Mem, output_matrix, nextstate_matrix, laststate_matrix, tail_bit);

	for(i=0; i<size-Mem; i++)
	{
		parity[i]	= output_matrix[2*state + msg[i]];
		state		= nextstate_matrix[2*state + msg[i]];
	}

	if (termination != 0)
	{
		for(i=size-Mem; i<size; i++)
		{
			msg[i]		= tail_bit[state];
			parity[i]	= output_matrix[2*state + msg[i]];
			state		= nextstate_matrix[2*state + msg[i]];
		}
	}
	else
	{
		for(i=size-Mem; i<size; i++)
		{
			parity[i]	= output_matrix[2*state + msg[i]];
			state		= nextstate_matrix[2*state + msg[i]];
		}
	}

	free(output_matrix);
	free(nextstate_matrix);
	free(laststate_matrix);
	free(tail_bit);
}

void turbo_encode(int* msg, int* stream, int puncture, int Len, int g0 ,int g1, int Mem, int* interleave_table)
{
	int		i;
	
	int*	parity1;
	int*	parity2;
	int*	imsg;

	parity1 = (int*) malloc(Len*sizeof(int));
	parity2 = (int*) malloc(Len*sizeof(int));
	imsg	= (int*) malloc(Len*sizeof(int));

	rsc_encode(msg, parity1, Len, 1, g0, g1, Mem);

	interleave(imsg, msg, Len, interleave_table);

	rsc_encode(imsg, parity2, Len, 0, g0, g1, Mem);

	for(i=0; i<Len; i++)
	{
		if (puncture)
		{
			stream[2*i]		= msg[i];
			stream[2*i+1]	= (i%2) ? parity2[i] : parity1[i];
		}
		else
		{
			stream[3*i]	  = msg[i];
			stream[3*i+1] = parity1[i];
			stream[3*i+2] = parity2[i];
		}
	}
	
	free(parity1);
	free(parity2);
	free(imsg);

}

void turbo_decode(
short *	decoded, 
double*	old_llr,
double*	new_llr,
double*	llr_all,
double*	stream, 
int		puncture, 
int		Len, 
int		iteration,
int   *	interleave_table,
int		g0,
int		g1,
int		Mem)
{
	double*		parity1;
	double*		parity2;
	double*		msg;
	double*		imsg;
	double*		L1;
	double*		L2;
	double*		llrp1;
	double*		llrp2;
	double*		temp_L;

	double*		a1;
	double*		a2;
	double*		b1;
	double*		b2;
	double*		r1;
	double*		r2;
	double*		ru1;
	double*		ru2;
	double*		rc1;
	double*		rc2;
	
	int			num_state;
	int*		output_matrix;
	int*		nextstate_matrix;
	int*		laststate_matrix;
	int*		tail_bit;

	int		S;
	int		L;
	int		inf;
	
	int		i;
	int		j;
	int		i_iter;
	int		input;
	double		nom;
	double		denom;
	double		t0;
	double		t1;
	
	num_state	=	(1<<Mem);
	
	output_matrix		=	(int*) malloc(num_state*2*sizeof(int));
	nextstate_matrix	=	(int*) malloc(num_state*2*sizeof(int));
	laststate_matrix	=	(int*) malloc(num_state*2*sizeof(int));
	tail_bit			=	(int*) malloc(num_state*sizeof(int));
	
	trel_gen(g0, g1, Mem, output_matrix, nextstate_matrix, laststate_matrix, tail_bit);

	msg		= (double*) malloc(Len*sizeof(double));
	imsg	= (double*) malloc(Len*sizeof(double));
	parity1	= (double*) malloc(Len*sizeof(double));
	parity2 = (double*) malloc(Len*sizeof(double));
	L1		= (double*) malloc(Len*sizeof(double));
	L2		= (double*) malloc(Len*sizeof(double));
	llrp1	= (double*) malloc(Len*sizeof(double));
	llrp2	= (double*) malloc(Len*sizeof(double));
	temp_L	= (double*) malloc(Len*sizeof(double));

	a1	= (double*) malloc((Len+1)*num_state*sizeof(double));
	a2	= (double*) malloc((Len+1)*num_state*sizeof(double));
	b1	= (double*) malloc((Len+1)*num_state*sizeof(double));
	b2	= (double*) malloc((Len+1)*num_state*sizeof(double));
	r1	= (double*) malloc(Len*num_state*2*sizeof(double));
	r2	= (double*) malloc(Len*num_state*2*sizeof(double));
	rc1	= (double*) malloc(Len*num_state*2*sizeof(double));
	rc2	= (double*) malloc(Len*num_state*2*sizeof(double));
	ru1	= (double*) malloc(Len*num_state*2*sizeof(double));
	ru2	= (double*) malloc(Len*num_state*2*sizeof(double));

	L	=	Len;
	S	=	num_state;//convient to present
	
	for(i=0; i<Len; i++)
	{
		if (puncture)
		{
			msg[i]		= stream[2*i];
			parity1[i]	= (i%2) ? 0 : stream[2*i+1];
			parity2[i]	= (i%2) ? stream[2*i+1] : 0;
		}
		else
		{
			msg[i]		= stream[3*i];
			parity1[i]	= stream[3*i+1];
			parity2[i]	= stream[3*i+2];
		}
	}

	interleave_double(imsg, msg, Len, interleave_table);

	//initialize

	//Lc	=	2.0*1.0/N0;
	inf	=	1000;

	//initialize D1:
	
	a1[0*S+0]	=	0.0;
	b1[L*S+0]	=	0.0;
	for(j=1; j<num_state; j++)
	{
		a1[0*S+j]	=	-inf;
		b1[L*S+j]	=	-inf;
	}

	for(i=0; i<L; i++)
	{
		L2[i]	=	old_llr[i];
	}

	//initialize D2:
	
	a2[0*S+0]	=	0.0;
	b2[L*S+0]	=	0.0;

	for(j=1; j<num_state; j++)
	{
		a2[0*S+j] = -inf;
		b2[L*S+j] = 0.0;
	}
	//end of initialize
	

	//the nth iteration
	for(i_iter=0; i_iter<iteration; i_iter++)
	{
		//D1 process:
		
		//computate the gamma1
		for(i=0; i<L; i++)
		{
			for(j=0; j<S; j++)
			{
				for(input=0; input<2; input++)
				{	
					double	uk	=	(input == 1)? 1.0:-1.0;
					double	xk	=	(output_matrix[2*j+input] == 1)? 1.0:-1.0;
					
					rc1[(i*S+j)*2+input]	=	0.5*parity1[i]*xk;
					ru1[(i*S+j)*2+input]	=	0.5*uk*msg[i];
					r1[(i*S+j)*2+input] 	=	0.5*uk*L2[i]+ru1[(i*S+j)*2+input]+rc1[(i*S+j)*2+input];
				}
			}
		

		}//end of computing gamma1

		//computate the alfa1
		for(i=1; i<L; i++)
		{	
			for(j=0; j<S; j++)
			{
				t0	=	a1[(i-1)*S+laststate_matrix[2*j+0]]
						+ r1[((i-1)*S+laststate_matrix[2*j+0])*2+0];
				t1	=	a1[(i-1)*S+laststate_matrix[2*j+1]]
						+ r1[((i-1)*S+laststate_matrix[2*j+1])*2+1];
				a1[i*S+j] = g(t0, t1);
			}

		}//end of computing alfa1

		//compute the beta1
		for(i=L-1; i>0; i--)
		{
			for(j=0; j<S; j++)
			{
				t0	=	b1[(i+1)*S+nextstate_matrix[2*j+0]]
						+ r1[(i*S+j)*2+0];
				t1	=	b1[(i+1)*S+nextstate_matrix[2*j+1]]
						+ r1[(i*S+j)*2+1];
				b1[i*S+j] = g(t0,t1);
			}
		}//end of computing beta1
		
		for(i=0; i<L; i++)
		{	
			nom	=	a1[i*S+0] + rc1[(i*S+0)*2+1] 
						+ b1[(i+1)*S+nextstate_matrix[2*0+1]];
			denom	=	a1[i*S+0] + rc1[(i*S+0)*2+0]
						+ b1[(i+1)*S+nextstate_matrix[2*0+0]];
			
			for(j=1; j<S; j++)
			{
				nom	= g(nom, a1[i*S+j] + rc1[(i*S+j)*2+1] 
						+ b1[(i+1)*S+nextstate_matrix[2*j+1]]);
				denom	= g(denom, a1[i*S+j] + rc1[(i*S+j)*2+0] 
						+ b1[(i+1)*S+nextstate_matrix[2*j+0]]);

			}

			L1[i] = nom - denom;

			if (L1[i] < -10*inf)
			{
				L1[i] = -10*inf;
			}
			if (L1[i] > 10*inf)
			{
				L1[i] = 10*inf;
			}
		}//end of D1 process

		interleave_double(temp_L, L1, Len, interleave_table);

		for(i=0; i<Len; i++)
		{
			L1[i] = temp_L[i];
		}
		
		//D2 processing:
		//computate the gamma2
		for(i=0; i<L; i++)
		{
			for(j=0; j<S; j++)
			{
				for(input=0; input<2; input++)
				{	
					double	uk	=	(input == 1)? 1.0:-1.0;
					double	xk	=	(output_matrix[2*j+input] == 1)? 1.0:-1.0;
					
					*(rc2+(i*S+j)*2+input)	=	0.5*(*(parity2+i))*xk;
					*(ru2+(i*S+j)*2+input)	=	0.5*uk*(*(imsg+i));
					*(r2+(i*S+j)*2+input)	=	0.5*uk*L1[i]+ru2[(i*S+j)*2+input]+rc2[(i*S+j)*2+input];
				}
			}
		}//end of computing gamma2

		//computate the alfa2
		for(i=1; i<L; i++)
		{	
			for(j=0; j<S; j++)
			{
				t0	=	a2[(i-1)*S+laststate_matrix[2*j+0]]
						+ r2[((i-1)*S+laststate_matrix[2*j+0])*2+0];
				t1	=	a2[(i-1)*S+laststate_matrix[2*j+1]]
						+ r2[((i-1)*S+laststate_matrix[2*j+1])*2+1];
				a2[i*S+j] = g(t0, t1);
			}

		}//end of computing alfa2

		//compute the beta2
		for(i=L-1; i>0; i--)
		{
			for(j=0; j<S; j++)
			{
				t0	=	b2[(i+1)*S+nextstate_matrix[2*j+0]]
						+ r2[(i*S+j)*2+0];
				t1	=	b2[(i+1)*S+nextstate_matrix[2*j+1]]
						+ r2[(i*S+j)*2+1];
				b2[i*S+j] = g(t0,t1);
			}
		}//end of computing beta2

		for(i=0; i<L; i++)
		{
			nom	=	a2[i*S+0] + rc2[(i*S+0)*2+1] 
						+ b2[(i+1)*S+nextstate_matrix[2*0+1]];
			denom	=	a2[i*S+0] + rc2[(i*S+0)*2+0]
						+ b2[(i+1)*S+nextstate_matrix[2*0+0]];

			for(j=1; j<S; j++)
			{
				nom	= g(nom, a2[i*S+j] + rc2[(i*S+j)*2+1] 
						+ b2[(i+1)*S+nextstate_matrix[2*j+1]]);
				denom	= g(denom, a2[i*S+j] + rc2[(i*S+j)*2+0] 
						+ b2[(i+1)*S+nextstate_matrix[2*j+0]]);
			}

			L2[i] = nom - denom;

			if (L2[i] < -10*inf)
			{
				L2[i] = -10*inf;
			}
			if (L2[i] > 10*inf)