zzconnectdlg.cpp

组拨技术

// ZZConnectDlg.cpp : implementation file
//

#include "stdafx.h"
#include "ZZConnect.h"
#include "ZZConnectDlg.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

#define		MULTICAST_IP		"239.9.9.9"
#define		MULTICAST_PORT		999


#include "SmsCtrlLib.h"
#include "ZJ_interface.h"
#include "ZJ_platform.h"
#include "ZJ_datapublic.h"



bool DisposePacket( char * packet );

bool ParseTS( char * buf,int iLength );

bool DisposePAT( char * packet );

bool DisposePMT( char * packet );

bool DisPoseData( char * packet );

#define		BUFFER_SIZE		40980
#define		ONE_PACKET_SIZE		188
char				m_buf[BUFFER_SIZE];				//缓冲区
long				m_lLength = 0;							//缓冲中剩余的长度	
char				m_packet[ONE_PACKET_SIZE];			//包缓冲区
TSHeader	m_header;
PAT			m_pat;
PMTPIDITEM	m_pmt[64];
DATAPID		m_dataPID[64];
PMTDATACIRCLE m_pmtcircle;

PMTDATA		m_PMTdata;
PMTDATA1	m_PMTdata1;
//PACKET处理
bool		m_patHasReceived = false;
bool		m_pmtHasReceived = false;
int m_iIndex = 0;





DWORD	m_requestIdMark;
ZJStreamFilter		m_filter;
UINT32 m_pid = 36;
UINT32 m_pid1 = 69;
UINT32 m_pid2 = 8190;
DWORD dwWaitResult;

HANDLE hEventInit;
HANDLE hEventTuneComplete;
HANDLE hEventAddPIDComplete;
HANDLE hEventRemovePIDComplete;
HANDLE hEventGetStatisticsComplete;
HANDLE hEventGetSITable;
SmsHostApiDeviceHandle hDevice;
SMSHOSTLIB_ERR_CODES_E g_lastError;
SMSHOSTLIB_STATISTICS_ST g_statistics;
CFile g_outFile;

void DataCallback(void*	ClientPtr, 
				  UINT32	ServiceHandle, 
				  UINT8*	pBuffer, 
				  UINT32	BufferSize );

void CallbackFunction( 
					  void*						ClientContext,	
					  SMSHOSTLIB_MSG_TYPE_RES_E	MsgType,		
					  SMSHOSTLIB_ERR_CODES_E		ErrCode,	
					  void* 						pPayload,	
					  UINT32						PayloadLen);

#define VALIDATE_RETVAL(retval,strName) \
	if (retval == SMSHOSTLIB_ERR_OK) \
{ \
	 \
} \
	else \
{ \
	; \
	return 1; \
}

#define VALIDATE_RETVAL_SILENT(retval,strName) \
	if (retval == SMSHOSTLIB_ERR_OK) \
{ \
} \
	else \
{ \
	; \
	return 1; \
}

#define WAIT_CALLBACK(eventName,timeout) \
	dwWaitResult = WaitForSingleObject(eventName,timeout); \
	if (dwWaitResult != WAIT_OBJECT_0) \
{ \
	; \
} \
	if (g_lastError != SMSHOSTLIB_ERR_OK) \
{ \
	; \
}






















/////////////////////////////////////////////////////////////////////////////
// CZZConnectDlg dialog

CZZConnectDlg::CZZConnectDlg(CWnd* pParent /*=NULL*/)
	: CDialog(CZZConnectDlg::IDD, pParent)
{
	//{{AFX_DATA_INIT(CZZConnectDlg)
		// NOTE: the ClassWizard will add member initialization here
	//}}AFX_DATA_INIT
	// Note that LoadIcon does not require a subsequent DestroyIcon in Win32
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);

}







//	m_socketMul.SetMulticastIP(MULTICAST_IP);
//	m_socketMul.SetMulticastPort(MULTICAST_PORT);
//	m_socketMul.CreateReceiver();
//	m_socketMul.StartReceiving();



void CZZConnectDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CZZConnectDlg)
		// NOTE: the ClassWizard will add DDX and DDV calls here
	//}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CZZConnectDlg, CDialog)
	//{{AFX_MSG_MAP(CZZConnectDlg)
	ON_WM_CLOSE()
	ON_WM_DESTROY()
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CZZConnectDlg message handlers

BOOL CZZConnectDlg::OnInitDialog()
{

	CDialog::OnInitDialog();

	// Set the icon for this dialog.  The framework does this automatically
	//  when the application's main window is not a dialog
	SetIcon(m_hIcon, TRUE);			// Set big icon
	SetIcon(m_hIcon, FALSE);		// Set small icon
	
	CenterWindow(GetDesktopWindow());	// center to the hpc screen

	// TODO: Add extra initialization here

	InitSms();
	InitZJ();






//	unsigned char buffer[] = "sdfsdfsdf";
//	sprintf(buffer, "sdfsdfsdf");
//	int iErro = zj_T2Z_SendRetrieved(m_requestIdMark,0,buffer,64);



	return TRUE;  // return TRUE  unless you set the focus to a control
}

void InitPAT(char * packet)
{
	m_header.sync_byte = *packet;
	packet++;
	m_header.error_indicator = (*packet & 0x8000)>>15;
	m_header.payload_indicator = (*packet & 0x4000)>>14;
	m_header.transport_priority = (*packet & 0x2000)>>13;
	m_header.PID = (*packet & 0x1FFFF);
	packet+=2;
	m_header.scrambling = (*packet & 0xC0)>>6;
	m_header.adaptation_field = (*packet & 0x30)>>4;
	m_header.counter = (*packet & 0xF);

}

bool DisposePacket( char * packet )
{
//	InitPAT(packet);
	int iSize = sizeof(TSHeader);

	memcpy(&m_header,packet,iSize);


	char buf[5];
	memset(buf,0,5);

	memcpy(buf,packet,4);

	memcpy(&m_header,buf,4);
/*
	memcpy(&m_header,packet,4);
*/

	int nPID = m_header.PID;

	if( nPID == 0x0000 )		//PAT
	{	
		if( m_patHasReceived )
			return true;

		memset(m_pmt,0,64*sizeof(PMTPIDITEM));
		DisposePAT( packet+4 );
		m_patHasReceived = true;
		return true;
	}

	if( !m_patHasReceived )
		return false;
	else
	{
		//PMT
		for( int i = 0 ; i < 64 ; i++ )
		{
			if( nPID == m_pmt[i].pmt_pid )
			{
				DisposePMT( packet+4 );
				m_pmtHasReceived = true;
			}

		}
		return true;
	}

	if( !m_pmtHasReceived )		//音频视频其他
		return false;
	else
	{
		for( int i = 0 ; i < 64 ; i++ )
		{
			if( nPID == m_dataPID[i].pid )
				DisPoseData( packet+4 );
		}
		
	}
	
	

	return true;
}


bool DisPoseData( char * packet )
{
	return true;
}

bool DisposePMT( char * packet )
{
	char * pointerMark = packet;

	//前64
	int iSize = sizeof(PMTDATA); 
	int iSize1 = sizeof(PMTDATA1); 
	memcpy( &m_PMTdata,packet,iSize );
	packet += iSize;
	//接着的32
	memcpy( &m_PMTdata1,packet,iSize1 );
	packet += iSize1;


	//N1循环的字节数
	int cal = m_PMTdata.section_length - 12 + 3 - m_PMTdata1.program_info_length - 4;

	//判断循环结束的地址
	pointerMark = pointerMark + m_PMTdata.section_length + 3;


	//N1开始指针位置
	packet += m_PMTdata1.program_info_length;

	m_iIndex = 0;
	while( packet != pointerMark )
	{
		//stramtype:第一字节
		BYTE istreamType;
		memcpy( &istreamType,packet,1 );
		m_dataPID[m_iIndex].type = istreamType;
		packet+=1;
		//后4字节
		memcpy( &m_pmtcircle,packet,sizeof(PMTDATACIRCLE) );
		packet+= sizeof(PMTDATACIRCLE);

		m_dataPID[m_iIndex].pid = m_pmtcircle.elemantry_pid;
		
		//description循环
		packet += m_pmtcircle.es_info_length;

		m_iIndex++;
	}
	




	return true;
}



