dvb_db.c

DVB软件,基于CT216软件的开发源程序.

#include <stdio.h>

#include <string.h>
#include "ap_defs.h"
#include "dvb_type.h"
#include "db_defs.h"
#include "dvb_msg.h"
#include "dvb_sys.h"
#include "dvb_si.h"

#include "db_defs.h"
#include "db_fs.h"

/*******************************************************************************************/
#if 1
#define DB_MSG(p)
#else
#define DB_MSG(p)			printf p
#endif

#if 1
#define DB_DBG(p)
#else
#define DB_DBG(p) 		printf p
#endif

/*******************************************************************************************/          

#define TYPE_EX_SKIP_BITMASK 0x8000



static DVB_ServiceInfo pgmItem, pgmItem2;

static s16 s16NumOfItems;
static s16 s16temp;
#ifdef ENABLE_LCN_SUPPORT
static s16 s16temp2;
#endif // end #ifdef ENABLE_LCN_SUPPORT

static u32 u32temp;

static EN_PGM_DISPLAY_TYPE enPgmNoDisplayType;
static EN_AUD_MODE enTVAudioMode=EN_AUD_MODE_LR;
static EN_AUD_MODE enRadioAudioMode=EN_AUD_MODE_LR;
/*******************************************************************************************/          

#ifdef No_diff_cap_small
extern char *strupr(char *string);
extern char *strlwr(char *string);
#endif

u8 u8DVB_DBStartBank = DB_START_BANK;

void Dump_ServiceDatabase(EN_SERVICE_TYPE tvRadioMode)
{
	EN_SYSTEM_TYPE	enSysType, enOrigSysType;
	EN_SERVICE_TYPE	enSrvType;
	u16				u16idx, u16Total;
	DVB_ServiceInfo	stSrvInfo;
	
	enOrigSysType = DVB_DBGetSystemType();
	for(enSysType=0; enSysType<EN_SYSTEM_TYPE_TOTAL; enSysType++)
	{
		DVB_DBSetSystemType(enSysType);

		for(enSrvType = 0; enSrvType < EN_SERVICE_TYPE_TOTAL; enSrvType++)
		{
			u16Total = DVB_ServiceGetTotal(enSrvType);
			DB_DBG(("\n\n====== DUMP DB: SERVICE(%d,%d)=%d =============\n", enSysType, enSrvType, u16Total));
			
			for(u16idx = 0; u16idx < u16Total; u16idx++)
			{
				if(DVB_ServiceRead(enSrvType, u16idx, &stSrvInfo) == FALSE)
					continue;
				
				DB_DBG(("   %03d/%03d) ", u16idx, u16Total));
				DB_DBG(("SrvID=%05d "   , stSrvInfo.u16ServiceId));
				DB_DBG(("PCR_PID=%05d " , stSrvInfo.u16PCRPid));
				DB_DBG(("V.PID=%05d "   , stSrvInfo.u16VideoPid));
				DB_DBG(("A.PID=%05d "   , stSrvInfo.au16AudioPid[0]));
				DB_DBG(("TpIdx=%05d "   , stSrvInfo.u8TransponderIndex));
				DB_DBG(("Type=%02X "    , stSrvInfo.u8Type));
				DB_DBG(("AudioVol=%02d ", stSrvInfo.u8AudioVolume));
				DB_DBG(("EIT_Idx=%05d " , stSrvInfo.u16EitHeaderIdx));
				DB_DBG(("TTXPid=%05d "  , stSrvInfo.u16TTXPid));
				DB_DBG(("TypeEX=%04X "  , stSrvInfo.u16TypeEX));
				DB_DBG(("PMT_PID=%05d " , stSrvInfo.u16PMTPid));
				DB_DBG(("Name=%s "      , stSrvInfo.acServiceName));
				DB_DBG(("\n"));
			}
		}		
	}
	DVB_DBSetSystemType(enOrigSysType);
}
/*******************************************************************************************/          

