Media Foundation学习笔记（八）编程练习：一个通用视频文件播放器

最新推荐文章于 2024-09-06 23:00:49 发布
最新推荐文章于 2024-09-06 23:00:49 发布
阅读量4.5k 收藏 4
点赞数
分类专栏： MediaFundation 文章标签： Media Foundation direct3d 架构 编程 视频
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuyangwuhan1980/article/details/20781289
版权


我将有关Media Foundation的函数调用封装到一个类CSpsPlayer中了，CSpsPlayer类的使用方法如下：


1)CSpsPlayer* pPlayer = new CSpsPlayer(hWndPlay);

2)pPlayer->OpenFile("c:\\ttt.asf");

3)获取视频时长pPlayer->GetTimeLen();单位是1/10^4毫秒;

4)pPlayer->Play();

5)暂定pPlayer->Pause();

6)暂停后继续pPlayer->Play();

7)获取播放位置pPlayer->GetCurrentPos();单位是1/10^4毫秒;

8)设置音量pPlayer->SetAudioVolumn(lVolumn);lVolumn取值是0~100

9)Seek操作pPlayer->Move(pos);pos单位是1/10^4毫秒;

10)播放窗口尺寸变化pPlayer->AdjustWindowPosition();

11)停止播放pPlayer->Stop();

12)关闭文件pPlayer->CloseFile();


SpsPlayer.h文件：

//
//	Class:		CSpsPlayer
//
//	Compiler:	Visual C++
//	Tested on:	Visual C++ 2010
//
//	Created:	08/March/2014
//
//	Author:		Liu Yang		464585657@qq.com
//
//
#ifndef SPSPLAYER_H
#define SPSPLAYER_H

#include <Windows.h>
#include <string>
#include <vector>
#include <new>
#include <shobjidl.h> 
#include <shlwapi.h>
#include <assert.h>
#include <strsafe.h>

// Media Foundation headers
#include <mfapi.h>
#include <mfidl.h>
#include <mferror.h>
#include <evr.h>

#define SAFE_RELEASE(x) { if (x) x->Release(); x = NULL; }
#define SAFE_CLOSE_HANDLE(x) { if (x)CloseHandle(x); x = NULL; }

enum PlayerState//播放器状态
{
    Closed = 0,     // No session.
    Started,        // Session is playing a file.
    Paused,         // Session is paused.
    Stopped,        // Session is stopped (ready to play). 
};

class CMyCriticalSection
{
public:
	CMyCriticalSection()
	{
		::InitializeCriticalSection(&m_cs);
	}
	virtual ~CMyCriticalSection()
	{
		::DeleteCriticalSection(&m_cs);
	}
	void lock()
	{
		::EnterCriticalSection(&m_cs);
	}
	void unlock()
	{
		::LeaveCriticalSection(&m_cs);
	}
private:
	CRITICAL_SECTION m_cs;
};

class CMyAutoLock
{
public:
	CMyAutoLock(CMyCriticalSection * pCrit)
	{
		m_pCrit = pCrit;
		m_pCrit->lock();
	}
	virtual ~CMyAutoLock()
	{
		m_pCrit->unlock();
	}
private:
	CMyCriticalSection * m_pCrit;
};


class CSpsPlayer : public IMFAsyncCallback
{
public:
	CSpsPlayer(HWND hWndVideo);
	virtual ~CSpsPlayer();

	// IUnknown methods
    STDMETHODIMP QueryInterface(REFIID iid, void** ppv);
    STDMETHODIMP_(ULONG) AddRef();
    STDMETHODIMP_(ULONG) Release();

    // IMFAsyncCallback methods
    STDMETHODIMP  GetParameters(DWORD*, DWORD*)
    {
        // Implementation of this method is optional.
        return E_NOTIMPL;
    }
    STDMETHODIMP  Invoke(IMFAsyncResult* pAsyncResult);

