mp_apdlg.cpp

一个在Linux下开发的IP摄像头的驱动程序及控制软件

	{
		scResult = AvSynchronizer_GetCurrentSnapShot (g_Channel_Info[nCnt].hChannel, &tSnapShot, (g_nAVRawDBAskType << 16) | SPECIFY_FMT);

		assert ( IS_SUCCESS (scResult));

		if (IS_SUCCESS (scResult))
		{
			sprintf(szFileName, "c:\\test%d.%s", nCnt + 1, g_szAVCBExtName);
			fp = fopen ( szFileName, "wb");
			assert ( fp );
			if (fp)
			{
				fwrite ( tSnapShot.pDataStart, tSnapShot.dwdataSize, 1, fp);
				fclose (fp );
			}
			scResult = AvSynchronizer_FreePicture(&tSnapShot);
		}
	}
}


void CMP_APDlg::OnBnClickedButton3()
{
	CRect rect;

	::GetWindowRect(g_Channel_Info[g_iFocus].hDisplay, &rect);
	::SetWindowPos(g_Channel_Info[g_iFocus].hDisplay, NULL, 
		rect.left, rect.top, rect.Width() + 10, rect.Height() + 10, 
		SWP_NOMOVE | SWP_NOZORDER);
}


void CMP_APDlg::OnBnClickedCheckDisplay()
{
	g_Channel_Info[g_iFocus].bNoDisplay = CButton_ChDisplay.GetCheck() ? FALSE : TRUE;

	TUPDATECHANNELOPTION tOpt;

	ZeroMemory(&tOpt, sizeof(tOpt));

	tOpt.dwFlags = UPCH_VIDEOOUT;
	tOpt.bVideoOut = !g_Channel_Info[g_iFocus].bNoDisplay;
	AvSynchronizer_UpdateChannelSettings(g_Channel_Info[g_iFocus].hChannel, tOpt);
}



void CMP_APDlg::OnBnClickedCheckEventrecord()
{
	g_Channel_Info[g_iFocus].bEventRecord = m_btnEventDrivenRec.GetCheck() ? TRUE : FALSE;

	if (g_Channel_Info[g_iFocus].bEventRecord)
	{
		TMediaLocationOption tLocOption;
		memset(&tLocOption, 0, sizeof(tLocOption));
		tLocOption.pszLocation = g_Channel_Info[g_iFocus].chDBLocation;
		tLocOption.dwMaxFileSize = 1024*1024*300;
		tLocOption.dwMaxIndexNumber = 20240;
		tLocOption.dwPreBufferSecond = 10;
		tLocOption.dwDIMask = 1;
		g_Channel_Info[g_iFocus].hDBLocation = NULL;

		EnterCriticalSection(&g_CS[g_iFocus]);
		if (MediaDB_OpenLocation(g_hDatabase, &tLocOption, &(g_Channel_Info[g_iFocus].hDBLocation)) != S_OK)
			MediaDB_CreateLocation(g_hDatabase, &tLocOption, &(g_Channel_Info[g_iFocus].hDBLocation));
		LeaveCriticalSection(&g_CS[g_iFocus]);
	}
	else
	{
		EnterCriticalSection(&g_CS[g_iFocus]);
		if ( (g_Channel_Info[g_iFocus].hDBLocation) != NULL )
		{
			MediaDB_CloseLocation(g_Channel_Info[g_iFocus].hDBLocation);
			g_Channel_Info[g_iFocus].hDBLocation = NULL;
		}
		LeaveCriticalSection(&g_CS[g_iFocus]);
		g_Channel_Info[g_iFocus].bEventRecording = FALSE;
		g_Channel_Info[g_iFocus].dwCBCount = 0;
	}
}

void CMP_APDlg::OnBnClickedShrinkWnd()
{
	CRect rect;

	::GetWindowRect(g_Channel_Info[g_iFocus].hDisplay, &rect);
	::SetWindowPos(g_Channel_Info[g_iFocus].hDisplay, NULL, 
		rect.left, rect.top, rect.Width() - 10, rect.Height() - 10, 
		SWP_NOMOVE | SWP_NOZORDER);
}



