适合于流式播放的DirectShow客户服的编写

 

转载请标明是引用于 http://blog.csdn.net/chenyujing1234

 例子代码:(包括客户端与服务端)(编译工具：VS2005)

http://www.rayfile.com/zh-cn/files/a34cb700-74ce-11e1-999e-0015c55db73d/

 

参考书籍：<<DirectShow开发指南>>

1、设计思路.

1、1需要写一个能够接收服务器发来的数据，并提供给Filter Graph中其他解码的Source Filter，如图所示

0001的source Filter用于接收网络上发来的MPEG数据，且工作在拉模式下。(可参考 http://blog.csdn.net/chenyujing1234/article/details/7378315).

DirectShow提供了MPEG1解码的所有filter，包括MPEG1-1 Stream Splitter、MPEG Vieo Decoder、MPEG Audio Decoder，因为MPEG-1 Stream Splitter（流分离器）只能工作在拉模式下，这样不得不把Source Filter也设计成拉模式。（不过如果有第三方的可以工作的推模式下的Splitter FIlter，则完全可以把Source Filter设计成推模式，即接到网络上的数据就主动传给Splitter Filter，而不是被动地等待Splitter去读取）

1、2 一各种双缓冲队列技术.

必须让Source Filter接收一定数量的数据，并缓存起来。因为在Source Filter和Splitter连接过程中，会从Source Filter中读取一部分数据，以获得数据的格式,否则Filter Graph无法完成连接。而当完整的Filter Graph构建完成，且处于运行状态后，Source Filter必须动态地接收数据，并持续把新的数据给Splitter。

这里使用双缓冲技术。

工作原理：

建立两个队列，一个是空闲的缓冲队列PoolList,用以接收存放数据，另一是尚未处理的数据缓冲队列DataList,等待Splitter读取。

当Source Filter使用socket接收数据后，从PoolList队列的头上取出一个缓冲块，存放数据，然后将这个缓冲块加入到DataList尾部，等待Splitter读取。

而在Splitter要求读取时，Source Filter会从DataList 队列的头上取出一个缓冲块，读取数据，再将读完的缓冲块加到PoolList尾部，回收再利用。

2、源码分析。

主要分析两个类CMemStream CMemReader 及CFilterGraph

//
// MemFilter.h
//
#ifndef  __MemFilter_h__
#define  __MemFilter_h__

#include <streams.h>
#include <stdio.h>
#include "asyncio.h"
#include "asyncrdr.h"
#include "CMediaSocketClient.h"
#include "CDataAdmin.h"
#include "MyDef.h"


//
//  Define an internal filter that wraps the base CBaseReader stuff //
//
class CMemStream : public CAsyncStream
{
private:
    CCritSec       m_csLock;    // 数据操作的同步对象
	CDataAdmin *   m_pDataList; // 数据接收队列管理器
    ULONG          m_ulPositionInPack;//  当前缓冲块内的偏移量
    // Total length available
	LONGLONG       m_llLength;  // 当前可以获得的数据总长度
	// Bytes totally read
    DWORD          m_dwTimeStart;

public:
    CMemStream(CDataAdmin* inBuffer)
    {
		// 成员变量初始化
		m_pDataList         = inBuffer;
		m_ulPositionInPack  = 0;
		m_llLength          = 0;   
    }

    HRESULT SetPointer(LONGLONG llPos)
    {
		return S_OK;
    }

	// 当Splitter要求数据时，必须在这个函数中提供
    HRESULT Read(PBYTE pbBuffer,        // 装载读出数据的缓存地址
                 DWORD dwBytesToRead,   // 要求读取的字节数
                 BOOL bAlign,           // 数据对齐方式
                 LPDWORD pdwBytesRead)  // 实际读取的字节数
    {
		if (m_pDataList == NULL)
			return S_FALSE;

		CAutoLock     lck(&m_csLock);
		DWORD         dwHaveRead = 0;
		PMPEG1_PACK   pPack  = NULL;

		while (dwHaveRead < dwBytesToRead)
		{
			if (dwBytesToRead - dwHaveRead >= MPEG1_PACK_SIZE - m_ulPositionInPack)
			{
				// Just copy the whole pack data
				pPack = m_pDataList->GetDataBuffer();
				if (pPack != NULL)
				{
					CopyMemory((PVOID)(pbBuffer + dwHaveRead), 
						(PVOID)((PBYTE)(pPack) + m_ulPositionInPack), (SIZE_T)MPEG1_PACK_SIZE - m_ulPositionInPack);
					m_pDataList->ReleaseDataBuffer(pPack);
					dwHaveRead += MPEG1_PACK_SIZE - m_ulPositionInPack;
					m_ulPositionInPack = 0;
				}
				else if (m_pDataList->IsFlushing())
				{
				//	FILE * fp = fopen("c:\\log.txt","a+");
				//	fprintf(fp,"failed!\n");
				//	fclose(fp); 
					return E_FAIL;
				}
				else 
				{
				//	FILE * fp = fopen("c:\\log.txt","a+");
				//	fprintf(fp,"SLEEP!\n");
				//	fclose(fp); 
					Sleep(10);
				}
			}
			else
			{
				// Copy part of the pack data
				pPack = m_pDataList->PointToDataHead();
				if (pPack != NULL)
				{
					m_ulPositionInPack = dwBytesToRead - dwHaveRead;
					CopyMemory((PVOID)(pbBuffer + dwHaveRead), 
						(PVOID)(pPack), (SIZE_T)m_ulPositionInPack);
					dwHaveRead += m_ulPositionInPack;
				}
				else if (m_pDataList->IsFlushing())
				{
				//	FILE * fp = fopen("c:\\log.txt","a+");
				//	fprintf(fp,"failed!\n");
				//	fclose(fp); 
					return E_FAIL;
				}
				else 
				{
				//	FILE * fp = fopen("c:\\log.txt","a+");
				//	fprintf(fp,"SLEEP!\n");
				//	fclose(fp);
					Sleep(10);
				}
			}
		}
		*pdwBytesRead = dwBytesToRead;

		return S_OK;
    }

    LONGLONG Size(LONGLONG *pSizeAvailable)
    {
        *pSizeAvailable = m_llLength;
        return 0x7fffffffff;
    }

    DWORD Alignment()
    {
        return 1;
    }

    void Lock()
    {
        m_csLock.Lock();
    }

    void Unlock()
    {
        m_csLock.Unlock();
    }

	void AddAvailableLength(LONGLONG inLength)
	{
		m_llLength += inLength;
	}
};

class CMemReader : public CAsyncReader
{
public:

    //  We're not going to be CoCreate'd so we don't need registration
    //  stuff etc
    STDMETHODIMP Register()
    {
        return S_OK;
    }
    STDMETHODIMP Unregister()
    {
        return S_OK;
    }
    CMemReader(CMemStream *pStream, CMediaType *pmt, HRESULT *phr) :
        CAsyncReader(NAME("Mem Reader"), NULL, pStream, phr)
    {
        m_mt = *pmt;
    }
};

#endif  // __MemFilter_h__

 

class CMemReader : public CAsyncReader
{
public:

    //  We're not going to be CoCreate'd so we don't need registration
    //  stuff etc
    STDMETHODIMP Register()
    {
        return S_OK;
    }
    STDMETHODIMP Unregister()
    {
        return S_OK;
    }
    CMemReader(CMemStream *pStream, CMediaType *pmt, HRESULT *phr) :
        CAsyncReader(NAME("Mem Reader"), NULL, pStream, phr)
    {
        m_mt = *pmt;
    }
};

 

下面来看Filter Graph的构建过程。（参见CFiltreGraph::BuildeGraph的实现）。可以看到BuildGraph函数首先创建一个Filter Graph组件，然后获得一系统控制接口，

接下来创建source filter,值得注意的是，因为这是一个应用程序实现的Filter,不能通过CoCreateInstance函数去创建它，而要直接成成:

// construct source filter
	// Media type
	if (m_bInit)
	{
		CMediaType   mt;      
		mt.majortype = MEDIATYPE_Stream;
		mt.subtype   = MEDIASUBTYPE_MPEG1System;
		m_pSourceStream  = new CMemStream(m_pDataList);
		m_pSourceReader  = new CMemReader(m_pSourceStream, &mt, &hr);
		m_pSourceReader->AddRef();  // 增加一个引用计数,防止COM自动删除
		//  Add our filter
		hr = m_pGB->AddFilter(m_pSourceReader, NULL);
		if (FAILED(hr)) 
		{
			m_bInit = false;
		}  
	}

BuildGraph函数最后并没有将Source Filter的输出Pin连出去，因为Source Filter在没有缓存
 一定数据的数据之前，与Filter连接是不会成功的，解决方法是，启动一个等待线程，
当Source Filter预先接收到足够的数据后，再构建完整的Filter Graph。

if (m_bInit)
	{
		// Waiting for event to start filter graph
		::AfxBeginThread((AFX_THREADPROC)CFilterGraph::WaitingThrd, this);
	}

// When data buffer enough, start the filter graph
UINT CFilterGraph::WaitingThrd(void * pParam)
{
	CFilterGraph * pGraph = (CFilterGraph *) pParam;
	if (pGraph != NULL && pGraph->m_pDataList != NULL)
	{
		// 询问数据接收队列管理器，是否已经接受到了足够的数据
		::WaitForSingleObject(pGraph->m_pDataList->m_hBufEnough, INFINITE);
		if (!pGraph->IsRunning())
		{
			// 开始构建完成的Filter Graph
			pGraph->StartGraph();
		}
	}
	return 1;
}

// 构建完成的Filter Graph,并运行它
bool CFilterGraph::StartGraph(void)
{
	if (m_bInit)
	{
		m_bRun = true;
		// 使用智能连接，将Source Filter 的输出Pin连出来
		HRESULT hr  = m_pGB->Render(m_pSourceReader->GetPin(0));
		if (FAILED(hr))
		{
			m_bRun = false;
			return false;
		}
        // 设置视窗的一些属性
		hr = m_pVW->put_Visible(OAFALSE);
		hr = m_pVW->put_Owner((OAHWND)m_hOwner);
		hr = m_pVW->put_WindowStyle(WS_CHILD | WS_CLIPSIBLINGS | WS_CLIPCHILDREN);
		hr = m_pVW->SetWindowPosition(m_nLeft, m_nTop, m_nWidth, m_nHeight);
		// Enable the parent window to get the mouse and keyboard event in the video window
		hr = m_pVW->put_MessageDrain((OAHWND)m_hOwner);
		hr = m_pVW->put_Visible(OATRUE);
		
		// run the filter graph
		hr = m_pMC->Run();
		return true;
	}
	
	return false;
}

从CMediaSocketClient::ReceivingLoop函数的实现中，查看客户端的整个数据接收过程。可以看到，ReceivingLoop函数使用了一个while循环不断地接收数据，

并把数据交给队列管理；同时对接收到的数据包进行计数。

 CMemReader(CMemStream *pStream, CMediaType *pmt, HRESULT *phr) :
        CAsyncReader(NAME("Mem Reader"), NULL, pStream, phr)
    {
        m_mt = *pmt;
    }

 

在CMemStream中有Read函数，它就是对收到的数据取出来.

// 当Splitter要求数据时，必须在这个函数中提供
    HRESULT Read(PBYTE pbBuffer,        // 装载读出数据的缓存地址
                 DWORD dwBytesToRead,   // 要求读取的字节数
                 BOOL bAlign,           // 数据对齐方式
                 LPDWORD pdwBytesRead)  // 实际读取的字节数
    {
		if (m_pDataList == NULL)
			return S_FALSE;

		CAutoLock     lck(&m_csLock);
		DWORD         dwHaveRead = 0;
		PMPEG1_PACK   pPack  = NULL;

		while (dwHaveRead < dwBytesToRead)
		{
			if (dwBytesToRead - dwHaveRead >= MPEG1_PACK_SIZE - m_ulPositionInPack)
			{
				// Just copy the whole pack data
				pPack = m_pDataList->GetDataBuffer();
				if (pPack != NULL)
				{
					CopyMemory((PVOID)(pbBuffer + dwHaveRead), 
						(PVOID)((PBYTE)(pPack) + m_ulPositionInPack), (SIZE_T)MPEG1_PACK_SIZE - m_ulPositionInPack);
					m_pDataList->ReleaseDataBuffer(pPack);
					dwHaveRead += MPEG1_PACK_SIZE - m_ulPositionInPack;
					m_ulPositionInPack = 0;
				}
				else if (m_pDataList->IsFlushing())
				{
				//	FILE * fp = fopen("c:\\log.txt","a+");
				//	fprintf(fp,"failed!\n");
				//	fclose(fp); 
					return E_FAIL;
				}
				else 
				{
				//	FILE * fp = fopen("c:\\log.txt","a+");
				//	fprintf(fp,"SLEEP!\n");
				//	fclose(fp); 
					Sleep(10);
				}
			}
			else
			{
				// Copy part of the pack data
				pPack = m_pDataList->PointToDataHead();
				if (pPack != NULL)
				{
					m_ulPositionInPack = dwBytesToRead - dwHaveRead;
					CopyMemory((PVOID)(pbBuffer + dwHaveRead), 
						(PVOID)(pPack), (SIZE_T)m_ulPositionInPack);
					dwHaveRead += m_ulPositionInPack;
				}
				else if (m_pDataList->IsFlushing())

客户端的设计可以用下面的框图表示: