CCapture directshow 视频捕获类

// Capture.h for class CCapture

#include <dshow.h>
#include <qedit.h>
#include <atlbase.h>
#if !defined(CAPTURE_H_________)
#define CAPTURE_H_________

// image size: 160*120  176*144   320*240  640*480  1024*1806
#define IMG_WIDTH 320
#define IMG_HEIGHT 240

typedef void (*capCallBackFunc)(LPVOID lParam);
enum DeviceType{DTypeVideo, DTypeAudio};
class CSampleGrabberCB; // 用于不会帧数据保存图片的接口
class CCapture
{
friend class CSampleGrabberCB;
public:
// 设置回调函数 用于处理获取的图片帧数据
CDialog *m_dlgParent;
capCallBackFunc calFunc;
void SetCallBKFun(capCallBackFunc f);
/////////////////////////////////
CCapture();
virtual ~CCapture();
int EnumDevice(HWND hCmbList, DeviceType deviceType); // 设备枚举
//	void SaveGraph(TCHAR *wFileName);	// 保存滤波器链表
void SetCameraFormat(HWND hwndParent);	// 设置摄像头的视频格式
void SetCameraFilter(HWND hwndParent);	// 设置摄像头的图像参数
HRESULT CaptureVideo(CString inFileName);	// 捕获保存视频
HRESULT CaptureImage(CString inFileName);	// 抓取保存图片
HRESULT CaptureImage(); // 抓取图片并显示
HRESULT Preview(int iDevVideoID, HWND hVideo, int iDevAudioID = 0, HWND hAudio = NULL);	// 采集预览视频
HRESULT InitCaptureGraphBuilder();	// 创建滤波器管理器，查询其各种控制接口
void StopCapture();  // 停止捕获
void FreeMediaType(AM_MEDIA_TYPE &mt);  // 释放对象内存

void SetOnShot(BOOL bFlag);   // 设置是否捕获帧数据
void SetParent(CDialog *pdlg);
protected:
bool BindFilter(int iDeviceID, IBaseFilter **pOutFilter, DeviceType deviceType); // 把指定的设备滤波器捆绑到链表中
void ResizeVideoWindow();			// 更改视频显示窗口
HRESULT SetupVideoWindow();			// 设置视频显示窗口的特性
static UINT ThreadFunDrawText(LPVOID lParam);
private:
HWND m_hWnd;			// 视频显示窗口的句柄
IBaseFilter *m_pVideoCap;		// 视频捕获滤波器
IBaseFilter *m_pAudioCap;		// 音频捕获滤波器
CComPtr<ISampleGrabber> m_pGrabber;		// 抓取图片滤波器
IBaseFilter *m_pMux;	// 写文件滤波器
ICaptureGraphBuilder2 *m_pCapGB;	// 增强型捕获滤波器链表管理
IGraphBuilder *m_pGB;	// 滤波链表管理器
IVideoWindow *m_pVW;	// 视频显示窗口接口
IMediaControl *m_pMC;	// 媒体控制接口
static bool m_bRecording;		// 录制视频标志

IBaseFilter *m_pXviDCodec;   //mpeg4 滤波器
};

#endif

/// Capture.cpp for class CCapture implement
//
///
////////////////////////////////////////

#include "StdAfx.h"
#include "Capture.h"
#include <atlconv.h>
#include "VideoChatDlg.h"
#include "yuv2bmp.h"

#ifndef srelease
#define srelease(x) if (NULL != x)\
{\
x->Release();\
x = NULL;\
}
#endif

#ifndef MAX_PATH
#define  MAX_PATH 1024
#endif
BOOL bOneShot = FALSE; // 全局变量
capCallBackFunc fun;

