sdc_sts.c

QPSK Tuner details, for conexant chipset.

/*+++ *******************************************************************\
*
*  Abstract:
*
*       Hamaro find candidate transponders in the way that devised by SDC.
*
*  Created: 11/22/2005
*
*
*  Copyright and Disclaimer: 
*  
*     --------------------------------------------------------------- 
*     This software is provided "AS IS" without warranty of any kind, 
*     either expressed or implied, including but not limited to the 
*     implied warranties of noninfringement, merchantability and/or  
*     fitness for a particular purpose.
*     --------------------------------------------------------------- 
*       
*   Author: Shen Wei Wang
*  
*     Copyright (c) 2005 Conexant Systems, Inc. 
*     All rights reserved. 
*
\******************************************************************* ---*/

#include "hamaro_sts.h"
#include "sdc_sts.h"
#include "kal.h"


#include "trace.h"
#define TRACE_FLAG  (TRACE_LEVEL_ALWAYS|TRACE_ALL|TRACE_NO_TIMESTAMP)

TP_CANDIDATE g_tp_data0[STS_MAX_SCAN_CANDIDATES];
TP_CANDIDATE g_tp_data1[STS_MAX_SCAN_CANDIDATES];
//TP_CANDIDATE  *g_tp_data0_base;
//TP_CANDIDATE  *g_tp_data1_base;
//#define g_tp_data0_base HWBUF_DEC_BUF1_ADDR
//#define g_tp_data1_base (HWBUF_DEC_BUF1_ADDR+ 2000*sizeof(TP_CANDIDATE))
//#define g_tp_data0  (*(TP_CANDIDATE *)g_tp_data0_base)
//#define g_tp_data1  (*(TP_CANDIDATE *)g_tp_data1_base)

static unsigned short g_peak_swap_buf[450];

unsigned short GetMedianNum(unsigned short *bArray, int iFilterLen)
{
	int i;
	int j;

	unsigned short bTemp;

	for (j=0; j<iFilterLen - 1; j++)
	{
		for (i=0; i<iFilterLen - 1; i++)
		{
			if (bArray[i] > bArray[i+1])
			{
				bTemp = bArray[i];

				bArray[i] = bArray[i+1];
				bArray[i+1] = bTemp;
			}
			  
		}
	}
	
	if ((iFilterLen & 1) != 0)
	{
		bTemp = bArray[(iFilterLen + 1)/2];
	}
	else
	{
		bTemp = (bArray[iFilterLen/2] + bArray[iFilterLen/2 + 1]) / 2;
	}
	
	return bTemp;
}


BOOL MedianFilter(unsigned short *pData, unsigned int length, unsigned int len)
{
	unsigned short *pSrc = 0;
	unsigned short *pDst = 0;
	unsigned short *pMedian = 0;
	unsigned int flen = length - len ;
	unsigned int i = 0;
	unsigned short g_tmp_power[10];

	if (pData == 0)
		return FALSE;
  if (len > sizeof g_tmp_power)
      return FALSE;
      
	pMedian = g_tmp_power;//(unsigned short *)malloc(len * sizeof(short));
	
	pSrc = pData;
	pDst = pData;// + len/2 + 1;

	for (i=0; i<flen; i++)
	{
		memcpy((unsigned char *)pMedian, (unsigned char *)pSrc, len*sizeof(short));
        *pDst = GetMedianNum(pMedian, len);
		pSrc ++;
		pDst ++;
	}
 
	//memcpy((unsigned char *)pData, (unsigned char *)power_dst, flen*sizeof(short));
	return TRUE;
}

unsigned long MeanValue(unsigned short *pData, unsigned short len)
{
	unsigned int i=0;
	unsigned long sum=0;
	unsigned short t_len=0;
	
	if (pData==NULL)
	    return 0;
	    
	while(i<len)
	{
	    if( *(pData+i) > 0 )
	    {
	        if( *(pData+i)>6000 )
	        {
	            sum+= 6000;
	        }
	        else
	        {
	            sum += *(pData + i);
	        }
	        t_len++;
	    }
		i++;
	}
	
	return sum/t_len;
}