bool DisposePAT( char * packet )
{
	int iSize = sizeof(PAT); 
	memcpy( &m_pat,packet,iSize );
	packet += iSize;
	int n = (m_pat.section_length - 9)/4;


	int iItemSize = sizeof(PATCIRCLE);
	PATCIRCLE circle;
	for( int i = 0 ; i < n ; i++ )
	{
		memcpy( &circle, packet,iItemSize );
		packet += iItemSize;
		m_pmt[i].channel_number = circle.program_number;
		m_pmt[i].pmt_pid = circle.PID;
	}
	return true;
}


			



bool ParseTS( char * buf,int iLength )
{
	int iSize = sizeof(m_buf);
	if( iLength + m_lLength > iSize )		//缓冲长度不够
		return false;

	memcpy( m_buf+m_lLength,buf,iLength );
	m_lLength += iLength;
	char * pCurrent = NULL;
	pCurrent = m_buf;

	while( m_lLength >= ONE_PACKET_SIZE )
	{
		memcpy( m_packet,pCurrent,ONE_PACKET_SIZE );
		if( m_packet[0] != 0x47 )
			::AfxMessageBox(_T("不是188对应"));
		DisposePacket( m_packet );
		pCurrent += ONE_PACKET_SIZE;
		m_lLength -= ONE_PACKET_SIZE;
	}

	memmove( m_buf,pCurrent,m_lLength );

 
	return true;
}