void CMP_APDlg::OnBnClickedCheckSwap12()
{
	CButton *pButton = (CButton *) GetDlgItem(IDC_CHECK_SWAP12);
	TUPDATECHANNELOPTION tOpt;

	ZeroMemory(&tOpt, sizeof(tOpt));

	if (pButton->GetCheck())
	{
		// swap 12, 1-2, 2-1
		g_Channel_Info[0].hDisplay = GetDlgItem(IDC_STATIC_DISPLAY2)->m_hWnd;
		g_Channel_Info[1].hDisplay = GetDlgItem(IDC_STATIC_DISPLAY1)->m_hWnd;

	}
	else
	{
		// swap back, 1-1, 2-2
		g_Channel_Info[0].hDisplay = GetDlgItem(IDC_STATIC_DISPLAY1)->m_hWnd;
		g_Channel_Info[1].hDisplay = GetDlgItem(IDC_STATIC_DISPLAY2)->m_hWnd;
	}

	tOpt.dwFlags = UPCH_VIDEOOUT | UPCH_RESTORE_WINPROC;
	tOpt.bVideoOut = FALSE;
	AvSynchronizer_UpdateChannelSettings(g_Channel_Info[0].hChannel, tOpt);
	AvSynchronizer_UpdateChannelSettings(g_Channel_Info[1].hChannel, tOpt);

	tOpt.dwFlags = UPCH_VIDEOOUT | UPCH_WIN_HANDLE;
	tOpt.bVideoOut = TRUE;
	tOpt.hWnd = g_Channel_Info[0].hDisplay;
	AvSynchronizer_UpdateChannelSettings(g_Channel_Info[0].hChannel, tOpt);
	tOpt.hWnd = tOpt.hWnd = g_Channel_Info[1].hDisplay;
	AvSynchronizer_UpdateChannelSettings(g_Channel_Info[1].hChannel, tOpt);
}
void CMP_APDlg::OnBnClickedButTx()
{
	if (m_hAudioCapCh)
		TxOnChannel(g_iFocus);
}

void CMP_APDlg::OnBnClickedButTxBrowse()
{
	char szFileName[MAX_PATH];

	m_editTxFileName.GetWindowText(szFileName, MAX_PATH);
	CFileDialog dlg(TRUE, "", szFileName);

	if (dlg.DoModal() == IDOK)
	{
		m_editTxFileName.SetWindowText(dlg.GetPathName());
	}
}


void CMP_APDlg::OnBnClickedCheckNoborder()
{
	CButton *pButton = (CButton *) GetDlgItem(IDC_CHECK_NOBORDER);
	TUPDATECHANNELOPTION tOpt;

	ZeroMemory(&tOpt, sizeof(tOpt));
	if (pButton->GetCheck())
	{
		tOpt.dwFlags = UPCH_IGNORE_BORDER;
		tOpt.bIgnoreBorder = TRUE;

		AvSynchronizer_UpdateChannelSettings(g_Channel_Info[g_iFocus].hChannel, tOpt);
		g_Channel_Info[g_iFocus].bNoBorder = TRUE;
	}
	else
	{
		tOpt.dwFlags = UPCH_IGNORE_BORDER;
		tOpt.bIgnoreBorder = FALSE;

		AvSynchronizer_UpdateChannelSettings(g_Channel_Info[g_iFocus].hChannel, tOpt);
		g_Channel_Info[g_iFocus].bNoBorder = FALSE;
	}
}

void CMP_APDlg::OnBnClickedButtonTalk()
{
	if (m_hAudioCapCh)
		TalkOneChannel(g_iFocus);
}
 
void CMP_APDlg::OnBnClickedButtonPause()
{
	AvSynchronizer_SetChannelOption(g_Channel_Info[g_iFocus].hChannel, SETCH_RESUME_PLAYING, FALSE, 0);
	DataBroker_PauseMediaStreaming(g_Channel_Info[g_iFocus].hConn);
	g_Channel_Info[g_iFocus].eRtspState = eRtspStPause;
	CheckUI();
}
void CMP_APDlg::OnBnClickedButtonPlay()
{
	AvSynchronizer_SetChannelOption(g_Channel_Info[g_iFocus].hChannel, SETCH_RESUME_PLAYING, TRUE, 0);

	DataBroker_ResumeMediaStreaming(g_Channel_Info[g_iFocus].hConn);
	g_Channel_Info[g_iFocus].eRtspState = eRtspStPlay;
	CheckUI();
}

void CMP_APDlg::OnBnClickedCheckNonYuv()
{
	DWORD dwFlags;

	AvSynchronizer_GetFlags(g_hAvSync, &dwFlags);

	dwFlags &= ~FORCE_NON_YUV;

	CButton *pBug = (CButton *) GetDlgItem(IDC_CHECK_NON_YUV);
	if (pBug->GetCheck())
		dwFlags |= FORCE_NON_YUV;

	AvSynchronizer_SetFlags(g_hAvSync, dwFlags);
}