void Dump_SatelliteDatabase(void)
{
	EN_SYSTEM_TYPE	enSysType, enOrigSysType;
	u16				u16idx, u16Total;
	DB_NetDetail	stNetDetail;
	DB_SatRel		stNetRel;
	
	enOrigSysType = DVB_DBGetSystemType();
	for(enSysType=0; enSysType<EN_SYSTEM_TYPE_TOTAL; enSysType++)
	{
		DVB_DBSetSystemType(enSysType);
		u16Total = DVB_NetGetTotal();
		DB_DBG(("\n\n====== DUMP DB: NETWORK(%d)=%d ============\n", enSysType, u16Total));
		
		for(u16idx = 0; u16idx < u16Total; u16idx++)
		{
			if(DVB_NetReadDetail(u16idx, &stNetDetail, &stNetRel) == FALSE)
				continue;
			
			DB_DBG(("   %03d/%03d) SysType=%d ", u16idx, u16Total, stNetDetail.enSysType));
			DB_DBG(("vs:%05d ", stNetRel.as16SrvStartIdx[EN_SERVICE_TYPE_TV]));
			DB_DBG(("ve:%05d ", stNetRel.as16SrvEndIdx  [EN_SERVICE_TYPE_TV]));
			DB_DBG(("rs:%05d ", stNetRel.as16SrvStartIdx[EN_SERVICE_TYPE_RADIO]));
			DB_DBG(("re:%05d ", stNetRel.as16SrvEndIdx  [EN_SERVICE_TYPE_RADIO]));

			switch(stNetDetail.enSysType)
			{
			#ifdef DVB_SYSTEM_C
			case EN_SYSTEM_TYPE_DVBC:
				DB_DBG(("%c%c%c%c%c ", stNetDetail.netCable.acProviderName[0],
									  stNetDetail.netCable.acProviderName[1],
									  stNetDetail.netCable.acProviderName[2],
									  stNetDetail.netCable.acProviderName[3],
									  stNetDetail.netCable.acProviderName[4]));
				break;
			#else
			case EN_SYSTEM_TYPE_DVBT:
				DB_DBG(("%c%c%c%c%c ", stNetDetail.netTerre.acProviderName[0],
									  stNetDetail.netTerre.acProviderName[1],
									  stNetDetail.netTerre.acProviderName[2],
									  stNetDetail.netTerre.acProviderName[3],
									  stNetDetail.netTerre.acProviderName[4]));
				break;
			#endif				
			case EN_SYSTEM_TYPE_DVBS:
				DB_DBG(("lo:%05d ", stNetDetail.netSat.u16LocalFrequency));
				DB_DBG(("12:%hx " , stNetDetail.netSat.b8Control12V));
				DB_DBG(("22:%hx " , stNetDetail.netSat.b8Tone22K));
				DB_DBG(("di:%hx " , stNetDetail.netSat.u8DiSEqC));
				DB_DBG(("%s "     , stNetDetail.netSat.acSatelliteName));
				break;
			default:
				break;
			}				
			
			DB_DBG(( "\n"));
		}		
	}
	DVB_DBSetSystemType(enOrigSysType);
}
/*******************************************************************************************/          

