www.pudn.com > AVChat0926.rar > CPreviewAdmin.cpp

// 
// CPreviewAdmin.cpp 
// 
 
/*-----------------------------------------------------*\ 
			HQ Tech, Make Technology Easy!        
 More information, please go to http://hqtech.nease.net. 
/*-----------------------------------------------------*/ 
 
#include "stdafx.h" 
#include  
#include "CPreviewAdmin.h" 
 
#include "CDXGraph.h" 
#include "CDXFilter.h" 
#include "CAVDevice.h" 
#include "CVideoWindow.h" 
#include "GlobalDefs.h" 
#include "UDsUtils.h" 
 
#include "CVideoCaptureFilter2.h" 
#include "CAudioCaptureFilter2.h" 
 
#ifdef _DEBUG 
#define new DEBUG_NEW 
#undef THIS_FILE 
static char THIS_FILE[] = __FILE__; 
#endif 
 
///////////////////////////////////////////////////////////////////////// 
CPreviewAdmin::CPreviewAdmin() 
{ 
	mGraph   	 = NULL; 
	mVideoWindow = NULL; 
	mVideoDevice = NULL; 
	mAudioDevice = NULL; 
	 
	mVideoFilter = NULL; 
	mAudioFilter = NULL; 
	mVideoRenderer = NULL; 
	mAudioRenderer = NULL; 
} 
 
CPreviewAdmin::~CPreviewAdmin() 
{ 
	Deactivate(); 
} 
 
void CPreviewAdmin::SetAVDevice(CAVDevice * inVideo, CAVDevice * inAudio) 
{ 
	mVideoDevice = inVideo; 
	mAudioDevice = inAudio; 
} 
 
void CPreviewAdmin::SetVideoWindow(CVideoWindow * inWindow) 
{ 
	mVideoWindow = inWindow; 
} 
 
BOOL CPreviewAdmin::Activate(void) 
{ 
	BOOL pass = CreateGraph(); 
	if (pass) 
	{ 
		pass = CreateInputFilters(); 
	} 
	if (pass) 
	{ 
		pass = CreateOutputFilters(); 
	} 
	if (pass) 
	{ 
		pass = ConnectFilters(); 
	} 
	if (pass) 
	{ 
		pass = AfterBuildGraph(); 
	} 
	return pass; 
} 
 
void CPreviewAdmin::Deactivate(void) 
{ 
	StopGraph(); 
 
	ReleaseInputFilters(); 
	ReleaseOutputFilters(); 
	DeleteGraph(); 
} 
 
BOOL CPreviewAdmin::CreateGraph(void) 
{ 
	mGraph = new CDXGraph(); 
	BOOL pass = mGraph->Create(); 
	return pass; 
} 
 
void CPreviewAdmin::DeleteGraph(void) 
{ 
	// Clean up the video window 
	if (mVideoWindow) 
	{ 
		mVideoWindow->SetGraph(0); 
	} 
	SAFE_DELETE(mGraph); 
} 
 
BOOL CPreviewAdmin::CreateInputFilters(void) 
{ 
	BOOL pass = FALSE; 
 
	mAudioFilter = new CAudioCaptureFilter2(mGraph->GetGraph()); 
	((CAudioCaptureFilter2 *)mAudioFilter)->SetDevice(mAudioDevice); 
	pass |= mAudioFilter->CreateFilter(); 
	 
	return pass; 
} 
 
void CPreviewAdmin::ReleaseInputFilters(void) 
{ 
	SAFE_DELETE(mVideoFilter); 
	SAFE_DELETE(mAudioFilter); 
} 
 
BOOL CPreviewAdmin::CreateOutputFilters(void) 
{ 
	BOOL pass = TRUE; 
	mAudioRenderer = new CDXFilter(mGraph->GetGraph(),  
		CLSID_DSoundRender, "Audio Renderer"); 
	pass = mAudioRenderer->CreateFilter(); 
	 
	return pass; 
} 
 
void CPreviewAdmin::ReleaseOutputFilters(void) 
{ 
	SAFE_DELETE(mVideoRenderer); 
	SAFE_DELETE(mAudioRenderer); 
} 
 
// Connect input filters to output filters 
BOOL CPreviewAdmin::ConnectFilters(void) 
{ 
	BOOL pass   = FALSE; 
	IPin * pOut = NULL; 
	IPin * pIn  = NULL; 
 
	// Connect audio capture filter to audio renderer 
	if (mAudioDevice->IsDeviceAvailable()) 
	{ 
		pOut = mAudioFilter->GetPin(FALSE); 
		pIn  = mAudioRenderer->GetPin(TRUE); 
		pass = mGraph->ConnectFilters(pOut, pIn); 
	} 
 
	// Connect video filters 
	if (pass && mVideoDevice->IsDeviceAvailable()) 
	{ 
		// DV camcorder 
		if (mVideoDevice->IsDVDevice()) 
		{ 
			pOut = mVideoFilter->GetPin(FALSE, "DV Vid Out"); 
			pIn  = mVideoRenderer->GetPin(TRUE); 
			pass = RenderDVVideo(mGraph, pOut, pIn); 
		} 
		else // USB camera 
		{ 
			pOut = mVideoFilter->GetPin(FALSE, "Capture"); 
			pIn  = mVideoRenderer->GetPin(TRUE); 
			// Try intelligent connect 
			HRESULT hr = mGraph->GetGraph()->Connect(pOut, pIn); 
			pass = SUCCEEDED(hr); 
		} 
	} 
 
	return pass; 
} 
 
BOOL CPreviewAdmin::AfterBuildGraph(void) 
{ 
	if (mVideoWindow) 
	{ 
		mVideoWindow->SetGraph(mGraph); 
		// Auto-play 
		PlayGraph(); 
		return TRUE; 
	} 
	return FALSE; 
} 
 
BOOL CPreviewAdmin::PlayGraph(void) 
{ 
	if (mGraph) 
	{ 
		mGraph->Run(); 
		return TRUE; 
	} 
	return FALSE; 
} 
 
BOOL CPreviewAdmin::PauseGraph(void) 
{ 
	if (mGraph) 
	{ 
		mGraph->Pause(); 
		return TRUE; 
	} 
	return FALSE; 
} 
 
BOOL CPreviewAdmin::StopGraph(void) 
{ 
	if (mGraph) 
	{ 
		mGraph->Stop(); 
		return TRUE; 
	} 
	return FALSE; 
} 
 
void CPreviewAdmin::ShowVideoCapturePropertyPage(void) 
{ 
	if (!mVideoDevice->IsDVDevice()) 
	{ 
		UDsUtils::ShowFilterPropertyPage(mVideoFilter->GetFilter()); 
 
		// Update new resolution? 
		long format = ((CVideoCaptureFilter2 *)mVideoFilter)->GetResolution(); 
		mVideoDevice->SetVideoResolution(format); 
	} 
} 
 
void CPreviewAdmin::ShowAudioCapturePropertyPage(void) 
{ 
	UDsUtils::ShowFilterPropertyPage(mAudioFilter->GetFilter()); 
 
	// Update new connector? 
	long index = ((CAudioCaptureFilter2 *)mAudioFilter)->GetConnector(); 
	mAudioDevice->SetAudioConnector(index); 
} 
 
// Utilities 
// Render DV to renderer, inserting a DV decoder filter 
BOOL CPreviewAdmin::RenderDVVideo(CDXGraph * inGraph, IPin * inDVPin, IPin * inRenderedPin) 
{ 
	BOOL pass   = FALSE; 
	IPin * pOut = NULL; 
	IPin * pIn  = NULL; 
 
	if (inGraph) 
	{ 
		// Add DV video decoder 
		CDXFilter * pDecoder = NULL; 
		pDecoder = new CDXFilter(inGraph->GetGraph(), CLSID_DVVideoCodec, 
			"DV Video Decoder"); 
		pDecoder->CreateFilter(); 
		// Settings on DV Video Decoder 
		IIPDVDec *  pIPDVDec = NULL;  
		pDecoder->QueryInterface(IID_IIPDVDec, (void**)&pIPDVDec); 
		if (pIPDVDec) 
		{ 
			pIPDVDec->Release(); 
			// DVRESOLUTION_HALF? DVRESOLUTION_QUARTER? 
			pIPDVDec->put_IPDisplay(DVRESOLUTION_HALF); 
		} 
 
		pIn  = pDecoder->GetPin(TRUE); 
		pass = inGraph->ConnectFilters(inDVPin, pIn); 
 
		pOut = pDecoder->GetPin(FALSE); 
		pass = inGraph->ConnectFilters(pOut, inRenderedPin); 
 
		pDecoder->Detach(); 
		delete pDecoder; 
	} 
 
	return pass; 
}