	//播放控制函数
	std::string GetSpsFilePathName();//获取文件名
	BOOL OpenFile(const char * s);//打开文件
	BOOL CloseFile();//关闭文件
	long GetPlayStatus();//获取播放器状态，返回：0:停止；1:播放；2:暂停
	BOOL Play();//播放
	BOOL Pause();//暂停
	BOOL Stop();//停止
	LONGLONG GetTimeLen();//获取时长(单位是1/10^4毫秒)
	LONGLONG GetCurrentPos();//获取当前播放位置(单位是1/10^4毫秒)
	BOOL Move(LONGLONG pos);//跳到指定位置播放(单位是1/10^4毫秒)
	BOOL GetAudioIsOpenedOrClosed();//获取声音是开启还是关闭状态
	BOOL OpenOrCloseAudio(BOOL bOpen);//打开或关闭声音
	long GetAudioVolumn();//获取音量
	BOOL SetAudioVolumn(long lVolumn);//设置音量
	void AdjustWindowPosition();//播放窗口尺寸发生变化时调用
	void RepaitVideo();//暂停时，播放窗口重绘后调用

private:
	BOOL AddBranchToTopology( IMFTopology *pTopology, IMFMediaSource *pSource, IMFPresentationDescriptor *pPD, DWORD iStream);//添加流的分支到topology
	IMFGetService* GetMFGetService();
	IMFSimpleAudioVolume* GetSimpleAudioVolume();
	IMFPresentationClock* GetPresentationClock();
	IMFVideoDisplayControl* GetVideoDisplayControl();

private:
	CMyCriticalSection		m_csCrit;//播放器锁
	HWND					m_hWndVideo;//播放窗口
	std::string				m_sSpsFileName;//视频文件
	//
	IMFMediaSession*		m_pSession;//Media Session
	PlayerState				m_state;//播放器状态
	LONGLONG				m_llTimeLen;//1/10^4毫秒
	long                    m_nRefCount;        // Reference count.
};


#endif


SpsPlayer.cpp文件：

//
//	Class:		CSpsPlayer
//
//	Compiler:	Visual C++
//	Tested on:	Visual C++ 2010
//
//	Created:	08/March/2014
//
//	Author:		Liu Yang		464585657@qq.com
//
//
#include "SpsPlayer.h"

#include <assert.h>

#pragma comment(lib, "shlwapi")

static const GUID MY_MR_VIDEO_RENDER_SERVICE ={0x1092a86c,0xab1a,0x459a, {0xa3, 0x36, 0x83, 0x1f, 0xbc, 0x4d, 0x11, 0xff} };

CSpsPlayer::CSpsPlayer(HWND hWndVideo)
{
	m_hWndVideo = hWndVideo;
	//
	m_pSession = NULL;
	m_state = Closed;
	m_llTimeLen = 0;
}

CSpsPlayer::~CSpsPlayer()
{
	CloseFile();
}

HRESULT CSpsPlayer::QueryInterface(REFIID riid, void** ppv)
{
    static const QITAB qit[] = 
    {
        QITABENT(CSpsPlayer, IMFAsyncCallback),
        { 0 }
    };
    return QISearch(this, qit, riid, ppv);
}

ULONG CSpsPlayer::AddRef()
{
    return InterlockedIncrement(&m_nRefCount);
}

ULONG CSpsPlayer::Release()
{
    ULONG uCount = InterlockedDecrement(&m_nRefCount);
    if (uCount == 0)
    {
        delete this;
    }
    return uCount;
}

std::string CSpsPlayer::GetSpsFilePathName()
{
	CMyAutoLock lock(&m_csCrit);

	return m_sSpsFileName;
}

