bool VideoCapture::CreateMediaSource() { HRESULT hr; pin_ptr<IMFAttributes *> pConfig = &(this->Config); hr = MFCreateAttributes(pConfig, 1); if (hr != S_OK) { MFUtil::ShowErrorNameFromCode(hr); return false; } hr = this->Config->SetGUID( MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE, MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID ); if (hr != S_OK) { MFUtil::ShowErrorNameFromCode(hr); return false; } pin_ptr<IMFActivate **> pDevices = &(this->Devices); pin_ptr<UINT32> pCount = &(this->DeviceCount); hr = MFEnumDeviceSources(this->Config, pDevices, pCount); if (hr != S_OK) { MFUtil::ShowErrorNameFromCode(hr); return false; } if (this->DeviceCount <= 0) { MFUtil::ShowMessage(TEXT("Device Not Found."), ML_ERROR); return false; } // Debug : 利用するデバイス(リストの先頭)の名前を確認 LPWSTR devName = NULL; UINT32 devNameLen = 0; hr = this->Devices[0]->GetAllocatedString(MF_DEVSOURCE_ATTRIBUTE_FRIENDLY_NAME, &devName, &devNameLen); if (hr != S_OK) { MFUtil::ShowErrorNameFromCode(hr); return false; } MFUtil::ShowMessage(devName, ML_DEBUG); pin_ptr<IMFMediaSource *> pSource = &(this->Source); hr = this->Devices[0]->ActivateObject( __uuidof(IMFMediaSource), reinterpret_cast<void**>(pSource) ); if (hr != S_OK) { MFUtil::ShowErrorNameFromCode(hr); return false; } return true; }
void OnChooseDevice(HWND hwnd) { ChooseDeviceParam param; IMFAttributes *pAttributes = NULL; HRESULT hr = MFCreateAttributes(&pAttributes, 1); if (FAILED(hr)) { goto done; } // Ask for source type = video capture devices hr = pAttributes->SetGUID(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE, MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID); if (FAILED(hr)) { goto done; } // Enumerate devices. hr = MFEnumDeviceSources(pAttributes, ¶m.ppDevices, ¶m.count); if (FAILED(hr)) { goto done; } // Ask the user to select one. INT_PTR result = DialogBoxParam(GetModuleHandle(NULL), MAKEINTRESOURCE(IDD_CHOOSE_DEVICE), hwnd, ChooseDeviceDlgProc, (LPARAM)¶m); if ((result == IDOK) && (param.selection != (UINT32)-1)) { UINT iDevice = param.selection; if (iDevice >= param.count) { hr = E_UNEXPECTED; goto done; } hr = g_pEngine->InitializeCaptureManager(hPreview, param.ppDevices[iDevice]); if (FAILED(hr)) { goto done; } SafeRelease(&pSelectedDevice); pSelectedDevice = param.ppDevices[iDevice]; pSelectedDevice->AddRef(); } done: SafeRelease(&pAttributes); if (FAILED(hr)) { ShowError(hwnd, IDS_ERR_SET_DEVICE, hr); } UpdateUI(hwnd); }
void MFPlayer::init(HWND handle) { HRESULT ret; // Initialize M$ bullshit //ret = CoInitializeEx(NULL, COINIT_MULTITHREADED); //assert(ret == S_OK); ret = MFStartup(MF_VERSION); assert(ret == S_OK); // Create factory IMFMediaEngineClassFactory *pMediaEngineClassFactory = nullptr; ret = CoCreateInstance(CLSID_MFMediaEngineClassFactory, nullptr, CLSCTX_ALL, IID_PPV_ARGS(&pMediaEngineClassFactory)); assert(ret == S_OK); // Create notify m_pPlayerNodify = new MFPlayerNotify(shared_from_this()); // Create attributes IMFAttributes *pAttributes = nullptr; ret = MFCreateAttributes(&pAttributes, 1); assert(ret == S_OK); ret = pAttributes->SetUnknown(MF_MEDIA_ENGINE_CALLBACK, m_pPlayerNodify); assert(ret == S_OK); ret = pAttributes->SetUINT64(MF_MEDIA_ENGINE_PLAYBACK_HWND, reinterpret_cast<UINT64>(handle)); assert(ret == S_OK); // Create player ret = pMediaEngineClassFactory->CreateInstance(0, pAttributes, &m_pMediaEngine); assert(ret == S_OK); // Release bullshits pAttributes->Release(); pMediaEngineClassFactory->Release(); }
static int mf_enumerate_cameras(int (*callback)(IMFSourceReader* reader)) { com_t<IMFAttributes> config; if_failed_return_result(MFCreateAttributes(&config, 1)); if_failed_return_result(config->SetGUID(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE, MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID)); UINT32 num = 0; IMFActivate** factory = null; // [count] if_failed_return_result(MFEnumDeviceSources(config, &factory, &num)); if (num == 0) { return 0; } for (int i = 0; i < (int)num; i++) { const char* sl = ""; const char* fn= ""; WCHAR* symbolic_link = null; WCHAR* friendly_name = null; UINT32 size = 0; if (OK(factory[i]->GetAllocatedString(MF_SL, &symbolic_link, &size))) { sl = wcs2str(symbolic_link); } if (OK(factory[i]->GetAllocatedString(MF_FN, &friendly_name, &size))) { fn = wcs2str(friendly_name); } com_t<IMFMediaSource> source; if_failed_return_result(factory[i]->ActivateObject(IID_PPV_ARGS(&source))); com_t<IMFSourceReader> reader; if_failed_return_result(MFCreateSourceReaderFromMediaSource(source, null, &reader)); print("\nMMF camera %d %s %s\n", i, fn, sl); callback(reader); com_release(factory[i]); } CoTaskMemFree(factory); return S_OK; }
//------------------------------------------------------------------- // Initialise the source reader // HRESULT VidReader::initSourceReader(WCHAR *filename) { HRESULT hr = S_OK; IMFAttributes *pAttributes = NULL; SafeRelease(&m_pReader); // Configure the source reader to perform video processing hr = MFCreateAttributes(&pAttributes, 1); if (FAILED(hr)) goto done; hr = pAttributes->SetUINT32(MF_SOURCE_READER_ENABLE_VIDEO_PROCESSING, TRUE); if (FAILED(hr)) goto done; // Create the source reader from the URL hr = MFCreateSourceReaderFromURL(filename, pAttributes, &m_pReader); if (FAILED(hr)) goto done; // Attempt to find a video stream hr = selectVideoStream(); if (FAILED(hr)) goto done; // Get the stream format hr = getVideoFormat(); if (FAILED(hr)) goto done; // Get the duration hr = getDuration(); done: return hr; }
bool MediaFoundationCaptureLibrary::BuildListOfDevices() { HRESULT hr = S_OK; IMFAttributes *pAttributes = NULL; CoInitialize(NULL); hr = MFCreateAttributes(&pAttributes, 1); if (SUCCEEDED(hr)) { hr = pAttributes->SetGUID( MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE, MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID ); } if (SUCCEEDED(hr)) { hr = MediaFoundationVideoDevices::GetInstance().InitDevices(pAttributes); } else { LOG_ERROR("MEDIA FOUNDATION: The access to the video cameras denied."); } SafeRelease(&pAttributes); return (SUCCEEDED(hr)); }
int CountCaptureDevices() { HRESULT hr = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED | COINIT_DISABLE_OLE1DDE); if (FAILED(hr)) return 0; hr = MFStartup(MF_VERSION); if (FAILED(hr)) return 0; // choose device IMFAttributes *attributes = NULL; hr = MFCreateAttributes(&attributes, 1); ScopedRelease<IMFAttributes> attributes_s(attributes); if (FAILED(hr)) return 0; hr = attributes->SetGUID( MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE, MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID ); if (FAILED(hr)) return 0; ChooseDeviceParam param = { 0 }; hr = MFEnumDeviceSources(attributes, ¶m.mDevices, ¶m.mCount); if (FAILED(hr)) return 0; return param.mCount; }
HRESULT CCapture::OpenMediaSource(IMFMediaSource *pSource) { HRESULT hr = S_OK; IMFAttributes *pAttributes = NULL; hr = MFCreateAttributes(&pAttributes, 2); if (SUCCEEDED(hr)) { hr = pAttributes->SetUnknown(MF_SOURCE_READER_ASYNC_CALLBACK, this); } if (SUCCEEDED(hr)) { hr = MFCreateSourceReaderFromMediaSource( pSource, pAttributes, &m_pReader ); } SafeRelease(&pAttributes); return hr; }
// Initialize Device List HRESULT DeviceList::EnumerateDevices() { HRESULT hr = S_OK; IMFAttributes *pAttributes = NULL; Clear(); // Initialize an attribute store. We will use this to // specify the enumeration parameters. hr = MFCreateAttributes(&pAttributes, 1); // Ask for source type = video capture devices if (SUCCEEDED(hr)) { hr = pAttributes->SetGUID( MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE, MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID ); } // Enumerate devices. if (SUCCEEDED(hr)) { hr = MFEnumDeviceSources(pAttributes, &m_ppDevices, &m_cDevices); } SafeRelease(&pAttributes); return hr; }
bool VideoCapture::CreateSourceReaderAsync() { HRESULT hr; HANDLE hEvent = CreateEvent(NULL, FALSE, FALSE, NULL); if (hEvent == NULL) { MFUtil::ShowMessage(TEXT("CreateEvent Failed."), ML_ERROR); return false; } this->CallBack = new SourceReaderCallBack(hEvent); if (this->CallBack == NULL) { MFUtil::ShowMessage(TEXT("CreateCallBack Failed."), ML_ERROR); return false; } IMFAttributes *pAttributes = NULL; hr = MFCreateAttributes(&pAttributes, 1); if (hr != S_OK) { MFUtil::ShowMessage(TEXT("CreateAttributes Failed."), ML_ERROR); this->ReleaseDevices(); return false; } hr = pAttributes->SetUnknown(MF_SOURCE_READER_ASYNC_CALLBACK, this->CallBack); if (hr != S_OK) { MFUtil::ShowMessage(TEXT("AttributeSetting Failed."), ML_ERROR); this->ReleaseDevices(); return false; } pin_ptr<IMFSourceReader *> pSourceReader = &(this->SourceReader); hr = MFCreateSourceReaderFromMediaSource(this->Source, pAttributes, pSourceReader); if (hr != S_OK) { MFUtil::ShowMessage(TEXT("CreateSourceReader Failed."), ML_ERROR); this->ReleaseDevices(); return false; } hr = this->ConfigureSourceReader(); if (hr != S_OK) { MFUtil::ShowMessage(TEXT("ConfigureDecoder Failed."), ML_ERROR); MFUtil::ShowErrorNameFromCode(hr); return false; } // 二回目以降の ReadSample() はコールバック内で呼ぶため、 // SourceReaderCallBack クラスにも SourceReader が必要。 this->CallBack->SourceReader = this->SourceReader; return true; }
void GetCaptureDeviceName(int aDevice, char * aNamebuffer, int aBufferlength) { int i; if (!aNamebuffer || aBufferlength <= 0) return; aNamebuffer[0] = 0; HRESULT hr = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED | COINIT_DISABLE_OLE1DDE); if (FAILED(hr)) return; hr = MFStartup(MF_VERSION); if (FAILED(hr)) return; // choose device IMFAttributes *attributes = NULL; hr = MFCreateAttributes(&attributes, 1); ScopedRelease<IMFAttributes> attributes_s(attributes); if (FAILED(hr)) return; hr = attributes->SetGUID( MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE, MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID ); if (FAILED(hr)) return; ChooseDeviceParam param = { 0 }; hr = MFEnumDeviceSources(attributes, ¶m.mDevices, ¶m.mCount); if (FAILED(hr)) return; if (aDevice < (signed)param.mCount) { WCHAR *name = 0; UINT32 namelen = 255; hr = param.mDevices[aDevice]->GetAllocatedString( MF_DEVSOURCE_ATTRIBUTE_FRIENDLY_NAME, &name, &namelen ); if (SUCCEEDED(hr) && name) { i = 0; while (i < aBufferlength - 1 && i < (signed)namelen && name[i] != 0) { aNamebuffer[i] = (char)name[i]; i++; } aNamebuffer[i] = 0; CoTaskMemFree(name); } } }
HRESULT CTranscoder::ConfigureVideoOutput() { assert (m_pProfile); HRESULT hr = S_OK; IMFAttributes* pVideoAttrs = NULL; // Configure the video stream // Create a new attribute store. if (SUCCEEDED(hr)) { hr = MFCreateAttributes( &pVideoAttrs, 5 ); } // Set the encoder to be Windows Media video encoder, so that the appropriate MFTs are added to the topology. if (SUCCEEDED(hr)) { hr = pVideoAttrs->SetGUID(MF_MT_SUBTYPE, MFVideoFormat_WMV3); } // Set the frame rate. if (SUCCEEDED(hr)) { hr = MFSetAttributeRatio(pVideoAttrs, MF_MT_FRAME_RATE, 30, 1); } //Set the frame size. if (SUCCEEDED(hr)) { hr = MFSetAttributeSize(pVideoAttrs, MF_MT_FRAME_SIZE, 320, 240); } //Set the pixel aspect ratio if (SUCCEEDED(hr)) { hr = MFSetAttributeRatio(pVideoAttrs, MF_MT_PIXEL_ASPECT_RATIO, 1, 1); } // Set the bit rate. if (SUCCEEDED(hr)) { hr = pVideoAttrs->SetUINT32(MF_MT_AVG_BITRATE, 300000); } // Set the attribute store on the transcode profile. if (SUCCEEDED(hr)) { hr = m_pProfile->SetVideoAttributes( pVideoAttrs ); } SafeRelease(&pVideoAttrs); return hr; }
void MFPlayer::init(const OTextureRef& pRenderTarget) { m_pRenderTarget = pRenderTarget; auto pRendererD3D11 = std::dynamic_pointer_cast<ORendererD3D11>(oRenderer); HRESULT ret; // Initialize M$ bullshit //ret = CoInitializeEx(NULL, COINIT_MULTITHREADED); //assert(ret == S_OK); ret = MFStartup(MF_VERSION); assert(ret == S_OK); // Create factory IMFMediaEngineClassFactory *pMediaEngineClassFactory = nullptr; ret = CoCreateInstance(CLSID_MFMediaEngineClassFactory, nullptr, CLSCTX_ALL, IID_PPV_ARGS(&pMediaEngineClassFactory)); assert(ret == S_OK); // Create notify m_pPlayerNodify = new MFPlayerNotify(shared_from_this()); // Create attributes IMFAttributes *pAttributes = nullptr; ret = MFCreateAttributes(&pAttributes, 1); assert(ret == S_OK); ret = pAttributes->SetUnknown(MF_MEDIA_ENGINE_CALLBACK, m_pPlayerNodify); assert(ret == S_OK); ID3D10Multithread *pMultithread = nullptr; ID3D11Device *pDevice = pRendererD3D11->getDevice(); ret = pDevice->QueryInterface(IID_PPV_ARGS(&pMultithread)); assert(ret == S_OK); pMultithread->SetMultithreadProtected(TRUE); pMultithread->Release(); UINT resetToken = 0; ret = MFCreateDXGIDeviceManager(&resetToken, &m_pDXGIManager); assert(ret == S_OK); ret = m_pDXGIManager->ResetDevice(pRendererD3D11->getDevice(), resetToken); assert(ret == S_OK); ret = pAttributes->SetUnknown(MF_MEDIA_ENGINE_DXGI_MANAGER, m_pDXGIManager); assert(ret == S_OK); ret = pAttributes->SetUINT32(MF_MEDIA_ENGINE_VIDEO_OUTPUT_FORMAT, DXGI_FORMAT_R8G8B8A8_UNORM); assert(ret == S_OK); // Create player ret = pMediaEngineClassFactory->CreateInstance(MF_MEDIA_ENGINE_WAITFORSTABLE_STATE, pAttributes, &m_pMediaEngine); assert(ret == S_OK); // Release bullshits pAttributes->Release(); pMediaEngineClassFactory->Release(); }
HRESULT ConfigureAudioEncoding(IMFCaptureSource *pSource, IMFCaptureRecordSink *pRecord, REFGUID guidEncodingType) { IMFCollection *pAvailableTypes = NULL; IMFMediaType *pMediaType = NULL; IMFAttributes *pAttributes = NULL; // Configure the audio format for the recording sink. HRESULT hr = MFCreateAttributes(&pAttributes, 1); if(FAILED(hr)) { goto done; } // Enumerate low latency media types hr = pAttributes->SetUINT32(MF_LOW_LATENCY, TRUE); if(FAILED(hr)) { goto done; } // Get a list of encoded output formats that are supported by the encoder. hr = MFTranscodeGetAudioOutputAvailableTypes(guidEncodingType, MFT_ENUM_FLAG_ALL | MFT_ENUM_FLAG_SORTANDFILTER, pAttributes, &pAvailableTypes); if (FAILED(hr)) { goto done; } // Pick the first format from the list. hr = GetCollectionObject(pAvailableTypes, 0, &pMediaType); if (FAILED(hr)) { goto done; } // Connect the audio stream to the recording sink. DWORD dwSinkStreamIndex; hr = pRecord->AddStream((DWORD)MF_CAPTURE_ENGINE_PREFERRED_SOURCE_STREAM_FOR_AUDIO, pMediaType, NULL, &dwSinkStreamIndex); if(hr == MF_E_INVALIDSTREAMNUMBER) { //If an audio device is not present, allow video only recording hr = S_OK; } done: SafeRelease(&pAvailableTypes); SafeRelease(&pMediaType); SafeRelease(&pAttributes); return hr; }
/*static */ComPtr_t<IMFAttributes> MFMovieSource::CreateSourceReaderAttribute() { ComPtr_t<IMFAttributes> attr; MFCreateAttributes( &attr, 0 ); // https://msdn.microsoft.com/ja-jp/library/windows/desktop/dd757760(v=vs.85).aspx // attr->SetUINT32( MF_SOURCE_READER_ENABLE_VIDEO_PROCESSING, TRUE ); // https://msdn.microsoft.com/ja-jp/library/windows/desktop/dd375764(v=vs.85).aspx // attr->SetUINT32( MF_READWRITE_DISABLE_CONVERTERS, FALSE ); // https://msdn.microsoft.com/ja-jp/library/windows/desktop/dd375772(v=vs.85).aspx // //attr->SetUINT32( MF_SOURCE_READER_D3D_MANAGER, FALSE ); return std::move( attr ); }
IMFActivate* WinCaptureDevice::ChooseFirst(std::string& error) { IMFActivate* result = NULL; HRESULT hr = S_OK; UINT iDevice = 0; // Index into the array of devices BOOL bCancel = FALSE; // Initialize an attribute store to specify enumeration parameters. IMFAttributes* pAttributes = NULL; hr = MFCreateAttributes(&pAttributes, 1); if (FAILED(hr)) { goto done; } // Ask for source type = video capture devices. hr = pAttributes->SetGUID(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE, MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID); if (FAILED(hr)) { goto done; } // Enumerate devices. IMFActivate **devices = NULL; uint numDevices = 0; hr = MFEnumDeviceSources(pAttributes, &devices, &numDevices); if (FAILED(hr)) { goto done; } if (numDevices > 0) result = devices[0]; done: SafeRelease(&pAttributes); for (uint i = 0; i < numDevices; i++) { if (devices[i] != result) SafeRelease(&devices[i]); } CoTaskMemFree(devices); if (FAILED(hr)) { //ShowErrorMessage(L"Cannot create a video capture device", hr); } return result; }
HRESULT CMFCamCapture::enumVideoDevices() { IMFAttributes *pAttributes = NULL; IMFActivate **ppDevices = NULL; // Create an attribute store to specify the enumeration parameters. HRESULT hr = MFCreateAttributes(&pAttributes, 1); if (FAILED(hr)) { goto done; } // Source type: video capture devices hr = pAttributes->SetGUID( MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE, MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID ); if (FAILED(hr)) { goto done; } // Enumerate devices. UINT32 count; hr = MFEnumDeviceSources(pAttributes, &ppDevices, &count); if (FAILED(hr)) { goto done; } if (count == 0) { hr = E_FAIL; goto done; } // cache the devices. m_deviceActivateObjects.clear(); for (DWORD i = 0; i < count; i++) { m_deviceActivateObjects.push_back(CComPtr<IMFActivate>(ppDevices[i])); } done: SafeRelease(&pAttributes); for (DWORD i = 0; i < count; i++) { SafeRelease(&ppDevices[i]); } CoTaskMemFree(ppDevices); return hr; }
HRESULT CTedPlayer::InitProtected() { HRESULT hr; if(m_spSession) { if(m_bIsPlaying) { m_bIsPlaying = false; m_spSession->Stop(); } m_spSession.Release(); } if(m_fPendingProtectedCustomTopoloader && m_spProtectedSession.p) { m_spProtectedSession->Shutdown(); m_spProtectedSession.Release(); } if(m_spProtectedSession.p == NULL) { CComPtr<IMFAttributes> spAttr; IFC( MFCreateAttributes(&spAttr, 1) ); IFC( spAttr->SetUnknown(MF_SESSION_CONTENT_PROTECTION_MANAGER, m_pCPM) ); if(m_fPendingProtectedCustomTopoloader && GUID_NULL != m_gidCustomTopoloader) { IFC( spAttr->SetGUID(MF_SESSION_TOPOLOADER, m_gidCustomTopoloader) ); } IFC( MFCreatePMPMediaSession( 0, spAttr, &m_spProtectedSession, NULL ) ); IFC( m_spProtectedSession->BeginGetEvent(&m_xOnProtectedSessionEvent, NULL) ); m_fPendingProtectedCustomTopoloader = false; } m_spSession = m_spProtectedSession; IFC( InitFromSession() ); Cleanup: return hr; }
audio_reader::audio_reader(std::wstring& source) { { IMFByteStreamPtr stream; CHK(MFCreateFile(MF_FILE_ACCESSMODE::MF_ACCESSMODE_READ, MF_FILE_OPENMODE::MF_OPENMODE_FAIL_IF_NOT_EXIST, MF_FILE_FLAGS::MF_FILEFLAGS_NONE, source.c_str(), &stream)); IMFAttributesPtr attr; CHK(MFCreateAttributes(&attr, 10)); CHK(attr->SetUINT32(MF_READWRITE_ENABLE_HARDWARE_TRANSFORMS, true)); IMFSourceReaderPtr reader; CHK(MFCreateSourceReaderFromByteStream(stream.Get(), attr.Get(), &reader)); // CHK(MFCreateSourceReaderFromURL(source.c_str(),attr.Get(), &reader)); CHK(reader.As(&reader_)); QWORD length; CHK(stream->GetLength(&length)); fileSize_ = length; } //CHK(reader_->GetServiceForStream(0, MF_WRAPPED_OBJECT, __uuidof(IMFByteStream), &stream)); CHK(reader_->GetNativeMediaType(0, 0, &native_media_type_)); CHK(MFCreateMediaType(¤t_media_type_)); CHK(current_media_type_->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio)); CHK(current_media_type_->SetGUID(MF_MT_SUBTYPE, MFAudioFormat_PCM)); CHK(current_media_type_->SetUINT32(MF_MT_AUDIO_BITS_PER_SAMPLE, MFGetAttributeUINT32(native_media_type_.Get(), MF_MT_AUDIO_BITS_PER_SAMPLE, bits_per_sample) ) ); CHK(current_media_type_->SetUINT32(MF_MT_AUDIO_SAMPLES_PER_SECOND, MFGetAttributeUINT32(native_media_type_.Get(), MF_MT_AUDIO_SAMPLES_PER_SECOND, samples_per_second) )); CHK(current_media_type_->SetUINT32(MF_MT_AUDIO_NUM_CHANNELS, MFGetAttributeUINT32(native_media_type_.Get(), MF_MT_AUDIO_NUM_CHANNELS, channel_count) )); //DWORD blockAlign; //CHK(native_media_type_->GetUINT32(MF_MT_AUDIO_BLOCK_ALIGNMENT, &blockAlign)); //CHK(current_media_type_->SetUINT32(MF_MT_AUDIO_BLOCK_ALIGNMENT,blockAlign )); CHK(reader_->SetCurrentMediaType(0, nullptr, current_media_type_.Get())); CHK(reader_->GetCurrentMediaType(0, current_media_type_.ReleaseAndGetAddressOf())); UINT32 blockAlign; CHK(current_media_type_->GetUINT32(MF_MT_AUDIO_BLOCK_ALIGNMENT, &blockAlign)); DOUT(boost::wformat(L"Block Align: %10d %10x") % blockAlign % blockAlign); }
IMFMediaType* MFDecoderSourceReader::setSource(IMFMediaSource *source, const QAudioFormat &audioFormat) { IMFMediaType *mediaType = NULL; if (m_source == source) return mediaType; if (m_source) { m_source->Release(); m_source = NULL; } if (m_sourceReader) { m_sourceReader->Release(); m_sourceReader = NULL; } if (!source) return mediaType; IMFAttributes *attr = NULL; MFCreateAttributes(&attr, 1); if (SUCCEEDED(attr->SetUnknown(MF_SOURCE_READER_ASYNC_CALLBACK, this))) { if (SUCCEEDED(MFCreateSourceReaderFromMediaSource(source, attr, &m_sourceReader))) { m_source = source; m_source->AddRef(); m_sourceReader->SetStreamSelection(DWORD(MF_SOURCE_READER_ALL_STREAMS), FALSE); m_sourceReader->SetStreamSelection(DWORD(MF_SOURCE_READER_FIRST_AUDIO_STREAM), TRUE); IMFMediaType *pPartialType = NULL; MFCreateMediaType(&pPartialType); pPartialType->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio); if (audioFormat.sampleType() == QAudioFormat::Float) { pPartialType->SetGUID(MF_MT_SUBTYPE, MFAudioFormat_Float); } else { pPartialType->SetGUID(MF_MT_SUBTYPE, MFAudioFormat_PCM); } m_sourceReader->SetCurrentMediaType(DWORD(MF_SOURCE_READER_FIRST_AUDIO_STREAM), NULL, pPartialType); pPartialType->Release(); m_sourceReader->GetCurrentMediaType(DWORD(MF_SOURCE_READER_FIRST_AUDIO_STREAM), &mediaType); // Ensure the stream is selected. m_sourceReader->SetStreamSelection(DWORD(MF_SOURCE_READER_FIRST_AUDIO_STREAM), TRUE); } attr->Release(); } return mediaType; }
HRESULT CTedPlayer::InitClear() { HRESULT hr; if(m_spSession) { if(m_bIsPlaying) { m_bIsPlaying = false; m_spSession->Stop(); } m_spSession.Release(); } if(m_fPendingClearCustomTopoloader && m_spClearSession.p) { m_spClearSession->Shutdown(); m_spClearSession.Release(); } if(m_spClearSession.p == NULL) { CComPtr<IMFAttributes> spConfiguration = NULL; if(m_fPendingClearCustomTopoloader && GUID_NULL != m_gidCustomTopoloader) { IFC( MFCreateAttributes(&spConfiguration, 1) ); IFC( spConfiguration->SetGUID(MF_SESSION_TOPOLOADER, m_gidCustomTopoloader) ); } IFC( MFCreateMediaSession(spConfiguration, &m_spClearSession) ); IFC( m_spClearSession->BeginGetEvent(&m_xOnClearSessionEvent, NULL) ); m_fPendingClearCustomTopoloader = false; } m_spSession = m_spClearSession; IFC( InitFromSession() ); Cleanup: return hr; }
HRESULT CTranscoder::ConfigureContainer() { assert (m_pProfile); HRESULT hr = S_OK; IMFAttributes* pContainerAttrs = NULL; //Set container attributes hr = MFCreateAttributes( &pContainerAttrs, 2 ); //Set the output container to be ASF type if (SUCCEEDED(hr)) { hr = pContainerAttrs->SetGUID( MF_TRANSCODE_CONTAINERTYPE, MFTranscodeContainerType_ASF ); } // Use the default setting. Media Foundation will use the stream // settings set in ConfigureAudioOutput and ConfigureVideoOutput. if (SUCCEEDED(hr)) { hr = pContainerAttrs->SetUINT32( MF_TRANSCODE_ADJUST_PROFILE, MF_TRANSCODE_ADJUST_PROFILE_DEFAULT ); } //Set the attribute store on the transcode profile. if (SUCCEEDED(hr)) { hr = m_pProfile->SetContainerAttributes(pContainerAttrs); } SafeRelease(&pContainerAttrs); return hr; }
static void test_MFCreateAttributes(void) { IMFAttributes *attributes; HRESULT hr; UINT32 count; hr = MFCreateAttributes( &attributes, 3 ); ok(hr == S_OK, "got 0x%08x\n", hr); count = 88; hr = IMFAttributes_GetCount(attributes, &count); todo_wine ok(hr == S_OK, "got 0x%08x\n", hr); ok(count == 0, "got %d\n", count); hr = IMFAttributes_SetUINT32(attributes, &MF_READWRITE_ENABLE_HARDWARE_TRANSFORMS, 0); todo_wine ok(hr == S_OK, "got 0x%08x\n", hr); hr = IMFAttributes_GetCount(attributes, &count); todo_wine ok(hr == S_OK, "got 0x%08x\n", hr); todo_wine ok(count == 1, "got %d\n", count); IMFAttributes_Release(attributes); }
void GetCameraDevices(IMFActivate*** pppDevices, UINT32* pnCount) { HRESULT hr = S_OK; IMFAttributes* pAttributes = NULL; WCHAR* pszFriendlyName = NULL; UINT32 cchName = 0; hr = MFCreateAttributes(&pAttributes, 1); if (FAILED(hr)) goto END; hr = pAttributes->SetGUID(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE, MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID); if (FAILED(hr)) goto END; hr = MFEnumDeviceSources(pAttributes, pppDevices, pnCount); if (FAILED(hr)) goto END; END: SafeRelease(&pAttributes); return; }
//---------------------------------------------------------------------------- long MediaFoundationVideoDevice::InitDevice() { HRESULT hr = S_OK; IMFAttributes *pAttributes = NULL; IMFActivate * vd_pActivate = NULL; CoInitialize(NULL); if (SUCCEEDED(hr)) { hr = MFCreateAttributes(&pAttributes, 1); } if (SUCCEEDED(hr)) { hr = pAttributes->SetGUID(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE,MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID); if (!SUCCEEDED(hr)) { LOG_ERROR("MediaFoundationVideoDevice::InitDevice failed: device " << this->DeviceIndex << ": The attribute of the capture device cannot be retrieved"); } } if (SUCCEEDED(hr)) { hr = CheckDevice(pAttributes, &vd_pActivate); if (SUCCEEDED(hr) && vd_pActivate) { SafeRelease(&this->Source); hr = vd_pActivate->ActivateObject(__uuidof(IMFMediaSource), (void**)&this->Source); SafeRelease(&vd_pActivate); } else { LOG_ERROR("MediaFoundationVideoDevice::InitDevice failed: device " << this->DeviceIndex << ": Cannot activate device"); } } SafeRelease(&pAttributes); return hr; }
HRESULT CaptureManager::InitializeCaptureManager(HWND hwndPreview, IUnknown* pUnk) { HRESULT hr = S_OK; IMFAttributes* pAttributes = NULL; IMFCaptureEngineClassFactory* pFactory = NULL; DestroyCaptureEngine(); m_hEvent = CreateEvent(NULL, FALSE, FALSE, NULL); if (NULL == m_hEvent) { hr = HRESULT_FROM_WIN32(GetLastError()); goto Exit; } m_pCallback = new (std::nothrow) CaptureEngineCB(m_hwndEvent); if (m_pCallback == NULL) { hr = E_OUTOFMEMORY; goto Exit; } m_pCallback->m_pManager = this; m_hwndPreview = hwndPreview; //Create a D3D Manager hr = CreateD3DManager(); if (FAILED(hr)) { goto Exit; } hr = MFCreateAttributes(&pAttributes, 1); if (FAILED(hr)) { goto Exit; } hr = pAttributes->SetUnknown(MF_CAPTURE_ENGINE_D3D_MANAGER, g_pDXGIMan); if (FAILED(hr)) { goto Exit; } // Create the factory object for the capture engine. hr = CoCreateInstance(CLSID_MFCaptureEngineClassFactory, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&pFactory)); if (FAILED(hr)) { goto Exit; } // Create and initialize the capture engine. hr = pFactory->CreateInstance(CLSID_MFCaptureEngine, IID_PPV_ARGS(&m_pEngine)); if (FAILED(hr)) { goto Exit; } hr = m_pEngine->Initialize(m_pCallback, pAttributes, NULL, pUnk); if (FAILED(hr)) { goto Exit; } Exit: if (NULL != pAttributes) { pAttributes->Release(); pAttributes = NULL; } if (NULL != pFactory) { pFactory->Release(); pFactory = NULL; } return hr; }
HRESULT InitMFStreamer() { printf("InitMFStreamer.\n"); CoInitializeEx(NULL, COINIT_APARTMENTTHREADED | COINIT_DISABLE_OLE1DDE); CHECK_HR(InitVPXEncoder(&_vpxConfig, &_vpxCodec, WIDTH, HEIGHT), L"Failed to intialise the VPX encoder.\n"); // Create an attribute store to hold the search criteria. CHECK_HR(MFCreateAttributes(&videoConfig, 1), L"Error creating video configuation."); //CHECK_HR(MFCreateAttributes(&audioConfig, 1), L"Error creating audio configuation.");; // Request video capture devices. CHECK_HR(videoConfig->SetGUID( MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE, MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID), L"Error initialising video configuration object."); // Request audio capture devices. /*CHECK_HR(audioConfig->SetGUID( MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE, MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_AUDCAP_GUID), L"Error initialising audio configuration object.");*/ // Enumerate the devices, CHECK_HR(MFEnumDeviceSources(videoConfig, &videoDevices, &videoDeviceCount), L"Error enumerating video devices."); //CHECK_HR(MFEnumDeviceSources(audioConfig, &audioDevices, &audioDeviceCount), L"Error enumerating audio devices."); //printf("Video device Count: %i, Audio device count: %i.\n", videoDeviceCount, audioDeviceCount); printf("Video device Count: %i.\n", videoDeviceCount); CHECK_HR(videoDevices[0]->ActivateObject(IID_PPV_ARGS(&videoSource)), L"Error activating video device."); //CHECK_HR(audioDevices[0]->ActivateObject(IID_PPV_ARGS(&audioSource)), L"Error activating audio device."); // Initialize the Media Foundation platform. CHECK_HR(MFStartup(MF_VERSION), L"Error on Media Foundation startup."); /*WCHAR *pwszFileName = L"sample.mp4"; IMFSinkWriter *pWriter;*/ /*CHECK_HR(MFCreateSinkWriterFromURL( pwszFileName, NULL, NULL, &pWriter), L"Error creating mp4 sink writer.");*/ // Create the source readers. CHECK_HR(MFCreateSourceReaderFromMediaSource( videoSource, videoConfig, &videoReader), L"Error creating video source reader."); //ListModes(videoReader); /*CHECK_HR(MFCreateSourceReaderFromMediaSource( audioSource, audioConfig, &audioReader), L"Error creating audio source reader.");*/ FindVideoMode(videoReader, MF_INPUT_FORMAT, WIDTH, HEIGHT, desiredInputVideoType); if (desiredInputVideoType == NULL) { printf("The specified media type could not be found for the MF video reader.\n"); } else { CHECK_HR(videoReader->SetCurrentMediaType((DWORD)MF_SOURCE_READER_FIRST_VIDEO_STREAM, NULL, desiredInputVideoType), L"Error setting video reader media type.\n"); CHECK_HR(videoReader->GetCurrentMediaType( (DWORD)MF_SOURCE_READER_FIRST_VIDEO_STREAM, &videoType), L"Error retrieving current media type from first video stream."); CMediaTypeTrace *videoTypeMediaTrace = new CMediaTypeTrace(videoType); printf("Video input media type: %s.\n", videoTypeMediaTrace->GetString()); LONG pStride = 0; GetDefaultStride(videoType, &pStride); printf("Stride %i.\n", pStride); /*printf("Press any key to continue..."); getchar();*/ /*audioReader->GetCurrentMediaType( (DWORD)MF_SOURCE_READER_FIRST_AUDIO_STREAM, &audioType);*/ //CMediaTypeTrace *audioTypeMediaTrace = new CMediaTypeTrace(audioType); //printf("Audio input media type: %s.\n", audioTypeMediaTrace->GetString()); //printf("Configuring H.264 sink.\n"); // Set up the H.264 sink. /*CHECK_HR(ConfigureEncoder(videoType, &videoStreamIndex, &audioStreamIndex, pWriter), L"Error configuring encoder."); printf("Video stream index %i, audio stream index %i.\n", videoStreamIndex, audioStreamIndex);*/ // Register the color converter DSP for this process, in the video // processor category. This will enable the sink writer to enumerate // the color converter when the sink writer attempts to match the // media types. CHECK_HR(MFTRegisterLocalByCLSID( __uuidof(CColorConvertDMO), MFT_CATEGORY_VIDEO_PROCESSOR, L"", MFT_ENUM_FLAG_SYNCMFT, 0, NULL, 0, NULL ), L"Error registering colour converter DSP."); // Add the input types to the H.264 sink writer. /*CHECK_HR(pWriter->SetInputMediaType(videoStreamIndex, videoType, NULL), L"Error setting the sink writer video input type."); videoType->Release(); CHECK_HR(pWriter->SetInputMediaType(audioStreamIndex, audioType, NULL), L"Error setting the sink writer audio input type."); audioType->Release();*/ //CHECK_HR(pWriter->BeginWriting(), L"Failed to begin writing on the H.264 sink."); //InitializeCriticalSection(&critsec); } }
unsigned char *BBWin8Game::LoadAudioData( String path,int *length,int *channels,int *format,int *hertz ){ String url=PathToFilePath( path ); DXASS( MFStartup( MF_VERSION ) ); IMFAttributes *attrs; DXASS( MFCreateAttributes( &attrs,1 ) ); DXASS( attrs->SetUINT32( MF_LOW_LATENCY,TRUE ) ); IMFSourceReader *reader; DXASS( MFCreateSourceReaderFromURL( url.ToCString<wchar_t>(),attrs,&reader ) ); attrs->Release(); IMFMediaType *mediaType; DXASS( MFCreateMediaType( &mediaType ) ); DXASS( mediaType->SetGUID( MF_MT_MAJOR_TYPE,MFMediaType_Audio ) ); DXASS( mediaType->SetGUID( MF_MT_SUBTYPE,MFAudioFormat_PCM ) ); DXASS( reader->SetCurrentMediaType( MF_SOURCE_READER_FIRST_AUDIO_STREAM,0,mediaType ) ); mediaType->Release(); IMFMediaType *outputMediaType; DXASS( reader->GetCurrentMediaType( MF_SOURCE_READER_FIRST_AUDIO_STREAM,&outputMediaType ) ); WAVEFORMATEX *wformat; uint32 formatByteCount=0; DXASS( MFCreateWaveFormatExFromMFMediaType( outputMediaType,&wformat,&formatByteCount ) ); *channels=wformat->nChannels; *format=wformat->wBitsPerSample/8; *hertz=wformat->nSamplesPerSec; CoTaskMemFree( wformat ); outputMediaType->Release(); /* PROPVARIANT var; DXASS( reader->GetPresentationAttribute( MF_SOURCE_READER_MEDIASOURCE,MF_PD_DURATION,&var ) ); LONGLONG duration=var.uhVal.QuadPart; float64 durationInSeconds=(duration / (float64)(10000 * 1000)); m_maxStreamLengthInBytes=(uint32)( durationInSeconds * m_waveFormat.nAvgBytesPerSec ); */ std::vector<unsigned char*> bufs; std::vector<uint32> lens; uint32 len=0; for( ;; ){ uint32 flags=0; IMFSample *sample; DXASS( reader->ReadSample( MF_SOURCE_READER_FIRST_AUDIO_STREAM,0,0,reinterpret_cast<DWORD*>(&flags),0,&sample ) ); if( flags & MF_SOURCE_READERF_ENDOFSTREAM ){ break; } if( sample==0 ){ abort(); } IMFMediaBuffer *mediaBuffer; DXASS( sample->ConvertToContiguousBuffer( &mediaBuffer ) ); uint8 *audioData=0; uint32 sampleBufferLength=0; DXASS( mediaBuffer->Lock( &audioData,0,reinterpret_cast<DWORD*>( &sampleBufferLength ) ) ); unsigned char *buf=(unsigned char*)malloc( sampleBufferLength ); memcpy( buf,audioData,sampleBufferLength ); bufs.push_back( buf ); lens.push_back( sampleBufferLength ); len+=sampleBufferLength; DXASS( mediaBuffer->Unlock() ); mediaBuffer->Release(); sample->Release(); } reader->Release(); *length=len/(*channels * *format); unsigned char *data=(unsigned char*)malloc( len ); unsigned char *p=data; for( int i=0;i<bufs.size();++i ){ memcpy( p,bufs[i],lens[i] ); free( bufs[i] ); p+=lens[i]; } gc_force_sweep=true; return data; }
HRESULT CaptureClass::initCapture(int aDevice) { mWhoAmI = aDevice; HRESULT hr = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED | COINIT_DISABLE_OLE1DDE); DO_OR_DIE; hr = MFStartup(MF_VERSION); DO_OR_DIE; // choose device IMFAttributes *attributes = NULL; hr = MFCreateAttributes(&attributes, 1); ScopedRelease<IMFAttributes> attributes_s(attributes); DO_OR_DIE; hr = attributes->SetGUID( MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE, MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID ); DO_OR_DIE; ChooseDeviceParam param = { 0 }; hr = MFEnumDeviceSources(attributes, ¶m.mDevices, ¶m.mCount); DO_OR_DIE; if ((signed)param.mCount > aDevice) { // use param.ppDevices[0] IMFAttributes *attributes = NULL; IMFMediaType *type = NULL; EnterCriticalSection(&mCritsec); hr = param.mDevices[aDevice]->ActivateObject( __uuidof(IMFMediaSource), (void**)&mSource ); DO_OR_DIE_CRITSECTION; hr = MFCreateAttributes(&attributes, 3); ScopedRelease<IMFAttributes> attributes_s(attributes); DO_OR_DIE_CRITSECTION; hr = attributes->SetUINT32(MF_READWRITE_DISABLE_CONVERTERS, TRUE); DO_OR_DIE_CRITSECTION; hr = attributes->SetUnknown( MF_SOURCE_READER_ASYNC_CALLBACK, this ); DO_OR_DIE_CRITSECTION; hr = MFCreateSourceReaderFromMediaSource( mSource, attributes, &mReader ); DO_OR_DIE_CRITSECTION; int preferredmode = scanMediaTypes(gParams[mWhoAmI].mWidth, gParams[mWhoAmI].mHeight); mUsedIndex = preferredmode; hr = mReader->GetNativeMediaType( (DWORD)MF_SOURCE_READER_FIRST_VIDEO_STREAM, preferredmode, &type ); ScopedRelease<IMFMediaType> type_s(type); DO_OR_DIE_CRITSECTION; hr = setVideoType(type); DO_OR_DIE_CRITSECTION; hr = mReader->SetCurrentMediaType( (DWORD)MF_SOURCE_READER_FIRST_VIDEO_STREAM, NULL, type ); DO_OR_DIE_CRITSECTION; hr = mReader->ReadSample( (DWORD)MF_SOURCE_READER_FIRST_VIDEO_STREAM, 0, NULL, NULL, NULL, NULL ); DO_OR_DIE_CRITSECTION; LeaveCriticalSection(&mCritsec); } else { return MF_E_INVALIDINDEX; } /* for (i = 0; i < 16; i++) { char temp[128]; float v; int f; int r = GetProperty(i, v, f); sprintf(temp, "%d: %3.3f %d (%d)\n", i, v, f, r); OutputDebugStringA(temp); } */ return 0; }
camera_t * camera_open(const char *portname, int highres) { camera_internal_t *camera = (camera_internal_t*)malloc(sizeof(camera_internal_t)); camera->reader = NULL; if (highres) { console_printf("camera: highres is not supported on windows (yet).\n"); highres = 0; } HRESULT hr = S_OK; // Initialize Media Foundation if (SUCCEEDED(hr)) { hr = MFStartup(MF_VERSION); } /////////////////////////////////////////// IMFAttributes *pAttributes = NULL; UINT32 m_cDevices = 0; IMFActivate **m_ppDevices = NULL; // Initialize an attribute store. We will use this to // specify the enumeration parameters. hr = MFCreateAttributes(&pAttributes, 1); // Ask for source type = video capture devices if (SUCCEEDED(hr)) { hr = pAttributes->SetGUID( MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE, MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID ); } // Enumerate devices. if (SUCCEEDED(hr)) { hr = MFEnumDeviceSources(pAttributes, &m_ppDevices, &m_cDevices); } SafeRelease(&pAttributes); ///////////////////////////////////////////////// IMFActivate *pActivate = NULL; if (m_cDevices) { console_printf("camera: there are %d camera devices connected (0..%d).\n", m_cDevices, m_cDevices > 0 ? m_cDevices - 1 : 0); int device = strtol(portname, 0, 10); if (device < 0 || device >= m_cDevices) console_printf("camera: device %d does not exist.\n", device); else pActivate = m_ppDevices[device]; } else { console_printf("camera: could not find a device\n"); } ///////////////////////////////////////////////// IMFMediaSource *pSource = NULL; //EnterCriticalSection(&m_critsec); // Create the media source for the device. hr = pActivate->ActivateObject( __uuidof(IMFMediaSource), (void**)&pSource ); /////////////////////////////////////////// //IMFAttributes *pAttributes = NULL; /*hr = MFCreateAttributes(&pAttributes, 2); if (SUCCEEDED(hr)) { hr = pAttributes->SetUnknown(MF_SOURCE_READER_ASYNC_CALLBACK, this); }*/ if (SUCCEEDED(hr)) { hr = MFCreateSourceReaderFromMediaSource( pSource, NULL,//pAttributes, &camera->reader ); } //SafeRelease(&pAttributes); //////////////////////////////////////////////////// // The list of acceptable types. GUID subtypes[] = { MFVideoFormat_NV12, MFVideoFormat_YUY2, MFVideoFormat_UYVY, MFVideoFormat_RGB32, MFVideoFormat_RGB24, MFVideoFormat_IYUV }; //HRESULT hr = S_OK; BOOL bUseNativeType = FALSE; GUID subtype = { 0 }; IMFMediaType *pType = NULL; UINT32 width = 0, height = 0; int selectedSubtype = -1; // If the source's native format matches any of the formats in // the list, prefer the native format. // Note: The camera might support multiple output formats, // including a range of frame dimensions. The application could // provide a list to the user and have the user select the // camera's output format. That is outside the scope of this // sample, however. DWORD selectedStreamIndex = MF_SOURCE_READER_FIRST_VIDEO_STREAM; //while (true) //{ hr = camera->reader->GetNativeMediaType( selectedStreamIndex, 0, // Type index &pType ); if (FAILED(hr)) { console_printf("camera: could not get media type\n"); goto done; } hr = ::MFGetAttributeSize(pType, MF_MT_FRAME_SIZE, &width, &height); if (FAILED(hr)) { console_printf("camera: could not get resolution\n"); goto done; } //if (width != 1280 || height != 960) //{ console_printf("camera: found resolution %dx%d\n", width, height); //selectedStreamIndex++; //continue; //} camera->size.width = width; camera->size.height = height; //break; //} /*UINT32 num = 0, denom = 0; hr = ::MFGetAttributeRatio(pType, MF_MT_FRAME_RATE_RANGE_MAX, &num, &denom); if (FAILED(hr)) { goto done; }*/ //hr = ::MFSetAttributeSize(pType, MF_MT_FRAME_SIZE, 1280, 960); //if (FAILED(hr)) { goto done; } /*hr = ::MFSetAttributeRatio(pType, MF_MT_FRAME_RATE, num, denom); if (FAILED(hr)) { goto done; }*/ hr = pType->GetGUID(MF_MT_SUBTYPE, &subtype); if (FAILED(hr)) { console_printf("camera: could not get stream type(1)\n"); goto done; } for (UINT32 i = 0; i < ARRAYSIZE(subtypes); i++) { if (subtype == subtypes[i]) { hr = camera->reader->SetCurrentMediaType( (DWORD)MF_SOURCE_READER_FIRST_VIDEO_STREAM, NULL, pType ); bUseNativeType = TRUE; selectedSubtype = i; break; } } if (!bUseNativeType) { // None of the native types worked. The camera might offer // output a compressed type such as MJPEG or DV. // Try adding a decoder. for (UINT32 i = 0; i < ARRAYSIZE(subtypes); i++) { hr = pType->SetGUID(MF_MT_SUBTYPE, subtypes[i]); if (FAILED(hr)) { console_printf("camera: could not get stream type(2)\n"); goto done; } hr = camera->reader->SetCurrentMediaType( (DWORD)MF_SOURCE_READER_FIRST_VIDEO_STREAM, NULL, pType ); if (SUCCEEDED(hr)) { selectedSubtype = i; break; } } } /* hr = ::MFGetAttributeSize(pType, MF_MT_FRAME_SIZE, &width, &height); WIDTH = width; HEIGHT = height;*/ if (FAILED(hr)) { console_printf("camera: could not find stream type\n"); goto done; } done: SafeRelease(&pType); console_printf("camera: selected type: %d, native: %s, resolution: %dx%d\n", selectedSubtype, bUseNativeType ? "yes" : "no", camera->size.width, camera->size.height); /////////////////////////////////////// /*if (SUCCEEDED(hr)) { hr = camera->reader->GetCurrentMediaType( (DWORD)MF_SOURCE_READER_FIRST_VIDEO_STREAM, &pType ); } if (SUCCEEDED(hr)) { // Register the color converter DSP for this process, in the video // processor category. This will enable the sink writer to enumerate // the color converter when the sink writer attempts to match the // media types. hr = MFTRegisterLocalByCLSID( __uuidof(CColorConvertDMO), MFT_CATEGORY_VIDEO_PROCESSOR, L"", MFT_ENUM_FLAG_SYNCMFT, 0, NULL, 0, NULL ); }*/ ///////////////////////////////////////////////// /* IMFSample *pSample = NULL; DWORD streamIndex = 0, flags = 0; LONGLONG llTimeStamp = 0; hr = camera->reader->ReadSample( (DWORD)MF_SOURCE_READER_ANY_STREAM, // Stream index. 0, // Flags. &streamIndex, // Receives the actual stream index. &flags, // Receives status flags. &llTimeStamp, // Receives the time stamp. &pSample // Receives the sample or NULL. );*/ if (selectedSubtype != 4) { console_printf("camera: unexpected stream type.\n"); SafeRelease(&camera->reader); free(camera); return 0; } return (camera_t*)camera; }