turbo_code_log_map.c

一些关于Turbo编码译码实现所需的函数和原程序。

		{
			blockinterleaver_double(M_BLOCK_INT, N_BLOCK_INT, data_unintlvr, interleaveddata);
			break;
		}
		case 2:
		{
			randominterleaver_double(data_unintlvr, interleaveddata, nturbo, type_flow);
			break;
		}
		case 3:
		{
			break;
		}
		default:
		{
			printf("error! This type of interleaver doesn't exits!\n");
		}
	}
}
/*---------------------------------------------------------------
函数:
	void de_interleave_int(int *data_unintlvr, int *interleaveddata, int typeofinterleave, int nturbo, int type_flow)

介绍:
	int型数据解交织函数.交织器类型选择：0为CDMA2000交织器，1为块交织，2为随机交织,3为卷积交织（暂缺）

参数:
	输入参数:
		data_unintlvr - 交织前数据
        nturbo -  数据长度
        typeofinerleaver - 交织器类型
		type_flow - 信息类型 - 1-业务信息, 0补充信息.
    输出参数:
		interleaveddata - 交织后数据..
返回值:
	无
---------------------------------------------------------------*/
void de_interleave_int(int *data_unintlvr, int *interleaveddata, int typeofinterleave, int nturbo, int type_flow)
{
	switch(typeofinterleave)
	{
	    case 0:
		{
			deintlvrcdma2000_int(data_unintlvr, interleaveddata, nturbo);
			break;
		}
		case 1:
		{
			blockinterleaver_int(N_BLOCK_INT, M_BLOCK_INT, interleaveddata, data_unintlvr);
			break;
		}
		case 2:
		{
			random_deinterlvr_int(data_unintlvr, interleaveddata, nturbo, type_flow);
			break;
		}
		case 3:
		{
			break;
		}
		default:
		{
			printf("error! This type of interleaver doesn't exits!\n");
		}
	}
}

/*---------------------------------------------------------------
函数:
	void de_interleave_double(double *data_unintlvr, double *interleaveddata, int typeofinterleave, int nturbo, int type_flow)

介绍:
	double型数据解交织函数.交织器类型选择：0为CDMA2000交织器，1为块交织，2为随机交织,3为卷积交织（暂缺）

参数:
	输入参数:
		data_unintlvr - 交织前数据
        nturbo - 数据长度
        typeofinerleaver - 交织器类型
		type_flow - 信息类型 - 1-业务信息, 0补充信息.
    输出参数:
		interleaveddata - 交织后数据..
返回值:
	无
---------------------------------------------------------------*/
void de_interleave_double(double *data_unintlvr, double *interleaveddata, int typeofinterleave, int nturbo, int type_flow)
{
	switch(typeofinterleave)
	{
	    case 0:
		{
			deintlvrcdma2000_double(data_unintlvr, interleaveddata, nturbo);
			break;
		}
		case 1:
		{
			blockinterleaver_double(N_BLOCK_INT, M_BLOCK_INT, interleaveddata, data_unintlvr);
			break;
		}
		case 2:
		{	
			random_deinterlvr_double(data_unintlvr, interleaveddata, nturbo, type_flow);
			break;
		}
		case 3:
		{
			break;
		}
		default:
			printf("error! This type of interleaver doesn't exits!\n");
	}
}

/*---------------------------------------------------------------
函数:
	void encoderm_turbo(int *source, int *send_turbo, int len_info, int type_flow)

介绍:
	Turbo编码调制.
参数:
	输入参数:
		source -源数据序列首址.
		len_info - 源数据序列长度．
		type_flow - 信息类型: 1-业务信息, 0补充信息.
	输出参数:
		send_turbo - 编码调制后数据序列首址.
返回值:
	无．
---------------------------------------------------------------*/
void encoderm_turbo(int *source, int *send_turbo, int len_info, int type_flow)
{
	int i;									/* 循环变量 */
	int len_total = len_info + M_num_reg;	/* 总长度 */

	int *rsc1, *rsc2;		/* 两个RSC编码器的输出 */
	
	int *input2;			/* RSC2的输入 */

	if ((rsc1=(int *)malloc(2*len_total*sizeof(int)))==NULL)
	{
	  printf("\n fail to allocate memory of rsc1 \n");
	  exit(1);  
	}
	if ((rsc2=(int *)malloc(2*len_total*sizeof(int)))==NULL)
	{
	  printf("\n fail to allocate memory of rsc2 \n");
	  exit(1);  
	}

	if ((input2=(int *)malloc(len_info*sizeof(int)))==NULL)
	{
	  printf("\n fail to allocate memory of input2 \n");
	  exit(1);  
	}

	/* RSC1 */
	rsc_encode(source, rsc1, 1, len_info);

	/* 交织信源比特 */
	interleave_int(source, input2, TYPE_INTERLEAVER, len_info, type_flow);

	/* RSC2 */
	rsc_encode(input2, rsc2, 1, len_info);

	/* 信息位复用调制 */
	for (i=0; i<len_info; i++)
	{
		*(send_turbo+3*i) = *(rsc1+2*i) *2 - 1;
		*(send_turbo+3*i+1) = *(rsc1+2*i+1) *2 - 1;
		*(send_turbo+3*i+2) = *(rsc2+2*i+1) *2 - 1;
	}
	
	/* 结尾位复用调制 */
	for (i=0; i<2*M_num_reg; i++)
	{
		*(send_turbo+3*len_info+i) = *(rsc1+2*len_info+i) *2 - 1;
		*(send_turbo+3*len_info+2*M_num_reg+i) = *(rsc2+2*len_info+i) *2 - 1;
	}
	
	free(rsc1);
	free(rsc2);
	free(input2);
}