class CSampleGrabberCB : public ISampleGrabberCB
{
public:
long lWidth;
long lHeight;
CCapture *pCap;
TCHAR m_szFileName[MAX_PATH]; // 位图文件名称
CSampleGrabberCB(){
strcpy(m_szFileName, ".\\sample.bmp");
}
STDMETHODIMP_(ULONG) AddRef() { return 2; }
STDMETHODIMP_(ULONG) Release() { return 1; }
STDMETHODIMP QueryInterface(REFIID riid, void ** ppv){
if( riid == IID_ISampleGrabberCB || riid == IID_IUnknown ){
*ppv = (void *) static_cast<ISampleGrabberCB*> ( this );
return NOERROR;
}
return E_NOINTERFACE;
}
STDMETHODIMP SampleCB( double SampleTime, IMediaSample * pSample ){
return 0;
}
STDMETHODIMP BufferCB( double dblSampleTime, BYTE * pBuffer, long lBufferSize ){
if( !bOneShot )
return 0;
if (!pBuffer)
{
AfxMessageBox(_T("Save Bmp File Failure!"));
return E_POINTER;
}
if (pBuffer != NULL && pCap)
{
// 			BYTE *rgb = new BYTE[lWidth*lHeight*3];
// 			YUV422_C_RGB(pBuffer,rgb, (int)lHeight, (int)lWidth);
//			outBmpBuf(pBuffer, pCap);  // 将一帧图像数据传给显示函数
//			((CVideoNetDlg *)pCap->m_dlgParent)->SendVideo(pBuffer, (int)lBufferSize);
}
//	SaveBitmap(pBuffer, lBufferSize);  // 保存成位图文件
//		bOneShot = FALSE; // 停止捕获图像
//		AfxMessageBox(_T("Get bmp data success."));
return 0;
}
void outBmpBuf(BYTE *buf, CCapture* cap)
{
cap->calFunc(buf);
}
// 创建位图文件
BOOL SaveBitmap(BYTE *pBuffer, long lBufferLen)
{
HANDLE hf = CreateFile(m_szFileName, GENERIC_WRITE,
FILE_SHARE_READ, NULL, CREATE_ALWAYS, NULL, NULL);
if (hf == INVALID_HANDLE_VALUE) return 0;
// 写文件头
BITMAPFILEHEADER fileheader;
ZeroMemory(&fileheader, sizeof(BITMAPFILEHEADER));
fileheader.bfType = 'MB';
fileheader.bfSize = sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+lBufferLen;
fileheader.bfOffBits = sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER);
DWORD dwWritter = 0;
WriteFile(hf, &fileheader, sizeof(BITMAPFILEHEADER), &dwWritter, NULL);
// 写文图格式
BITMAPINFOHEADER infoHeader;
ZeroMemory(&infoHeader, sizeof(BITMAPINFOHEADER));
infoHeader.biSize = sizeof(BITMAPINFOHEADER);
infoHeader.biSizeImage = lBufferLen;
infoHeader.biWidth = lWidth;
infoHeader.biHeight = lHeight;
infoHeader.biBitCount = 24;
WriteFile(hf, &infoHeader, sizeof(BITMAPINFOHEADER), &dwWritter, NULL);
// 写位图数据
WriteFile(hf, pBuffer, lBufferLen, &dwWritter, NULL);
CloseHandle(hf);
MessageBox(NULL, _T("Save bmp file succeed!"), _T("warn"), MB_OK|MB_ICONINFORMATION);
return 0;
}
};

/////////////////////////////////////////////
/// for class CCapture's Function
///
////////////////////////////////////////////////
CSampleGrabberCB samCB;
CCapture::CCapture()
{
CoInitialize(NULL);  // 初始化COM库
m_hWnd = NULL;
m_pVideoCap = NULL;
m_pAudioCap = NULL;
m_pCapGB = NULL;
m_pGB = NULL;
m_pMC = NULL;
m_pMux = NULL;
m_pVW = NULL;
m_pGrabber = NULL;
m_dlgParent = NULL;
}
bool CCapture::m_bRecording = false;

CCapture::~CCapture()
{
if (m_pMC) m_pMC->Stop();
if (m_pVW)
{
m_pVW->put_Owner(NULL);
m_pVW->put_Visible(OAFALSE);
}
m_hWnd = NULL;
srelease(m_pVideoCap);
srelease(m_pGB);
srelease(m_pCapGB);
srelease(m_pMC);
srelease(m_pVW);
m_bRecording = false;
CoUninitialize(); // 释放COM库
}