void Dump_TransponderDatabase(int iTotal)
{
	EN_SYSTEM_TYPE	enSysType, enOrigSysType;
	u16				u16idx, u16Total;
	DB_TpDetailEx	stTpDetail;
	DB_TpRel		stTpRel;
	
	enOrigSysType = DVB_DBGetSystemType();
	for(enSysType=0; enSysType<EN_SYSTEM_TYPE_TOTAL; enSysType++)
	{
		DVB_DBSetSystemType(enSysType);
		u16Total = DVB_TPGetTotal();
		DB_DBG(("\n\n====== DUMP DB: TP(%d)=%d ============\n", enSysType, u16Total));
		
		for(u16idx = 0; u16idx < u16Total; u16idx++)
		{
			if(DVB_TPReadDetailEx(u16idx, &stTpDetail, &stTpRel) == FALSE)
			{
				continue;
			}
			DB_DBG(("%03d/%03d) ", u16idx, u16Total));

			switch(enSysType)
			{
			#ifdef DVB_SYSTEM_C
			case EN_SYSTEM_TYPE_DVBC:
				DB_DBG(("NetIdx: %d, "      , stTpRel.u16SatIdx));
				DB_DBG(("Freq: %dKHz, "     , stTpDetail.tpCable.u32FrequencyKHz));
				DB_DBG(("Bandwidth: %dMHz, ", stTpDetail.tpCable.u8BandwidthMHz));
				DB_DBG(("Spectrum: %d, "    , stTpDetail.tpCable.u8SpectrumInv));
				DB_DBG(("ChNo: %d, "        , stTpDetail.tpCable.u8ChNo));
				DB_DBG(("Symbol: %dKSR/s, " , stTpDetail.tpCable.u16SymbRateKB));
				DB_DBG(("QAM: %d, "         , stTpDetail.tpCable.u8QamType));
				DB_DBG(("ONID:%d "			,(int)stTpDetail.tpCable.u16OrgNID));
				DB_DBG(("TPID:%d "			,(int)stTpDetail.tpCable.u16TPID));
				break;
			#else
			case EN_SYSTEM_TYPE_DVBT:
				DB_DBG(("NetIdx: %d, "      , stTpRel.u16SatIdx));
				DB_DBG(("Freq: %dKHz, "     , stTpDetail.tpTerre.u32FrequencyKHz));
				DB_DBG(("Bandwidth: %dMHz, ", stTpDetail.tpTerre.u8BandwidthMHz));
				DB_DBG(("ChNo: %d, "        , stTpDetail.tpTerre.u8ChNo));
				DB_DBG(("ONID:%d "			, (int)stTpDetail.tpTerre.u16OrgNID));
				DB_DBG(("TPID:%d "				, (int)stTpDetail.tpTerre.u16TPID));
				break;
			#endif				
			case EN_SYSTEM_TYPE_DVBS:
				DB_DBG(( "Lo:%05d ",stTpDetail.tpSat.u16LocalFrequency));
				DB_DBG(( "TP:%05d ",stTpDetail.tpSat.u16TPFrequency));
				DB_DBG(( "Sym:%05d ",stTpDetail.tpSat.u16SymbolRate));
				DB_DBG(( "Po:%d ",(int)stTpDetail.tpSat.b8Polar_H));
		//		DB_DBG(( "12:%hX ",stTpDetail.tpSat.b8Control12V));
				DB_DBG(( "Sat:%02d ", (int)stTpRel.u16SatIdx));
				DB_DBG(( "22:%d ", (int)stTpDetail.tpSat.b8Tone22K));
				DB_DBG(( "Di:%d ", (int)stTpDetail.tpSat.u8DiSEqC));
				DB_DBG(( "ONID:%d ", (int)stTpDetail.tpSat.u16OrgNID));
				DB_DBG(( "TPID:%d ", (int)stTpDetail.tpSat.u16TPID));
			    DB_DBG(( "Srv#:%02d ", DVB_ServiceGetTotalbyTP(EN_SERVICE_TYPE_TV, u16idx)+DVB_ServiceGetTotalbyTP(EN_SERVICE_TYPE_RADIO, u16idx)));
				break;
			default:
				break;
			}				
			
			DB_DBG(( "\n"));
		}		
	}
	DVB_DBSetSystemType(enOrigSysType);
}
/*******************************************************************************************/          

void DVB_SetPgmDisplayType( EN_PGM_DISPLAY_TYPE enType)
{
	enPgmNoDisplayType = enType;
}
/*******************************************************************************************/          

EN_PGM_DISPLAY_TYPE DVB_GetPgmDisplayType(void)
{
	return enPgmNoDisplayType;
}

/*******************************************************************************************/          

u16 DVB_GetSrvIDByDbIdx(EN_SERVICE_TYPE enServiceType,  u16 u16DbIdx)
{
	if(u16DbIdx>=DVB_ServiceGetTotal(enServiceType))
		return 0xffff;
	
	DVB_ServiceRead(enServiceType, u16DbIdx, &pgmItem);
	
	return pgmItem.u16ServiceId;
}
/*******************************************************************************************/          

#ifdef ATSC_SYSTEM
u16 DVB_GetDbIdxByMaMiNum(EN_SERVICE_TYPE enServiceType, u16 u16MajorNum, u16 u16MinorNum)
{
	DB_SrvDetail pstService;
	DB_SrvRel pstSrvRel;
	
	s16NumOfItems = DVB_ServiceGetTotal(enServiceType);
	for(s16temp=0; s16temp<s16NumOfItems; s16temp++)
	{
		DVB_ServiceRead(enServiceType, s16temp, &pgmItem);
		if ((u16MajorNum == (u16)pgmItem.u32MajorCHNo) &&
			(u16MinorNum == (u16)pgmItem.u32MinorCHNo))
			break;
	}
	
	if(s16temp<s16NumOfItems)
		return s16temp;
	else
		return 0xffff;
}
#endif // end ATSC_SYSTEM
/*******************************************************************************************/          

u16 DVB_GetDbIdxBySrvID(EN_SERVICE_TYPE enServiceType,  u16 u16SrvID)
{
	s16NumOfItems = DVB_ServiceGetTotal(enServiceType);
	for(s16temp=0; s16temp<s16NumOfItems; s16temp++)
	{
		DVB_ServiceRead(enServiceType, s16temp, &pgmItem);
		if(u16SrvID==pgmItem.u16ServiceId)
			break;
	}
	
	if(s16temp<s16NumOfItems)
	{
		return s16temp;
	}	
	else
	{
		return 0xffff;
	}	
}
/*******************************************************************************************/          

