sdc_sts.c

QPSK Tuner details, for conexant chipset.

			if ( (wdata->f1 < scur->f1) && (wdata->f2 > scur->f2) &&
				   (wdata->f1 > sprev->f2) && (wdata->f2 < snext->f1) )
				   return scur;
		}
		else	if (sprev)
		{
			if ( (wdata->f1 < scur->f1) && (wdata->f2 > scur->f2) &&
				   (wdata->f1 > sprev->f2) )
				   return scur;			
		}
		else	if (snext)
		{
			if ( (wdata->f1 < scur->f1) && (wdata->f2 > scur->f2)&&
				   (wdata->f2 < snext->f1) )
				   return scur;			
		}
		else
		{
			if ( (wdata->f1 < scur->f1) && (wdata->f2 > scur->f2))
				   return scur;
		}
		
		i++;
		scur++;
	}
	
	return 0;
}
							 
unsigned short MergeCandidateTP(TP_CANDIDATE *wdata,unsigned short wlen,
 												TP_CANDIDATE *sdata,unsigned short slen)
{
	TP_CANDIDATE *scur, *wcur;
	unsigned int i;
	unsigned int f1dif, f2dif;
	
	if ((wdata==NULL) || (sdata==NULL))
	    return 0;
	
	i=0;
	wcur = wdata;
	
	while(i<wlen)
	{
	   scur = GetMatchedTP(wcur, sdata, slen);
	   if (scur)
	   {
	   	  f1dif = (wcur->f1 - scur->f1);
	   	  f2dif = (wcur->f2 - scur->f2);
	      *scur = *wcur;
	      scur->bw -= (f2dif - f1dif);
	      //scur->bw -= scur->bw/10;
	      
	      wcur->remove = 1;
	   }
		 wcur++;
		 i++;
	}
	
	return 0;
}

unsigned short ParseCandidateTPByPeak(unsigned short *meter, 
									TP_CANDIDATE *data, unsigned short len, unsigned short mean)

{
	unsigned int i=0, j=0;
	TP_CANDIDATE *sd;
	unsigned short max=0;
	TP_CANDIDATE *prev, *next;
	
	if (meter==NULL)
		return 0;
		
	sd = data;
	i = 0;
	while(i<len)
	{
		j = sd->x1;
		max = 0;
		while(j<sd->x2)
		{
			if (meter[j]>max)
			   max = meter[j];
			j++;
		}
		sd->peak = max;
		
		if(max<(mean+500))
			sd->remove = 1;
		i++;
		sd++;
	}
	i = 0;
	sd = data;
	while(i<len)
	{
		prev = GetCandidatePrev(data, len, i);
		next = GetCandidateNext(data, len, i);
		
		if (prev && next && (sd->remove==1))
		{		

			
			if ((next->x1-sd->x2) > (sd->x1-prev->x2))
			{
				prev->x2 = sd->x2;
				prev->f2 = sd->f2;
				prev->mid = (prev->f1 + prev->f2)/2;
				prev->bw = prev->f2 - prev->f1;
			}
			else
			{
				next->x1 = sd->x1;
				next->f1 = sd->f1;
				next->mid = (next->f1 + next->f2)/2;
				next->bw = next->f2 - next->f1;
		  }
		}
		
		i++;
		sd++;
		
	}
	
	return 0;
	
}

#if 0
unsigned short ParseCandidateTPByBW(TP_CANDIDATE *data, unsigned short len)
{
	unsigned int i=0, j=0;
	
	TP_CANDIDATE *cur, *next, *last;
	
	cur = data;
	
	i = 0;
	j = 0;
	last = data + len;
	while(i<len)
	{
		next = GetCandidateNext(data, len, i);
		if (next==NULL)
			break;
	    
		if ((next->f1 - cur->f2) < BW_MIN_THRESHOLD)
		{
			*last = *next;
			last->f1 = cur->f1;
			last->mid = (last->f1 + last->f2)/2;
			last->bw = (last->f2 - last->f1);
			last++;
			j++;
		}
    i++;
    cur++;
	}
	return j;
}
#else
unsigned short ParseCandidateTPByBW(TP_CANDIDATE *data, unsigned short len)
{
	unsigned int i=0, j=0;
	
	TP_CANDIDATE *cur, *next, *last;
	
	cur = data;
	
	i = 0;
	j = 0;
	
	while(i<len)
	{
	    if( !cur->remove && cur->bw <= BW_MIN_THRESHOLD)
	    {
	        cur->remove =1;
	        j++;
	    }
	    cur++;
	    i++;
	}
	
//	while(i < (len-1) )
//	{
//		next = GetCandidateNext(data, len, i);
//		if (next==NULL)
//			break;
//	    
//		if ( !next->remove && (next->f1 - cur->f2) < BW_MIN_THRESHOLD)
//		{
//			cur->remove = 1;
//		}
//        i++;
//        cur = next;
//	}
	return j;
}
#endif

unsigned short ParseCandidateTPByLowHump(unsigned short *meter, 
									TP_CANDIDATE *data, unsigned short len, unsigned short threshold)