int CCapture::EnumDevice( HWND hCmbList, DeviceType deviceType )
{
if (hCmbList == NULL) return -1;
int id = 0;
/////枚举捕获设备
ICreateDevEnum *pCreateDevEnum;
HRESULT hr = CoCreateInstance(CLSID_SystemDeviceEnum,
NULL,
CLSCTX_INPROC_SERVER,
IID_ICreateDevEnum,
(LPVOID *)&pCreateDevEnum);
if ( hr != NOERROR) return -1;
//////// 获取视频类的枚举器
IEnumMoniker *pEm;			 //枚举监控器接口
if (deviceType == DTypeVideo)
hr = pCreateDevEnum->CreateClassEnumerator(CLSID_VideoInputDeviceCategory, &pEm, 0);
// 如果获取音频类的枚举器 用下面的代码
else
hr = pCreateDevEnum->CreateClassEnumerator(CLSID_AudioInputDeviceCategory, &pEm, 0);
//	if (hr != NOERROR) return -1;
if (!pEm || FAILED(hr)) return -1;
////////////////////////
pEm->Reset();   // 类型枚举器复位
ULONG cFetched;
IMoniker *pM;    // 监控器接口指针
while(hr = pEm->Next(1, &pM, &cFetched), hr == S_OK)
{
IPropertyBag *pBag;   // 属性页接口指针
hr = pM->BindToStorage(0, 0, IID_IPropertyBag, (void **)&pBag);
// 获取设备属性页
if (SUCCEEDED(hr))
{
VARIANT var;
var.vt = VT_BSTR;		// 保存的是二进制数据
// 获取firendlyName 形式的信息
hr = pBag->Read(L"FriendlyName", &var, NULL);
if (hr == NOERROR) // 获取成功
{
id++;
char szDeviceName[256] = {0};
WideCharToMultiByte(CP_ACP, 0, var.bstrVal, -1, szDeviceName,80, NULL, NULL);  // 字符串编码转换UNICODE TO ANSI
::SendMessage(hCmbList, CB_ADDSTRING, 0, (LPARAM)szDeviceName);//添加到组合列表框
SysFreeString(var.bstrVal);  //释放资源，特别要注意
}
pBag->Release();
}
pM->Release();
}
return 0;
}

void CCapture::ResizeVideoWindow()
{
if (m_pVW)
{
// 让图像充满整个指定窗口
CRect rc;
::GetClientRect(m_hWnd, &rc);
m_pVW->SetWindowPosition(0, 0, rc.right, rc.bottom);
}
}

HRESULT CCapture::SetupVideoWindow()
{
HRESULT hr;
//m_hWnd为类CCapture的成员变量，在使用该函数前须初始化
hr = m_pVW->put_Visible(OAFALSE);  // 视频窗口不可见
hr = m_pVW->put_Owner((OAHWND)m_hWnd);  // 设置视频窗口
if (FAILED(hr)) return hr;
hr = m_pVW->put_WindowStyle(WS_CHILD | WS_CLIPCHILDREN); //设置窗口类型
if (FAILED(hr)) return hr;
ResizeVideoWindow();   // 更改窗口大小
hr = m_pVW->put_Visible(OATRUE);  // 显示视频窗口
return hr;
}

HRESULT CCapture::InitCaptureGraphBuilder()
{
HRESULT hr;
//创建IGraphBuilder接口(滤波器链表管理器) m_pGB
hr = CoCreateInstance(CLSID_FilterGraph, NULL,
CLSCTX_INPROC, IID_IGraphBuilder, (void **)&m_pGB);
if (FAILED(hr)) return hr;
//创建ICaptureGraphBuilder2接口（增强型捕获滤波器链表管理器）m_pCapGB
hr = CoCreateInstance(CLSID_CaptureGraphBuilder2, NULL,
CLSCTX_INPROC, IID_ICaptureGraphBuilder2, (void **)&m_pCapGB);
if (FAILED(hr)) return hr;
// 创建抓取图片滤波器
if (m_pGrabber){
m_pGrabber.Release();
m_pGrabber = NULL;
}

hr = CoCreateInstance(CLSID_SampleGrabber, NULL,CLSCTX_INPROC_SERVER, IID_ISampleGrabber, (void **)&m_pGrabber);
//	hr = m_pGrabber.CoCreateInstance( CLSID_SampleGrabber );
if (FAILED(hr)) return hr;
// 初始化滤波器链表管理器IGraphBuilder
m_pCapGB->SetFiltergraph(m_pGB);
// 查询媒体控制接口
hr = m_pGB->QueryInterface(IID_IMediaControl, (void **)&m_pMC);
if (FAILED(hr))  return hr;
// 查询视频窗口接口
hr = m_pGB->QueryInterface(IID_IVideoWindow, (LPVOID *)&m_pVW);
if (FAILED(hr)) return hr;
/////
return hr;
}