/*---------------------------------------------------------------
函数:
	void rsc_encode(int *source, int *rsc, int terminated, int len_info)
介绍:
	RSC编码器.
参数:
	输入参数:
		source -源数据序列首址.
		len_info - 源数据序列长度．
		terminated - 是否结尾: 1-结尾, 0-不结尾.
	输出参数:
		RSC - 编码后数据序列首址.
返回值:
	无．
---------------------------------------------------------------*/
void rsc_encode(int *source, int *rsc, int terminated, int len_info)
{
	int i, j;			/* 循环变量 */

	int *state;			/* 状态序列 */
	int dk_turbo, ak_turbo, outbit;		/* 编码器内的dk,ak和编码输出比特 */

	int len_total;						/* 总长度 */

	if ((state=(int *)malloc(M_num_reg*sizeof(int)))==NULL)
	{
	  printf("\n fail to allocate memory of state \n");
	  exit(1);  
	}

	/* 计算总长度 */
	len_total = len_info+M_num_reg;

	/* 初状态为0 */
	for (i=0; i<M_num_reg; i++)
	{
		*(state+i) = 0;
	}

	for (i=0; i<len_total; i++)							/* 逐比特编码 */
	{
		if (!terminated || (terminated && i<len_info))	/* 对信息比特 */
		{
			dk_turbo = *(source+i);
		}
		else											/* 结尾Trellis */
		{
			if (terminated && i>=len_info)
			{
				dk_turbo = 0;
				for (j=1; j<turbo_g.K_num_col; j++)
				{
					dk_turbo = dk_turbo + (*(turbo_g.g_matrix+j)) * (*(state+j-1));
				}
				dk_turbo = dk_turbo%2;
			}
		}

		/* 计算ak */
		ak_turbo = *(turbo_g.g_matrix+0) * dk_turbo;
		for (j=1; j<turbo_g.K_num_col; j++)
		{
			ak_turbo = ak_turbo + (*(turbo_g.g_matrix+j))*(*(state+j-1));
		}

		ak_turbo = ak_turbo%2;

		/* 对ak进行比特编码 */
		outbit = encode_bit(ak_turbo, state);

		/* 写dk和输出比特 */
		*(rsc+2*i) = dk_turbo;
		*(rsc+2*i+1) = outbit;

	}				/* 逐比特编码结束 */

	free(state);
}

/*---------------------------------------------------------------
函数:
	int encode_bit(int inbit, int *stat)
介绍:
	比特编码器.
参数:
	输入参数:
		inbit -输入比特.
		stat - 当前寄存器状态首址.
	输出参数:
		stat - 编码后寄存器状态首址.
返回值:
	输出比特．
---------------------------------------------------------------*/
int encode_bit(int inbit, int *stat)
{
	int j;			/* 循环变量 */
	int output;		/* 输出比特 */

	/* 计算输出比特 */
	output = (*(turbo_g.g_matrix+turbo_g.K_num_col+0)) * inbit;

	for (j=1; j<turbo_g.K_num_col; j++)
	{
		output = (output + (*(turbo_g.g_matrix+turbo_g.K_num_col+j)) * (*(stat+j-1)))%2;
	}

	/* 修改状态序列 */
	for (j=turbo_g.K_num_col-2; j>0; j--)
	{
		*(stat+j)=*(stat+j-1);
	}

	*(stat+0) = inbit;

	return output;
}