BOOL CSpsPlayer::OpenFile(const char * s)
{
	CloseFile();

	CMyAutoLock lock(&m_csCrit);

	std::string sSpsFileName;
	sSpsFileName = s;

	//初始化Media Foundataion平台
	HRESULT hr = MFStartup(MF_VERSION);
	if (FAILED(hr))
	{
		return FALSE;
	}

	//创建Media Session对象
    hr = MFCreateMediaSession(NULL, &m_pSession);
    if (FAILED(hr))
    {
        MFShutdown();
		return FALSE;
    }

    //开始从Media Session接收事件
    hr = m_pSession->BeginGetEvent((IMFAsyncCallback*)this, NULL);
    if (FAILED(hr))
    {
		SAFE_RELEASE(m_pSession);
        MFShutdown();
		return FALSE;
    }

	MF_OBJECT_TYPE ObjectType = MF_OBJECT_INVALID;

    IMFSourceResolver* pSourceResolver = NULL;//Media Source选择器
    IUnknown* pSource = NULL;
    IMFMediaSource* pMFMediaSource = NULL;

    //根据给定的文件路径，创建Media Source对象，并获取IMFMediaSource接口
    hr = MFCreateSourceResolver(&pSourceResolver);
    if (FAILED(hr))
    {
        SAFE_RELEASE(m_pSession);
        MFShutdown();
		return FALSE;
    }
	WCHAR szwFile[MAX_PATH] = {0};
	MultiByteToWideChar(CP_ACP, 0, sSpsFileName.c_str(), -1, szwFile, MAX_PATH);
    hr = pSourceResolver->CreateObjectFromURL( szwFile, MF_RESOLUTION_MEDIASOURCE, NULL, &ObjectType, &pSource );
    if (FAILED(hr))
    {
        SAFE_RELEASE(pSourceResolver);
		SAFE_RELEASE(m_pSession);
        MFShutdown();
		return FALSE;
    }
    hr = pSource->QueryInterface(IID_PPV_ARGS(&pMFMediaSource));
	if (FAILED(hr))
    {
		SAFE_RELEASE(pSource);
        SAFE_RELEASE(pSourceResolver);
		SAFE_RELEASE(m_pSession);
        MFShutdown();
		return FALSE;
    }	
	SAFE_RELEASE(pSource);
    SAFE_RELEASE(pSourceResolver);

    IMFPresentationDescriptor* pSourcePD = NULL;

	//创建Presentation描述符
    hr = pMFMediaSource->CreatePresentationDescriptor(&pSourcePD);
    if (FAILED(hr))
    {
		SAFE_RELEASE(pMFMediaSource);        
		SAFE_RELEASE(m_pSession);
        MFShutdown();
		return FALSE;
    }

	MFTIME mDuration = 0;
	hr = pSourcePD->GetUINT64(MF_PD_DURATION, (UINT64*)&mDuration);
	if (FAILED(hr))
	{
		SAFE_RELEASE(pSourcePD); 
		SAFE_RELEASE(pMFMediaSource);        
		SAFE_RELEASE(m_pSession);
        MFShutdown();
		return FALSE;
    }
	m_llTimeLen = mDuration;

	DWORD cSourceStreams = 0;

    //获取Media Source对象的流的数目
    hr = pSourcePD->GetStreamDescriptorCount(&cSourceStreams);
    if (FAILED(hr))
	{
		SAFE_RELEASE(pSourcePD);   
        SAFE_RELEASE(pMFMediaSource);      
		SAFE_RELEASE(m_pSession);
        MFShutdown();
		return FALSE;
    }

	IMFTopology *pTopology = NULL;

	//创建topology对象
    hr = MFCreateTopology(&pTopology);
    if (FAILED(hr))
    {
		SAFE_RELEASE(pSourcePD);   
        SAFE_RELEASE(pMFMediaSource);      
		SAFE_RELEASE(m_pSession);
        MFShutdown();
		return FALSE;
    }

	//为每一个流创建节点，并将节点添加到topology中
    for (DWORD i = 0; i < cSourceStreams; i++)
    {
        BOOL bRet = AddBranchToTopology(pTopology, pMFMediaSource, pSourcePD, i);
        if (!bRet)
        {
			SAFE_RELEASE(pTopology);   
			SAFE_RELEASE(pSourcePD);   
			SAFE_RELEASE(pMFMediaSource);      
			SAFE_RELEASE(m_pSession);
			MFShutdown();
			return FALSE;
        }
    }

	//将topology对象设置到Media Session对象中
	hr = m_pSession->SetTopology(0, pTopology);
    if (FAILED(hr))
    {
		SAFE_RELEASE(pTopology);   
		SAFE_RELEASE(pSourcePD);   
		SAFE_RELEASE(pMFMediaSource);      
		SAFE_RELEASE(m_pSession);
		MFShutdown();
		return FALSE;
    }

	m_sSpsFileName = sSpsFileName;

	m_state = Stopped;

	return TRUE;
}

BOOL CSpsPlayer::CloseFile()
{
	Stop();

	CMyAutoLock lock(&m_csCrit);

	SAFE_RELEASE(m_pSession);
    MFShutdown();
	m_sSpsFileName = "";
	return TRUE;
}

long CSpsPlayer::GetPlayStatus()
{
	CMyAutoLock lock(&m_csCrit);

	switch(m_state)
	{
	case Closed://还没有打开文件
	case Stopped://停止了--打开文件后就是此状态
		return 0;
		break;
	case Started://开始播放了
		return 1;
		break;
	case Paused://暂停了
		return 2;
		break;
	default:
		return -1;
		break;
	}
}

BOOL CSpsPlayer::Play()
{
	CMyAutoLock lock(&m_csCrit);

	if (m_state != Paused && m_state != Stopped)
    {
        return FALSE;
    }

	PROPVARIANT varStart;
    PropVariantInit(&varStart);

    HRESULT hr = m_pSession->Start(&GUID_NULL, &varStart);

	PropVariantClear(&varStart);

    if (SUCCEEDED(hr))
    {
        // Note: Start is an asynchronous operation. However, we
        // can treat our state as being already started. If Start
        // fails later, we'll get an MESessionStarted event with
        // an error code, and we will update our state then.
        m_state = Started;
		return TRUE;
    }

	return FALSE;
}