void CMP_APDlg::OnBnClickedConnectAll()
{
	for (int nCnt = 0; nCnt < g_nMaxChannel; nCnt++)
	{
		g_iFocus = nCnt;		
		if (strlen(g_Channel_Info[g_iFocus].chServer_Type) == 0)
			continue;
		OnBnClickedButtonConnect();
	}	 
}

//=================================================================
//	Function Group: User Function Start Line
//=================================================================
//=================================================================
//	Function   : Initial_Module
//	Description: initial DataBroker and AvSyhchronizer
//				 
//	Parameters :                     
//	Return     : 
//=================================================================
int CMP_APDlg::Initial_Module(void)
{
	// step1. Initial DB
	SCODE sRet;
	char szBuf[MAX_PATH];

	TMediaDBInitOption tInitOption;
	tInitOption.pszDatabasePath = g_chDBPath;
	tInitOption.dwVersion = DATABASE_VERSION;
	sRet = MediaDB_Initial(&g_hDatabase,&tInitOption,DB_CREATE | DB_OPEN);
	if (IS_FAIL(sRet))
	{
		sprintf(szBuf, "MediaDB_Initial failed with error %X", sRet);
		MessageBox(szBuf, "Error", MB_OK);
		return -1;
	}
     
    // step2. initial DataBroker

	sRet = DataBroker_Initial(&g_hDataBroker, g_nMaxChannel * 2,DataBrokerStatusCallBack,DataBrokerAVCallBack,
		mctJPEG | mctH263 | mctMP4V | mctG7221 | mctG729A | mctAAC | mctGAMR, 0,
		DATABROKER_VERSION);
	if (IS_FAIL(sRet))
	{
		sprintf(szBuf, "DataBroker_Initial failed with error %X", sRet);
		MessageBox(szBuf, "Error", MB_OK);
		return -1;
	}
	
#ifdef STATICLIB
	DataBroker_Use2K();
	DataBroker_Use3K();
	DataBroker_Use5K();
	DataBroker_Use7K();
#endif	

	if (g_szProxy[0] != 0)
	{
		TDataBrokerOptions tDBOpt;

		memset(&tDBOpt, 0, sizeof(tDBOpt));
		tDBOpt.bEnableProxy = TRUE;
		tDBOpt.dwProxyPort = g_nProxyPort;
		strcpy(tDBOpt.szProxyName , g_szProxy);
		tDBOpt.dwFlags = eOptEnableProxy | eOptProxyPort | eOptProxyName;

		DataBroker_SetOptions(g_hDataBroker, &tDBOpt);
	}

	// step3. initial AvSyhchronizer
	DWORD dwExtra = CHANGE_TIME_PRECISION;

	sRet = AvSynchronizer_InitialEx(&g_hAvSync, AvSyhchronizerStatusCallBack,
		AvSyhchronizerDisplayCallBack,
		this->m_hWnd, AUDIOOUT_FOCUS_STICKY, g_SynTime, AVSYNCHRONIZER_VERSION, 
		g_dwInitOpt | dwExtra, RGB(82, 130, 148));
	if (IS_FAIL(sRet))
	{
		sprintf(szBuf, "AvSynchronizer_Initial failed with error %X", sRet);
		MessageBox(szBuf, "Error", MB_OK);
		return -1;
	}

#ifdef STATICLIB
	AvSynchronizer_UseAllCodecs();
	AvSynchronizer_UseAudioOut();
	AvSynchronizer_ShowCaption();
#endif	

	if (sRet == AVSYNCHRONIZER_S_NO_AUDIO_PLAY)
	{
		m_bNoAudio = TRUE;
	}

	PacketMaker_Initial(&m_hPacketMaker, 0, PACKET_MAKER_VERSION);
	// step4. create connection of the DataBroker
	for ( int i = 0 ; i < g_nMaxChannel ; i ++ )
	{
		sRet = DataBroker_CreateConnection(g_hDataBroker, &(g_Channel_Info[i].hConn));
		if (IS_FAIL(sRet))
		{
			sprintf(szBuf, "DataBroker_CreateConnection for channel %d failed with error %X", i + 1, sRet);
			MessageBox(szBuf, "Error", MB_OK);
			return -1;
		}

		if (g_Channel_Info[i].bNetPacketCallback)
		{
			sRet = DataBroker_CreateInputEx(g_hDataBroker, &g_Channel_Info[i].hDataBrokerInput);
			if (IS_FAIL(sRet))
			{
				sprintf(szBuf, "DataBroker_CreateInputEx for channel %d failed with error %X", i + 1, sRet);
				MessageBox(szBuf, "Error", MB_OK);
				return -1;
			}
		}
		int nRet = CreateAvSyncChannel (i);
		if (nRet != 0)
			return -1;
	}

	// if one channel mode and show dz is enabled
	if (g_nMaxChannel == 1 && g_dwShowDZWnd != 0)
	{
		TDIGITALZOOMPARAM tDigitalZoom;
		ZeroMemory(&tDigitalZoom, sizeof(tDigitalZoom));

		tDigitalZoom.bCanvasWin = FALSE;
		GetDlgItem(IDC_STATIC_DZWND)->GetWindowRect(&tDigitalZoom.unCanvas.rectTarget);
		tDigitalZoom.bDisplayed = TRUE;
		tDigitalZoom.bZoomEnabled = TRUE;
		tDigitalZoom.bZoomWin = FALSE;

		GetDlgItem(IDC_STATIC_DZWND_CHILD)->GetWindowRect(&tDigitalZoom.unZoom.rectZoomArea);
		GetDlgItem(IDC_STATIC_DZWND)->SetWindowPos(GetDlgItem(IDC_STATIC_DZWND_CHILD), 0, 0, 0, 0, SWP_NOSIZE |
			SWP_NOMOVE);

		AvSynchronizer_SetChannelOption(g_Channel_Info[0].hChannel, SETCH_DIGITAL_ZOOM,
			(DWORD) &tDigitalZoom, DZ_CANVAS | DZ_CANVAS_DISPLAY | DZ_ZOOM_AREA | DZ_ENABLE_ZOOM);
	}

	ServerUtl_Initial(&m_hServUtil,SERVERUTL_VERSION);

	if (!m_bNoAudio)
	{
		if (InitialAudioCapture() != 0)
		{
			MessageBox("Could not initialize capture device, talk will not be available", "Information", MB_OK);
			return 0;
		}
	}

	return 0;
}
//=================================================================
//	Function   : Release_Module
//	Description: release DataBroker and AvSyhchronizer
//				 
//	Parameters :                     
//	Return     : 
//=================================================================
int CMP_APDlg::Release_Module(void)
{
	// step1. delete connection of DataBroker & close location of DB
	int nOldFocus = g_iFocus;

	for ( int i=0 ; i < g_nMaxChannel ; i ++ )
	{
		g_ExitWait[i] = CreateEvent(NULL, FALSE, FALSE, NULL);
		g_iFocus=i;
		StopRecord_Channel();
		if (g_Channel_Info[i].bConnecting == TRUE ||
			g_Channel_Info[i].chStatus == channelConnecting)
		{
			TRACE("Release_Module: Disconnect_Channel %d\n", i);
			g_Channel_Info[i].bExitBlock = TRUE;

			Disconnect_Channel(i, TRUE);
		}
		else
		{
			TRACE("Release_Module: Set Event %d\n", i);
			SetEvent(g_ExitWait[i]);
		}
		g_Channel_Info[i].bConnecting = FALSE;
	}

	WaitForMultipleObjects(g_nMaxChannel, g_ExitWait, TRUE, INFINITE);

	for ( i = 0 ; i < g_nMaxChannel ; i ++ )
	{
		CloseHandle(g_ExitWait[i]);
		g_iFocus = i;

		AvSynchronizer_DeleteChannel (g_hAvSync, &g_Channel_Info[i].hChannel);
		if (g_Channel_Info[i].hDecoderChannel)
			AvSynchronizer_DeleteDecoderChannel(g_hAvSync, &g_Channel_Info[i].hDecoderChannel);
		if (g_Channel_Info[i].hPacketMakerChannel)
			PacketMaker_DeleteChannel(&g_Channel_Info[i].hPacketMakerChannel);
		if (g_Channel_Info[i].pbyVideoBuff)
			free(g_Channel_Info[i].pbyVideoBuff);
		if (g_Channel_Info[i].pbyAudioBuff)
			free(g_Channel_Info[i].pbyAudioBuff);

		g_Channel_Info[i].hChannel = NULL;

		if (g_Channel_Info[i].pFileMedia)
			fclose(g_Channel_Info[i].pFileMedia);
		if (g_Channel_Info[i].pbyTxData)
			free(g_Channel_Info[i].pbyTxData);

	}
	g_iFocus = nOldFocus;
   
	MediaDB_Release(g_hDatabase);