HRESULT CCapture::Preview( int iDevVideoID, HWND hVideo, int iDevAudioID /*= 0*/, HWND hAudio /*= NULL*/ )
{
HRESULT hr;
if (m_pMC)
m_pMC->Stop();
m_bRecording = false;
// 初始化视频捕获滤波器链表管理器
hr = InitCaptureGraphBuilder();
if (FAILED(hr)) return hr;

// 把指定的视频采集设备与滤波器捆绑
if (BindFilter(iDevVideoID, &m_pVideoCap, DTypeVideo))
{
// 把滤波器添加到滤波器链表中
hr = m_pGB->AddFilter(m_pVideoCap, L"Video Capture Filter");
if (FAILED(hr)) return hr;
}
else return FALSE;

if (BindFilter(iDevAudioID, &m_pAudioCap, DTypeAudio))
{
hr = m_pGB->AddFilter(m_pAudioCap, L"Audio Capture Filter");
if (FAILED(hr))
{
MessageBox(NULL, _T("绑定音频设备失败!"), _T("系统提示"), MB_OK|MB_ICONINFORMATION);
//	return hr;
}
}
else
{
MessageBox(NULL, _T("绑定音频设备失败!"), _T("系统提示"), MB_OK|MB_ICONINFORMATION);
//	return FALSE;
}
// 如果我们想抓取24位的RGB图片，如下设置媒体图片类型
CComQIPtr<IBaseFilter, &IID_IBaseFilter> pGrabBase(m_pGrabber);

AM_MEDIA_TYPE mediaType;
VIDEOINFOHEADER vih;

IAMStreamConfig* pConfig = NULL;
m_pCapGB->FindInterface(&PIN_CATEGORY_CAPTURE, &MEDIATYPE_Video, m_pVideoCap, IID_IAMStreamConfig, (void**)&pConfig);
// 设置视频格式
ZeroMemory(&mediaType, sizeof(AM_MEDIA_TYPE));
vih.bmiHeader.biWidth = IMG_WIDTH;
vih.bmiHeader.biHeight = IMG_HEIGHT;
vih.bmiHeader.biSizeImage = IMG_HEIGHT*IMG_WIDTH*3;
mediaType.pbFormat = (BYTE *)(&vih);
mediaType.cbFormat = sizeof(VIDEOINFOHEADER);
mediaType.subtype = MEDIASUBTYPE_YUY2;
mediaType.majortype = MEDIATYPE_Video;
mediaType.formattype = FORMAT_VideoInfo;
hr = pConfig->SetFormat(&mediaType);
hr = m_pGrabber->SetMediaType(&mediaType);
if( FAILED( hr ) ){
AfxMessageBox("Fail to set media type!");
return hr;
}

hr = m_pGB->AddFilter(pGrabBase, L"SampleGrabber");
if (FAILED(hr)) return hr;
// 渲染媒体， 把链表中滤波器链接起来
hr = m_pCapGB->RenderStream(&PIN_CATEGORY_PREVIEW, &MEDIATYPE_Audio, m_pAudioCap, NULL, NULL);
hr = m_pCapGB->RenderStream(&PIN_CATEGORY_PREVIEW, &MEDIATYPE_Video, m_pVideoCap, pGrabBase, NULL);
if (FAILED(hr))
hr = m_pCapGB->RenderStream(&PIN_CATEGORY_CAPTURE, &MEDIATYPE_Video, m_pVideoCap, pGrabBase, NULL);
if( FAILED( hr ) ){
AfxMessageBox(_T("Can’t build the graph"));
return hr;
}

////////// 设置图片捕获数据
hr = m_pGrabber->GetConnectedMediaType( &mediaType );
if ( FAILED( hr) ){
AfxMessageBox(_T("Failt to read the connected media type"));
return hr;
}
VIDEOINFOHEADER * pVih = (VIDEOINFOHEADER*)mediaType.pbFormat;
samCB.lWidth = pVih->bmiHeader.biWidth;
samCB.lHeight = pVih->bmiHeader.biHeight;
samCB.pCap = (CCapture *)this;
FreeMediaType(mediaType);
hr = m_pGrabber->SetBufferSamples( TRUE );  // 如果此处为false 第一次抓取图片时失败(不用回调方式)
hr = m_pGrabber->SetOneShot( FALSE );
hr = m_pGrabber->SetCallback( &samCB, 1 );
SetOnShot(TRUE);// ture 时开始捕获视频帧数据
// 设置视频显示窗口
m_hWnd = hVideo;
SetupVideoWindow(); // 设置显示窗口
hr = m_pMC->Run();  // 开始采集、预览视频，并在指定窗口显示
if (FAILED(hr))
{
MessageBox(NULL, _T("请检查该设备是否被占用!"), _T("系统提示"), MB_OK|MB_ICONINFORMATION);
return hr;
}
return S_OK;
}