unsigned short DoBubbleSort(unsigned short *data, unsigned short len)
{
	unsigned short tmp=0;
	unsigned short i=0, j=0;
	unsigned short count=0;

	if (data==NULL)
	    return 0;
	    
	for (j=0; j<len - 1; j++)
	{
		for (i=0; i<len - 1; i++)
		{
			if (data[i] > data[i+1])
			{
				tmp = data[i];
      
				data[i] = data[i+1];
				data[i+1] = tmp;
			  
			  count++;
			}
		}
	}
		

	return count;
  
}

STD_NUM GetStdNumber(unsigned short *pData, unsigned short len, unsigned short mean)
{
	unsigned long sum1=0, sum2=0, sum3=0;
	unsigned short i=0;
	STD_NUM std = {0,0};
	//static unsigned short std_raw_array[STS_MAX_INDEX];
	#define std_raw_array_base (HWBUF_DEC_BUF0_ADDR + sizeof(HAMARO_STS_POWER_SPECTRUM_DATA)+4)
  #define std_raw_array  ((unsigned short *)std_raw_array_base)

	
	if (pData==NULL)
		return std;
		
	while(i<len)
	{
		sum1 += abs(pData[i] - mean);
		std_raw_array[i] = abs(pData[i] - mean);
		i++;
	}
	
	DoBubbleSort(std_raw_array, len);
	
	i=0;
	while (i<len/3)
	{
		sum2 += std_raw_array[len-i-1];
		sum3 += std_raw_array[i];
		i++;
	}

//	while (i<len/2)
//	{
////		sum2 += std_raw_array[len-i-1];
//		sum3 += std_raw_array[i];
//		i++;
//	}

  trace_new( TRACE_FLAG, "STD1 = %05d  STD_HIGH = %05d STD_LOW = %05d\r\n",
				sum1/len, sum2*3/len, sum3*3/len);
  
  task_time_sleep(10);
  std.high = sum2*3/len;
  std.low = sum3*3/len;
  std.mid = sum1/len;

	return std;	
}

unsigned short CalcTransponderPeak(unsigned short *meter, 
				unsigned short x1, unsigned short x2)
{
	unsigned short i=0;
	unsigned short len=0, slen=0;
	unsigned long sum=0;
	
	if ((meter==NULL)||(x2<x1))
		return 0;
	
	len = x2 - x1;
	if (len > sizeof(g_peak_swap_buf)/2)
	   len = sizeof(g_peak_swap_buf)/2;
	   
	i = 0;
	while(i<len)
	{
		g_peak_swap_buf[i] = *(meter+x1+i);
		i++;
	}
	
	DoBubbleSort(g_peak_swap_buf, len);
	
	i = 1;
	
	if (len<80)
	{
		slen = len/2;
	}
	else if (len<200)
	{
		slen = len*2/3;
	}
	else
	{
		slen = len*4/5;
  }
	if (slen<=1)
		return 0;
		
	while (i<slen)
	{
		 sum += g_peak_swap_buf[len-i];
		 i++;
	}
	
	return sum/slen;
}
					
unsigned int FindTransponders(unsigned short *pData, unsigned long *freq, 
				unsigned short len, unsigned short mean, unsigned char no)
{
	unsigned short i=0, j=0;
	unsigned short left=0, right=0;
	unsigned char x1=0, x2=0;
	unsigned long middle=0;
	
	if((pData==NULL) || (freq==NULL))
	    return 0;
	
	while(i<(len-1))
	{
	   /* Check whether the candidate array is full */
		if( j >= STS_MAX_SCAN_CANDIDATES )
		   break;
		   
		if((pData[i]<mean) && (pData[i+1]>=mean))
		{
			x1 = 1;
			x2 = 0;
			left = i;
			right = 0;
		}
		else if ((x1==1) && (pData[i]>=mean) && (pData[i+1]<mean))
		{
			x2 = 1;
			right = i+1;
//			if((right - left)<20)
//			   x1 = 0;
            /* If the band width is too small, then discard it */
            if( ( *(freq+right) - *(freq+left) ) <= STS_MIN_SYMBOL_RATE_MHZ*MILLION  )
            {
                x1 = 0;
                x2 = 0;
            }                
		}
		
		if ((x1==1) && (x2==1))
		{
			middle = (freq[left] +  freq[right])/2;
			
			if(no==0)
			{
			    g_tp_data0[j].f1 = *(freq+left);
			    g_tp_data0[j].f2 = *(freq+right);
			    g_tp_data0[j].bw = *(freq+right) - *(freq+left);
			    g_tp_data0[j].x1 = left;
			    g_tp_data0[j].x2 = right;			    
			    g_tp_data0[j].mid = middle;
			    g_tp_data0[j].prev = g_tp_data0[j].next = 0;
			    g_tp_data0[j].remove = 0;
			    g_tp_data0[j].peak = CalcTransponderPeak(pData, left, right);
			}
			else
			{
			    g_tp_data1[j].f1 = *(freq+left);
			    g_tp_data1[j].f2 = *(freq+right);
			    g_tp_data1[j].bw = *(freq+right) - *(freq+left);
			    g_tp_data1[j].x1 = left;
			    g_tp_data1[j].x2 = right;		
			    g_tp_data1[j].mid = middle;
			    g_tp_data1[j].prev = g_tp_data1[j].next = 0;
			    g_tp_data1[j].remove = 0;				
			    g_tp_data1[j].peak = CalcTransponderPeak(pData, left, right);
			}
			
			x1 = 0;
			x2 = 0;
			j++;
		}
		i++;
	}
	
	return j;
}



TP_CANDIDATE *GetCandidatePrev(TP_CANDIDATE *data, unsigned short len,
						unsigned short index)
{
	unsigned short i=0;
	TP_CANDIDATE *sd;
	
	if ((data==NULL)||index==0)
	    return 0;
	
	i = index; 
	sd = data+index-1;   
	while(i>0)
	{
		if (sd->remove!=1)
		    break;
		sd--;
		i--;
	}
	if (i==0)
		sd = 0;
		
	return sd;
}


TP_CANDIDATE *GetCandidateNextAdv(TP_CANDIDATE *data, unsigned short len,
						unsigned short index)
{
	unsigned short i=0, j=0;
	TP_CANDIDATE *sd;
	
	if ( (data==NULL) )//||(index>=len-1))
	    return 0;
	
	i = 0; 
	j = 0;
	sd = data;   
	while(i<len)
	{
		if (sd->remove!=1)
		{
				j++;
		}
		
		if (j==index)
		   break;
		sd++;
		i++;
	}
	if (j!=index)
		sd = 0;
	
	return sd;
}

TP_CANDIDATE *GetCandidateNext(TP_CANDIDATE *data, unsigned short len,
						unsigned short index)
{
	unsigned short i=0;
	unsigned short nosd=1;
	TP_CANDIDATE *sd;
	
	if ((data==NULL)||(index>=len-1))
	    return 0;
	
	i = index; 
	sd = data+index+1;   
	while(i<len)
	{
		if (sd->remove!=1)
		{
			nosd = 0;
		    break;
		}
		sd++;
		i++;
	}
	if ((i==len) || (sd->f1==0)||(nosd==1))
		sd = 0;
		
	return sd;
}

TP_CANDIDATE *GetMatchedTP(TP_CANDIDATE *wdata, TP_CANDIDATE *sdata,unsigned short slen)
{
	TP_CANDIDATE *sprev, *snext, *scur;
	unsigned int i;
	
	if (sdata==NULL)
		return 0;
		
	i=0;
	scur = sdata;
	while(i<slen)
	{
		sprev = GetCandidatePrev(sdata, slen, i);
		snext = GetCandidateNext(sdata, slen, i);
		if (sprev && snext)
		{