BOOL CSpsPlayer::Pause()
{
	CMyAutoLock lock(&m_csCrit);

	if (m_state != Started)
    {
        return FALSE;
    }

    HRESULT hr = m_pSession->Pause();
    if (SUCCEEDED(hr))
    {
        m_state = Paused;
		return TRUE;
    }
	return FALSE;
}

BOOL CSpsPlayer::Stop()
{
	CMyAutoLock lock(&m_csCrit);

	if (m_state != Started && m_state != Paused)
    {
        return FALSE;
    }

	HRESULT hr = m_pSession->Stop();
    if (SUCCEEDED(hr))
    {
        m_state = Stopped;
		return TRUE;
    }
	return FALSE;
}

LONGLONG CSpsPlayer::GetTimeLen()
{
	CMyAutoLock lock(&m_csCrit);

	return m_llTimeLen;
}

LONGLONG CSpsPlayer::GetCurrentPos()
{
	CMyAutoLock lock(&m_csCrit);

	IMFPresentationClock* pPresentationClock = GetPresentationClock();
	if (!pPresentationClock)
		return 0;

	MFTIME pos = 0;
	HRESULT hr = pPresentationClock->GetTime(&pos);
	SAFE_RELEASE(pPresentationClock);
	if (FAILED(hr))
		return 0;

	return pos;
}

BOOL CSpsPlayer::Move(LONGLONG pos)
{
	CMyAutoLock lock(&m_csCrit);

	if (!m_pSession)
        return FALSE;

	PROPVARIANT varStart;
    varStart.vt = VT_I8;
    varStart.hVal.QuadPart = pos;

    HRESULT hr =  m_pSession->Start(NULL, &varStart);
	if (FAILED(hr))
		return FALSE;

	return TRUE;
}

BOOL CSpsPlayer::GetAudioIsOpenedOrClosed()
{
	CMyAutoLock lock(&m_csCrit);

	if (!m_pSession)
    {
        return FALSE;
    }

	IMFSimpleAudioVolume* pa = GetSimpleAudioVolume();
	if(pa)
	{
		BOOL bMute = FALSE;
		HRESULT hr = pa->GetMute(&bMute);
		if (FAILED(hr))
			return FALSE;
		return bMute;
	}
	return FALSE;
}

BOOL CSpsPlayer::OpenOrCloseAudio(BOOL bOpen)
{
	CMyAutoLock lock(&m_csCrit);

	if (!m_pSession)
    {
        return FALSE;
    }

	IMFSimpleAudioVolume* pa = GetSimpleAudioVolume();
	if(pa)
	{
		HRESULT hr;
		if (bOpen)
		{
			hr = pa->SetMute(FALSE);
			if (FAILED(hr))
				return FALSE;
		}
		else
		{
			hr = pa->SetMute(TRUE);
			if (FAILED(hr))
				return FALSE;
		}
	}	
	return TRUE;
}

long CSpsPlayer::GetAudioVolumn()
{
	CMyAutoLock lock(&m_csCrit);

	if (!m_pSession)
    {
        return 0;
    }

	IMFSimpleAudioVolume* pa = GetSimpleAudioVolume();
	if(pa)
	{
		HRESULT hr;
		float f = 0.0f;
		hr = pa->GetMasterVolume(&f);
		if (FAILED(hr))
			return 0;
		f = (f < 0.0f ? 0.0f : (f > 1.0f ? 1.0f : f));
		return (long)(f * 100.0f);
	}
	return 0;
}

BOOL CSpsPlayer::SetAudioVolumn(long ll)
{
	CMyAutoLock lock(&m_csCrit);

	if (!m_pSession)
    {
        return FALSE;
    }

	IMFSimpleAudioVolume* pa = GetSimpleAudioVolume();
	if(pa)
	{
		HRESULT hr;
		ll = (ll < 0 ? 0 : (ll > 100 ? 100 : ll));
		float f = ((float)ll / 100.0f);
		f = (f < 0.0f ? 0.0f : (f > 1.0f ? 1.0f : f));
		hr = pa->SetMasterVolume(f);
		if (FAILED(hr))
			return FALSE;
		return TRUE;
	}
	return FALSE;
}