int InitSms()
{
	SMSHOSTLIB_ERR_CODES_E retval;
	bool bDemodulatorLocked;

	hEventInit = CreateEvent(NULL,FALSE,FALSE,NULL);
	hEventTuneComplete = CreateEvent(NULL,FALSE,FALSE,NULL);
	hEventAddPIDComplete = CreateEvent(NULL,FALSE,FALSE,NULL);
	hEventRemovePIDComplete = CreateEvent(NULL,FALSE,FALSE,NULL);
	hEventGetStatisticsComplete = CreateEvent(NULL,FALSE,FALSE,NULL);
	hEventGetSITable = CreateEvent(NULL,FALSE,FALSE,NULL);

	SMSHOSTLIB_API_INITLIB_PARAMS_ST initparams;
	initparams.Size = sizeof(SMSHOSTLIB_API_INITLIB_PARAMS_ST);
	initparams.pCtrlCallback = CallbackFunction;
	initparams.pDataCallback = DataCallback;
	initparams.CommType = SMSHOSTLIB_COMM_SDIO;
	initparams.pCommParam = NULL;
	initparams.WorkingDirectory = 
		"\\Program Files\\SianoSmsUtils";		
	initparams.IsSupportMultInstances = TRUE;
	retval = SmsHostApiLibInit(&initparams);

	DEBUGMSG(TRUE, (TEXT("SmsHostApiLibInit %d\r\n"), retval));

	VALIDATE_RETVAL(retval,"InitLib");

	UINT nDevices;
	SmsHostApiDeviceData_ST deviceData;
	retval = SmsHostApiGetDevicesList(1,&nDevices,&deviceData);
	DEBUGMSG(TRUE, (TEXT("SmsHostApiGetDevicesList %d\r\n"), retval));
	VALIDATE_RETVAL(retval,"GetDevicesList");
//	cout << nDevices << " device(s) returned." << endl;

	retval = SmsHostApiDeviceInit_Req(deviceData.DeviceName,SMSHOSTLIB_DEVMD_DVBT,12000000,NULL,&hDevice);
	DEBUGMSG(TRUE, (TEXT("SmsHostApiDeviceInit_Req %d\r\n"), retval));
	VALIDATE_RETVAL(retval,"InitDevice");
	WAIT_CALLBACK(hEventInit,10000);

	SMSHOSTLIB_FREQ_BANDWIDTH_ET bandwidth = BW_8_MHZ;
	retval = SmsHostApiTune_Req(hDevice,602000000,bandwidth);
	DEBUGMSG(TRUE, (TEXT("SmsHostApiTune_Req %d\r\n"), retval));
	VALIDATE_RETVAL(retval,"Tune");
	WAIT_CALLBACK(hEventTuneComplete,1000);
	bDemodulatorLocked = false;
	for (int i = 0; i < 10 && !bDemodulatorLocked; i++)
	{
		Sleep(50);
		retval = SmsHostApiGetStatistics_Req(hDevice);
		DEBUGMSG(TRUE, (TEXT("SmsHostApiGetStatistics_Req %d\r\n"), retval));
		VALIDATE_RETVAL_SILENT(retval,"GetStatistics");
		WAIT_CALLBACK(hEventGetStatisticsComplete,1000);

		if (g_statistics.IsDemodLocked == 1)
		{
			bDemodulatorLocked = true;
		}
	}

	if (!bDemodulatorLocked)
	{
//		cout << "No transmission found, aborting!" << endl;
		return 1;
	}

	retval = SmsHostApiAddPidFilter_Req(hDevice,m_pid);
	DEBUGMSG(TRUE, (TEXT("SmsHostApiAddPidFilter_Req %d\r\n"), retval));


	

	retval = SmsHostApiAddPidFilter_Req(hDevice,m_pid1);
	DEBUGMSG(TRUE, (TEXT("SmsHostApiAddPidFilter_Req  %d\r\n"), retval));


	retval = SmsHostApiAddPidFilter_Req(hDevice,m_pid2);
	DEBUGMSG(TRUE, (TEXT("SmsHostApiAddPidFilter_Req %d\r\n"), retval));


	WAIT_CALLBACK(hEventAddPIDComplete,1000);



	g_outFile.Open( _T("dump.ts"),CFile::modeCreate|CFile::modeWrite );
	int nSecondsSleep = 10;
//	cout << "Sleeping " << nSecondsSleep << " seconds..." << endl;
//	Sleep(nSecondsSleep * 1000);



	CloseHandle(hEventTuneComplete);
	CloseHandle(hEventInit);
	CloseHandle(hEventAddPIDComplete);
	CloseHandle(hEventGetStatisticsComplete);

	return 0;

	
}



void CallbackFunction( 
					  void*						ClientContext,	
					  SMSHOSTLIB_MSG_TYPE_RES_E	MsgType,		
					  SMSHOSTLIB_ERR_CODES_E		ErrCode,		
					  void* 						pPayload,		
					  UINT32						PayloadLen) 	
{
	g_lastError = ErrCode;
	DEBUGMSG(TRUE,(TEXT("CallbackFunction\r\n")));
	switch(MsgType)
	{
	case SMSHOSTLIB_MSG_INIT_DEVICE_RES:
		SetEvent(hEventInit);
		break;
	case SMSHOSTLIB_MSG_ADD_PID_FILTER_RES:
		SetEvent(hEventAddPIDComplete);
		break;
	case SMSHOSTLIB_MSG_REMOVE_PID_FILTER_RES:
		SetEvent(hEventRemovePIDComplete);
		break;
	case SMSHOSTLIB_MSG_TUNE_RES:
		SetEvent(hEventTuneComplete);
		break;
	case SMSHOSTLIB_MSG_GET_STATISTICS_RES:
		memcpy(&g_statistics,pPayload,sizeof(SMSHOSTLIB_STATISTICS_ST));
		SetEvent(hEventGetStatisticsComplete);
		break;
	case SMSHOSTLIN_MSG_GET_SI_TBL_RES:	    
		SetEvent(hEventGetSITable);
		DEBUGMSG(TRUE,(TEXT("SMSHOSTLIN_MSG_GET_SI_TBL_RES\r\n")));
		break;
	}	
}


int InitZJ()
{
	void * p = NULL;
	int iNodeCount = 512;
	p = &iNodeCount;
	ZJ_T2ZRegFunction reg;
	reg.m_zj_Z2T_SetRetrieveFilter = zj_Z2T_SetRetrieveFilter;
	reg.m_zj_Z2T_StopRetrieve = zj_Z2T_StopRetrieve;

	char  directory[64];
	memset(directory,0,64);
	sprintf(directory, "\\Program Files\\SianoSmsUtils");
	ZJRESULT error = zj_T2Z_Init( (void*)&iNodeCount,&reg,directory );

/*
	char buf[64];
	memset(buf,0,sizeof(64));
	sprintf(buf, MULTICAST_IP);

	char buflocalIP[64];
	memset(buflocalIP,0,sizeof(64));
	sprintf(buflocalIP, "127.0.0.1");


	int MulticastPort = MULTICAST_PORT;
	ZJRESULT error1 = zj_T2Z_SetMulticast(buf,MulticastPort,buflocalIP);
*/
	return 1;
}








void DataCallback(void*	ClientPtr, 
				  UINT32	ServiceHandle, 
				  UINT8*	pBuffer, 
				  UINT32	BufferSize )
{

	ParseTS( (char *)pBuffer,BufferSize );


//	int iError = zj_T2Z_SendRetrieved(m_requestIdMark,0,pBuffer,BufferSize);

	if( g_outFile.m_hFile != CFile::hFileNull )
	{
		g_outFile.SeekToEnd();
		g_outFile.Write( pBuffer,BufferSize );
	}

}

ZJRESULT zj_Z2T_SetRetrieveFilter(unsigned long requestId, ZJStreamFilter filter)
{
//	m_filter = filter;
	UINT32	pActSize = 0;
	UINT8	pTableBuff[4096];
	memset(pTableBuff,0,4096);
	int ie = SmsHostDvbGetSITable_Req(0,0,4096,&pActSize,pTableBuff);
	DEBUGMSG(TRUE, (TEXT("SmsHostDvbGetSITable_Req %d\r\n"), ie));

	m_requestIdMark = requestId;
	ZJRESULT ret=0;


	return ret; 
}

ZJRESULT zj_Z2T_StopRetrieve(unsigned long requestId )
{
	ZJRESULT ret=0;

	return ret; 
}


void CZZConnectDlg::OnClose() 
{
	// TODO: Add your message handler code here and/or call default
	if( g_outFile.m_hFile != CFile::hFileNull )
	{
		g_outFile.Close();	
	}


	SMSHOSTLIB_ERR_CODES_E	retval = SmsHostApiRemovePidFilter_Req(hDevice,m_pid);
	DEBUGMSG(TRUE, (TEXT("SmsHostApiRemovePidFilter_Req %d\r\n"), retval));
	retval = SmsHostApiRemovePidFilter_Req(hDevice,m_pid1);
	DEBUGMSG(TRUE, (TEXT("SmsHostApiRemovePidFilter_Req %d\r\n"), retval));
	retval = SmsHostApiRemovePidFilter_Req(hDevice,m_pid2);

	DEBUGMSG(TRUE, (TEXT("SmsHostApiRemovePidFilter_Req %d\r\n"), retval));

	

	WAIT_CALLBACK(hEventRemovePIDComplete,1000);

	SmsHostApiLibTerminate();


	CloseHandle(hEventRemovePIDComplete);
	CloseHandle(hEventGetSITable);


	CDialog::OnClose();
}

void CZZConnectDlg::OnDestroy() 
{
	CDialog::OnDestroy();
	
	// TODO: Add your message handler code here
	
}