turbo_code_log_map.c

turbo 码的c语言程序

void randominterleaver_int(int *data_unintlvr, int *interleaverddata,
						   int length, int type_flow)
{
	int i;
	int *index_random = type_flow? index_randomintlvr : index_randomintlvr_sup;

	for (i=0; i<length; i++)
	{
		*(interleaverddata+i) = *(data_unintlvr+ (*(index_random+i)));
	}
}

/*---------------------------------------------------------------
FUNCTION: 
	void randominterleaver_float(float *data_unintlvr, float *interleaverddata, int length, int type_flow)
	
DESCRIPTION:
	Random interleaver of float.

PARAMETERS:
	INPUT:
		data_unintlvr - Contains pointer to data_unintlvr before interleavered.
		length - Length of interleaver.
		type_flow - 1 for traffic flow, 0 for suplement flow.
	OUTPUT:
		interleaverddata - Contains pointer to interleavered data_unintlvr.

RETURN VALUE:
	None
---------------------------------------------------------------*/
void randominterleaver_float(float *data_unintlvr, float *interleaverddata, int length, int type_flow)
{
	int i;
	int *index_random = type_flow? index_randomintlvr : index_randomintlvr_sup;

	for (i=0; i<length; i++)
	{
		*(interleaverddata+i) = *(data_unintlvr+ (*(index_random+i)));
	}
}

/*---------------------------------------------------------------
FUNCTION: 
	void random_deinterlvr_int(int *data_unintlvr, int *interleaverddata, int length, int type_flow)
	
DESCRIPTION:
	Random deinterleaver of int.

PARAMETERS:
	INPUT:
		data_unintlvr - Contains pointer to data_unintlvr before interleavered.
		length - Length of interleaver.
		type_flow - 1 for traffic flow, 0 for suplement flow.

	OUTPUT:
		interleaverddata - Contains pointer to interleavered data_unintlvr.

RETURN VALUE:
	None
---------------------------------------------------------------*/
void random_deinterlvr_int(int *data_unintlvr, int *interleaverddata, int length, int type_flow)
{
	int i;
	int *index_random = type_flow? index_randomintlvr : index_randomintlvr_sup;

	for (i=0; i<length; i++)
	{
		*(data_unintlvr+(*(index_random+i))) = *(interleaverddata+i);
	}
}

/*---------------------------------------------------------------
FUNCTION: 
	void random_deinterlvr_float(float *data_unintlvr, float *interleaverddata, int length, int type_flow)
	
DESCRIPTION:
	Random interleaver of float.

PARAMETERS:
	INPUT:
		data_unintlvr - Contains pointer to data_unintlvr before interleavered.
		length - Length of interleaver.
		type_flow - 1 for traffic flow, 0 for suplement flow.
	OUTPUT:
		interleaverddata - Contains pointer to interleavered data_unintlvr.

RETURN VALUE:
	None
---------------------------------------------------------------*/
void random_deinterlvr_float(float *data_unintlvr, float *interleaverddata, int length, int type_flow)
{
	int i;
	int *index_random = type_flow? index_randomintlvr : index_randomintlvr_sup;

	for (i=0; i<length; i++)
	{
		*(data_unintlvr+(*(index_random+i))) = *(interleaverddata+i);
	}
}

/*
* 函数介绍：float型数据的块交织及解交织
* 输入参数：m_blockintlvr:块的行数
*           n_blockintlvr:块的列数
*           inputdata：交织（解交织）前的数据序列
* 输出参数：poutput：交织（解交织）后的数据序列
* 返回值：  无
* 说明：    块交织与解交织使用同一个函数，行数与列数互相交换。块交织的块大小必须与帧长相等
*/
void blockinterleaver_float(int m_blockintlvr, int n_blockintlvr, float *inputdata, float *outputdata)
{
	int i, j;
	for(i=0; i<m_blockintlvr; i++)
	{
		for(j=0; j<n_blockintlvr; j++)
		{
			outputdata[i*n_blockintlvr+j] = inputdata[j*m_blockintlvr+i];
		}
	}
}

/*
* 函数介绍：int型数据的块交织及解交织
* 输入参数：m_blockintlvr:块的行数
*           n_blockintlvr:块的列数
*           inputdata：交织（解交织）前的数据序列
* 输出参数：poutput：交织（解交织）后的数据序列
* 返回值：  无
* 说明：    块交织与解交织使用同一个函数，行数与列数互相交换。块交织的块大小必须与帧长相等
*/
void blockinterleaver_int(int m_blockintlvr, int n_blockintlvr, int *inputdata, int *outputdata)
{
	int i, j;
	for(i=0; i<m_blockintlvr; i++)
	{
		for(j=0; j<n_blockintlvr; j++)
		{
			outputdata[i*n_blockintlvr+j] = inputdata[j*m_blockintlvr+i];
		}
	}
}