void CSpsPlayer::AdjustWindowPosition()
{
	CMyAutoLock lock(&m_csCrit);

	IMFVideoDisplayControl* pVideoDisplayControl = GetVideoDisplayControl();
	if (pVideoDisplayControl)
	{
		RECT rcDest;
		GetWindowRect(m_hWndVideo, &rcDest);
		POINT pt;
		pt.x = rcDest.left;
		pt.y = rcDest.top;
		ScreenToClient(m_hWndVideo, &pt);
		rcDest.left = pt.x;
		rcDest.top = pt.y;
		pt.x = rcDest.right;
		pt.y = rcDest.bottom;
		ScreenToClient(m_hWndVideo, &pt);
		rcDest.right = pt.x;
		rcDest.bottom = pt.y;
		pVideoDisplayControl->SetVideoPosition(0, &rcDest);
	}	
}

void CSpsPlayer::RepaitVideo()
{
	CMyAutoLock lock(&m_csCrit);

	IMFVideoDisplayControl* pVideoDisplayControl = GetVideoDisplayControl();
	if (pVideoDisplayControl)
		pVideoDisplayControl->RepaintVideo();
}

BOOL CSpsPlayer::AddBranchToTopology( IMFTopology *pTopology, IMFMediaSource *pSource, IMFPresentationDescriptor *pPD, DWORD iStream)
{
    IMFStreamDescriptor *pSD = NULL;
    IMFTopologyNode     *pSourceNode = NULL;
    IMFTopologyNode     *pOutputNode = NULL;

    BOOL fSelected = FALSE;

	//获取流描述符
    HRESULT hr = pPD->GetStreamDescriptorByIndex(iStream, &fSelected, &pSD);
    if (FAILED(hr))
    {
        return FALSE;
    }

    if (fSelected)
    {
		// Create the media sink activation object.
        IMFMediaTypeHandler *pHandler = NULL;
		IMFActivate         *pActivate = NULL;

		//获取流的IMFMeidaTypeHandle
		HRESULT hr = pSD->GetMediaTypeHandler(&pHandler);
		if (FAILED(hr))
		{
			SAFE_RELEASE(pSD);
			return FALSE;
		}

		//获取流的主类型
		GUID guidMajorType;
		hr = pHandler->GetMajorType(&guidMajorType);
		if (FAILED(hr))
		{
			SAFE_RELEASE(pHandler);
			SAFE_RELEASE(pSD);
			return FALSE;
		}

		SAFE_RELEASE(pHandler);
 
		// 根据流的主类型为Render创建IMFActivate对象
		if (MFMediaType_Audio == guidMajorType)
		{
			hr = MFCreateAudioRendererActivate(&pActivate);
			if (FAILED(hr))
			{
				SAFE_RELEASE(pSD);
				return FALSE;
			}
		}
		else if (MFMediaType_Video == guidMajorType)
		{
			hr = MFCreateVideoRendererActivate(m_hWndVideo, &pActivate);
			if (FAILED(hr))
			{
				SAFE_RELEASE(pSD);
				return FALSE;
			}
		}		

		//创建源节点
		hr = MFCreateTopologyNode(MF_TOPOLOGY_SOURCESTREAM_NODE, &pSourceNode);
		if (FAILED(hr))
		{
			SAFE_RELEASE(pActivate);
			SAFE_RELEASE(pSD);
			return FALSE;
		}

		//设置源节点的源属性
		hr = pSourceNode->SetUnknown(MF_TOPONODE_SOURCE, pSource);
		if (FAILED(hr))
		{
			SAFE_RELEASE(pSourceNode);
			SAFE_RELEASE(pActivate);
			SAFE_RELEASE(pSD);
			return FALSE;
		}

		//设置源节点的Presentation描述符
		hr = pSourceNode->SetUnknown(MF_TOPONODE_PRESENTATION_DESCRIPTOR, pPD);
		if (FAILED(hr))
		{
			SAFE_RELEASE(pSourceNode);
			SAFE_RELEASE(pActivate);
			SAFE_RELEASE(pSD);
			return FALSE;
		}

		//设置源节点的流的描述符
		hr = pSourceNode->SetUnknown(MF_TOPONODE_STREAM_DESCRIPTOR, pSD);
		if (FAILED(hr))
		{
			SAFE_RELEASE(pSourceNode);
			SAFE_RELEASE(pActivate);
			SAFE_RELEASE(pSD);
			return FALSE;
		}
    
		//添加源节点到topology.
		hr = pTopology->AddNode(pSourceNode);
		if (FAILED(hr))
		{
			SAFE_RELEASE(pSourceNode);
			SAFE_RELEASE(pActivate);
			SAFE_RELEASE(pSD);
			return FALSE;
		}

		//创建输出节点
		hr = MFCreateTopologyNode(MF_TOPOLOGY_OUTPUT_NODE, &pOutputNode);
		if (FAILED(hr))
		{
			SAFE_RELEASE(pSourceNode);
			SAFE_RELEASE(pActivate);
			SAFE_RELEASE(pSD);
			return FALSE;
		}

		//设置输出节点的指针
		hr = pOutputNode->SetObject(pActivate);
		if (FAILED(hr))
		{
			SAFE_RELEASE(pOutputNode);
			SAFE_RELEASE(pSourceNode);
			SAFE_RELEASE(pActivate);
			SAFE_RELEASE(pSD);
			return FALSE;
		}

		SAFE_RELEASE(pActivate);

		//设置输出节点所在流的id
		hr = pOutputNode->SetUINT32(MF_TOPONODE_STREAMID, 0);
		if (FAILED(hr))
		{
			SAFE_RELEASE(pOutputNode);
			SAFE_RELEASE(pSourceNode);
			SAFE_RELEASE(pSD);
			return FALSE;
		}

		hr = pOutputNode->SetUINT32(MF_TOPONODE_NOSHUTDOWN_ON_REMOVE, FALSE);
		if (FAILED(hr))
		{
			SAFE_RELEASE(pOutputNode);
			SAFE_RELEASE(pSourceNode);
			SAFE_RELEASE(pSD);
			return FALSE;
		}

		//添加输出节点到topology.
		hr = pTopology->AddNode(pOutputNode);
		if (FAILED(hr))
		{
			SAFE_RELEASE(pOutputNode);
			SAFE_RELEASE(pSourceNode);
			SAFE_RELEASE(pSD);
			return FALSE;
		}

        hr = pSourceNode->ConnectOutput(0, pOutputNode, 0);
		if (FAILED(hr))
		{
			SAFE_RELEASE(pOutputNode);
			SAFE_RELEASE(pSourceNode);
			SAFE_RELEASE(pSD);
			return FALSE;
		}
    }

	SAFE_RELEASE(pOutputNode);
	SAFE_RELEASE(pSourceNode);
	SAFE_RELEASE(pSD);
    return TRUE;
}

