gs_media_dxvideo.cpp

网络泡泡被.net管理

// GS_Media_DxVideo.cpp: implementation of the GS_Media_DxVideo class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "GsMedia.h"
#include "VideoSurfaceRenderer.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

GS_Media_DxVideo::GS_Media_DxVideo(CGsEngine* pEngine)
:CGsMedia(pEngine)
{
	m_pVR	= NULL;
	HRESULT hr;
    m_pVR = new CVideoSurfaceRenderer(NULL, &hr);
    if (FAILED(hr))                                      
    {
        if(g_pDebug)
			g_pDebug->ADD_LOG(TEXT("Could not create texture renderer object!  hr=0x%x"), hr);
        //return E_FAIL;
    }
	m_apBuf[0]	= NULL;
	m_apBuf[1]	= NULL;
}

GS_Media_DxVideo::~GS_Media_DxVideo()
{
	CVideoSurfaceRenderer* pVSR	= (CVideoSurfaceRenderer*)(m_pVR);
	SAFE_DELETE(pVSR);
	m_pVR	= NULL;
	SAFE_DELETE(m_apBuf[0]);
	SAFE_DELETE(m_apBuf[1]);
}
CDxSurface* GS_Media_DxVideo::GetFrontSurface()
{
	CVideoSurfaceRenderer* pVSR	= (CVideoSurfaceRenderer*)(m_pVR);
	if(pVSR==NULL)
		return NULL;
	return pVSR->apSurface[pVSR->m_front];
}

BOOL GS_Media_DxVideo::SetDxSurface(CDxSurface* pSurface_1, CDxSurface* pSurface_2)
{
	if(NULL==m_pVR)
		return FALSE;
	CVideoSurfaceRenderer* pVSR	= (CVideoSurfaceRenderer*)(m_pVR);
	if(pVSR==NULL)
		return FALSE;
	pVSR->apSurface[0]	= pSurface_1;
	pVSR->apSurface[1]	= pSurface_2;

	return TRUE;
}

BOOL GS_Media_DxVideo::SetStreamSource(const char *strSource)
{
	if(m_key_source==strSource)
		return TRUE;
	if(NULL==m_pVR)
		return FALSE;
	Cleanup();
	m_key_source	= strSource;
    HRESULT hr = S_OK;
    WCHAR wFile[MAX_PATH];

	GSFILE_INFO* pfi	= m_pEngine->FindSource(strSource);
	if(pfi)
	{
#ifndef UNICODE
    MultiByteToWideChar(CP_ACP, 0, pfi->strFile, -1, wFile, MAX_PATH);
#else
    lstrcpy(wFile, pfi->strFile);
#endif
	}
	else
	{
#ifndef UNICODE
    MultiByteToWideChar(CP_ACP, 0, strSource, -1, wFile, MAX_PATH);
#else
    lstrcpy(wFile, strSource);
#endif
	}
	if(FAILED(FreeDirectShow()))
		return FALSE;
	if(FAILED(InitDirectShow()))
		return FALSE;
    // Allow DirectShow to create the FilterGraph for this media file

	IBaseFilter*	pFSrc;
    IPin*           pFTRPinIn;      // Texture Renderer Input Pin
    IPin*           pFSrcPinOut;    // Source Filter Output Pin   
	CVideoSurfaceRenderer* pVSR	= (CVideoSurfaceRenderer*)(m_pVR);

    if (FAILED(hr = m_pGB->AddFilter(pVSR, L"SurfaceRenderer")))
    {
        if(g_pDebug)
			g_pDebug->ADD_LOG(TEXT("Could not add renderer filter to graph!  hr=0x%x"), hr);
        return hr;
    }

    if (FAILED(hr = m_pGB->AddSourceFilter (wFile, L"SOURCE", &pFSrc)))
    {
        if(g_pDebug)
			g_pDebug->ADD_LOG(TEXT("Could not create source filter to graph!  hr=0x%x"), hr);
        return FALSE;
    }
    // Find the source's output and the renderer's input
    if (FAILED(hr = pVSR->FindPin(L"In", &pFTRPinIn)))
    {
        if(g_pDebug)
			g_pDebug->ADD_LOG(TEXT("Could not find input pin!  hr=0x%x"), hr);
        return FALSE;
    }

    if (FAILED(hr = pFSrc->FindPin(L"Output", &pFSrcPinOut)))
    {
        if(g_pDebug)
			g_pDebug->ADD_LOG(TEXT("Could not find output pin!  hr=0x%x"), hr);
        return FALSE;
    }
    
    // Connect these two filters
    if (FAILED(hr = m_pGB->Connect(pFSrcPinOut, pFTRPinIn)))
    {
        if(g_pDebug)
			g_pDebug->ADD_LOG(TEXT("Could not connect pins!  hr=0x%x"), hr);
        return FALSE;
    }
	
    // Have the graph signal event via window callbacks
    hr = m_pME->SetNotifyWindow((OAHWND)(m_pEngine->GetEngineWnd()), GS_MEDIA_GRAPHNOTIFY+m_ID, 0);


	return hr;
}



BOOL GS_Media_DxVideo::CreateSurfaceBuffers(int width, int height, BOOL bUseVideoMem)
{
	Pause();
	SetDxSurface(NULL, NULL);
	SAFE_DELETE(m_apBuf[0]);
	SAFE_DELETE(m_apBuf[1]);
	CGsSurface* pSurface	= new CGsSurface(m_pEngine);
	pSurface->CreateEx(width, height, bUseVideoMem);
	pSurface->Clear(0);
	m_apBuf[0]	= pSurface;
	pSurface	= new CGsSurface(m_pEngine);
	pSurface->CreateEx(width, height, bUseVideoMem);
	pSurface->Clear(0);
	m_apBuf[1]	= pSurface;
	SetDxSurface(m_apBuf[0], m_apBuf[1]);
	Resume();
	return TRUE;
}

BOOL GS_Media_DxVideo::CreateTextureBuffers(DWORD width, DWORD height, DXSF dxsf)
{
	Pause();
	SetDxSurface(NULL, NULL);
	SAFE_DELETE(m_apBuf[0]);
	SAFE_DELETE(m_apBuf[1]);
	CGsSurface* pSurface	= new CGsSurface(m_pEngine);
	pSurface->CreateEx(width, height, dxsf);
	pSurface->Clear(0);
	m_apBuf[0]	= pSurface;
	pSurface	= new CGsSurface(m_pEngine);
	pSurface->CreateEx(width, height, dxsf);
	pSurface->Clear(0);
	m_apBuf[1]	= pSurface;
	SetDxSurface(m_apBuf[0], m_apBuf[1]);
	Resume();
	return TRUE;
}

HRESULT GS_Media_DxVideo::ReleaseObjects()
{
	Pause();
	SetDxSurface(NULL, NULL);
	if(m_apBuf[0])
		m_apBuf[0]->ReleaseSurface();
	if(m_apBuf[1])
		m_apBuf[1]->ReleaseSurface();
	return S_OK;
}

HRESULT GS_Media_DxVideo::RestoreObjects()
{
	if(m_apBuf[0])
		m_apBuf[0]->RestoreSurface();
	if(m_apBuf[1])
		m_apBuf[1]->RestoreSurface();
	SetDxSurface(m_apBuf[0], m_apBuf[1]);
	Resume();
	return S_OK;
}