#if 1  // avi video format
HRESULT CCapture::CaptureVideo( CString inFileName )  // 录制视频
{
HRESULT hr = 0;
DWORD dwId;
HANDLE hThread;
m_bRecording = false;
m_pMC->Stop();   // 先停止视频采集

// 设置文件名，注意第二个参数类型
hr = m_pCapGB->SetOutputFileName(&MEDIASUBTYPE_Avi, inFileName.AllocSysString(), &m_pMux, NULL);

//渲染媒体 连接捕获器和AVI Muxer过滤器
hr = m_pCapGB->RenderStream(&PIN_CATEGORY_CAPTURE, &MEDIATYPE_Video, m_pVideoCap, NULL, m_pMux);
hr = m_pCapGB->RenderStream(&PIN_CATEGORY_CAPTURE, &MEDIATYPE_Audio, m_pAudioCap, NULL, m_pMux);
//设置音频流为主流
IConfigAviMux *pConfigMux;
m_pMux->QueryInterface(IID_IConfigAviMux, (void **)&pConfigMux);
hr = pConfigMux->SetMasterStream(1);   // 0 为视频  1为音频

pConfigMux->Release();
m_pMux->Release();
m_bRecording = true;
hThread = CreateThread(NULL, 0,
(LPTHREAD_START_ROUTINE)ThreadFunDrawText,
(LPVOID)m_hWnd,
0, &dwId);
m_pMC->Run();  // 恢复视频采集，同时写入文件

return hr;
}
#else  // mpeg4 format video
HRESULT CCapture::CaptureVideo(CString inFileName)
{
HRESULT hr=0;

m_pMC->Stop();

m_pGB->AddFilter(m_pXviDCodec,L"99 Xvid MPEG-4 Codec");
m_pXviDCodec->Release();

hr = m_pCapGB->SetOutputFileName(&MEDIASUBTYPE_Avi, inFileName.AllocSysString(), &m_pMux, NULL );
hr = ConnectFilters(m_pGB,m_pSmartTee_1,m_pXviDCodec, 0);    //0，连接capture引脚
hr = ConnectFilters(m_pGB,m_pXviDCodec,m_pMux, 2);    //2，默认自然连接
m_pMux->Release();

m_pMC->Run();

return hr;
}
#endif

///////////////////////////////

HRESULT CCapture::CaptureImage() // 抓取并显示图像
{ // 采用CB接口回调函数存储图片
bOneShot = TRUE;
return 0;
}