{
	unsigned int i=0, j=0;
	TP_CANDIDATE *sd;
	unsigned short min=0;
	TP_CANDIDATE *next;
	
	if ((meter==NULL) || (data==NULL)||(len==0))
		return 0;
		
	sd = data;
	next = sd + 1;
	i = 0;
	while(i<len-1)
	{
		j = sd->x2;
		min = meter[j];
		while(j<next->x1)
		{
			if (meter[j]<min)
			   min = meter[j];
			j++;
		}
	
		if(min>threshold)
		{

			if ((next->f2-sd->f1)<MAX_SYMBOL_RATE)
			{
				sd->remove = 1;	
				next->x1 = sd->x1;
				next->f1 = sd->f1;
				next->mid = (next->f1 + next->f2)/2;
				next->bw = next->f2 - next->f1;
			}
		}
		
		i++;
		sd++;
		next++;
	}
	
	return 0;
	
}


TP_CANDIDATE *GetMatchedTPAdv(TP_CANDIDATE *scur, TP_CANDIDATE *sdata, unsigned short slen, TP_CANDIDATE *wdata,unsigned short wlen)
{
	TP_CANDIDATE *sprev, *snext, *sd, *wd;
	unsigned int i;
	
	if ((sdata==NULL) || (wdata==NULL) || (scur==NULL))
	    return 0;

	sd = sdata;
	i=0;
	while (scur!=sd)
	{
		sd++;		
		i++;
	}
	sprev = GetCandidatePrev(sdata, slen, i);
	snext = GetCandidateNext(sdata, slen, i);
	i=0;
	wd = wdata;
	while(i<wlen)
	{
		
		if ((wd->x2<scur->x1))
		{
			wd++;
			i++;
			continue;		
		}
		
		if (wd->remove==1)
		{
			wd++;
			i++;
			continue;				
		}
		if (wd->x2<scur->x2)
		    return 0;		
		
		if( sprev && snext )
		{
			if ((wd->x1<=scur->x1) && (wd->x2>=scur->x2) && 
							(sprev->x2<=wd->x1) && (snext->x1>=wd->x2))
			{
				//*scur = *wd;
				return wd;
			}
		}
		
		if (sprev && (snext==NULL))
		{
			if ((wd->x1<=scur->x1) && (wd->x2>=scur->x2) && 
							(sprev->x2<=wd->x1))
			{
				//*scur = *wd;
				return wd;				
			}
		}
			
		
   if (snext && (sprev==NULL))
		{
			if ((wd->x1<=scur->x1) && (wd->x2>=scur->x2) && 
							(snext->x1>=wd->x2))
			{
				//*scur = *wd;
				return wd;
			}			
		} 
		
		break;				
	}
	
	return 0;
}

unsigned short MergeCandidateTPAdv(TP_CANDIDATE *wdata,unsigned short wlen,
 												TP_CANDIDATE *sdata,unsigned short slen)
{
	TP_CANDIDATE *scur, *mcur;
	unsigned int i;
	unsigned int f1dif, f2dif, tmp;
	
	if ((wdata==NULL) || (sdata==NULL))
	    return 0;
	
	i=0;
	scur = sdata;
	
	while(i<slen)
	{
	   mcur = GetMatchedTPAdv(scur, sdata, slen, wdata, wlen);

	   if (mcur==NULL)
	   {
	//			scur->remove = 1;
				scur->bw += 500000;
				if( scur->bw > STS_MAX_SYMBOL_RATE_MHZ*MILLION )
				{
				    scur->bw = STS_MAX_SYMBOL_RATE_MHZ*MILLION;
				}
	   }
	   else
	   {
				f1dif = scur->f1 - mcur->f1;
				f2dif = mcur->f2 - scur->f2;
				
				//tmp = abs(f2dif-f1dif)/2;
				tmp = scur->bw;
				
				if (mcur->bw<STS_MAX_SYMBOL_RATE_MHZ*MILLION)
					*scur = *mcur;
//				if (f1dif>f2dif)
//				{
//					scur->bw = tmp + 2*f2dif;
//					scur->f1 += (f1dif-f2dif);
//				}
//				else
//				{
//				  scur->bw = tmp + 2*f1dif;
//				  scur->f2  -= (f2dif-f1dif);
//				}
				mcur->remove = 1;
	   }
		 scur++;
		 i++;
	}
	
	return 0;
}


void CandidateTPOutput(TP_CANDIDATE *data,unsigned short len)
{
	unsigned int i=0;
	TP_CANDIDATE *sd;
	
	if (data==NULL)
		return;

	i=0;
	sd = data;
	while(i<len)
	{
		//if(sd->remove!=1)
		{
			trace_new( TRACE_FLAG, "F1=%04d F2=%04d MID=%04d SR=%05d P=%05d  (%01d)\r\n",
				sd->f1/MILLION, sd->f2/MILLION, sd->mid/MILLION, sd->bw/1000, sd->peak, sd->remove);
		  task_time_sleep(10);
		}
		i++;
		sd++;
	}
	
	return;
}

unsigned short DeleteRemovedNodes(TP_CANDIDATE *data, unsigned short len)
{
	unsigned int i=0, count=0;
	TP_CANDIDATE *curr, *next;
	
	if (data==NULL)
	    return 0;
	
	curr = data;
	
	i = 0;
	count = 0;
	while(i<len)
	{
		if (curr->remove==1)
		{
			next = GetCandidateNext(data, len, i);
			if (next)
			{
				*curr = *next;
				next->remove = 1;
				count ++;
			}
			else
			{
				return count;
			}
		}
		i++;
		curr++;		
	}
	
	return count;
}