/*---------------------------------------------------------------
函数:
	int gen_mx_punc()
介绍:
	生成删余阵.
参数:
	无
返回值:
	1 - 成功．
	0 - 失败.
---------------------------------------------------------------*/
int gen_mx_punc()
{
	int i;		/* 循环变量 */
	int type_punc;	/* 打孔类型 */
	int *mx_puncture_turbo;		/* 用于选择打孔矩阵 */

	for (type_punc=1; type_punc<5; type_punc++)
	{
		switch (type_punc)
		{
		case 1:
			mx_puncture_turbo = mx_puncture_turbo_80;	/* 3*80 */
			break;
		case 2:
			mx_puncture_turbo = mx_puncture_turbo_160;	/* 3*160 */
			break;
		case 4:
			mx_puncture_turbo = mx_puncture_turbo_320;	/* 3*320 */
			break;
		default:
			break;
		}

		if (type_punc==3)
		{
			continue;
		}
		
		/* 第一行赋1 */
		for (i=0; i<type_punc*80; i++)
		{
			*(mx_puncture_turbo+i) = 1;
		}

		/* 二,三行交替赋0,1 */
		for (i=0; i<type_punc*80; i++)
		{
			if(i%2)
			{
				*(mx_puncture_turbo+type_punc*80+i) = 0;
			}
			else
			{
				*(mx_puncture_turbo+type_punc*80+i) = 1;
			}
		}
		for (i=0; i<type_punc*80; i++)
		{
			if(i%2)
			{
				*(mx_puncture_turbo+type_punc*80*2+i) = 1;
			}
			else
			{
				*(mx_puncture_turbo+type_punc*80*2+i) = 0;
			}
		}

		/* 对几个指定位赋0 */
		switch (type_punc)
		{
		case 1:
			{
				*(mx_puncture_turbo+type_punc*80*2+20) = 0;
				*(mx_puncture_turbo+type_punc*80+20) = 0;

				*(mx_puncture_turbo+type_punc*80*2+41) = 0;
				*(mx_puncture_turbo+type_punc*80+41) = 0;

				*(mx_puncture_turbo+type_punc*80*2+62) = 0;
				*(mx_puncture_turbo+type_punc*80+62) = 0;

				break;
			}
		case 2:
			{
				*(mx_puncture_turbo+type_punc*80*2+50) = 0;
				*(mx_puncture_turbo+type_punc*80+50) = 0;

				*(mx_puncture_turbo+type_punc*80*2+101) = 0;
				*(mx_puncture_turbo+type_punc*80+101) = 0;
				
				*(mx_puncture_turbo+type_punc*80*2+152) = 0;
				*(mx_puncture_turbo+type_punc*80+152) = 0;
				
				break;
			}
		case 4:
			{
				*(mx_puncture_turbo+type_punc*80*2+90) = 0;
				*(mx_puncture_turbo+type_punc*80+90) = 0;

				*(mx_puncture_turbo+type_punc*80*2+191) = 0;
				*(mx_puncture_turbo+type_punc*80+191) = 0;
				
				*(mx_puncture_turbo+type_punc*80*2+272) = 0;
				*(mx_puncture_turbo+type_punc*80+272) = 0;
				
				break;
			}
		default:
			{
				return 0;
			}
		}
	}
	return 1;

}

/*---------------------------------------------------------------
函数:
	void puncture(int *data_unpunc, int length_unpunc, int *data_punctured, 
			  int M_mx_punc, int N_mx_punc, int times_punc)
介绍:
	删余.
参数:
	输入参数:
		data_unpunc - 未删余数据首址.
		length_unpunc - 未删余数据长度.
		M_mx_punc - 删余阵行数.
		N_mx_punc - 删余阵列数.
		times_punc - 几次使用删余阵.
	输出参数:
		data_punctured - 删余后数据首址.
返回值:
	无．
---------------------------------------------------------------*/
void puncture(int *data_unpunc, int length_unpunc, int *data_punctured, 
			  int M_mx_punc, int N_mx_punc, int times_punc)
{
	int i, j, k=0, temp_time=0;		/* 循环变量 */
	int *mx_puncture_turbo;			/* 用于选择删余阵 */

	switch (N_mx_punc)
	{
	case 80:
		{
			mx_puncture_turbo = mx_puncture_turbo_80;
			break;
		}
	case 160:
		{
			mx_puncture_turbo = mx_puncture_turbo_160;
			break;
		}
	case 320:
		{
			mx_puncture_turbo = mx_puncture_turbo_320;
			break;
		}
	default:
		{
			printf("error in puncturing!\n");
			exit(1);
		}
	}
		
	for (temp_time=0; temp_time<times_punc; temp_time++)	/* 删余阵使用次数循环 */
	{
		/* 从头至尾遍历删余阵 */
		for (j=0; j<N_mx_punc && (temp_time*M_mx_punc*N_mx_punc+j*M_mx_punc)<length_unpunc; j++)
		{
			for (i=0; i<M_mx_punc && (temp_time*M_mx_punc*N_mx_punc+j*M_mx_punc+i)<length_unpunc;i++)
			{
				if (*(mx_puncture_turbo+i*N_mx_punc+j))
				{
					*(data_punctured+k) = *(data_unpunc+temp_time*M_mx_punc*N_mx_punc+j*M_mx_punc+i);
					k++;
				}
			}
		}
	}/* 删余阵使用次数循环结束 */

	/* 尾比特不打孔 */
	if (times_punc*M_mx_punc*N_mx_punc<length_unpunc)