HRESULT CCapture::CaptureImage( CString inFileName ) // 抓取图像
{
HRESULT hr;
AM_MEDIA_TYPE mediaType;
hr = m_pGrabber->GetConnectedMediaType(&mediaType);
if (FAILED(hr))  return hr;
VIDEOINFOHEADER *pVih;
if (mediaType.formattype == FORMAT_VideoInfo &&
(mediaType.cbFormat >= sizeof(VIDEOINFOHEADER)) &&
mediaType.pbFormat != NULL)
{
pVih = (VIDEOINFOHEADER *)mediaType.pbFormat;
}
else
return VFW_E_INVALIDMEDIATYPE;

//	hr = m_pGrabber->SetOneShot(TRUE);
if (SUCCEEDED(m_pGrabber->SetBufferSamples(TRUE)) )  // 设置为缓冲形式)
{
long cbBuffer = 0;
hr = m_pGrabber->GetCurrentBuffer(&cbBuffer, NULL);
BYTE *pBuffer = new BYTE[cbBuffer];
if (!pBuffer) return -1;
// 获取一帧媒体的数据
hr = m_pGrabber->GetCurrentBuffer(&cbBuffer, (long *)pBuffer);
if (FAILED(hr))  return hr;
//  		if (pBuffer != NULL)
//  		{
//  			calFunc(pBuffer);   // 将一帧图像数据传给显示函数
// 		}

///-------------------------测试所得数据是rgb格式还是yuv格式--------
long n1,n2;
int datalen = IMG_WIDTH*IMG_HEIGHT*3;
BYTE *rgb = new BYTE[datalen];

YUV422_C_RGB(pBuffer,rgb, IMG_HEIGHT, IMG_WIDTH);
n1 = strlen((char *)pBuffer);
n2 = strlen((char *)rgb);
//		((CVideoNetDlg *)(m_dlgParent))->SendVideo((BYTE *)pBuffer, (int)cbBuffer);
///------------------------------------------------------------------
///////////////////////////////////////////////////////////////
// Create a file to hold the bitmap
HANDLE hf = CreateFile(inFileName, GENERIC_WRITE, FILE_SHARE_READ,
NULL, CREATE_ALWAYS, NULL, NULL );

if( hf == INVALID_HANDLE_VALUE ){
MessageBox(NULL, _T("Create bmp file failure!"), _T(""), MB_OK|MB_ICONINFORMATION);
return 0;
}

// Write out the file header
//
// 信息头
BITMAPFILEHEADER bfh;
memset( &bfh, 0, sizeof( bfh ) );
bfh.bfType = 'MB';
bfh.bfSize = sizeof( bfh ) + cbBuffer + sizeof( BITMAPINFOHEADER );
bfh.bfOffBits = sizeof( BITMAPINFOHEADER ) + sizeof( BITMAPFILEHEADER );

DWORD Written = 0;
WriteFile( hf, &bfh, sizeof( bfh ), &Written, NULL );

// Write the bitmap format
//文件头
BITMAPINFOHEADER bih;
memset( &bih, 0, sizeof( bih ) );
bih.biSize = sizeof( bih );
bih.biWidth = pVih->bmiHeader.biWidth;
bih.biHeight = pVih->bmiHeader.biHeight;
bih.biPlanes = 1;
bih.biBitCount = 24;

Written = 0;
WriteFile( hf, &bih, sizeof( bih ), &Written, NULL );

// Write the bitmap bits
//
Written = 0;
WriteFile( hf, rgb, datalen, &Written, NULL );
CloseHandle( hf );
delete pBuffer;
MessageBox(NULL, _T("Save photo succeeded!"), _T("抓取图片提示"), MB_OK|MB_ICONINFORMATION);
}
m_pGrabber->SetOneShot(FALSE);
m_pGrabber->SetBufferSamples(FALSE);
FreeMediaType(mediaType);
return 0;
}

bool CCapture::BindFilter( int iDeviceID, IBaseFilter **pOutFilter, DeviceType deviceType )
{
if (iDeviceID < 0) return false;
// 枚举所有的视频设备
ICreateDevEnum *pCreateDevEnum;
//生成设备枚举器pCreateDevEnum
HRESULT hr = CoCreateInstance(CLSID_SystemDeviceEnum,
NULL, CLSCTX_INPROC_SERVER, IID_ICreateDevEnum, (void **)&pCreateDevEnum);
if (hr != NOERROR) return false;
IEnumMoniker *pEM;
// 创建视频输入设备类枚举器
if (deviceType == DTypeVideo)
hr = pCreateDevEnum->CreateClassEnumerator(CLSID_VideoInputDeviceCategory, &pEM, 0);
// 音频设备枚举器
else
hr = pCreateDevEnum->CreateClassEnumerator(CLSID_AudioInputDeviceCategory, &pEM, 0);
if (hr != NOERROR) return false;
pEM->Reset();  // 复位该设备
ULONG cFetched;
IMoniker *pM;
int indexDev = 0;
// 获取设备
while(hr = pEM->Next(1, &pM, &cFetched), hr == S_OK, indexDev <= iDeviceID)
{
IPropertyBag *pBag;
// 获取该设备属性集
hr = pM->BindToStorage(0,0,IID_IPropertyBag,(void **)&pBag);
if (SUCCEEDED(hr))
{
VARIANT var;
var.vt = VT_BSTR;
hr = pBag->Read(L"FriendlyName", &var, NULL);
if (hr == NOERROR)
{
// 采集设备与捕获滤波器捆绑
if (indexDev == iDeviceID) pM->BindToObject(0, 0, IID_IBaseFilter, (void **)pOutFilter);
SysFreeString(var.bstrVal);
}
pBag->Release();
}
pM->Release();
indexDev++;
}
return true;
}