HRESULT CSpsPlayer::Invoke(IMFAsyncResult *pResult)
{
    MediaEventType meType = MEUnknown;  // Event type

    IMFMediaEvent *pEvent = NULL;

	m_csCrit.lock();

    // Get the event from the event queue.
    HRESULT hr = m_pSession->EndGetEvent(pResult, &pEvent);
    if (FAILED(hr))
    {
		m_csCrit.unlock();
		return S_OK;
    }

    // Get the event type. 
    hr = pEvent->GetType(&meType);
    if (FAILED(hr))
    {
		SAFE_RELEASE(pEvent);
		m_csCrit.unlock();
		return S_OK;
    }

	if (meType == MEEndOfPresentation)
    {
		SAFE_RELEASE(pEvent);

        m_csCrit.unlock();

		Stop();

		return S_OK;
    }
    else
    {
		SAFE_RELEASE(pEvent);
        // For all other events, get the next event in the queue.
        hr = m_pSession->BeginGetEvent(this, NULL);
        if (FAILED(hr))
        {
			//error
        }
    }

	m_csCrit.unlock();
    return S_OK;
}

IMFGetService* CSpsPlayer::GetMFGetService()
{
	if (!m_pSession)
		return NULL;

	IMFGetService* pGetService = NULL;

	HRESULT hr = m_pSession->QueryInterface(IID_IMFGetService, (void **)&pGetService);
	if(FAILED(hr))
		return NULL;

	return pGetService;
}

IMFSimpleAudioVolume* CSpsPlayer::GetSimpleAudioVolume()
{
	if (!m_pSession)
		return NULL;

	IMFGetService* pGetService = GetMFGetService();
	if(!pGetService)
		return NULL;

	IMFSimpleAudioVolume* pa = NULL;
	HRESULT hr = pGetService->GetService(MR_POLICY_VOLUME_SERVICE, IID_PPV_ARGS(&pa));
	SAFE_RELEASE(pGetService);
	if(FAILED(hr))
		return NULL;

	return pa;
}

IMFPresentationClock* CSpsPlayer::GetPresentationClock()
{
	if (!m_pSession)
		return NULL;

	IMFClock* pClock = NULL;
	HRESULT hr = m_pSession->GetClock(&pClock);
	if(FAILED(hr))
		return NULL;

	IMFPresentationClock* pPresentationClock = NULL;
	hr = pClock->QueryInterface(IID_PPV_ARGS(&pPresentationClock));
	SAFE_RELEASE(pClock);
    if(FAILED(hr))
		return NULL;

	return pPresentationClock;
}