/*
* 函数介绍：int型CDMA2000交织器
* 输入参数：data_unintlvr：交织前的数据
*           nturbo:交织块的大小
* 输出参数：interleaveddata：交织后的数据序列
* 返回值：  无
* 说明：    nturbo必须在256和32768之间
*/
void intlvrcdma2000_int(int *data_unintlvr, int *interleaveddata, int nturbo)
{   
	int i;
	int n = (int)ceil(log(nturbo)/log(2))-5;
	int *sub_2000 = (int*)malloc(sizeof(int)*nturbo);
	subscript(nturbo, sub_2000);

	for(i=0; i<nturbo; i++)
	{  
		interleaveddata[i] = data_unintlvr[sub_2000[i]];
	}
	free(sub_2000);

}

/*
* 函数介绍：float型CDMA2000交织器
* 输入参数：data_unintlvr：交织前的数据
*           nturbo:交织块的大小
* 输出参数：interleaveddata：交织后的数据序列
* 返回值：  无
* 说明：    nturbo必须在256和32768之间
*/
void intlvrcdma2000_float(float *data_unintlvr, float *interleaveddata, int nturbo)
{   
	int i;
	int n = (int)ceil(log(nturbo)/log(2))-5;
	int *sub_2000 = (int*)malloc(sizeof(int)*nturbo);
	subscript(nturbo, sub_2000);

	for(i=0; i<nturbo; i++)
	{  
		interleaveddata[i] = data_unintlvr[sub_2000[i]];
	}
	free(sub_2000);

}

/*
* 函数介绍：float型CDMA2000解交织器
* 输入参数：interleaveddata：解交织前的数据
*           nturbo:交织块的大小
* 输出参数：data_unintlvr：解交织后的数据序列
* 返回值：  无
* 说明：    nturbo必须在256和32768之间
*/
void deintlvrcdma2000_float(float *data_unintlvr, float *interleaveddata, int nturbo)
{   
	int i;
	int n = (int)ceil(log(nturbo)/log(2))-5;
	int *sub_2000 = (int*)malloc(sizeof(int)*nturbo);
	subscript(nturbo, sub_2000);

	for(i=0; i<nturbo; i++)
	{  
		data_unintlvr[sub_2000[i]] = interleaveddata[i];
	}
	free(sub_2000);

}

/*
* 函数介绍：int型CDMA2000解交织器
* 输入参数：interleaveddata：解交织前的数据
*           nturbo:交织块的大小
* 输出参数：data_unintlvr：解交织后的数据序列
* 返回值：  无
* 说明：    nturbo必须在256和32768之间
*/
void deintlvrcdma2000_int(int *data_unintlvr, int *interleaveddata, int nturbo)
{   
	int i;
	int n = (int)ceil(log(nturbo)/log(2))-5;
	int *sub_2000 = (int*)malloc(sizeof(int)*nturbo);
	subscript(nturbo, sub_2000);

	for(i=0; i<nturbo; i++)
	{  
		data_unintlvr[sub_2000[i]] = interleaveddata[i];
	}
	free(sub_2000);

}

/*
* 函数介绍：生成CDMA2000交织器的下标对应关系
* 输入参数：nturbo:交织块的大小
* 输出参数：sub_2000：交织后序列各元素在原序列中的对应位置
* 返回值：  无
* 说明：    nturbo必须在256和32768之间
*/
void subscript(int nturbo, int *sub_2000)
{
	int n;
	int indx;
	int counternum = 0;
	int tentative = 0;
	int temp1, temp2, temp3;
	int num = 0;
	n = (int)ceil(log(nturbo)/log(2))-5;
	counternum = (1<<(n+5))-1;
	for(indx=0; indx<(1<<(n+5)); indx++)
	{
		temp1 = msbs(indx, n+5, n)+1;
		temp1 = lsbs(temp1, n);
		temp2 = lookuptable_cdma2000[n-4][lsbs(indx, 5)];
		temp1 = lsbs(temp1*temp2, n);
		temp3 = bitreverse(lsbs(indx,5),5);
		tentative = (temp3<<n) + temp1;
		if(tentative < nturbo)
		{
			*(sub_2000+num) = tentative;
			num++;
		}
		if(num == nturbo)
		{
			break;
		}
		
	}
		
}

/*
* 函数介绍：取value的高num_bits位
* 输入参数：value：输入数据
*           numofbits: value的位数
*           num_bits: 要取的位数
* 输出参数：无
* 返回值：  value的高num_bits位所组成的十进制数
*/
int msbs(int value, int numofbits, int num_bits)
{
	int result = value>>(numofbits-num_bits);
	return result;
}

/*
* 函数介绍：取value的低num_bits位
* 输入参数：value：输入数据
*           num_bits: 要取的位数
* 输出参数：无
* 返回值：  value的低num_bits位所组成的十进制数
*/
int lsbs(int value, int num_bits)
{
	int result;
	int temp = (1<<num_bits)-1;
	result = value & temp;
	return result;
}


