coef_seq.cpp

ALTERA公司的quartusII fir_compilier-v3.31对工程师很有帮助的哦

		}
		else if(coef_store_type == M4K)
		{
			coef_one_mem = (int) floor(36.0/((double) coef_bit_width));
		}
		else
		{
			coef_one_mem = 1;
		}

		mem_num = (int) ceil(((double) num_mac)/ ((double)coef_one_mem));
		mcv_reload_zero_insert = mem_num * coef_one_mem - num_mac;
		if(mem_num == 1)
		{
			mcv_reload_zero_insert = 0;
		}

		if(sym == 0)
		{
			zeros_insert = 0;
		}
		else
		{
			zeros_insert =(int) floor((double) (mcv_coef_length - coef_length));
		}

		for (i=0; i<2048; ++i)
		{
			tmp_coef[i] = 0;
		}

		for (i=0; i<coef_length; ++ i)
		{
			tmp_coef[i + int(zeros_insert)] = coef[i];
		}

		for (i=0; i<mcv_coef_length; ++ i)
		{
			coef[i] = tmp_coef[i];
		}

		k = 0;
		for (j=0; j<num_mac; ++j)
		{
			for (i=0; i<num_cycles; ++i)
			{
				k = i*num_mac + j;
				if (i==0)
				{
					tmp_coef[k] = coef[(num_cycles - 1) * num_mac + j];
				}
				else
				{
					tmp_coef[k] = coef[(i -1 ) * num_mac + j];
				}
			}
		}

		for (j=0; j<num_mac; ++j)
		{
			for (i=0; i<num_cycles; ++i)
			{
				k = i*num_mac + (num_mac - 1 - j);
				if(coef_store_type == LC)
				{
					coef[j*num_cycles + i] = tmp_coef[k];
				}
			}
		}
		mcv_coef_length = (num_mac + mcv_reload_zero_insert) * num_cycles;

		if(mcv_reload_zero_insert > 0)
		{
			for( i = 0; i < num_cycles; i++)
			{
				for(j = 0; j < num_mac + mcv_reload_zero_insert ; j++)
				{
					int ini_index = i * (num_mac) + j;
					int new_index = i * (num_mac + mcv_reload_zero_insert) + j;
					if(j < (mem_num-1) * coef_one_mem)
					{
						tmp_coef[new_index] = coef[ini_index];
					}
					else if(j < (mem_num-1) * coef_one_mem + mcv_reload_zero_insert)
					{
						tmp_coef[new_index] = 0;
					}
					else
					{
						tmp_coef[new_index] = coef[ini_index - mcv_reload_zero_insert];
					}
				}
			}
			for (i=0; i<2048; ++i)
			{
				coef[i] = tmp_coef[i] ;
			}
		}
	}

}
void distru_reseq()
{
/**********************************************************************************
*
* Reorder For distrubuted architecture 
* single and multi rate.
*
**********************************************************************************/
	int width_stage[6];
	int half_len = (int) ceil(((double) coef_length)/2.0);
	int coef_set_width = (int)ceil(log((double) num_coef_set)/log(2.0));
	int width_index_ini = 5;
	int group_size_ini = 7 - coef_set_width;
	float max_value;
	int width_index;
	int flag = 0;

	length_wr = (int)ceil((double)((double)coef_length/(double)poly_fact));
	if(length_wr<3)
	{
		length_wr = 3;
	}
	coef_length_ori = coef_length;
	if(poly_type==INT||poly_type==DEC)
	{
		coef_length = length_wr;
	}
	width_stage[0] = 1;
	width_stage[1] = 2;
	width_stage[2] = 4;
	width_stage[3] = 9;
	width_stage[4] = 18;
	width_stage[5] = 36;

	if(sym == 1)
	{
		coef_length = half_len;
	}

	if(coef_store_type == M512)//M512
	{
		width_stage[5] = 0;
		if(coef_set_width<=4)
		{
			width_index_ini = 4;
			group_size_ini = 5 - coef_set_width;
		}
		else
		{
			width_index_ini = 4;
			group_size_ini = 1;
		}
		max_value = (float)pow(2.0,18);
	}
	else
	{
		width_index_ini = 5;
		group_size_ini = 7 - coef_set_width;
		if(coef_set_width<=6)
		{
			group_size_ini = 7 - coef_set_width;
		}
		else
		{
			group_size_ini = 1;
		}
		max_value = (float)pow(2.0,36);
	}

	group_size = group_size_ini;
	if( group_size > coef_length)
	{
		group_size = coef_length;
		mem_width = coef_bit_width + (int)ceil(log((double) group_size)/log(2.0));
	}
	else
	{
		width_index = width_index_ini;
		mem_width = coef_bit_width + (int)ceil(log((double) group_size)/log(2.0));
		if(group_size<length_wr){
			while(mem_width < width_stage[width_index])
			{
				flag =1;
				group_size++;
				width_index --;
				mem_width = coef_bit_width + (int) ceil(log((double) group_size)/log(2.0));
			}
			if(flag == 1)
			{
				group_size--;
				width_index ++;
				mem_width = coef_bit_width + (int) ceil(log((double) group_size)/log(2.0));
			}
			if(group_size>length_wr)
			{
				group_size = length_wr;
				mem_width = coef_bit_width + (int) ceil(log((double) group_size)/log(2.0));
			}
		}
	}
	num_coef_group = (int)ceil(((double)coef_length) /((double) group_size));


}
void multi_rate_poly_mcv_reseq()
{
/**********************************************************************************
*
* Reorder For Multi-Rate Coeficient Sets, MCV only
*
**********************************************************************************/
	int coef_mr[2048];
	int tmp_coef[2048];
	int coef_one_mem = 0;
	int mem_num = 0;
	int half_len =(int) ceil(((double) coef_length)/2.0);
	int mcv_coef_length;
	int i,j,k;
	int ai = 0;
	int bi = 0;
	int ci = 0;

	if(poly_type==INT||poly_type==DEC)
	{
		length_wr = (int)ceil((double)((double)(coef_length)/(double)poly_fact));
		if(length_wr<3)
		{
				length_wr = 3;
		}

		// Multi-Cycle Variable
		if(struct_type == MCV)
		{
			// Store to temporary array coef_mr[]
			num_mac = (int)ceil(((double) length_wr)/((double) num_cycles));
			mcv_coef_length = num_mac * num_cycles;
			if(coef_store_type == M512)
			{
				coef_one_mem = (int) floor(18.0/((double) coef_bit_width));
				if(coef_one_mem == 0)
				{
					coef_one_mem = 1;
				}
			}
			else if(coef_store_type == M4K)
			{
				coef_one_mem = (int) floor(36.0/((double) coef_bit_width));
			}
			else
			{
				coef_one_mem = 1;
			}
			mem_num = (int) ceil(((double) num_mac)/ ((double)coef_one_mem));
			mcv_reload_zero_insert = mem_num * coef_one_mem - num_mac;
			if(mem_num == 1)
			{
				mcv_reload_zero_insert = 0;
			}

			for(i=0;i<2048;i++)
			{
				coef_mr[i] = 0;
				coef[i] = 0;
			}
			if(coef_store_type==LC)
			{
				for(i=0;i<poly_fact;i++)
				{
					for(j=0;j<mcv_coef_length;j++)
					{
						ai = i+j*poly_fact;
						bi = j+i*mcv_coef_length;	
						ci = (mcv_coef_length-1-j)+i*mcv_coef_length;	
						if(num_cycles==1)
						{
							//reorder and reverse each set
							coef_mr[ci] = coef_ori[ai];
						}
						else
						{
							// just reorder
							coef_mr[bi] = coef_ori[ai];
						}
					}
				}
				coef_mr[mcv_coef_length*poly_fact] = 0;
							
				for (int iset = 0; iset<poly_fact; ++iset)
				{
					for (j=0; j<num_mac; ++j)
					{
						for (i=0; i<num_cycles; ++i)
						{
							k = i*num_mac + j + iset * mcv_coef_length;
							if (i==0)
							{
								tmp_coef[k] = coef_mr[(num_cycles - 1) * num_mac + j + iset * mcv_coef_length];
							}
							else
							{
								tmp_coef[k] = coef_mr[(i -1 ) * num_mac + j + iset * mcv_coef_length];
							}
						}
					}

					for (j=0; j<num_mac; ++j)
					{
						for (i=0; i<num_cycles; ++i)
						{
							k = i*num_mac + (num_mac - 1 - j) + iset * mcv_coef_length;
							if(coef_store_type == LC)
							{
								coef[j*num_cycles + i + iset * mcv_coef_length] = tmp_coef[k];
							}
						}
					}
				}
				for(i=0;i<2048;i++)
				{
					if(num_cycles>1)
					{
						coef_mr[i] = coef[i];
					}
				}
			}
			else
			{
				for(i=0;i<poly_fact;i++)
				{
					for(j=0;j<length_wr;j++)
					{
						ai = i+j*poly_fact;
						bi = j+i*mcv_coef_length;	
						coef_mr[bi] = coef_ori[ai];
					}
				}

				for(i=0;i<poly_fact;i++)
				{
					mcv_coef_length = (num_mac + mcv_reload_zero_insert) * num_cycles;
					if(mcv_reload_zero_insert > 0)
					{
						for( int i_p = 0; i_p < num_cycles; i_p++)
						{
							for(int j_p = 0; j_p < num_mac + mcv_reload_zero_insert ; j_p++)
							{
								int ini_index = i_p * (num_mac) + j_p + i * num_mac * num_cycles;
								int new_index = i_p * (num_mac + mcv_reload_zero_insert) + j_p + mcv_coef_length * i;
								if(j_p < (mem_num-1) * coef_one_mem)
								{
									tmp_coef[new_index] = coef_mr[ini_index];
								}
								else if(j_p < (mem_num-1) * coef_one_mem + mcv_reload_zero_insert)
								{
									tmp_coef[new_index] = 0;
								}
								else
								{
									tmp_coef[new_index] = coef_mr[ini_index - mcv_reload_zero_insert];
								}
							}
						}
					}
				}
				if(mcv_reload_zero_insert > 0)
				{
					for (int i_l=0; i_l<2048; ++i_l)
					{
						coef_mr[i_l] = tmp_coef[i_l] ;
					}
				}
				coef_mr[mcv_coef_length*poly_fact+1] = 0;
			}
			length_wr = mcv_coef_length;
			}
			//Reassign back to array before writing to disk
			for(i=0;i<2048;i++)
			{
				coef[i] = coef_mr[i];
			}
		}
				/*********************************************************************************/

}
void deci_reseq()
{
/**********************************************************************************
*
* Reorder for decimation fir (allow symmetric)
*	
**********************************************************************************/
	int half_len =(int) ceil(((double) coef_length)/2.0);
	int tmp_coef[2048];
	int loc_coef[2048];

	float mcv_coef_length;
	float zeros_insert; 

	int calc_cycles = num_cycles;

    if(poly_type == DEC)
	{
		calc_cycles = num_cycles * poly_fact;
	}
	int loc_length;

	if(sym == 0)
	{
		loc_length = coef_length;
	}
	else
	{
		loc_length = half_len;
	}

	num_mac =(int) ceil(((double) loc_length)/((double) calc_cycles));

	mcv_coef_length = num_mac * calc_cycles;
	zeros_insert = 0;

	if(sym == 0 )
	{
		zeros_insert = 0;
	}
	else