/* 枚举本地系统的采集设备 */
int CVMR_Capture::EnumDevices(HWND hList)
{
if (!hList) return -1;
int id = 0;
// enumerate all video capture devices
ICreateDevEnum *pCreateDevEnum;
HRESULT hr = CoCreateInstance(CLSID_SystemDeviceEnum, NULL,
CLSCTX_INPROC_SERVER,
IID_ICreateDevEnum, (void**)&pCreateDevEnum);
if (hr != NOERROR) return -1;
IEnumMoniker *pEm;
hr = pCreateDevEnum->CreateClassEnumerator(CLSID_VideoInputDeviceCategory, &pEm, 0);
if (hr != NOERROR) 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;
hr = pBag->Read(L"FriendlyName", &var, NULL);
if (hr == NOERROR)
{
id++;
(long)SendMessage(hList, CB_ADDSTRING, 0,(LPARAM)var.bstrVal);
SysFreeString(var.bstrVal);
}
pBag->Release();
}
pM->Release();
}
return id;
}
// Code from http://msdn.microsoft.com/en-us/library/windows/desktop/dd377566(v=vs.85).aspx
void Video::EnumerateDevices( EnumerateDelegate _pDeviceEnumerator, void* _pUserData )
{
IEnumMoniker* pEnumerator = NULL;
ASSERT( SUCCEEDED( EnumerateDevices( CLSID_VideoInputDeviceCategory, &pEnumerator ) ), "Failed enumerating devices!" );
VARIANT varFriendlyName, varDevicePath;
VariantInit( &varFriendlyName );
VariantInit( &varDevicePath );
int DeviceIndex = 0;
IMoniker* pMoniker = NULL;
while ( pEnumerator->Next( 1, &pMoniker, NULL ) == S_OK )
{
IPropertyBag* pPropBag;
HRESULT hr = pMoniker->BindToStorage( 0, 0, IID_PPV_ARGS( &pPropBag ) );
if ( FAILED(hr) )
{
pMoniker->Release();
continue;
}
// Get friendly name.
hr = pPropBag->Read( L"FriendlyName", &varFriendlyName, 0 );
if ( !SUCCEEDED(hr) )
continue;
hr = pPropBag->Read( L"DevicePath", &varDevicePath, 0 );
if ( !SUCCEEDED(hr) )
continue;
// Notify delegate
(*_pDeviceEnumerator)( DeviceIndex++, varFriendlyName.bstrVal, varDevicePath.bstrVal, pMoniker, _pUserData );
pPropBag->Release();
pMoniker->Release();
}
pEnumerator->Release();
}
void EnumDSF(void)
{
ICreateDevEnum *pCreateDevEnum;
IEnumMoniker *pEnumMoniker;
IMoniker *pMoniker;
ULONG nFetched;
char buf[256];
CoCreateInstance(CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC_SERVER, IID_ICreateDevEnum, (PVOID *)&pCreateDevEnum);
if (pCreateDevEnum->CreateClassEnumerator(CLSID_VideoCompressorCategory, &pEnumMoniker, 0) != S_OK)
{
pCreateDevEnum->Release();
return;
}
pEnumMoniker->Reset();
while (pEnumMoniker->Next(1, &pMoniker, &nFetched) == S_OK)
{
IPropertyBag *pPropertyBag;
VARIANT varFriendlyName;
WCHAR *pwszDisplayName;
pMoniker->GetDisplayName(NULL, NULL, &pwszDisplayName);
varFriendlyName.vt = VT_BSTR;
pMoniker->BindToStorage(0, 0, IID_IPropertyBag, (void **)&pPropertyBag);
pPropertyBag->Read(L"FriendlyName", &varFriendlyName, 0);
wsprintf(buf, "DSF\t1\t%S\t%S\n", varFriendlyName.bstrVal, pwszDisplayName);
printf("%s", buf);
VariantClear(&varFriendlyName);
CoTaskMemFree(pwszDisplayName);
pPropertyBag->Release();
pMoniker->Release();
}
pEnumMoniker->Release();
pCreateDevEnum->Release();
}
IMoniker* Device_Read(ICreateDevEnum* pDeviceEnum,IMoniker *pDeviceMonik,GUID DEVICE_CLSID,BSTR bstrDeviceName)
{
HRESULT hr;
IEnumMoniker *pEnumCat = NULL;// Device enumeration moniker
VARIANT varName;
hr = pDeviceEnum->CreateClassEnumerator(DEVICE_CLSID, &pEnumCat, 0);// Enumerate the specified device, distinguished by DEVICE_CLSID
if (hr == S_OK)
{
ULONG cFetched;
while (pEnumCat->Next(1, &pDeviceMonik, &cFetched) == S_OK)//Pickup as moniker
{
IPropertyBag *pPropBag = NULL;
hr = pDeviceMonik->BindToStorage(0, 0, IID_IPropertyBag,(void **)&pPropBag);//bind the properties of the moniker
if (SUCCEEDED(hr))
{
VariantInit(&varName);// Initialise the variant data type
hr = pPropBag->Read(L"FriendlyName", &varName, 0);
if (SUCCEEDED(hr))
{
if(Bstr_Compare(varName.bstrVal,bstrDeviceName) == true)//make a comparison
{
wcout<<varName.bstrVal<<" found"<<endl;
return pDeviceMonik;
}
}
else HR_Failed(hr);
VariantClear(&varName);//clear the variant data type
pPropBag->Release();//release the properties
}
else HR_Failed(hr);
pDeviceMonik->Release();//release Device moniker
}
pEnumCat->Release();//release category enumerator
}
else HR_Failed(hr);
return NULL;
}
bool CDirectShowDeviceEnumerator::EnumDevice(REFCLSID clsidDeviceClass)
{
HRESULT hr;
ICreateDevEnum *pDevEnum;
hr=::CoCreateInstance(CLSID_SystemDeviceEnum,NULL,CLSCTX_INPROC_SERVER,
IID_ICreateDevEnum,reinterpret_cast<void**>(&pDevEnum));
if (FAILED(hr))
return false;
IEnumMoniker *pEnumCategory;
hr=pDevEnum->CreateClassEnumerator(clsidDeviceClass,&pEnumCategory,0);
if (hr==S_OK) {
IMoniker *pMoniker;
ULONG cFetched;
while (pEnumCategory->Next(1,&pMoniker,&cFetched)==S_OK) {
IPropertyBag *pPropBag;
hr=pMoniker->BindToStorage(0,0,IID_IPropertyBag,reinterpret_cast<void**>(&pPropBag));
if (SUCCEEDED(hr)) {
VARIANT varName;
::VariantInit(&varName);
hr=pPropBag->Read(L"FriendlyName",&varName,0);
if (SUCCEEDED(hr)) {
m_DeviceList.push_back(CDeviceInfo(varName.bstrVal));
}
::VariantClear(&varName);
pPropBag->Release();
}
pMoniker->Release();
}
pEnumCategory->Release();
}
pDevEnum->Release();
return true;
}
IBaseFilter *GetAudioDevice (){
// Create the system device enumerator.
ICreateDevEnum *pDevEnum = NULL;
CoCreateInstance(CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC,
IID_ICreateDevEnum, (void **)&pDevEnum);
// Create an enumerator for video capture devices.
IEnumMoniker *pClassEnum = NULL;
pDevEnum->CreateClassEnumerator(CLSID_AudioInputDeviceCategory, &pClassEnum, 0);
ULONG cFetched;
IMoniker *pMoniker = NULL;
IBaseFilter *pSrc = NULL;
if (pClassEnum->Next(1, &pMoniker, &cFetched) == S_OK)
{
// Bind the first moniker to a filter object.
pMoniker->BindToObject(0, 0, IID_IBaseFilter, (void**)&pSrc);
pMoniker->Release();
}
pClassEnum->Release();
pDevEnum->Release();
return pSrc;
}
Camera::Camera(bool Show,bool Start) : eHandler(this),_realData(false),_UpdateWindow(Show),_LastData(0),_CurData(0) {
DWORD no;
IGraphBuilder *graph = 0;
ctrl = 0;
ICreateDevEnum *devs = 0;
IEnumMoniker *cams = 0;
IMoniker *mon = 0;
IBaseFilter *cam = 0;
IEnumPins *pins = 0;
IPin *pin = 0;
IEnumFilters *fil = 0;
IBaseFilter *rnd = 0;
IMemInputPin *mem = 0;
curCamera = this;
_isOn = Start;
CoCreateInstance( CLSID_FilterGraph, 0, CLSCTX_INPROC,IID_IGraphBuilder, (void **)&graph );
graph->QueryInterface( IID_IMediaControl, (void **)&ctrl );
CoCreateInstance (CLSID_SystemDeviceEnum, 0, CLSCTX_INPROC, IID_ICreateDevEnum, (void **) &devs);
devs->CreateClassEnumerator (CLSID_VideoInputDeviceCategory, &cams, 0);
cams->Next (1,&mon,0); // get first found capture device (webcam)
mon->BindToObject(0,0,IID_IBaseFilter, (void**)&cam);
graph->AddFilter(cam, L"Capture Source"); // add web cam to graph as source
cam->EnumPins(&pins); // we need output pin to autogenerate rest of the graph
pins->Next(1,&pin, 0); // via graph->Render
graph->Render(pin); // graph builder now builds whole filter chain including MJPG decompression on some webcams
graph->EnumFilters(&fil); // from all newly added filters
fil->Next(1,&rnd,0); // we find last one (renderer)
rnd->EnumPins(&pins); // because data we are intersted in are pumped to renderers input pin
pins->Next(1,&pin, 0); // via Receive member of IMemInputPin interface
pin->QueryInterface(IID_IMemInputPin,(void**)&mem);
DsHook(mem,6,Receive); // so we redirect it to our own proc to grab image data
if (Start) this->Start();
}
IBaseFilter * GetFilter(const char * fname)
{
HRESULT hr;
IFilterMapper3 * pFM3;
hr = CoCreateInstance(CLSID_FilterMapper2, NULL, CLSCTX_INPROC_SERVER,
IID_IFilterMapper3, (void **)&pFM3);
ICreateDevEnum *pSysDevEnum = NULL;
hr = pFM3->GetICreateDevEnum(&pSysDevEnum);
/*
hr = CoCreateInstance(CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC_SERVER,
IID_ICreateDevEnum, (void **)&pSysDevEnum);
*/
if (FAILED(hr))
{
return NULL;
}
IEnumMoniker *pEnumCat = NULL;
hr = pSysDevEnum->CreateClassEnumerator(CLSID_LegacyAmFilterCategory, &pEnumCat, 0);
char str[BUFSIZE_MONIKER_INF];
IBaseFilter *pFilter = NULL;
if (hr == S_OK)
{
// Enumerate the monikers.
IMoniker *pMoniker = NULL;
ULONG cFetched;
// cout << "Seeking ffdshow Video Decoder" << endl;
int ifilter = 0;
while(pEnumCat->Next(1, &pMoniker, &cFetched) == S_OK && pFilter == NULL)
{
IPropertyBag *pPropBag;
hr = pMoniker->BindToStorage(0, 0, IID_IPropertyBag,
(void **)&pPropBag);
if (SUCCEEDED(hr))
{
VARIANT varName;
VariantInit(&varName);
hr = pPropBag->Read(L"FriendlyName", &varName, 0);
if (SUCCEEDED(hr))
{
wcstombs(str, varName.bstrVal, BUFSIZE_MONIKER_INF);
// cout << ifilter << ":" << str << endl;
if(strcmp(str, fname) == 0){
hr = pMoniker->BindToObject(NULL, NULL, IID_IBaseFilter,
(void**)&pFilter);
}
}
VariantClear(&varName);
pPropBag->Release();
}
ifilter++;
pMoniker->Release();
}
pEnumCat->Release();
}
pSysDevEnum->Release();
pFM3->Release();
return pFilter;
}
QList<QByteArray> QWindowsAudioDeviceInfo::availableDevices(QAudio::Mode mode)
{
Q_UNUSED(mode)
QList<QByteArray> devices;
#ifndef Q_OS_WINCE
//enumerate device fullnames through directshow api
CoInitialize(NULL);
ICreateDevEnum *pDevEnum = NULL;
IEnumMoniker *pEnum = NULL;
// Create the System device enumerator
HRESULT hr = CoCreateInstance(CLSID_SystemDeviceEnum, NULL,
CLSCTX_INPROC_SERVER, IID_ICreateDevEnum,
reinterpret_cast<void **>(&pDevEnum));
unsigned long iNumDevs = mode == QAudio::AudioOutput ? waveOutGetNumDevs() : waveInGetNumDevs();
if (SUCCEEDED(hr)) {
// Create the enumerator for the audio input/output category
if (pDevEnum->CreateClassEnumerator(
mode == QAudio::AudioOutput ? CLSID_AudioRendererCategory : CLSID_AudioInputDeviceCategory,
&pEnum, 0) == S_OK) {
pEnum->Reset();
// go through and find all audio devices
IMoniker *pMoniker = NULL;
while (pEnum->Next(1, &pMoniker, NULL) == S_OK) {
IPropertyBag *pPropBag;
hr = pMoniker->BindToStorage(0,0,IID_IPropertyBag,
reinterpret_cast<void **>(&pPropBag));
if (FAILED(hr)) {
pMoniker->Release();
continue; // skip this one
}
// Find if it is a wave device
VARIANT var;
VariantInit(&var);
hr = pPropBag->Read(mode == QAudio::AudioOutput ? L"WaveOutID" : L"WaveInID", &var, 0);
if (SUCCEEDED(hr)) {
LONG waveID = var.lVal;
if (waveID >= 0 && waveID < LONG(iNumDevs)) {
VariantClear(&var);
// Find the description
hr = pPropBag->Read(L"FriendlyName", &var, 0);
if (SUCCEEDED(hr)) {
QByteArray device;
QDataStream ds(&device, QIODevice::WriteOnly);
ds << quint32(waveID) << QString::fromWCharArray(var.bstrVal);
devices.append(device);
}
}
}
pPropBag->Release();
pMoniker->Release();
}
}
}
CoUninitialize();
#else // Q_OS_WINCE
if (mode == QAudio::AudioOutput) {
WAVEOUTCAPS woc;
unsigned long iNumDevs,i;
iNumDevs = waveOutGetNumDevs();
for (i=0;i<iNumDevs;i++) {
if (waveOutGetDevCaps(i, &woc, sizeof(WAVEOUTCAPS))
== MMSYSERR_NOERROR) {
QByteArray device;
QDataStream ds(&device, QIODevice::WriteOnly);
ds << quint32(i) << QString::fromWCharArray(woc.szPname);
devices.append(device);
}
}
} else {
WAVEINCAPS woc;
unsigned long iNumDevs,i;
iNumDevs = waveInGetNumDevs();
for (i=0;i<iNumDevs;i++) {
if (waveInGetDevCaps(i, &woc, sizeof(WAVEINCAPS))
== MMSYSERR_NOERROR) {
QByteArray device;
QDataStream ds(&device, QIODevice::WriteOnly);
ds << quint32(i) << QString::fromWCharArray(woc.szPname);
devices.append(device);
}
}
}
#endif // !Q_OS_WINCE
return devices;
}
/*
* Enumerate all video devices
*
* See also:
*
* Using the System Device Enumerator:
* http://msdn2.microsoft.com/en-us/library/ms787871.aspx
*/
int enum_devices()
{
HRESULT hr;
printf("Enumerating video input devices ...\n");
// Create the System Device Enumerator.
ICreateDevEnum *pSysDevEnum = NULL;
hr = CoCreateInstance(CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC_SERVER,
IID_ICreateDevEnum, (void **)&pSysDevEnum);
if(FAILED(hr))
{
fprintf(stderr, "ERROR: Unable to create system device enumerator.\n");
return hr;
}
// Obtain a class enumerator for the video input device category.
IEnumMoniker *pEnumCat = NULL;
hr = pSysDevEnum->CreateClassEnumerator(CLSID_VideoInputDeviceCategory, &pEnumCat, 0);
if(hr == S_OK)
{
// Enumerate the monikers.
IMoniker *pMoniker = NULL;
ULONG cFetched;
while(pEnumCat->Next(1, &pMoniker, &cFetched) == S_OK)
{
IPropertyBag *pPropBag;
hr = pMoniker->BindToStorage(0, 0, IID_IPropertyBag,
(void **)&pPropBag);
if(SUCCEEDED(hr))
{
// To retrieve the filter's friendly name, do the following:
VARIANT varName;
VariantInit(&varName);
hr = pPropBag->Read(L"FriendlyName", &varName, 0);
if (SUCCEEDED(hr))
{
// Display the name in your UI somehow.
wprintf(L" Found device: %s\n", varName.bstrVal);
}
VariantClear(&varName);
// To create an instance of the filter, do the following:
IBaseFilter *pFilter;
hr = pMoniker->BindToObject(NULL, NULL, IID_IBaseFilter,
(void**)&pFilter);
process_filter(pFilter);
//Remember to release pFilter later.
pPropBag->Release();
}
pMoniker->Release();
}
pEnumCat->Release();
}
pSysDevEnum->Release();
return 0;
}
void MainDialog::OnButtonSearch()
{
HRESULT hr=S_OK;
int nFilters = 0;
IEnumMoniker *pEnum = NULL;
IMoniker *pMoniker=0;
// Clear any previous results
m_ListFilters.ClearItems();
// Enumerate filters based on the current dialog box selections.
hr = EnumerateFilters(&pEnum);
if (FAILED(hr))
{
return;
}
// Reset the enumerator.
hr = pEnum->Reset(); // Not strictly necessary but can't hurt.
// Go through each moniker in the collection.
while((hr = pEnum->Next(1, &pMoniker, NULL)) == S_OK)
{
IPropertyBag *pPropBag = NULL;
DWORD dwMerit;
VARIANT varName;
VARIANT varFilterClsid;
VariantInit(&varName);
VariantInit(&varFilterClsid);
// Initialize variant types
varName.vt = VT_BSTR;
varFilterClsid.vt = VT_BSTR;
// Get a property bag for this moniker.
hr = pMoniker->BindToStorage(
0, 0, IID_IPropertyBag, (void **)&pPropBag);
// Read the filter name from the property bag
if (SUCCEEDED(hr))
{
hr = pPropBag->Read(L"FriendlyName", &varName, 0);
}
// Read the Merit value from the property bag
if (SUCCEEDED(hr))
{
hr = GetMerit(pPropBag, &dwMerit);
}
// Read filter's CLSID from property bag. The CLSID is
// returned as a string (BSTR).
if (SUCCEEDED(hr))
{
hr = pPropBag->Read(L"CLSID", &varFilterClsid, 0);
}
// Add filter name and filename to listbox
if(SUCCEEDED(hr))
{
nFilters++;
AddFilterToList(varName.bstrVal, varFilterClsid.bstrVal, dwMerit);
}
// Clean up.
SysFreeString(varFilterClsid.bstrVal);
SysFreeString(varName.bstrVal);
SAFE_RELEASE(pPropBag);
SAFE_RELEASE(pMoniker);
}
// Display number of filters matching query
WCHAR szNumFilters[48];
hr = StringCchPrintf(szNumFilters, NUMELMS(szNumFilters), L"Filters Matching Query : %d\0", nFilters);
SetDlgItemText(IDC_STATIC_NUMFILTERS, szNumFilters);
if (nFilters == 0)
{
m_ListFilters.AddString(L"<No filters matched query>");
}
// Clean up enumerator
SAFE_RELEASE(pEnum);
}
void ListCodecs() {
HRESULT hr;
ICreateDevEnum *pSysDevEnum = NULL;
IEnumMoniker *pEnum = NULL;
IMoniker *pMoniker = NULL;
pEngfuncs->Con_Printf("Codecs:\n");
hr = CoCreateInstance(CLSID_SystemDeviceEnum, NULL,
CLSCTX_INPROC_SERVER, IID_ICreateDevEnum,
(void**)&pSysDevEnum);
if (FAILED(hr))
{
return;
}
hr = pSysDevEnum->CreateClassEnumerator(
CLSID_VideoCompressorCategory, &pEnum, 0);
if (hr == S_OK) // S_FALSE means nothing in this category.
{
while (S_OK == pEnum->Next(1, &pMoniker, NULL))
{
IPropertyBag *pPropBag = NULL;
pMoniker->BindToStorage(0, 0, IID_IPropertyBag,
(void **)&pPropBag);
VARIANT var;
VariantInit(&var);
hr = pPropBag->Read(L"FriendlyName", &var, 0);
if (SUCCEEDED(hr))
{
int ilen=WideCharToMultiByte(
CP_ACP,
0,
var.bstrVal,
-1,
NULL,
0,
NULL,
NULL
);
LPSTR str = (LPSTR)malloc(ilen);
if(0 != WideCharToMultiByte(
CP_ACP,
0,
var.bstrVal,
-1,
str,
ilen,
NULL,
NULL
))
pEngfuncs->Con_Printf("%s\n", str);
free(str);
}
VariantClear(&var);
pPropBag->Release();
pMoniker->Release();
}
}
pSysDevEnum->Release();
pEnum->Release();
}
HRESULT RecordGraph::BuildGraph(CString recordFileName)
{
HRESULT hr;
ICreateDevEnum *pSysAudioCaptureEnum = NULL;
hr = CoCreateInstance(CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC_SERVER, IID_ICreateDevEnum, (void **)&pSysAudioCaptureEnum);
if (FAILED(hr))
{
return hr;
}
IBaseFilter *pAudioCapture = NULL;
IEnumMoniker *pEnumMoniker = NULL;
hr = pSysAudioCaptureEnum->CreateClassEnumerator(CLSID_AudioInputDeviceCategory, &pEnumMoniker, 0);
if (hr == S_OK)
{
IMoniker *pMoniker = NULL;
ULONG fetched;
BOOL findMicrophone = FALSE;
while(pEnumMoniker->Next(1, &pMoniker, &fetched) == S_OK && !findMicrophone)
{
IPropertyBag *pPropBag;
hr = pMoniker->BindToStorage(0, 0, IID_IPropertyBag, (void **)&pPropBag);
if(SUCCEEDED(hr))
{
VARIANT varName;
VariantInit(&varName);
hr = pPropBag->Read(L"FriendlyName", &varName, 0);
if(SUCCEEDED(hr))
{
ASSERT(varName.vt == VT_BSTR);
CString friendlyName(varName.bstrVal);
if(friendlyName.Find(L"Microphone") >= 0)
{
hr = pMoniker->BindToObject(NULL, NULL, IID_IBaseFilter, (void **)&pAudioCapture);
findMicrophone = TRUE;
}
VariantClear(&varName);
pPropBag->Release();
}
}
}
pEnumMoniker->Release();
}
pSysAudioCaptureEnum->Release();
if(pAudioCapture == NULL)
{
return S_FALSE;
}
pBuilder->AddFilter(pAudioCapture, L"Audio Capture");
IBaseFilter *pWaveDest = NULL;
hr = CoCreateInstance(CLSID_WavDest, NULL, CLSCTX_INPROC_SERVER, IID_IBaseFilter, (void **)&pWaveDest);
if(FAILED(hr))
{
return hr;
}
pBuilder->AddFilter(pWaveDest, L"Wave Dest");
IBaseFilter *pFileWriter = NULL;
hr = CoCreateInstance(CLSID_FileWriter, NULL, CLSCTX_INPROC_SERVER, IID_IBaseFilter, (void **)&pFileWriter);
if(FAILED(hr))
{
return hr;
}
pBuilder->AddFilter(pFileWriter, L"File Writer");
IFileSinkFilter *pFileSetter = NULL;
hr = pFileWriter->QueryInterface(IID_IFileSinkFilter, (void **)&pFileSetter);
if(FAILED(hr))
{
return hr;
}
AM_MEDIA_TYPE pmt;
pmt.majortype = MEDIATYPE_Stream;
pmt.subtype = MEDIASUBTYPE_WAVE;
pmt.formattype = FORMAT_WaveFormatEx;
hr = pFileSetter->SetFileName(recordFileName, &pmt);
hr = ConnectFilters(pBuilder, pAudioCapture, pWaveDest, MEDIATYPE_NULL);if(FAILED(hr)) return hr;
hr = ConnectFilters(pBuilder, pWaveDest, pFileWriter, MEDIATYPE_NULL);//if(FAILED(hr)) return hr;
SaveGraphFile(pBuilder, L"D:\\Record.grf");
pFileSetter->Release();
pFileWriter->Release();
pWaveDest->Release();
pAudioCapture->Release();
}
/* Try to intelligently fetch a default video input device */
static HRESULT
GetDefaultInputDevice(IBaseFilter **ppSrcFilter)
{
HRESULT hr = S_OK;
IBaseFilter *pSrc = NULL;
IMoniker *pMoniker = NULL;
ICreateDevEnum *pDevEnum = NULL;
IEnumMoniker *pClassEnum = NULL;
if (!ppSrcFilter) {
return E_POINTER;
}
hr = CoCreateInstance(
CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC,
IID_ICreateDevEnum, (void **)&pDevEnum
);
if (FAILED(hr)) return hr;
hr = pDevEnum->CreateClassEnumerator(
CLSID_VideoInputDeviceCategory, &pClassEnum, 0
);
if (FAILED(hr)) {
SAFE_RELEASE(pDevEnum);
return hr;
}
if (pClassEnum == NULL) {
/* No devices available */
SAFE_RELEASE(pDevEnum);
return E_FAIL;
}
/* Pick the first device from the list.
* Note that if the Next() call succeeds but there are no monikers,
* it will return S_FALSE (which is not a failure).
*/
hr = pClassEnum->Next (1, &pMoniker, NULL);
if (hr == S_FALSE) {
SAFE_RELEASE(pDevEnum);
SAFE_RELEASE(pClassEnum);
return E_FAIL;
}
hr = pMoniker->BindToObject(0, 0, IID_IBaseFilter, (void**)&pSrc);
if (FAILED(hr)) {
SAFE_RELEASE(pDevEnum);
SAFE_RELEASE(pClassEnum);
SAFE_RELEASE(pMoniker);
return hr;
}
*ppSrcFilter = pSrc;
(*ppSrcFilter)->AddRef();
SAFE_RELEASE(pSrc);
SAFE_RELEASE(pMoniker);
SAFE_RELEASE(pDevEnum);
SAFE_RELEASE(pClassEnum);
return hr;
}
WelcomeDialog::WelcomeDialog(QWidget* parent) : QDialog(parent) {
HRESULT hr;
IMoniker *pMoniker =NULL;
ULONG cFetched;
QString lastcam;
setupUi(this);
prefs->readEarlyConfig();
lastcam = prefs->qsVideoDevice;
CComPtr <ICreateDevEnum> pDevEnum =NULL;
hr = CoCreateInstance (CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC,
IID_ICreateDevEnum, (void **) &pDevEnum);
if (FAILED(hr))
qFatal("WelcomeDialog: Couldn't create system enumerator!");
IEnumMoniker *pClassEnum = NULL;
hr = pDevEnum->CreateClassEnumerator (CLSID_VideoInputDeviceCategory, &pClassEnum, 0);
if (FAILED(hr))
qFatal("WelcomeDialog: Couldn't create class enumerator");
if (pClassEnum == NULL)
qFatal("WelcomeDialog: No capture device found");
while (S_OK == (pClassEnum->Next (1, &pMoniker, &cFetched)))
{
IPropertyBag *pBag=0;
hr = pMoniker->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)
{
QString name;
int i = 0;
while(var.bstrVal[i])
name.append(QChar(var.bstrVal[i++]));
comboBoxVideoSource->insertItem(comboBoxVideoSource->count(), name);
if (name ==lastcam)
comboBoxVideoSource->setCurrentIndex(comboBoxVideoSource->count()-1);
SysFreeString(var.bstrVal);
}
pBag->Release();
}
pMoniker->Release();
}
pClassEnum->Release();
comboBoxVideoSource->setEditable(FALSE);
lineUsername->setText(prefs->qsUsername);
lineServer->setText(prefs->qsServer);
qcbNoReceive->setChecked(prefs->bNoReceive);
qcbNoAudio->setChecked(prefs->bNoSendAudio);
qcbLoopback->setChecked(prefs->bLoopback);
qcbStereo->setChecked(prefs->bStereo);
qcbNoExclusive->setChecked(prefs->bNoExclusive);
}
bool GetCaptureCrossbarDevices(std::vector<IBaseFilter*>& crossbarFilterList, std::vector<std::wstring>& crossbarNameList)
{
HRESULT hr;
ICreateDevEnum* createDevEnum; //创建枚举器
hr = CoCreateInstance(CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC_SERVER, IID_ICreateDevEnum, (void**)&createDevEnum);
if(FAILED(hr))
{
ErrorPrint("Crate system device enum error", hr);
return false;
}
ComReleaser createDevEnumReleaser(createDevEnum);
IEnumMoniker *enumMoniker;
hr = createDevEnum->CreateClassEnumerator(AM_KSCATEGORY_CROSSBAR, &enumMoniker, 0); //创建crossbar枚举器
if(hr != S_OK)
{
ErrorPrint("Create class enumerator error", hr);
return false;
}
ComReleaser enumMonikerReleaser(enumMoniker);
IMoniker *moniker;
while(S_OK == enumMoniker->Next(1, &moniker, NULL)) //枚举输入设备
{
ComReleaser monikerReleaser(moniker);
IPropertyBag* propBag;
hr = moniker->BindToStorage(NULL, NULL, IID_IPropertyBag, (void**)&propBag);
if(FAILED(hr))
{
ErrorPrint("Bind to storage error", hr);
return false;
}
VARIANT varName;
VariantInit(&varName);
hr = propBag->Read(L"FriendlyName", &varName, NULL);
if(FAILED(hr))
{
ErrorPrint("Read friendly name error", hr);
VariantClear(&varName);
continue;
}
VariantClear(&varName);
IBaseFilter* captureSourceFilter;
hr = moniker->BindToObject(NULL, NULL, IID_IBaseFilter, (void**)&captureSourceFilter); //生成video input对应的source filter,记得要手动释放
if (FAILED(hr))
{
ErrorPrint(wstring(L"Get caputre device ") + varName.bstrVal + L" source filter error", hr);
continue;
}
crossbarNameList.push_back(varName.bstrVal);
crossbarFilterList.push_back(captureSourceFilter);
}
#ifdef _DEBUG
std::cout<<"Start print all crossbar device name:\n";
using namespace boost::lambda;
std::for_each(crossbarNameList.begin(), crossbarNameList.end(), wcout<<_1<<"\n");
#endif
return true;
}
void MainDialog::DisplayFullCategorySet()
{
HRESULT hr;
int nClasses=0;
IEnumMoniker *pEmCat = 0;
ICreateDevEnum *pCreateDevEnum = NULL;
IPropertyBag *pPropBag = NULL;
// Create the system device enumerator.
hr = CoCreateInstance(CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC_SERVER,
IID_ICreateDevEnum, (void**)&pCreateDevEnum);
if (SUCCEEDED(hr))
{
// Use the meta-category that contains a list of all categories.
// This emulates the behavior of GraphEdit.
hr = pCreateDevEnum->CreateClassEnumerator(
CLSID_ActiveMovieCategories, &pEmCat, 0);
if (hr == S_FALSE)
{
// If CreateClassEnumerator returns S_OK, it means this
// category does not exist or is empty. For the meta-category,
// that would qualify as a failure!
hr = E_FAIL;
}
}
// Enumerate over every category and get the category CLSID and description.
if (SUCCEEDED(hr))
{
IMoniker *pMCat = NULL;
while (S_OK == pEmCat->Next(1, &pMCat, NULL))
{
VARIANT varCatName;
VariantInit(&varCatName);
VARIANT varCatClsid;
VariantInit(&varCatClsid);
CLSID clsidCat;
// Associate moniker with a file
hr = pMCat->BindToStorage(0, 0, IID_IPropertyBag, (void **)&pPropBag);
// Read CLSID string from property bag
if (SUCCEEDED(hr))
{
hr = pPropBag->Read(L"CLSID", &varCatClsid, 0);
}
// Convert to a CLSID
if (SUCCEEDED(hr))
{
hr = CLSIDFromString(varCatClsid.bstrVal, &clsidCat);
}
// Read the category name. If that fails, use the CLSID string.
if (SUCCEEDED(hr))
{
HRESULT hrTmp = pPropBag->Read(L"FriendlyName", &varCatName, 0);
// Add category name and CLSID to list box
if(SUCCEEDED(hrTmp))
{
hr = AddFilterCategory(varCatName.bstrVal, clsidCat);
}
else
{
hr = AddFilterCategory(varCatClsid.bstrVal, clsidCat);
}
nClasses++;
}
SAFE_RELEASE(pMCat);
SAFE_RELEASE(pPropBag);
VariantClear(&varCatName);
VariantClear(&varCatClsid);
if (FAILED(hr))
{
break;
}
} // for loop
}
// Update listbox title with number of classes
if (SUCCEEDED(hr))
{
SetNumClasses(nClasses);
}
SAFE_RELEASE(pEmCat);
SAFE_RELEASE(pCreateDevEnum);
}
HRESULT FindVideoCompressor(const std::wstring& format, IBaseFilter *&result)
{
HRESULT hr = S_OK;
CoInitialize(NULL);
ComUninitial comUninitial;
ICreateDevEnum *createDevEnum;
hr = CoCreateInstance(CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC_SERVER, IID_ICreateDevEnum, (void**)&createDevEnum);
if(FAILED(hr))
{
ErrorPrint("Create system device enum error", hr);
return hr;
}
ComReleaser createDevEnumReleaser(createDevEnum);
IEnumMoniker *enumMoniker;
hr = createDevEnum->CreateClassEnumerator(CLSID_VideoCompressorCategory, &enumMoniker, 0);
if (FAILED(hr))
{
ErrorPrint("Create Video compressor enum error", hr);
return hr;
}
IMoniker *moniker;
while(S_OK == enumMoniker->Next(1, &moniker, NULL))
{
ComReleaser monikerReleaser(moniker);
LPOLESTR oleDisplayName;
hr = moniker->GetDisplayName(NULL, NULL, &oleDisplayName);
if(FAILED(hr))
{
ErrorPrint("Get display name error", hr);
continue;
}
std::wstring displayName(oleDisplayName);
size_t slashPos;
for (slashPos = 0; slashPos < displayName.size(); ++slashPos)
{
if(displayName[slashPos] == L'\\')
break;
}
if(slashPos == displayName.size())
{
ErrorPrint("Find slash error");
continue;
}
displayName = displayName.substr(slashPos+1);
if (displayName == format)
{
hr = moniker->BindToObject(NULL, NULL, IID_IBaseFilter, (void**)&result);
if(FAILED(hr))
{
ErrorPrint("Create video compressor filter error", hr);
continue;
}
return S_OK;
}
}
return E_FAIL;
}
bool GetAudioCaptureDevices(std::vector<IBaseFilter*>& captureSourceFilterList, std::vector<std::wstring>& captureDeviceNameList)
{
HRESULT hr;
CoInitialize(NULL);
ComUninitial comUninitial;
ICreateDevEnum* createDevEnum;
hr = CoCreateInstance(CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC_SERVER, IID_ICreateDevEnum, (void**)&createDevEnum);
if (FAILED(hr))
{
ErrorPrint("Create system device enum error",hr);
return false;
}
ComReleaser createDevEnumReleaser(createDevEnum);
IEnumMoniker *enumMoniker = NULL;
hr = createDevEnum->CreateClassEnumerator(CLSID_AudioInputDeviceCategory,&enumMoniker, 0);
if (hr != S_OK)
{
ErrorPrint("Create class enumerator error",hr);
return false;
}
std::cout<<"HRESULT VALUE:"<<std::hex<<hr<<std::endl;
std::cout<<"Enum moniker value:"<<std::hex<<(int)enumMoniker<<std::endl;
ComReleaser enumMonikerReleaser(enumMoniker);
IMoniker* moniker;
int i = 0;
while (S_OK == enumMoniker->Next(1, &moniker, NULL))
{
std::cout<<"Find audio count:"<<++i<<std::endl;
ComReleaser monikerReleaser(moniker);
IPropertyBag* propBag;
hr = moniker->BindToStorage(NULL,NULL,IID_IPropertyBag, (void**)&propBag);
if (FAILED(hr))
{
ErrorPrint("Bind to storage error",hr);
}
else
{
ComReleaser propBagReleaser(propBag);
VARIANT varName;
VariantInit(&varName);
hr = propBag->Read(L"FriendlyName", &varName, NULL);
if (FAILED(hr))
{
ErrorPrint("Get audio input device friendly name error",hr);
VariantClear(&varName);
continue;
}
VariantClear(&varName);
IBaseFilter* audioCaptureInputDevice;
hr = moniker->BindToObject(NULL, NULL, IID_IBaseFilter, (void**)&audioCaptureInputDevice);
if (FAILED(hr))
{
ErrorPrint("Bind to object error",hr);
continue;
}
captureSourceFilterList.push_back(audioCaptureInputDevice);
captureDeviceNameList.push_back(varName.bstrVal);
}
}
#ifdef _DEBUG
std::cout<<"Start print all capture device name:\n";
using namespace boost::lambda;
std::for_each(captureDeviceNameList.begin(), captureDeviceNameList.end(), wcout<<_1<<"\n");
#endif
return true;
}
HRESULT CAccessSys::FindCaptureDevice(void)
{
HRESULT hr = S_OK;
IBaseFilter * pSrc = NULL;
IMoniker* pMoniker = NULL;
ICreateDevEnum *pDevEnum = NULL;
IEnumMoniker *pClassEnum = NULL;
// Create the system device enumerator
hr = CoCreateInstance(CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC,
IID_ICreateDevEnum, (void **)&pDevEnum);
if (FAILED(hr))
{
Msg(TEXT("Couldn't create system enumerator! hr=0x%x"), hr);
}
// Create an enumerator for the video capture devices
if (SUCCEEDED(hr))
{
hr = pDevEnum->CreateClassEnumerator(CLSID_VideoInputDeviceCategory, &pClassEnum, 0);
if (FAILED(hr))
{
Msg(TEXT("Couldn't create class enumerator! hr=0x%x"), hr);
}
}
if (SUCCEEDED(hr))
{
// If there are no enumerators for the requested type, then
// CreateClassEnumerator will succeed, but pClassEnum will be NULL.
if (pClassEnum == NULL)
{
MessageBox(NULL, TEXT("No video capture device was detected.\r\n\r\n")
TEXT("This sample requires a video capture device, such as a USB WebCam,\r\n")
TEXT("to be installed and working properly. The sample will now close."),
TEXT("No Video Capture Hardware"), MB_OK | MB_ICONINFORMATION);
hr = E_FAIL;
}
}
// Use the first video capture device on the device list.
// Note that if the Next() call succeeds but there are no monikers,
// it will return S_FALSE (which is not a failure). Therefore, we
// check that the return code is S_OK instead of using SUCCEEDED() macro.
if (SUCCEEDED(hr))
{
hr = pClassEnum->Next(1, &pMoniker, NULL);
if (hr == S_FALSE)
{
Msg(TEXT("Unable to access video capture device!"));
hr = E_FAIL;
}
}
if (SUCCEEDED(hr))
{
// Bind Moniker to a filter object
hr = pMoniker->BindToObject(0, 0, IID_IBaseFilter, (void**)&pSrc);
if (FAILED(hr))
{
Msg(TEXT("Couldn't bind moniker to filter object! hr=0x%x"), hr);
}
}
// Copy the found filter pointer to the output parameter.
ULONG ref;
if (SUCCEEDED(hr))
{
p_streams[0].p_device_filter = pSrc;
ref = p_streams[0].p_device_filter->AddRef();
}
hr = p_capture_graph_builder2->FindInterface(&PIN_CATEGORY_CAPTURE,
&MEDIATYPE_Video, pSrc,
IID_IAMStreamConfig, (void **)&p_VSC);
if (FAILED(hr))
{
Msg(TEXT("Couldn't find IAMStreamConfig! hr=0x%x"), hr);
}
else {
AM_MEDIA_TYPE *pmt;
//VIDEO_STREAM_CONFIG_CAPS scc;
BYTE* scc = NULL;
int piCount, piSize;
hr = p_VSC->GetNumberOfCapabilities(&piCount, &piSize);
if (hr == S_OK){
for (int i = 0; i < piCount; i++){
scc = new BYTE[piSize];
hr = p_VSC->GetStreamCaps(i, &pmt, scc/*reinterpret_cast<BYTE*>(&scc)*/);
//hr = p_VSC->GetFormat(&pmt);
double FrameRate = 15.0;
if (hr == NOERROR)
{
if (pmt->subtype == MEDIASUBTYPE_RGB24 ||
pmt->subtype == MEDIASUBTYPE_I420 ||
pmt->subtype == MEDIASUBTYPE_YUY2){
if (pmt->formattype == FORMAT_VideoInfo)
{
//pmt->subtype = MEDIASUBTYPE_RGB24;
VIDEOINFOHEADER *pvi = (VIDEOINFOHEADER *)pmt->pbFormat;
if (pvi->bmiHeader.biHeight == 240 && pvi->bmiHeader.biWidth == 320){
pvi->AvgTimePerFrame = (LONGLONG)(10000000 / FrameRate);
//pvi->bmiHeader.biHeight = 240;
//pvi->bmiHeader.biWidth = 320;
hr = p_VSC->SetFormat(pmt);
if (FAILED(hr)){
Msg(TEXT("couldn't set video format! hr = 0x%x"), hr);
}
DeleteMediaType(pmt);
delete[] scc;
break;
}
}
}
DeleteMediaType(pmt);
}
delete[] scc;
}
}
ref = pSrc->Release();
}
SAFE_RELEASE(pSrc);
SAFE_RELEASE(pMoniker);
SAFE_RELEASE(pClassEnum);
// Create an enumerator for the audio capture devices
if (SUCCEEDED(hr))
{
hr = pDevEnum->CreateClassEnumerator(CLSID_AudioInputDeviceCategory, &pClassEnum, 0);
if (FAILED(hr))
{
Msg(TEXT("Couldn't create class enumerator! hr=0x%x"), hr);
}
}
if (SUCCEEDED(hr))
{
// If there are no enumerators for the requested type, then
// CreateClassEnumerator will succeed, but pClassEnum will be NULL.
if (pClassEnum == NULL)
{
MessageBox(NULL, TEXT("No audio capture device was detected.\r\n\r\n")
TEXT("This sample requires a audio capture device\r\n")
TEXT("to be installed and working properly. The sample will now close."),
TEXT("No Audio Capture Hardware"), MB_OK | MB_ICONINFORMATION);
hr = E_FAIL;
}
}
// Use the first video capture device on the device list.
// Note that if the Next() call succeeds but there are no monikers,
// it will return S_FALSE (which is not a failure). Therefore, we
// check that the return code is S_OK instead of using SUCCEEDED() macro.
if (SUCCEEDED(hr))
{
hr = pClassEnum->Next(1, &pMoniker, NULL);
if (hr == S_FALSE)
{
Msg(TEXT("Unable to access audio capture device!"));
hr = E_FAIL;
}
}
if (SUCCEEDED(hr))
{
// Bind Moniker to a filter object
hr = pMoniker->BindToObject(0, 0, IID_IBaseFilter, (void**)&pSrc);
if (FAILED(hr))
{
Msg(TEXT("Couldn't bind moniker to filter object! hr=0x%x"), hr);
}
}
// Copy the found filter pointer to the output parameter.
if (SUCCEEDED(hr))
{
p_streams[1].p_device_filter = pSrc;
ref = p_streams[1].p_device_filter->AddRef();
}
SAFE_RELEASE(pSrc);
SAFE_RELEASE(pMoniker);
SAFE_RELEASE(pClassEnum);
SAFE_RELEASE(pDevEnum);
return hr;
}
static int v4w_open_videodevice(V4wState *s, int format, MSVideoSize *vsize)
{
// Initialize COM
CoInitialize(NULL);
// get a Graph
HRESULT hr=s->m_pGraph.CoCreateInstance(CLSID_FilterGraph);
if(FAILED(hr))
{
return -1;
}
// get a CaptureGraphBuilder2
#if !defined(_WIN32_WCE)
hr=s->m_pBuilder.CoCreateInstance(CLSID_CaptureGraphBuilder2);
#else
hr=s->m_pBuilder.CoCreateInstance(CLSID_CaptureGraphBuilder);
#endif
if(FAILED(hr))
{
return -2;
}
// connect capture graph builder with the graph
s->m_pBuilder->SetFiltergraph(s->m_pGraph);
// get mediacontrol so we can start and stop the filter graph
hr=s->m_pGraph.QueryInterface(&(s->m_pControl));
if(FAILED(hr))
{
return -3;
}
// get DXFilter
s->m_pDXFilter = new CDXFilter(NULL, &hr, FALSE);
if(s->m_pDXFilter==NULL)
{
return -4;
}
s->m_pDXFilter->AddRef();
if(FAILED(hr))
{
return -4;
}
CMediaType mt;
mt.SetType(&MEDIATYPE_Video);
if (format==MS_YUV420P)
{
GUID m = (GUID)FOURCCMap(MAKEFOURCC('I','4','2','0'));
mt.SetSubtype(&m);
mt.SetSubtype(&MEDIASUBTYPE_YV12);
}
else //if (format==MS_RGB24)
{
mt.SetSubtype(&MEDIASUBTYPE_RGB24);
}
//mt.SetSubtype(&MEDIASUBTYPE_IYUV);
//mt.SetSubtype(&MEDIASUBTYPE_YUYV);
//mt.SetSubtype(&MEDIASUBTYPE_RGB24);
//mt.SetSampleSize();
mt.formattype = FORMAT_VideoInfo;
mt.SetTemporalCompression(FALSE);
VIDEOINFO *pvi = (VIDEOINFO *)
mt.AllocFormatBuffer(sizeof(VIDEOINFO));
if (NULL == pvi)
return E_OUTOFMEMORY;
ZeroMemory(pvi, sizeof(VIDEOINFO));
if (format==MS_YUV420P)
{
pvi->bmiHeader.biCompression = MAKEFOURCC('I','4','2','0');
pvi->bmiHeader.biCompression = MAKEFOURCC('Y','V','1','2');
pvi->bmiHeader.biBitCount = 12;
}
else
{
pvi->bmiHeader.biCompression = BI_RGB;
pvi->bmiHeader.biBitCount = 24;
}
pvi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
pvi->bmiHeader.biWidth = vsize->width;
pvi->bmiHeader.biHeight = vsize->height;
pvi->bmiHeader.biPlanes = 1;
pvi->bmiHeader.biSizeImage = GetBitmapSize(&pvi->bmiHeader);
pvi->bmiHeader.biClrImportant = 0;
mt.SetSampleSize(pvi->bmiHeader.biSizeImage);
mt.SetFormat((BYTE*)pvi, sizeof(VIDEOINFO));
hr = s->m_pDXFilter->SetAcceptedMediaType(&mt);
if(FAILED(hr))
{
return -5;
}
hr = s->m_pDXFilter->SetCallback(Callback);
if(FAILED(hr))
{
return -6;
}
hr = s->m_pDXFilter->QueryInterface(IID_IBaseFilter,
(LPVOID *)&s->m_pIDXFilter);
if(FAILED(hr))
{
return -7;
}
hr = s->m_pGraph->AddFilter(s->m_pIDXFilter, L"DXFilter Filter");
if(FAILED(hr))
{
return -8;
}
#ifdef WM6
ICreateDevEnum *pCreateDevEnum = NULL;
IEnumMoniker *pEnumMoniker = NULL;
IMoniker *pMoniker = NULL;
ULONG nFetched = 0;
hr = CoCreateInstance(CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC_SERVER,
IID_ICreateDevEnum, (PVOID *)&pCreateDevEnum);
if(FAILED(hr))
{
return -9;
}
hr = pCreateDevEnum->CreateClassEnumerator(CLSID_VideoInputDeviceCategory,
&pEnumMoniker, 0);
if (FAILED(hr) || pEnumMoniker == NULL) {
//printf("no device\n");
return -10;
}
pEnumMoniker->Reset();
hr = pEnumMoniker->Next(1, &pMoniker, &nFetched);
if(FAILED(hr) || pMoniker==NULL)
{
return -11;
}
hr = pMoniker->BindToObject(0, 0, IID_IBaseFilter, (void**)&s->m_pDeviceFilter );
if(FAILED(hr))
{
return -12;
}
s->m_pGraph->AddFilter(s->m_pDeviceFilter, L"Device Filter");
pMoniker->Release();
pEnumMoniker->Release();
pCreateDevEnum->Release();
#else
WCHAR wzDeviceName[ MAX_PATH + 1 ];
CComVariant varCamName;
CPropertyBag PropBag;
CComPtr<IPersistPropertyBag> pPropertyBag;
GetFirstCameraDriver(wzDeviceName);
hr = s->m_pDeviceFilter.CoCreateInstance( CLSID_VideoCapture );
if (FAILED(hr))
{
return -8;
}
s->m_pDeviceFilter.QueryInterface( &pPropertyBag );
varCamName = wzDeviceName;
if(( varCamName.vt == VT_BSTR ) == NULL ) {
return E_OUTOFMEMORY;
}
PropBag.Write( L"VCapName", &varCamName );
pPropertyBag->Load( &PropBag, NULL );
pPropertyBag.Release();
hr = s->m_pGraph->AddFilter( s->m_pDeviceFilter, L"Video capture source" );
#endif
if (FAILED(hr))
{
return -8;
}
// get null renderer
s->m_pNullRenderer = NULL;
#if 0
hr=s->m_pNullRenderer.CoCreateInstance(CLSID_NullRenderer);
if(FAILED(hr))
{
return -13;
}
#endif
if (s->m_pNullRenderer!=NULL)
{
s->m_pGraph->AddFilter(s->m_pNullRenderer, L"Null Renderer");
}
hr = s->m_pBuilder->RenderStream(&PIN_CATEGORY_PREVIEW,
&MEDIATYPE_Video, s->m_pDeviceFilter, s->m_pIDXFilter, s->m_pNullRenderer);
if (FAILED(hr))
{
//hr = s->m_pBuilder->RenderStream(&PIN_CATEGORY_CAPTURE,
// &MEDIATYPE_Video, s->m_pDeviceFilter, s->m_pIDXFilter, s->m_pNullRenderer);
if (FAILED(hr))
{
return -14;
}
}
//m_pDXFilter->SetBufferSamples(TRUE);
// Create the System Device Enumerator.
IFilterMapper *pMapper = NULL;
//IEnumMoniker *pEnum = NULL;
IEnumRegFilters *pEnum = NULL;
hr = CoCreateInstance(CLSID_FilterMapper,
NULL, CLSCTX_INPROC, IID_IFilterMapper,
(void **) &pMapper);
if (FAILED(hr))
{
// Error handling omitted for clarity.
}
GUID arrayInTypes[2];
arrayInTypes[0] = MEDIATYPE_Video;
arrayInTypes[1] = MEDIASUBTYPE_dvsd;
hr = pMapper->EnumMatchingFilters(
&pEnum,
MERIT_HW_COMPRESSOR, // Minimum merit.
FALSE, // At least one input pin?
MEDIATYPE_NULL,
MEDIASUBTYPE_NULL,
FALSE, // Must be a renderer?
FALSE, // At least one output pin?
MEDIATYPE_NULL,
MEDIASUBTYPE_NULL);
// Enumerate the monikers.
//IMoniker *pMoniker;
REGFILTER *pMoniker;
ULONG cFetched;
while (pEnum->Next(1, &pMoniker, &cFetched) == S_OK)
{
IPropertyBag *pPropBag = NULL;
#if 0
hr = pMoniker->BindToStorage(0, 0, IID_IPropertyBag,
(void **)&pPropBag);
if (SUCCEEDED(hr))
{
// To retrieve the friendly name of the filter, do the following:
VARIANT varName;
VariantInit(&varName);
hr = pPropBag->Read(L"FriendlyName", &varName, 0);
if (SUCCEEDED(hr))
{
// Display the name in your UI somehow.
}
VariantClear(&varName);
// To create an instance of the filter, do the following:
IBaseFilter *pFilter;
hr = pMoniker->BindToObject(NULL, NULL, IID_IBaseFilter, (void**)&pFilter);
// Now add the filter to the graph. Remember to release pFilter later.
// Clean up.
pPropBag->Release();
}
pMoniker->Release();
#endif
}
// Clean up.
pMapper->Release();
pEnum->Release();
s_callback = s;
hr = s->m_pControl->Run();
if(FAILED(hr))
{
return -15;
}
s->rotregvalue=1;
s->pix_fmt = format;
s->vsize.height = vsize->height;
s->vsize.width = vsize->width;
return 0;
}
HRESULT FindCaptureDevice(IBaseFilter ** ppSrcFilter)
{
HRESULT hr;
IBaseFilter * pSrc = NULL;
IMoniker *pMoniker = NULL;
ULONG cFetched;
if (!ppSrcFilter)
return E_POINTER;
// Create the system device enumerator
ICreateDevEnum *pDevEnum = NULL;
hr = CoCreateInstance(CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC,
IID_ICreateDevEnum, (void **)&pDevEnum);
if (FAILED(hr))
{
return hr;
}
// Create an enumerator for the video capture devices
IEnumMoniker *pClassEnum = NULL;
hr = pDevEnum->CreateClassEnumerator(CLSID_VideoInputDeviceCategory, &pClassEnum, 0);
if (FAILED(hr))
{
return hr;
}
// If there are no enumerators for the requested type, then
// CreateClassEnumerator will succeed, but pClassEnum will be NULL.
if (pClassEnum == NULL)
{
return E_FAIL;
}
// Use the first video capture device on the device list.
// Note that if the Next() call succeeds but there are no monikers,
// it will return S_FALSE (which is not a failure). Therefore, we
// check that the return code is S_OK instead of using SUCCEEDED() macro.
if (S_OK == (pClassEnum->Next(1, &pMoniker, &cFetched)))
{
IBindCtx *pbc = NULL;
CreateBindCtx(0, &pbc);
// Bind Moniker to a filter object
hr = pMoniker->BindToObject(pbc, 0, IID_IBaseFilter, (void**)&pSrc);
pbc->Release();
if (FAILED(hr))
{
return hr;
}
}
else
{
return E_FAIL;
}
// Copy the found filter pointer to the output parameter.
// Do NOT Release() the reference, since it will still be used
// by the calling function.
*ppSrcFilter = pSrc;
return hr;
}
QVector<QPair<QString,QString>> DirectShow::getDeviceList()
{
IMoniker* m = nullptr;
QVector<QPair<QString,QString>> devices;
ICreateDevEnum* devenum = nullptr;
if (CoCreateInstance(CLSID_SystemDeviceEnum, nullptr, CLSCTX_INPROC_SERVER,
IID_ICreateDevEnum, (void**) &devenum) != S_OK)
return devices;
IEnumMoniker* classenum = nullptr;
if (devenum->CreateClassEnumerator(CLSID_VideoInputDeviceCategory,
(IEnumMoniker**)&classenum, 0) != S_OK)
return devices;
while (classenum->Next(1, &m, nullptr) == S_OK)
{
VARIANT var;
IPropertyBag* bag = nullptr;
LPMALLOC coMalloc = nullptr;
IBindCtx* bindCtx = nullptr;
LPOLESTR olestr = nullptr;
char *devIdString=nullptr, *devHumanName=nullptr;
if (CoGetMalloc(1, &coMalloc) != S_OK)
goto fail;
if (CreateBindCtx(0, &bindCtx) != S_OK)
goto fail;
// Get an uuid for the device that we can pass to ffmpeg directly
if (m->GetDisplayName(bindCtx, nullptr, &olestr) != S_OK)
goto fail;
devIdString = wcharToUtf8(olestr);
// replace ':' with '_' since FFmpeg uses : to delimitate sources
for (unsigned i = 0; i < strlen(devIdString); i++)
if (devIdString[i] == ':')
devIdString[i] = '_';
// Get a human friendly name/description
if (m->BindToStorage(nullptr, nullptr, IID_IPropertyBag, (void**)&bag) != S_OK)
goto fail;
var.vt = VT_BSTR;
if (bag->Read(L"FriendlyName", &var, nullptr) != S_OK)
goto fail;
devHumanName = wcharToUtf8(var.bstrVal);
devices += {QString("video=")+devIdString, devHumanName};
fail:
if (olestr && coMalloc)
coMalloc->Free(olestr);
if (bindCtx)
bindCtx->Release();
delete[] devIdString;
delete[] devHumanName;
if (bag)
bag->Release();
m->Release();
}
classenum->Release();
return devices;
}
int CLS_DlgStreamPusher::GetDeviceInfo(int _iDeviceType)
{
int iRet = -1;
ICreateDevEnum *pDevEnum;
IEnumMoniker *pEnumMon;
IMoniker *pMoniker;
HRESULT hr = CoCreateInstance(CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC_SERVER,
IID_ICreateDevEnum, (LPVOID*)&pDevEnum);
if (SUCCEEDED(hr))
{
if (_iDeviceType == n_Video){
hr = pDevEnum->CreateClassEnumerator(CLSID_VideoInputDeviceCategory, &pEnumMon, 0);
}
else{
hr = pDevEnum->CreateClassEnumerator(CLSID_AudioInputDeviceCategory, &pEnumMon, 0);
}
if (hr == S_FALSE)
{
TRACE("没有找到合适的音视频设备！");
hr = VFW_E_NOT_FOUND;
return hr;
}
pEnumMon->Reset();
ULONG cFetched;
while (hr = pEnumMon->Next(1, &pMoniker, &cFetched), hr == S_OK)
{
IPropertyBag *pProBag;
hr = pMoniker->BindToStorage(0, 0, IID_IPropertyBag, (LPVOID*)&pProBag);
if (SUCCEEDED(hr))
{
VARIANT varTemp;
varTemp.vt = VT_BSTR;
hr = pProBag->Read(L"FriendlyName", &varTemp, NULL);
if (SUCCEEDED(hr))
{
iRet = 0;
_bstr_t bstr_t(varTemp.bstrVal);
std::string strDeviceName = bstr_t;
//将取到的设备名称存入容器中
std::vector<std::string> vecDeviceName;
vecDeviceName.clear();
vecDeviceName.push_back(strDeviceName);
SysFreeString(varTemp.bstrVal);
//如果容器相应的键值有值就量进行相应的添加处理，没值的话整体进行添加处理
std::map<int, std::vector<std::string>>::iterator iterInfo = m_mapDeviceInfo.find(_iDeviceType);
if (iterInfo == m_mapDeviceInfo.end()){
m_mapDeviceInfo.insert(map<int, std::vector<std::string>>::value_type(_iDeviceType, vecDeviceName));
}
else{
m_mapDeviceInfo[_iDeviceType].push_back(strDeviceName);
}
}
pProBag->Release();
}
pMoniker->Release();
}
pEnumMon->Release();
}
return iRet;
}
// delicious copypasta
static QList<QString> get_camera_names(void) {
QList<QString> ret;
#if defined(_WIN32) || defined(__WIN32)
// Create the System Device Enumerator.
HRESULT hr;
ICreateDevEnum *pSysDevEnum = NULL;
hr = CoCreateInstance(CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC_SERVER, IID_ICreateDevEnum, (void **)&pSysDevEnum);
if (FAILED(hr))
{
return ret;
}
// Obtain a class enumerator for the video compressor category.
IEnumMoniker *pEnumCat = NULL;
hr = pSysDevEnum->CreateClassEnumerator(CLSID_VideoInputDeviceCategory, &pEnumCat, 0);
if (hr == S_OK) {
// Enumerate the monikers.
IMoniker *pMoniker = NULL;
ULONG cFetched;
while (pEnumCat->Next(1, &pMoniker, &cFetched) == S_OK) {
IPropertyBag *pPropBag;
hr = pMoniker->BindToStorage(0, 0, IID_IPropertyBag, (void **)&pPropBag);
if (SUCCEEDED(hr)) {
// To retrieve the filter's friendly name, do the following:
VARIANT varName;
VariantInit(&varName);
hr = pPropBag->Read(L"FriendlyName", &varName, 0);
if (SUCCEEDED(hr))
{
// Display the name in your UI somehow.
QString str((QChar*)varName.bstrVal, wcslen(varName.bstrVal));
ret.append(str);
}
VariantClear(&varName);
////// To create an instance of the filter, do the following:
////IBaseFilter *pFilter;
////hr = pMoniker->BindToObject(NULL, NULL, IID_IBaseFilter,
//// (void**)&pFilter);
// Now add the filter to the graph.
//Remember to release pFilter later.
pPropBag->Release();
}
pMoniker->Release();
}
pEnumCat->Release();
}
pSysDevEnum->Release();
#else
for (int i = 0; i < 16; i++) {
char buf[128];
sprintf(buf, "/dev/video%d", i);
if (access(buf, R_OK | W_OK) == 0) {
ret.append(buf);
} else {
break;
}
}
#endif
return ret;
}
HRESULT FindCaptureDevice(IBaseFilter ** ppSrcFilter)
{
HRESULT hr = S_OK;
IBaseFilter * pSrc = NULL;
IMoniker* pMoniker =NULL;
ICreateDevEnum *pDevEnum =NULL;
IEnumMoniker *pClassEnum = NULL;
if (!ppSrcFilter)
{
return E_POINTER;
}
// Create the system device enumerator
hr = CoCreateInstance (CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC,
IID_ICreateDevEnum, (void **) &pDevEnum);
if (FAILED(hr))
{
Msg(TEXT("Couldn't create system enumerator! hr=0x%x"), hr);
}
// Create an enumerator for the video capture devices
if (SUCCEEDED(hr))
{
hr = pDevEnum->CreateClassEnumerator (CLSID_VideoInputDeviceCategory, &pClassEnum, 0);
if (FAILED(hr))
{
Msg(TEXT("Couldn't create class enumerator! hr=0x%x"), hr);
}
}
if (SUCCEEDED(hr))
{
// If there are no enumerators for the requested type, then
// CreateClassEnumerator will succeed, but pClassEnum will be NULL.
if (pClassEnum == NULL)
{
MessageBox(ghApp,TEXT("No video capture device was detected.\r\n\r\n")
TEXT("This sample requires a video capture device, such as a USB WebCam,\r\n")
TEXT("to be installed and working properly. The sample will now close."),
TEXT("No Video Capture Hardware"), MB_OK | MB_ICONINFORMATION);
hr = E_FAIL;
}
}
// Use the first video capture device on the device list.
// Note that if the Next() call succeeds but there are no monikers,
// it will return S_FALSE (which is not a failure). Therefore, we
// check that the return code is S_OK instead of using SUCCEEDED() macro.
if (SUCCEEDED(hr))
{
hr = pClassEnum->Next (1, &pMoniker, NULL);
if (hr == S_FALSE)
{
Msg(TEXT("Unable to access video capture device!"));
hr = E_FAIL;
}
}
if (SUCCEEDED(hr))
{
// Bind Moniker to a filter object
hr = pMoniker->BindToObject(0,0,IID_IBaseFilter, (void**)&pSrc);
if (FAILED(hr))
{
Msg(TEXT("Couldn't bind moniker to filter object! hr=0x%x"), hr);
}
}
// Copy the found filter pointer to the output parameter.
if (SUCCEEDED(hr))
{
*ppSrcFilter = pSrc;
(*ppSrcFilter)->AddRef();
}
SAFE_RELEASE(pSrc);
SAFE_RELEASE(pMoniker);
SAFE_RELEASE(pDevEnum);
SAFE_RELEASE(pClassEnum);
return hr;
}
static int v4w_configure_videodevice(V4wState *s)
{
// Initialize COM
CoInitialize(NULL);
// get a Graph
HRESULT hr= CoCreateInstance (CLSID_FilterGraph,
NULL,
CLSCTX_INPROC_SERVER,
IID_IGraphBuilder, //IID_IBaseFilter,
(void **)&s->m_pGraph);
if(FAILED(hr))
{
return -1;
}
// get a CaptureGraphBuilder2
hr= CoCreateInstance (CLSID_CaptureGraphBuilder2,
NULL,
CLSCTX_INPROC_SERVER,
IID_ICaptureGraphBuilder2, //IID_IBaseFilter,
(void **)&s->m_pBuilder);
if(FAILED(hr))
{
return -2;
}
// connect capture graph builder with the graph
s->m_pBuilder->SetFiltergraph(s->m_pGraph);
// get mediacontrol so we can start and stop the filter graph
hr=s->m_pGraph->QueryInterface (IID_IMediaControl, (void **)&s->m_pControl);
if(FAILED(hr))
{
return -3;
}
ICreateDevEnum *pCreateDevEnum = NULL;
IEnumMoniker *pEnumMoniker = NULL;
IMoniker *pMoniker = NULL;
ULONG nFetched = 0;
hr = CoCreateInstance(CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC_SERVER,
IID_ICreateDevEnum, (PVOID *)&pCreateDevEnum);
if(FAILED(hr))
{
return -4;
}
hr = pCreateDevEnum->CreateClassEnumerator(CLSID_VideoInputDeviceCategory,
&pEnumMoniker, 0);
if (FAILED(hr) || pEnumMoniker == NULL) {
//printf("no device\n");
return -5;
}
pEnumMoniker->Reset();
int pos=0;
while(S_OK == pEnumMoniker->Next(1, &pMoniker, &nFetched) )
{
IPropertyBag *pBag;
hr = pMoniker->BindToStorage( 0, 0, IID_IPropertyBag, (void**) &pBag );
if( hr != S_OK )
continue;
if (s->dev[0]=='\0')
break;
VARIANT var;
VariantInit(&var);
hr = pBag->Read( L"FriendlyName", &var, NULL );
if( hr != S_OK )
{
pMoniker->Release();
continue;
}
//USES_CONVERSION;
char szName[256];
WideCharToMultiByte(CP_UTF8,0,var.bstrVal,-1,szName,256,0,0);
VariantClear(&var);
if (strcmp(szName, s->dev)==0)
break;
pMoniker->Release();
pBag->Release();
pMoniker=NULL;
pBag=NULL;
}
if(pMoniker==NULL)
{
int pos=0;
while(S_OK == pEnumMoniker->Next(1, &pMoniker, &nFetched) )
{
IPropertyBag *pBag;
hr = pMoniker->BindToStorage( 0, 0, IID_IPropertyBag, (void**) &pBag );
if( hr != S_OK )
continue;
}
}
if(pMoniker==NULL)
{
return -6;
}
hr = pMoniker->BindToObject(0, 0, IID_IBaseFilter, (void**)&s->m_pDeviceFilter );
if(FAILED(hr))
{
return -7;
}
s->m_pGraph->AddFilter(s->m_pDeviceFilter, L"Device Filter");
pMoniker->Release();
pEnumMoniker->Release();
pCreateDevEnum->Release();
GUID pPinCategory;
if (try_format(s->m_pDeviceFilter, s->pix_fmt, &pPinCategory)==0)
s->pix_fmt = s->pix_fmt;
else if (try_format(s->m_pDeviceFilter,MS_YUV420P, &pPinCategory)==0)
s->pix_fmt = MS_YUV420P;
else if (try_format(s->m_pDeviceFilter,MS_YUY2, &pPinCategory)==0)
s->pix_fmt = MS_YUY2;
else if (try_format(s->m_pDeviceFilter,MS_YUYV, &pPinCategory)==0)
s->pix_fmt = MS_YUYV;
else if (try_format(s->m_pDeviceFilter,MS_UYVY, &pPinCategory)==0)
s->pix_fmt = MS_UYVY;
else if (try_format(s->m_pDeviceFilter,MS_RGB24, &pPinCategory)==0)
s->pix_fmt = MS_RGB24;
else
{
ms_error("Unsupported video pixel format.");
return -8;
}
if (s->pix_fmt == MS_YUV420P)
ms_message("Driver supports YUV420P, using that format.");
else if (s->pix_fmt == MS_YUY2)
ms_message("Driver supports YUY2 (YUYV), using that format.");
else if (s->pix_fmt == MS_YUYV)
ms_message("Driver supports YUV422, using that format.");
else if (s->pix_fmt == MS_UYVY)
ms_message("Driver supports UYVY, using that format.");
else if (s->pix_fmt == MS_RGB24)
ms_message("Driver supports RGB24, using that format.");
if (try_format_size(s, s->pix_fmt, s->vsize.width, s->vsize.height, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", s->vsize.width, s->vsize.height);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_QCIF_W, MS_VIDEO_SIZE_QCIF_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_QCIF_W, MS_VIDEO_SIZE_QCIF_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_CIF_W, MS_VIDEO_SIZE_CIF_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_CIF_W, MS_VIDEO_SIZE_CIF_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_4CIF_W, MS_VIDEO_SIZE_4CIF_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_4CIF_W, MS_VIDEO_SIZE_4CIF_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_QVGA_W, MS_VIDEO_SIZE_QVGA_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_QVGA_W, MS_VIDEO_SIZE_QVGA_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_QQVGA_W, MS_VIDEO_SIZE_QQVGA_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_QQVGA_W, MS_VIDEO_SIZE_QQVGA_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_NS1_W, MS_VIDEO_SIZE_NS1_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_NS1_W, MS_VIDEO_SIZE_NS1_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_QSIF_W, MS_VIDEO_SIZE_QSIF_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_QSIF_W, MS_VIDEO_SIZE_QSIF_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_SIF_W, MS_VIDEO_SIZE_SIF_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_SIF_W, MS_VIDEO_SIZE_SIF_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_VGA_W, MS_VIDEO_SIZE_VGA_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_VGA_W, MS_VIDEO_SIZE_VGA_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_SDTV_W, MS_VIDEO_SIZE_SDTV_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_SDTV_W, MS_VIDEO_SIZE_SDTV_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_288P_W, MS_VIDEO_SIZE_288P_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_288P_W, MS_VIDEO_SIZE_288P_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_448P_W, MS_VIDEO_SIZE_448P_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_448P_W, MS_VIDEO_SIZE_448P_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_576P_W, MS_VIDEO_SIZE_576P_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_576P_W, MS_VIDEO_SIZE_576P_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_720P_W, MS_VIDEO_SIZE_720P_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_720P_W, MS_VIDEO_SIZE_720P_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_1080P_W, MS_VIDEO_SIZE_1080P_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_1080P_W, MS_VIDEO_SIZE_1080P_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_4SIF_W, MS_VIDEO_SIZE_4SIF_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_4SIF_W, MS_VIDEO_SIZE_4SIF_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_SVGA_W, MS_VIDEO_SIZE_SVGA_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_SVGA_W, MS_VIDEO_SIZE_SVGA_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_XGA_W, MS_VIDEO_SIZE_XGA_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_XGA_W, MS_VIDEO_SIZE_XGA_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_WXGA_W, MS_VIDEO_SIZE_WXGA_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_WXGA_W, MS_VIDEO_SIZE_WXGA_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_HDTVP_W, MS_VIDEO_SIZE_HDTVP_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_HDTVP_W, MS_VIDEO_SIZE_HDTVP_H);
else
{
ms_error("No supported size found for format.");
/* size not supported? */
return -9;
}
return 0;
}
DirectShowScanner::DirectShowScanner() {
ICreateDevEnum *pDevEnum = 0;
int hr;
int devNum;
char nameBuf[80];
// Reference: Pesce, pp 54-56.
debug_msg("new DirectShowScanner()\n");
// Initialize the COM subsystem
hr=CoInitialize(NULL);
if (FAILED(hr)) {
debug_msg("Failed COM subsystem initialisation.\n");
return;
}
// Create a helper object to find the capture devices.
hr = CoCreateInstance(CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC_SERVER, IID_ICreateDevEnum, (LPVOID*)&pDevEnum);
if (FAILED(hr)) {
debug_msg("Failed to Create a helper object to find the DS capture devices.\n");
CoUninitialize();
return;
}
IEnumMoniker *pEnum = 0;
IMoniker *pMoniker = 0;
IPropertyBag *pPropBag = 0;
VARIANT varName;
// Get an enumerator over video capture filters
hr = pDevEnum->CreateClassEnumerator(CLSID_VideoInputDeviceCategory, &pEnum, 0);
//showErrorMessage(hr);
if (FAILED(hr) || pEnum == 0) {
debug_msg("Failed to Get an enumerator over DS video capture filters.\n");
CoUninitialize();
return;
}
// Get the capture filter for each device installed, up to NUM_DEVS devices
for( devNum=0; devNum < NUM_DEVS; ++devNum) {
if ( pEnum->Next(1, &pMoniker, NULL) == S_OK ) {
hr = pMoniker->BindToStorage(0, 0, IID_IPropertyBag, (void **)&pPropBag);
if (FAILED(hr)) {
debug_msg("Failed to Get propbag bound to storage on DS dev: %d\n", devNum);
continue;
}
//showErrorMessage(hr);
debug_msg("propbag bound to storage ok= %d\n", hr);
VariantInit(&varName);
hr = pPropBag->Read(L"FriendlyName", &varName, 0);
if (FAILED(hr)) {
debug_msg("Failed to Get friendly name read on DS dev: %d\n", devNum);
continue;
}
//showErrorMessage(hr);
debug_msg("friendly name read ok= %d\n", hr);
// Need this macro in atlconv.h to go from bStr to char* - msp
USES_CONVERSION;
strcpy(nameBuf, W2A(varName.bstrVal));
debug_msg("DirectShowScanner::DirectShowScanner(): found nameBuf/FriendlyName=%s\n", nameBuf);
// needs work, but don't add drivers that look like VFW drivers - msp
if( (strstr(nameBuf, "VFW") == NULL) ) {
hr = pMoniker->BindToObject(0, 0, IID_IBaseFilter, (void **)(pCaptureFilter+devNum));
//showErrorMessage(hr);
if (FAILED(hr)) {
debug_msg("Failed to Get friendly name read on DS dev: %d\n", devNum);
continue;
}
debug_msg("capture filter bound ok= %d\n", hr);
devs_[devNum] = new DirectShowDevice(strdup(nameBuf), pCaptureFilter[devNum]);
} else {
debug_msg("discarding an apparent VFW device= %s\n", nameBuf);
devs_[devNum] = NULL;
}
VariantClear(&varName);
pPropBag->Release();
}
}
// Release these objects so COM can release their memory
pMoniker->Release();
pEnum->Release();
pDevEnum->Release();
}
void DSManager::initCaptureDevices()
{
HRESULT ret = 0;
VARIANT name;
ICreateDevEnum* devEnum = NULL;
IEnumMoniker* monikerEnum = NULL;
IMoniker* moniker = NULL;
if(m_devices.size() > 0)
{
/* clean up our list in case of reinitialization */
for(std::list<DSCaptureDevice*>::iterator it = m_devices.begin() ; it != m_devices.end() ; ++it)
{
delete *it;
}
m_devices.clear();
}
/* get the available devices list */
ret = CoCreateInstance(CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC_SERVER,
IID_ICreateDevEnum, (void**)&devEnum);
if(FAILED(ret))
{
return;
}
ret = devEnum->CreateClassEnumerator(CLSID_VideoInputDeviceCategory,
&monikerEnum, 0);
/* error or no devices */
if(FAILED(ret) || ret == S_FALSE)
{
devEnum->Release();
return;
}
/* loop and initialize all available capture devices */
while(monikerEnum->Next(1, &moniker, 0) == S_OK)
{
DSCaptureDevice* captureDevice = NULL;
IPropertyBag* propertyBag = NULL;
{
IBaseFilter* cp = NULL;
if(!FAILED(moniker->BindToObject(0, 0, IID_IBaseFilter, (void**)&cp)))
{
IAMVfwCaptureDialogs* vfw = NULL;
if(!FAILED(
cp->QueryInterface(IID_IAMVfwCaptureDialogs, (void**)&vfw)))
{
if(vfw)
{
vfw->Release();
cp->Release();
continue;
}
}
}
}
/* get properties of the device */
ret = moniker->BindToStorage(0, 0, IID_IPropertyBag, (void**)&propertyBag);
if(!FAILED(ret))
{
VariantInit(&name);
ret = propertyBag->Read(L"FriendlyName", &name, 0);
if(FAILED(ret))
{
VariantClear(&name);
propertyBag->Release();
moniker->Release();
continue;
}
/* create a new capture device */
captureDevice = new DSCaptureDevice(name.bstrVal);
/* wprintf(L"%ws\n", name.bstrVal); */
if(captureDevice && captureDevice->initDevice(moniker))
{
/* initialization success, add to the list */
m_devices.push_back(captureDevice);
}
else
{
/* printf("failed to initialize device\n"); */
delete captureDevice;
}
/* clean up */
VariantClear(&name);
propertyBag->Release();
}
moniker->Release();
}
/* cleanup */
monikerEnum->Release();
devEnum->Release();
}
static int v4w_open_videodevice(V4wState *s)
{
// Initialize COM
CoInitialize(NULL);
// get a Graph
HRESULT hr= CoCreateInstance (CLSID_FilterGraph,
NULL,
CLSCTX_INPROC_SERVER,
IID_IGraphBuilder, //IID_IBaseFilter,
(void **)&s->m_pGraph);
if(FAILED(hr))
{
return -1;
}
// get a CaptureGraphBuilder2
hr= CoCreateInstance (CLSID_CaptureGraphBuilder2,
NULL,
CLSCTX_INPROC_SERVER,
IID_ICaptureGraphBuilder2, //IID_IBaseFilter,
(void **)&s->m_pBuilder);
if(FAILED(hr))
{
return -2;
}
// connect capture graph builder with the graph
s->m_pBuilder->SetFiltergraph(s->m_pGraph);
// get mediacontrol so we can start and stop the filter graph
hr=s->m_pGraph->QueryInterface (IID_IMediaControl, (void **)&s->m_pControl);
if(FAILED(hr))
{
return -3;
}
ICreateDevEnum *pCreateDevEnum = NULL;
IEnumMoniker *pEnumMoniker = NULL;
IMoniker *pMoniker = NULL;
ULONG nFetched = 0;
hr = CoCreateInstance(CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC_SERVER,
IID_ICreateDevEnum, (PVOID *)&pCreateDevEnum);
if(FAILED(hr))
{
return -4;
}
hr = pCreateDevEnum->CreateClassEnumerator(CLSID_VideoInputDeviceCategory,
&pEnumMoniker, 0);
if (FAILED(hr) || pEnumMoniker == NULL) {
//printf("no device\n");
return -5;
}
pEnumMoniker->Reset();
int pos=0;
while(S_OK == pEnumMoniker->Next(1, &pMoniker, &nFetched) )
{
IPropertyBag *pBag;
hr = pMoniker->BindToStorage( 0, 0, IID_IPropertyBag, (void**) &pBag );
if( hr != S_OK )
continue;
if (s->dev[0]=='\0')
break;
VARIANT var;
VariantInit(&var);
hr = pBag->Read( L"FriendlyName", &var, NULL );
if( hr != S_OK )
{
pMoniker->Release();
continue;
}
//USES_CONVERSION;
char szName[256];
WideCharToMultiByte(CP_UTF8,0,var.bstrVal,-1,szName,256,0,0);
VariantClear(&var);
if (strcmp(szName, s->dev)==0)
break;
pMoniker->Release();
pBag->Release();
pMoniker=NULL;
pBag=NULL;
}
if(pMoniker==NULL)
{
return -6;
}
hr = pMoniker->BindToObject(0, 0, IID_IBaseFilter, (void**)&s->m_pDeviceFilter );
if(FAILED(hr))
{
return -7;
}
s->m_pGraph->AddFilter(s->m_pDeviceFilter, L"Device Filter");
pMoniker->Release();
pEnumMoniker->Release();
pCreateDevEnum->Release();
GUID pPinCategory;
if (try_format(s->m_pDeviceFilter, s->pix_fmt, &pPinCategory)==0)
s->pix_fmt = s->pix_fmt;
else if (try_format(s->m_pDeviceFilter,MS_YUV420P, &pPinCategory)==0)
s->pix_fmt = MS_YUV420P;
else if (try_format(s->m_pDeviceFilter,MS_YUY2, &pPinCategory)==0)
s->pix_fmt = MS_YUY2;
else if (try_format(s->m_pDeviceFilter,MS_YUYV, &pPinCategory)==0)
s->pix_fmt = MS_YUYV;
else if (try_format(s->m_pDeviceFilter,MS_UYVY, &pPinCategory)==0)
s->pix_fmt = MS_UYVY;
else if (try_format(s->m_pDeviceFilter,MS_RGB24, &pPinCategory)==0)
s->pix_fmt = MS_RGB24;
else
{
ms_error("Unsupported video pixel format.");
return -8;
}
if (s->pix_fmt == MS_YUV420P)
ms_message("Driver supports YUV420P, using that format.");
else if (s->pix_fmt == MS_YUY2)
ms_message("Driver supports YUY2 (YUYV), using that format.");
else if (s->pix_fmt == MS_YUYV)
ms_message("Driver supports YUV422, using that format.");
else if (s->pix_fmt == MS_UYVY)
ms_message("Driver supports UYVY, using that format.");
else if (s->pix_fmt == MS_RGB24)
ms_message("Driver supports RGB24, using that format.");
if (try_format_size(s, s->pix_fmt, s->vsize.width, s->vsize.height, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", s->vsize.width, s->vsize.height);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_QCIF_W, MS_VIDEO_SIZE_QCIF_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_QCIF_W, MS_VIDEO_SIZE_QCIF_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_CIF_W, MS_VIDEO_SIZE_CIF_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_CIF_W, MS_VIDEO_SIZE_CIF_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_4CIF_W, MS_VIDEO_SIZE_4CIF_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_4CIF_W, MS_VIDEO_SIZE_4CIF_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_QVGA_W, MS_VIDEO_SIZE_QVGA_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_QVGA_W, MS_VIDEO_SIZE_QVGA_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_QQVGA_W, MS_VIDEO_SIZE_QQVGA_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_QQVGA_W, MS_VIDEO_SIZE_QQVGA_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_NS1_W, MS_VIDEO_SIZE_NS1_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_NS1_W, MS_VIDEO_SIZE_NS1_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_QSIF_W, MS_VIDEO_SIZE_QSIF_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_QSIF_W, MS_VIDEO_SIZE_QSIF_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_SIF_W, MS_VIDEO_SIZE_SIF_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_SIF_W, MS_VIDEO_SIZE_SIF_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_VGA_W, MS_VIDEO_SIZE_VGA_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_VGA_W, MS_VIDEO_SIZE_VGA_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_SDTV_W, MS_VIDEO_SIZE_SDTV_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_SDTV_W, MS_VIDEO_SIZE_SDTV_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_288P_W, MS_VIDEO_SIZE_288P_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_288P_W, MS_VIDEO_SIZE_288P_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_448P_W, MS_VIDEO_SIZE_448P_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_448P_W, MS_VIDEO_SIZE_448P_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_576P_W, MS_VIDEO_SIZE_576P_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_576P_W, MS_VIDEO_SIZE_576P_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_720P_W, MS_VIDEO_SIZE_720P_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_720P_W, MS_VIDEO_SIZE_720P_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_1080P_W, MS_VIDEO_SIZE_1080P_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_1080P_W, MS_VIDEO_SIZE_1080P_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_4SIF_W, MS_VIDEO_SIZE_4SIF_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_4SIF_W, MS_VIDEO_SIZE_4SIF_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_SVGA_W, MS_VIDEO_SIZE_SVGA_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_SVGA_W, MS_VIDEO_SIZE_SVGA_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_XGA_W, MS_VIDEO_SIZE_XGA_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_XGA_W, MS_VIDEO_SIZE_XGA_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_WXGA_W, MS_VIDEO_SIZE_WXGA_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_WXGA_W, MS_VIDEO_SIZE_WXGA_H);
else if (try_format_size(s, s->pix_fmt, MS_VIDEO_SIZE_HDTVP_W, MS_VIDEO_SIZE_HDTVP_H, &pPinCategory)==0)
ms_message("Selected Size: %ix%i.", MS_VIDEO_SIZE_HDTVP_W, MS_VIDEO_SIZE_HDTVP_H);
else
{
ms_error("No supported size found for format.");
/* size not supported? */
return -9;
}
// get DXFilter
s->m_pDXFilter = new CDXFilter(NULL, &hr, FALSE);
if(s->m_pDXFilter==NULL)
{
return -10;
}
s->m_pDXFilter->AddRef();
CMediaType mt;
mt.SetType(&MEDIATYPE_Video);
GUID m = MEDIASUBTYPE_RGB24;
if (s->pix_fmt == MS_YUV420P)
m = (GUID)FOURCCMap(MAKEFOURCC('I','4','2','0'));
else if (s->pix_fmt == MS_YUY2)
m = MEDIASUBTYPE_YUY2;
else if (s->pix_fmt == MS_YUYV)
m = MEDIASUBTYPE_YUYV;
else if (s->pix_fmt == MS_UYVY)
m = MEDIASUBTYPE_UYVY;
else if (s->pix_fmt == MS_RGB24)
m = MEDIASUBTYPE_RGB24;
mt.SetSubtype(&m);
mt.formattype = FORMAT_VideoInfo;
mt.SetTemporalCompression(FALSE);
VIDEOINFO *pvi = (VIDEOINFO *)
mt.AllocFormatBuffer(sizeof(VIDEOINFO));
if (NULL == pvi)
return -11;
ZeroMemory(pvi, sizeof(VIDEOINFO));
if (s->pix_fmt == MS_YUV420P)
pvi->bmiHeader.biCompression = MAKEFOURCC('I','4','2','0');
else if (s->pix_fmt == MS_YUY2)
pvi->bmiHeader.biCompression = MAKEFOURCC('Y','U','Y','2');
else if (s->pix_fmt == MS_YUYV)
pvi->bmiHeader.biCompression = MAKEFOURCC('Y','U','Y','V');
else if (s->pix_fmt == MS_UYVY)
pvi->bmiHeader.biCompression = MAKEFOURCC('U','Y','V','Y');
else if (s->pix_fmt == MS_RGB24)
pvi->bmiHeader.biCompression = BI_RGB;
if (s->pix_fmt == MS_YUV420P)
pvi->bmiHeader.biBitCount = 12;
else if (s->pix_fmt == MS_YUY2)
pvi->bmiHeader.biBitCount = 16;
else if (s->pix_fmt == MS_YUYV)
pvi->bmiHeader.biBitCount = 16;
else if (s->pix_fmt == MS_UYVY)
pvi->bmiHeader.biBitCount = 16;
else if (s->pix_fmt == MS_RGB24)
pvi->bmiHeader.biBitCount = 24;
pvi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
pvi->bmiHeader.biWidth = s->vsize.width;
pvi->bmiHeader.biHeight = s->vsize.height;
pvi->bmiHeader.biPlanes = 1;
pvi->bmiHeader.biSizeImage = GetBitmapSize(&pvi->bmiHeader);
pvi->bmiHeader.biClrImportant = 0;
mt.SetSampleSize(pvi->bmiHeader.biSizeImage);
mt.SetFormat((BYTE*)pvi, sizeof(VIDEOINFO));
hr = s->m_pDXFilter->SetAcceptedMediaType(&mt);
if(FAILED(hr))
{
return -12;
}
hr = s->m_pDXFilter->SetCallback(Callback);
if(FAILED(hr))
{
return -13;
}
hr = s->m_pDXFilter->QueryInterface(IID_IBaseFilter,
(LPVOID *)&s->m_pIDXFilter);
if(FAILED(hr))
{
return -14;
}
hr = s->m_pGraph->AddFilter(s->m_pIDXFilter, L"DXFilter Filter");
if(FAILED(hr))
{
return -15;
}
// get null renderer
hr=CoCreateInstance (CLSID_NullRenderer,
NULL,
CLSCTX_INPROC_SERVER,
IID_IBaseFilter,
(void **)&s->m_pNullRenderer);
if(FAILED(hr))
{
return -16;
}
if (s->m_pNullRenderer!=NULL)
{
s->m_pGraph->AddFilter(s->m_pNullRenderer, L"Null Renderer");
}
hr = s->m_pBuilder->RenderStream(&pPinCategory,
&MEDIATYPE_Video, s->m_pDeviceFilter, s->m_pIDXFilter, s->m_pNullRenderer);
if (FAILED(hr))
{
return -17;
}
IAMStreamConfig *pConfig = NULL;
hr = s->m_pBuilder->FindInterface(
&pPinCategory, // Preview pin.
&MEDIATYPE_Video, // Any media type.
s->m_pDeviceFilter, // Pointer to the capture filter.
IID_IAMStreamConfig, (void**)&pConfig);
if (pConfig!=NULL)
{
AM_MEDIA_TYPE *pType = NULL;
int iCount, iSize;
pConfig->GetNumberOfCapabilities(&iCount, &iSize);
for (int i = 0; i < iCount; i++) {
VIDEO_STREAM_CONFIG_CAPS scc;
pType = NULL;
pConfig->GetStreamCaps(i, &pType, (BYTE *)&scc);
if (!((pType->formattype == FORMAT_VideoInfo) &&
(pType->cbFormat >= sizeof(VIDEOINFOHEADER)) &&
(pType->pbFormat != NULL)))
continue;
VIDEOINFOHEADER & videoInfo = *(VIDEOINFOHEADER *)pType->pbFormat;
if (m != pType->subtype)
continue;
if (videoInfo.bmiHeader.biWidth != s->vsize.width)
continue;
if (videoInfo.bmiHeader.biHeight != s->vsize.height)
continue;
if (videoInfo.bmiHeader.biBitCount != pvi->bmiHeader.biBitCount)
continue;
if (videoInfo.bmiHeader.biCompression != pvi->bmiHeader.biCompression)
continue;
videoInfo.AvgTimePerFrame = UNITS / (LONGLONG)s->fps;
pConfig->SetFormat(pType);
}
pConfig->GetFormat(&pType);
if (pType!=NULL)
{
VIDEOINFO *pvi;
pvi = (VIDEOINFO *)pType->pbFormat;
ms_message("v4w: camera asked fps=%.2f // real fps=%.2f", s->fps, ((float)UNITS / (float)pvi->AvgTimePerFrame));
}
pConfig->Release();
}
//m_pDXFilter->SetBufferSamples(TRUE);
s_callback = s;
hr = s->m_pControl->Run();
if(FAILED(hr))
{
return -18;
}
s->rotregvalue=1;
return 0;
}