IMFVideoDisplayControl* CSpsPlayer::GetVideoDisplayControl()
{
	if (!m_pSession)
		return NULL;

	IMFVideoDisplayControl* pVideoDisplay = NULL;
	HRESULT hr = MFGetService(m_pSession, MY_MR_VIDEO_RENDER_SERVICE, IID_PPV_ARGS(&pVideoDisplay));
	if(FAILED(hr))
		return NULL;

	return pVideoDisplay;
}



相忘于江湖-mfc
关注
专栏目录
FFmpeg 开发(15)：学习如何使用 FFmpeg 打造一个自己的通用播放器？
字节流动
07-29 2万+
前面 FFmpeg 系列的文章中，已经实现了 FFmpeg 的编译和集成，基于 FFmpeg 实现音视频的播放、录制，并结合 OpenGL 添加丰富的滤镜等功能，这些 demo 基本上将 FFmpeg 使用涉及到的知识点基本上覆盖了。
Media Foundation——架构
王琦的专栏
05-07 6532
Media Foundation在windows7中的功能被大大增强，包括支持了更多的格式、支持采集、支持硬件编码器接口等，扩展了接口、增强了API等。本系列将逐一讲解。先介绍架构。 Media Foundation被分成几层： 一、基础层（Media Foundation Primitives）：贯穿于整个Media Foundation中的基础对象。 二、平台层（Med
Media Foundation
evsqiezi
06-29 969
1简介 Media Foundation是微软在Windows Vista上推出的新一代多媒体应用库，目的是提供Windows平台一个统一的多媒体影音解决方案，开发者可以通过Media Foundation播放视频或声音文件、进行多媒体文件格式转码，或者将一连串图片编码为视频等等。Media Foundation 是DirectShow为主的旧式多媒体应用程序接口的替代者与继承者，在微软的计划下
探索多媒体世界：Media Foundation 摄像头采集实例
最新发布
gitblog_09767的博客
09-06 583
探索多媒体世界：Media Foundation 摄像头采集实例 MFCaptureDev.rar项目地址:https://gitcode.com/open-source-toolkit/64ebb 项目介绍 在多媒体处理领域，摄像头采集是一个常见但复杂的需求。MFCaptureDev.rar 是一个基于 Media Foundation 的摄像头采集实例，它不仅提供了基本的摄像头采集功能，还加...
Media Foundation学习笔记（二）Media Foundation的架构 概览
相忘于江湖的专栏
02-12 6000
概览 下面的图表展示了Media Foundation架构的一个上层视图：    如上所示，Media Foundation提供了2种编程模型：   第一种，Media Pipeline模式。 如图表左边部分所示，使用一个端到端Pipeline，类似DShow中使用GraphBuilder、Filter的模式。   第二种：Souce Reader & Sink Writer模式。
media foundation (Using the Source Reader to Process Media Data)
smilestone322的专栏
12-01 1379
转自： https://msdn.microsoft.com/en-us/library/windows/desktop/dd389281(v=vs.85).aspx Using the Source Reader to Process Media Data This topic describes how to use the Source Reader to pr
Media Foundation——媒体类型（1）
王琦的专栏
05-08 4672
Media Foundaton对象的属性和特性 每一个对象上的数据，都可通过“属性（Attributes）”和“特性(Properties)”来设置、描述。属性和特性相似但不同。 在Media Foundation中使用属性（Attributes）属性（Attributes）= key +valueKey是个GUIDValue是个变量。变量的类型局限于：ü   
基于Media foundation的视频播放器
10-14
综合以上，这个项目是一个利用Media Foundation技术在Windows 7环境下用Visual Studio 2010开发的视频播放器，它采用多线程处理媒体内容，通过GDI+进行图形渲染，并可能利用DWM实现高级窗口效果。附带的文件可能包含...
DirectShow和MediaFoundation编写的本地视频播放器
05-19
在这个项目中，你可能会深入了解到如何利用这两个技术来编写一个本地视频播放器。 首先，DirectShow是Microsoft在Windows 98时代推出的一个多媒体处理框架，它提供了一种灵活的方式来构建媒体播放器。DirectShow...
MediaFoundation视频采集
qw_stone的博客
05-19 2302
原因：由于目前pc平台采集DirectShow老旧和复杂，故了解MediaFoundation简单调用。 概述：利用MediaFoundation实现视频采集，利用同步方式实现视频数据的读取。 MediaFoundation介绍： MediaFoundation是DirectShow的替代，vist及以上才能支持，也就是说xp不支持，且不同的系统某些功能支持情况也不同，提供了两种编码模型，第一种是Media Session为主的Media pipeline模型，复杂。 第二种就是通过SourceRe
Developing Microsoft Media Foundation Applications (PDF)
10-22
本书不仅涵盖了Media Foundation的基础概念，还深入探讨了如何构建多媒体播放器以及设计自定义的视频编解码器等高级主题。 #### 二、核心Media Foundation概念 - **媒体源**：Media Foundation将多媒体数据视为一...
Developing Microsoft Media Foundation Applications
10-24
作者：Anton Polinger 出版日期：October 2011 出版社：Microsoft Press 页数：384 ISBN：978-0-7356-5657-4 文件格式：PDF 文件大小：13.04 MB Create professional-quality media applications and components with Microsoft Media Foundation—and deliver the next generation of high-definition multimedia. With this hands-on book, you’ll learn how to build applications to capture video and audio files of different types, process media information, and stream it over the Internet. If you program with C++ and the Component Object Model (COM), this book is ideal—especially for developers looking to transfer their skills from Microsoft DirectShow®. Discover how to: Construct media pipelines with individual Media Foundation components Build a simple video player to see how a basic media session works Create applications that transcode media content from one format to another Process data streams by writing Media Foundation Transform objects Examine the internal architecture of Media Foundation Sources and Sinks Design a custom media session object to learn advanced Media Foundation concepts Create image overlays on top of video and send the result over the network
Media Foundation简单示例Demo
09-09
MFC使用Media Foundation 播放媒体文件。主要使用IMFMediaSession下的几个API接口函数实现。源自msdn。
windows media Foundation
smilestone322的专栏
05-20 556
转自：https://docs.microsoft.com/en-us/windows/desktop/medfound/microsoft-media-foundation-sdk Microsoft Media Foundation enables the development of applications and components for using digital medi...
Windows开发：关于微软媒体基础（Microsoft Media Foundation）
锕琅的博客
01-22 2753
目录序言介绍可用的基础工具基础概念 Essential Concepts流 Streams压缩 Compression媒体容器 Media Containers格式 Formats 注：文章由作者翻译和资料整理，转载请注明出处 序言 介绍 Microsoft Media Foundation是适用于Windows的下一代多媒体平台，使开发人员，消费者和内容提供商能够以更强的健壮性，无与伦比的质量和无缝交互来拥抱新一轮的高级内容。 Media Foundation需要Windows Vista或更高版本。它使
音频采集 via Media Foundation
Blueware多媒体之窗
01-29 839
音频采集 via Media FoundationMedia Foundation 简介Media Foundation 采集音频采集流程图采集代码概览MMDeviceHelper::enumAudCapDevices 函数CMFCapture::startCapture 函数CMFCapture::_configAudioCapture 函数createSrcReader 函数configSrc...
【Media Foundation]基本概念
blackboy的技术博客
10-14 4329
原文：http://msdn.microsoft.com/en-us/library/ee663601(v=vs.85).aspx 如果你是数字多媒体新手，这个主题介绍了一些你需要在缩写MF应用程序之前理解的概念。 流（streams)压缩 (compression)媒体容器 (media containers)格式 (formats)相关主题 流 流是具有统一类型的一系列媒体数据序列
Media Foundation架构简介
gnimgnot
10-28 3707
Media Foundation架构简介 如下图所示：MF提供了两套编程模型，分别是： 1，图中左边部分，用一个端到端的流水线。程序通过提供一个URL来初始化流水线，然后调用控制流的函数。 2，图中右边部分，程序既从源中抽数据，也将数据推送到目标中，这种模型在处理音视频数据时很有用，因为程序可以直接访问数据流。 从底依次往上说： primitives 是一些贯穿于整个MF
Media Foundation基本概念
gnimgnot
10-28 5129
Media Foundation Media Foundation（简称MF）是微软用来替换DirectShow的视频API，从Vista开始支持，直到现在的Windows 8，Windows Phone 8，让编码解码的操作更容易。 MF只支持C++，不支持C#。 MF加强了对DirectX Video Acceleration (DXVA)，EVR(enhanced video re
Linux基础学习笔记：命令行、帮助和文件管理
+ /passwd在文件中查找passwd字符，n键查找下一个，shift+n键查找上一个。 * 文件头和尾： + head filename显示文件头10行。 + head-n 15 filename显示文件15行。 + tail filename显示文件尾10行。 + tail-n 15...
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值