cmediaplayer.cpp

最近在学习directshow, Directshow实务精选的源代码

//
// CMediaPlayer.cpp
// 

/*-----------------------------------------------------*\
			HQ Tech, Make Technology Easy!       
 More information, please go to http://hqtech.nease.net.
/*-----------------------------------------------------*/

#include "stdafx.h"
#include "defines.h"
#include "CMediaPlayer.h"
#include "CDXGraph.h"
#include "CDXFilter.h"

#include <initguid.h>
#include "FilterNetReceiverGuid.h"

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

/////////////////////////////////////////////////////////////////////
CMediaPlayer::CMediaPlayer()
{
	mGraph         = NULL;
	mSourceFilter  = NULL;
	mINetReceiver  = NULL;
	mSplitter      = NULL;
}

CMediaPlayer::~CMediaPlayer()
{
	Deactive();
}

void CMediaPlayer::SetMediaInfo(CMediaInfo & inInfo)
{
	mMediaInfo = inInfo;
}

BOOL CMediaPlayer::Activate(void)
{
	Deactive();

	BOOL pass = CreateGraph();
	if (pass)
	{
		mSourceFilter = new CDXFilter(mGraph->GetGraph(),
			CLSID_NetReceiver, "Net Source");
		pass = mSourceFilter->CreateFilter();
		mSourceFilter->GetFilter()->QueryInterface(IID_INetReceiver,
			(void**) &mINetReceiver);
	}

	if (pass)
	{
		// Create splitter
		GUID    guid = GUID_NULL;
		switch (mMediaInfo.mFileType)
		{
		case FT_MPEG1:
		case FT_MP3:
			guid = CLSID_MPEG1Splitter;
			break;
		case FT_MPEG2:
			guid = CLSID_MMSPLITTER;
			break;
		case FT_AVI:
			guid = CLSID_AviSplitter;
			break;
		}
		mSplitter = new CDXFilter(mGraph->GetGraph(), guid, "Splitter");
		pass = mSplitter->CreateFilter();
	}

	return pass;
}

BOOL CMediaPlayer::ConnectFilters(void)
{
	BOOL pass = FALSE;
	if (mGraph && mSourceFilter && mSplitter)
	{
		// Connect source filter to splitter
		IPin * pOut = mSourceFilter->GetPin(FALSE);
		IPin * pIn  = mSplitter->GetPin(TRUE);
		pass = mGraph->ConnectFilters(pOut, pIn);
		if (pass)
		{
			// Connect output pins of splitter to renderers
			pass = RenderAllOutputPins(mSplitter->GetFilter());
		}
	}
	return pass;
}

void CMediaPlayer::Deactive(void)
{
	StopGraph();
	SAFE_RELEASE(mINetReceiver);
	SAFE_DELETE(mSourceFilter);
	SAFE_DELETE(mSplitter);
	DeleteGraph();
}

BOOL CMediaPlayer::CreateGraph(void)
{
	mGraph = new CDXGraph();
	if (mGraph->Create())
	{
		mGraph->AddMsgReceiver(this);
		return TRUE;
	}
	else
	{
		DeleteGraph();
		return FALSE;
	}
}

void CMediaPlayer::DeleteGraph(void)
{
	if (mGraph)
	{
		mGraph->RemoveMsgReceiver(this);
		delete mGraph;
		mGraph = NULL;
	}
}

BOOL CMediaPlayer::PlayGraph(void)
{
	if (mGraph)
	{
		mGraph->Run();
		return TRUE;
	}
	return FALSE;
}

BOOL CMediaPlayer::PauseGraph(void)
{
	if (mGraph)
	{
		mGraph->Pause();
		return TRUE;
	}
	return FALSE;
}

BOOL CMediaPlayer::StopGraph(void)
{
	if (mGraph)
	{
		mGraph->Stop();
		return TRUE;
	}
	return FALSE;
}

// Net Receiver Filter interface
BOOL CMediaPlayer::SetStreamType(long inType)
{
	HRESULT hr = E_FAIL;
	if (mINetReceiver)
	{
		hr = mINetReceiver->SetStreamType(inType);
	}
	return SUCCEEDED(hr);
}

BOOL CMediaPlayer::SetSize(long inTotalSize, long inCheckOffset)
{
	HRESULT hr = E_FAIL;
	if (mINetReceiver)
	{
		hr = mINetReceiver->SetSize(inTotalSize, inCheckOffset);
	}
	return SUCCEEDED(hr);
}

BOOL CMediaPlayer::SetStreamSocket(SOCKET inSocket)
{
	if (mINetReceiver && inSocket != INVALID_SOCKET)
	{
		mINetReceiver->SetStreamSocket(inSocket);
	}
	return TRUE;
}

BOOL CMediaPlayer::StartReceiving(void)
{
	HRESULT hr = E_FAIL;
	if (mINetReceiver)
	{
		hr = mINetReceiver->StartReceiving();
	}
	return SUCCEEDED(hr);
}

BOOL CMediaPlayer::StopReceiving(void)
{
	HRESULT hr = E_FAIL;
	if (mINetReceiver)
	{
		hr = mINetReceiver->StopReceiving();
	}
	return SUCCEEDED(hr);
}

BOOL CMediaPlayer::CanConnectToDownstream(void)
{
	HRESULT hr = S_FALSE;
	if (mINetReceiver)
	{
		hr = mINetReceiver->CanConnectToDownstream();
	}
	return (hr == S_OK);
}

BOOL CMediaPlayer::RenderAllOutputPins(IBaseFilter * inFilter)
{
	BOOL success = FALSE;
	
	if (inFilter)
	{
		IEnumPins * pinEnum = NULL;
		if (SUCCEEDED(inFilter->EnumPins(&pinEnum)))
		{
			pinEnum->Reset();

			IPin * pin = NULL;
			ULONG fetchCount = 0;
			while (SUCCEEDED(pinEnum->Next(1, &pin, &fetchCount)) && 
				fetchCount)
			{
				if (pin)
				{
					PIN_INFO pinInfo;
					if (SUCCEEDED(pin->QueryPinInfo(&pinInfo)))
					{
						pinInfo.pFilter->Release();

						if (pinInfo.dir == PINDIR_OUTPUT)
						{
							if (mGraph->Render(pin))
							{
								success = TRUE;
							}
						}						
					}
					pin->Release();
				}
			}
			pinEnum->Release();
		}
	}

	return success;
}

bool CMediaPlayer::ReceiveMessage(MessageT inMessage, 
								  void * ioParam,
								  void * ioParam2)
{
	if (inMessage == msg_FilterGraphError)
	{
		StopGraph();
		return true;
	}

	return CMsgReceiver::ReceiveMessage(inMessage, ioParam, ioParam2);
}