void CCapture::SetCameraFormat( HWND hwndParent ) // 设置视频格式
{
HRESULT hr;
IAMStreamConfig *pSC; // 流配置接口
ISpecifyPropertyPages *pSpec; //属性页接口
m_pMC->Stop();  // 只有停止后才能进行引脚属性的设置
m_bRecording = false;
// 首先查询捕获CAPTURE、视频Video接口
hr = m_pCapGB->FindInterface(&PIN_CATEGORY_CAPTURE, &MEDIATYPE_Video,
m_pVideoCap, IID_IAMStreamConfig, (void **)&pSC);

CAUUID cauuid; // 所有属性页结构体
hr = pSC->QueryInterface(IID_ISpecifyPropertyPages, (void **)&pSpec);
if (hr == S_OK)
{
// 显示属性页窗口
hr = pSpec->GetPages(&cauuid);  // 获取所有属性页
hr = OleCreatePropertyFrame(hwndParent, 30, 30, NULL, 1,
(IUnknown **)&pSC, cauuid.cElems, (GUID *)cauuid.pElems, 0, 0, NULL);
// 释放内存资源
CoTaskMemFree(cauuid.pElems);
pSpec->Release();
pSC->Release();
}
// 恢复运行
m_pMC->Run();
}

void CCapture::SetCameraFilter( HWND hwndParent ) // 设置图像各参数设置
{
HRESULT hr = 0;
ISpecifyPropertyPages *pSpec;
hr = m_pVideoCap->QueryInterface(IID_ISpecifyPropertyPages, (void **)&pSpec);
if (SUCCEEDED(hr))
{
// 获取滤波器名称和IUnknown 接口指针
FILTER_INFO FilterInfo;
hr = m_pVideoCap->QueryFilterInfo(&FilterInfo);
IUnknown *pFilterUnk;
m_pVideoCap->QueryInterface(IID_IUnknown, (void **)&pFilterUnk);
// 显示该页
CAUUID caGUID;
pSpec->GetPages(&caGUID);
OleCreatePropertyFrame(hwndParent,
0, 0,
FilterInfo.achName,
1,
&pFilterUnk,
caGUID.cElems,
caGUID.pElems,
0,
0, NULL);
// 释放内存资源
CoTaskMemFree(caGUID.pElems);
pFilterUnk->Release();
FilterInfo.pGraph->Release();
pSpec->Release();
}
}

void CCapture::StopCapture()
{
m_pMC->Stop();
}

UINT CCapture::ThreadFunDrawText( LPVOID lParam )
{
HWND hwnd = (HWND)lParam;
if (hwnd == NULL) return -1;
HDC hdc = GetDC(hwnd);
CRect rcDraw, rcTime;
CTime time, time0;
CTimeSpan timespan;
CString strTime;
CBrush br;
time0 = CTime::GetCurrentTime();
br.CreateSolidBrush(RGB(255,0,0));
GetClientRect(hwnd, &rcDraw);
rcTime = rcDraw;
rcTime.bottom = rcTime.top + 30;
rcDraw.top = rcDraw.bottom - 30;
SelectObject(hdc, &br);
SetTextColor(hdc, 0x0000ff);
SetBkMode(hdc, TRANSPARENT);
while(m_bRecording)
{
time = CTime::GetCurrentTime();
timespan = time - time0;
strTime = time.Format(_T(" %Y-%m-%d 星期%w %H:%M:%S"));
DrawText(hdc, strTime, strTime.GetLength(), &rcTime, DT_VCENTER|DT_LEFT|DT_SINGLELINE);
strTime = timespan.Format(_T("%H:%M:%S "));
strTime = _T("●录制 ") + strTime;
DrawText(hdc, strTime, strTime.GetLength(), &rcDraw, DT_VCENTER|DT_RIGHT|DT_SINGLELINE);
}
return 0;
}

void CCapture::FreeMediaType(AM_MEDIA_TYPE &mt)
{
if (mt.cbFormat != 0)
{
CoTaskMemFree((PVOID)mt.pbFormat);
mt.cbFormat = 0;
mt.pbFormat = NULL;
}
if (mt.pUnk != NULL)
{
mt.pUnk->Release();
mt.pUnk = NULL;
}
}

void CCapture::SetOnShot( BOOL bFlag )
{
bOneShot = bFlag;
}

void CCapture::SetCallBKFun( capCallBackFunc f )
{
this->calFunc = f;
samCB.pCap = static_cast<CCapture *>(this);
}

void CCapture::SetParent( CDialog *pdlg )
{
m_dlgParent = pdlg;
}