u16 DVB_GetDbIdxBySrvIDTPIdx(EN_SERVICE_TYPE enServiceType,  u16 u16SrvID, u8 u8TPIdx)
{
	s16NumOfItems = DVB_ServiceGetTotal(enServiceType);
	for(s16temp=0; s16temp<s16NumOfItems; s16temp++)
	{
		DVB_ServiceRead(enServiceType, s16temp, &pgmItem);
		if((u16SrvID==pgmItem.u16ServiceId)&&( u8TPIdx ==pgmItem.u8TransponderIndex))
		{
			break;
		}	
	}
	
	if(s16temp<s16NumOfItems)
	{
		return s16temp;
	}	
	else
	{
		return 0xffff;
	}	
}

#ifdef ENABLE_LCN_SUPPORT
u16 DVB_GetLCNsByDbIdx(EN_SERVICE_TYPE enServiceType,  u16 u16DbIdx, bool8 *pb8LCNEnable)
{
	if(pb8LCNEnable != NULL)
	{
		*pb8LCNEnable = FALSE;
	}
	if(DVB_ServiceRead(enServiceType, u16DbIdx, &pgmItem) == FALSE)
	{
		return 0xFFFF;
	}
	if(pb8LCNEnable != NULL)	
	{
		*pb8LCNEnable = pgmItem.b1LCNEnable;
	}	
	return pgmItem.u16LCN;
}
/*******************************************************************************************/          

u16 DVB_GetDbIdxByLCNs(EN_SERVICE_TYPE enServiceType,  u16 u16LCNs, bool8 *pb8LCNEnable)
{
	u16	u16idx;
    u16 u16Total;
	
	if(pb8LCNEnable != NULL)	
	{
		*pb8LCNEnable = FALSE;
	}

    u16Total = DVB_ServiceGetTotal(enServiceType);
    
	for(u16idx = 0; u16idx < u16Total; u16idx++)
	{
		if(DVB_ServiceRead(enServiceType, u16idx, &pgmItem) == FALSE)
		{
			break;
		}
		if(u16LCNs != pgmItem.u16LCN)	
		{
			continue;
		}
		if(pb8LCNEnable != NULL)	
		{
			*pb8LCNEnable = pgmItem.b1LCNEnable;
		}	
		return u16idx;
	}
	
	return 0xFFFF;
}
/*******************************************************************************************/          

void DVB_LCNResetByONID(u16 u16ONID)
{
	u16 u16TotalService, u16SrvIdx;
	DVB_ServiceInfo pstService;
	
	u16TotalService = DVB_ServiceGetTotal (EN_SERVICE_TYPE_TV);
	for(u16SrvIdx = 0; u16SrvIdx < u16TotalService; u16SrvIdx++)
	{
		DVB_ServiceRead (EN_SERVICE_TYPE_TV, u16SrvIdx, &pstService);
		if (pstService.u16ONID != u16ONID)
		{
			if (pstService.u16LCN >= 800)
			{
				break;
			}
			pstService.u16LCN = 800 + u16SrvIdx;
			DVB_ServiceUpdate (EN_SERVICE_TYPE_TV, u16SrvIdx, &pstService);
		}
	}
	u16TotalService = DVB_ServiceGetTotal (EN_SERVICE_TYPE_RADIO);
	for(u16SrvIdx = 0; u16SrvIdx < u16TotalService; u16SrvIdx++)
	{
		DVB_ServiceRead (EN_SERVICE_TYPE_RADIO, u16SrvIdx, &pstService);
		if (pstService.u16ONID != u16ONID)
		{
			if (pstService.u16LCN >= 800) 
			{
				break;
			}
			pstService.u16LCN = 800 + u16SrvIdx;
			DVB_ServiceUpdate (EN_SERVICE_TYPE_RADIO, u16SrvIdx, &pstService);
		}
	}
}

/*******************************************************************************************/          
bool8 DVB_CheckONIDinDB(EN_SERVICE_TYPE enServiceType, u16 u16ONID)
{
	u16 u16TotalService, u16SrvIdx;
	DVB_ServiceInfo pstService;
	
	u16TotalService = DVB_ServiceGetTotal (enServiceType);
	for(u16SrvIdx = 0; u16SrvIdx < u16TotalService; u16SrvIdx++)
	{
		DVB_ServiceRead (enServiceType, u16SrvIdx, &pstService);
		if (pstService.u16ONID == u16ONID)
		{
			return TRUE;