/*
* 函数介绍：比特翻转
* 输入参数：value：输入数据
*           num_bits: value的比特数
* 输出参数：无
* 返回值：  value比特翻转后组成的十进制数
*/
int bitreverse(int value, int num_bits)
{
	int i;
	int *bits = (int*)malloc(sizeof(int)*num_bits);
	int result;
	for(i=0; i<num_bits; i++)
	{
		bits[i] = (value>>i)&1;
	}
	/*将输入值变为num_bits个0，1数据*/
	result = 0;
	for(i=0; i<num_bits; i++)
	{
		result += bits[i]<<(num_bits-1-i);
	}
	/*翻转后组成新的十进制数*/
	free(bits);
	return result;
}


/*
* 函数介绍：int型数据交织函数
* 输入参数：data_unintlvr：交织前数据
*           nturbo: 数据长度
*           typeofinerleaver：交织器类型
* 输出参数：interleaveddata：交织后数据
* 返回值：  无
* 说明：    交织器类型选择：0为CDMA2000交织器，1为块交织，2为随机交织（暂缺），3为卷积交织（暂缺）
*/
void interleave_int(int *data_unintlvr, int *interleaveddata, int typeofinterleave, int nturbo, int type_flow)
{
	switch(typeofinterleave)
	{
	    case 0:
		{
			intlvrcdma2000_int(data_unintlvr, interleaveddata, nturbo);
			break;
		}
		case 1:
		{
			blockinterleaver_int(M_BLOCK_INT, N_BLOCK_INT, data_unintlvr, interleaveddata);
			break;
		}
		case 2:
		{
			randominterleaver_int(data_unintlvr, interleaveddata, nturbo, type_flow);
			break;
		}
		case 3:
		{
			break;
		}
		default:
		{
			printf("error! This type of interleaver doesn't exits!\n");
		}
	}
}

/*
* 函数介绍：float型数据交织函数
* 输入参数：data_unintlvr：交织前数据
*           nturbo: 数据长度
*           typeofinerleaver：交织器类型
* 输出参数：interleaveddata：交织后数据
* 返回值：  无
* 说明：    交织器类型选择：0为CDMA2000交织器，1为块交织，2为随机交织（暂缺），3为卷积交织（暂缺）
*/
void interleave_float(float *data_unintlvr, float *interleaveddata, int typeofinterleave, int nturbo, int type_flow)
{
	switch(typeofinterleave)
	{
	    case 0:
		{
			intlvrcdma2000_float(data_unintlvr, interleaveddata, nturbo);
			break;
		}
		case 1:
		{
			blockinterleaver_float(M_BLOCK_INT, N_BLOCK_INT, data_unintlvr, interleaveddata);
			break;
		}
		case 2:
		{
			randominterleaver_float(data_unintlvr, interleaveddata, nturbo, type_flow);
			break;
		}
		case 3:
		{
			break;
		}
		default:
		{
			printf("error! This type of interleaver doesn't exits!\n");
		}
	}
}

/*
* 函数介绍：int型数据解交织函数
* 输入参数：interleaveddata：解交织前数据
*           nturbo: 数据长度
*           typeofinerleaver：交织器类型
* 输出参数：data_unintlvr：解交织后数据
* 返回值：  无
* 说明：    交织器类型选择：0为CDMA2000交织器，1为块交织，2为随机交织（暂缺），3为卷积交织（暂缺）
*/
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");
		}
	}
}

/*
* 函数介绍：float型数据解交织函数
* 输入参数：interleaveddata：解交织前数据
*           nturbo: 数据长度
*           typeofinerleaver：交织器类型
* 输出参数：data_unintlvr：解交织后数据
* 返回值：  无
* 说明：    交织器类型选择：0为CDMA2000交织器，1为块交织，2为随机交织（暂缺），3为卷积交织（暂缺）
*/
void de_interleave_float(float *data_unintlvr, float *interleaveddata, int typeofinterleave, int nturbo, int type_flow)
{
	switch(typeofinterleave)
	{
	    case 0:
		{
			deintlvrcdma2000_float(data_unintlvr, interleaveddata, nturbo);
			break;
		}
		case 1:
		{
			blockinterleaver_float(N_BLOCK_INT, M_BLOCK_INT, interleaveddata, data_unintlvr);
			break;
		}
		case 2:
		{	
			random_deinterlvr_float(data_unintlvr, interleaveddata, nturbo, type_flow);
			break;
		}
		case 3:
		{
			break;
		}
		default:
			printf("error! This type of interleaver doesn't exits!\n");
	}
}

/*---------------------------------------------------------------
FUNCTION: 
	void encoderm_turbo(int *source, int *send_turbo, int len_info, int type_flow)
	
DESCRIPTION:
	This function encode the source data and modulate them using BPSK.