From 58a4f43a0c75285c30ce4806d011553ebc3f563d Mon Sep 17 00:00:00 2001 From: Peihsun Yeh Date: Wed, 1 Aug 2018 17:14:16 -0700 Subject: fix up of media source --- .../MediaSource/SimpleMediaSource.cpp | 598 +++++++++++---------- 1 file changed, 308 insertions(+), 290 deletions(-) (limited to 'general/SimpleMediaSource/MediaSource/SimpleMediaSource.cpp') diff --git a/general/SimpleMediaSource/MediaSource/SimpleMediaSource.cpp b/general/SimpleMediaSource/MediaSource/SimpleMediaSource.cpp index 34b6f2e2..1729fbcf 100644 --- a/general/SimpleMediaSource/MediaSource/SimpleMediaSource.cpp +++ b/general/SimpleMediaSource/MediaSource/SimpleMediaSource.cpp @@ -1,72 +1,62 @@ -#include "SimpleMediaSource.h" -#include "SimpleMediaStream.h" +#include "stdafx.h" /////////////////////////////////////////////////////////////////////////////// -HRESULT SimpleMediaSource::RuntimeClassInitialize() +HRESULT +SimpleMediaSource::RuntimeClassInitialize( + ) { HRESULT hr = S_OK; - if (SUCCEEDED(hr)) - { - hr = MFCreateAttributes(&_spAttributes, 10); - } - - if (SUCCEEDED(hr)) - { - hr = MFCreateEventQueue(&_spEventQueue); - } - - if (SUCCEEDED(hr)) - { - hr = MakeAndInitialize(&_stream, this); - } - - if (SUCCEEDED(hr)) + RETURN_IF_FAILED (MFCreateAttributes(&_spAttributes, 10)); + RETURN_IF_FAILED (MFCreateEventQueue(&_spEventQueue)); + RETURN_IF_FAILED (MakeAndInitialize(&_stream, this)); { ComPtr streamDescriptor(_stream.Get()->_spStreamDesc.Get()); - hr = MFCreatePresentationDescriptor(NUM_STREAMS, streamDescriptor.GetAddressOf(), &_spPresentationDescriptor); + RETURN_IF_FAILED (MFCreatePresentationDescriptor(NUM_STREAMS, streamDescriptor.GetAddressOf(), &_spPresentationDescriptor)); } - if (SUCCEEDED(hr)) - { - _wasStreamPreviouslySelected = false; - _sourceState = SourceState::Stopped; - } + _wasStreamPreviouslySelected = false; + _sourceState = SourceState::Stopped; return hr; } // IMFMediaEventGenerator methods. -/////////////////////////////////////////////////////////////////////////////// -IFACEMETHODIMP SimpleMediaSource::BeginGetEvent(IMFAsyncCallback *pCallback, IUnknown *punkState) +IFACEMETHODIMP +SimpleMediaSource::BeginGetEvent( + _In_ IMFAsyncCallback *pCallback, + _In_ IUnknown *punkState + ) { + HRESULT hr = S_OK; auto lock = _critSec.Lock(); - HRESULT hr = _CheckShutdownRequiresLock(); - if (SUCCEEDED(hr)) - { - hr = _spEventQueue->BeginGetEvent(pCallback, punkState); - } + RETURN_IF_FAILED (_CheckShutdownRequiresLock()); + RETURN_IF_FAILED (_spEventQueue->BeginGetEvent(pCallback, punkState)); return hr; } -/////////////////////////////////////////////////////////////////////////////// -IFACEMETHODIMP SimpleMediaSource::EndGetEvent(IMFAsyncResult *pResult, IMFMediaEvent **ppEvent) +IFACEMETHODIMP +SimpleMediaSource::EndGetEvent( + _In_ IMFAsyncResult *pResult, + _COM_Outptr_ IMFMediaEvent **ppEvent + ) { + HRESULT hr = S_OK; auto lock = _critSec.Lock(); - HRESULT hr = _CheckShutdownRequiresLock(); - if (SUCCEEDED(hr)) - { - hr = _spEventQueue->EndGetEvent(pResult, ppEvent); - } + RETURN_IF_FAILED (_CheckShutdownRequiresLock()); + RETURN_IF_FAILED (_spEventQueue->EndGetEvent(pResult, ppEvent)); return hr; } -/////////////////////////////////////////////////////////////////////////////// -IFACEMETHODIMP SimpleMediaSource::GetEvent(DWORD dwFlags, IMFMediaEvent **ppEvent) +IFACEMETHODIMP +SimpleMediaSource::GetEvent( + DWORD dwFlags, + _COM_Outptr_ IMFMediaEvent **ppEvent + ) { // NOTE: // GetEvent can block indefinitely, so we don't hold the lock. @@ -79,369 +69,398 @@ IFACEMETHODIMP SimpleMediaSource::GetEvent(DWORD dwFlags, IMFMediaEvent **ppEven { auto lock = _critSec.Lock(); - hr = _CheckShutdownRequiresLock(); - if (SUCCEEDED(hr)) - { - spQueue = _spEventQueue; - } + RETURN_IF_FAILED (_CheckShutdownRequiresLock()); + spQueue = _spEventQueue; } // Now get the event. - if (SUCCEEDED(hr)) - { - hr = spQueue->GetEvent(dwFlags, ppEvent); - } + RETURN_IF_FAILED (_spEventQueue->GetEvent(dwFlags, ppEvent)); return hr; } -/////////////////////////////////////////////////////////////////////////////// -IFACEMETHODIMP SimpleMediaSource::QueueEvent( +IFACEMETHODIMP +SimpleMediaSource::QueueEvent( MediaEventType eventType, REFGUID guidExtendedType, HRESULT hrStatus, - _In_opt_ PROPVARIANT const *pvValue) + _In_opt_ PROPVARIANT const *pvValue + ) { + HRESULT hr = S_OK; auto lock = _critSec.Lock(); - HRESULT hr = _CheckShutdownRequiresLock(); - if (SUCCEEDED(hr)) - { - hr = _spEventQueue->QueueEventParamVar(eventType, guidExtendedType, hrStatus, pvValue); - } + RETURN_IF_FAILED (_CheckShutdownRequiresLock()); + RETURN_IF_FAILED (_spEventQueue->QueueEventParamVar(eventType, guidExtendedType, hrStatus, pvValue)); return hr; } // IMFMediaSource methods -/////////////////////////////////////////////////////////////////////////////// -IFACEMETHODIMP SimpleMediaSource::CreatePresentationDescriptor( - IMFPresentationDescriptor **ppPresentationDescriptor) +IFACEMETHODIMP +SimpleMediaSource::CreatePresentationDescriptor( + _COM_Outptr_ IMFPresentationDescriptor **ppPresentationDescriptor + ) { + HRESULT hr = S_OK; + auto lock = _critSec.Lock(); + if (ppPresentationDescriptor == nullptr) { return E_POINTER; } - *ppPresentationDescriptor = nullptr; - auto lock = _critSec.Lock(); - - HRESULT hr = _CheckShutdownRequiresLock(); - if (SUCCEEDED(hr)) - { - hr = _spPresentationDescriptor->Clone(ppPresentationDescriptor); - } + RETURN_IF_FAILED (_CheckShutdownRequiresLock()); + RETURN_IF_FAILED (_spPresentationDescriptor->Clone(ppPresentationDescriptor)); return hr; } -/////////////////////////////////////////////////////////////////////////////// -IFACEMETHODIMP SimpleMediaSource::GetCharacteristics(DWORD *pdwCharacteristics) +IFACEMETHODIMP +SimpleMediaSource::GetCharacteristics( + _Out_ DWORD *pdwCharacteristics + ) { - *pdwCharacteristics = 0; - + HRESULT hr = S_OK; auto lock = _critSec.Lock(); - HRESULT hr = _CheckShutdownRequiresLock(); - if (SUCCEEDED(hr)) + if (nullptr == pdwCharacteristics) { - *pdwCharacteristics = MFMEDIASOURCE_IS_LIVE; + return E_POINTER; } + *pdwCharacteristics = 0; + + RETURN_IF_FAILED (_CheckShutdownRequiresLock()); + *pdwCharacteristics = MFMEDIASOURCE_IS_LIVE; return hr; } -/////////////////////////////////////////////////////////////////////////////// -IFACEMETHODIMP SimpleMediaSource::Pause() +IFACEMETHODIMP +SimpleMediaSource::Pause( + ) { - // Pause() not required/needed for live sources - HRESULT hr = MF_E_INVALID_STATE_TRANSITION; - - return hr; + // Pause() not required/needed + return MF_E_INVALID_STATE_TRANSITION; } -/////////////////////////////////////////////////////////////////////////////// -IFACEMETHODIMP SimpleMediaSource::Shutdown() + +IFACEMETHODIMP +SimpleMediaSource::Shutdown( + ) { HRESULT hr = S_OK; - { - auto lock = _critSec.Lock(); + auto lock = _critSec.Lock(); - _sourceState = SourceState::Shutdown; + _sourceState = SourceState::Shutdown; - _spAttributes.Reset(); - _spPresentationDescriptor.Reset(); + _spAttributes.Reset(); + _spPresentationDescriptor.Reset(); - if (_spEventQueue != nullptr) - { - _spEventQueue->Shutdown(); - _spEventQueue.Reset(); - } + if (_spEventQueue != nullptr) + { + _spEventQueue->Shutdown(); + _spEventQueue.Reset(); + } - if (_stream != nullptr) - { - _stream.Get()->Shutdown(); - _stream.Reset(); - } + if (_stream != nullptr) + { + _stream.Get()->Shutdown(); + _stream.Reset(); } + return hr; } -/////////////////////////////////////////////////////////////////////////////// -IFACEMETHODIMP SimpleMediaSource::Start( +IFACEMETHODIMP +SimpleMediaSource::Start( _In_ IMFPresentationDescriptor *pPresentationDescriptor, _In_opt_ const GUID *pguidTimeFormat, - _In_ const PROPVARIANT *pvarStartPos) + _In_ const PROPVARIANT *pvarStartPos + ) { HRESULT hr = S_OK; + auto lock = _critSec.Lock(); + DWORD count = 0; + PROPVARIANT startTime; + BOOL selected = false; + ComPtr streamDesc; + DWORD streamIndex = 0; if (pPresentationDescriptor == nullptr || pvarStartPos == nullptr) { - hr = E_INVALIDARG; + return E_INVALIDARG; } else if (pguidTimeFormat != nullptr && *pguidTimeFormat != GUID_NULL) { - hr = MF_E_UNSUPPORTED_TIME_FORMAT; + return MF_E_UNSUPPORTED_TIME_FORMAT; } - do - { - BREAK_ON_FAIL(hr); - - auto lock = _critSec.Lock(); - BREAK_ON_FAIL(hr = _CheckShutdownRequiresLock()); - - if (_sourceState != SourceState::Stopped) - { - hr = MF_E_INVALID_STATE_TRANSITION; - break; - } - - _sourceState = SourceState::Started; - - // This checks the passed in PresentationDescriptor matches the member of streams we - // have defined internally and that at least one stream is selected - BREAK_ON_FAIL(hr = _ValidatePresentationDescriptor(pPresentationDescriptor)); - - DWORD count = 0; - BREAK_ON_FAIL(hr = pPresentationDescriptor->GetStreamDescriptorCount(&count)); - - PROPVARIANT startTime; - BREAK_ON_FAIL(hr = InitPropVariantFromInt64(MFGetSystemTime(), &startTime)); - - // Send event that the source started. Include error code in case it failed. - BREAK_ON_FAIL(hr = _spEventQueue->QueueEventParamVar(MESourceStarted, GUID_NULL, hr, &startTime)); - - // Open and un-pause the selected stream(s) - BOOL selected = false; - ComPtr spStreamDescriptor; - BREAK_ON_FAIL(hr = pPresentationDescriptor->GetStreamDescriptorByIndex(0, &selected, &spStreamDescriptor)); - - DWORD streamIndex = 0; - BREAK_ON_FAIL(hr = spStreamDescriptor->GetStreamIdentifier(&streamIndex)); - - if (streamIndex >= NUM_STREAMS) - { - hr = MF_E_INVALIDSTREAMNUMBER; - break; - } - - if (selected) - { - // Update our internal PresentationDescriptor - BREAK_ON_FAIL(hr = _spPresentationDescriptor->SelectStream(streamIndex)); - BREAK_ON_FAIL(hr = _stream.Get()->SetStreamState(MF_STREAM_STATE_RUNNING)); + RETURN_IF_FAILED (_CheckShutdownRequiresLock()); - ComPtr spunkStream; - BREAK_ON_FAIL(hr = _stream.As(&spunkStream)); + if (_sourceState != SourceState::Stopped) + { + return MF_E_INVALID_STATE_TRANSITION; + } - BREAK_ON_FAIL(hr = _spEventQueue->QueueEventParamUnk(_wasStreamPreviouslySelected ? MEUpdatedStream : MENewStream, - GUID_NULL, S_OK, spunkStream.Get())); - BREAK_ON_FAIL(hr = _stream.Get()->QueueEvent(MEStreamStarted, GUID_NULL, S_OK, &startTime)); - } - _wasStreamPreviouslySelected = selected; + _sourceState = SourceState::Started; + + // This checks the passed in PresentationDescriptor matches the member of streams we + // have defined internally and that at least one stream is selected + RETURN_IF_FAILED (_ValidatePresentationDescriptor(pPresentationDescriptor)); + RETURN_IF_FAILED (pPresentationDescriptor->GetStreamDescriptorCount(&count)); + RETURN_IF_FAILED (InitPropVariantFromInt64(MFGetSystemTime(), &startTime)); + + // Send event that the source started. Include error code in case it failed. + RETURN_IF_FAILED (_spEventQueue->QueueEventParamVar(MESourceStarted, + GUID_NULL, + hr, + &startTime)); + + // We're hardcoding this to the first descriptor + // since this sample is a single stream sample. For + // multiple streams, we need to walk the list of streams + // and for each selected stream, send the MEUpdatedStream + // or MENewStream event along with the MEStreamStarted + // event. + RETURN_IF_FAILED (pPresentationDescriptor->GetStreamDescriptorByIndex(0, + &selected, + &streamDesc)); + RETURN_IF_FAILED (streamDesc->GetStreamIdentifier(&streamIndex)); + if (streamIndex >= NUM_STREAMS) + { + return MF_E_INVALIDSTREAMNUMBER; + } - } while (false); + if (selected) + { + ComPtr spunkStream; + MediaEventType met = (_wasStreamPreviouslySelected ? MEUpdatedStream : MENewStream); + + // Update our internal PresentationDescriptor + RETURN_IF_FAILED (_spPresentationDescriptor->SelectStream(streamIndex)); + RETURN_IF_FAILED (_stream.Get()->SetStreamState(MF_STREAM_STATE_RUNNING)); + RETURN_IF_FAILED (_stream.As(&spunkStream)); + + // Send the MEUpdatedStream/MENewStream to our source event + // queue. + RETURN_IF_FAILED (_spEventQueue->QueueEventParamUnk(met, + GUID_NULL, + S_OK, + spunkStream.Get())); + + // But for our stream started (MEStreamStarted), we post to our + // stream event queue. + RETURN_IF_FAILED (_stream.Get()->QueueEvent(MEStreamStarted, + GUID_NULL, + S_OK, + &startTime)); + } + _wasStreamPreviouslySelected = selected; return hr; } -/////////////////////////////////////////////////////////////////////////////// -IFACEMETHODIMP SimpleMediaSource::Stop() +IFACEMETHODIMP +SimpleMediaSource::Stop( + ) { HRESULT hr = S_OK; + auto lock = _critSec.Lock(); + PROPVARIANT stopTime; + DWORD count = 0; + MF_STREAM_STATE state; - do + if (_sourceState != SourceState::Started) { - auto lock = _critSec.Lock(); - - if (_sourceState != SourceState::Started) - { - BREAK_ON_FAIL(hr = MF_E_INVALID_STATE_TRANSITION); - } - - BREAK_ON_FAIL(hr = _CheckShutdownRequiresLock()); - - PROPVARIANT stopTime; - BREAK_ON_FAIL(hr = InitPropVariantFromInt64(MFGetSystemTime(), &stopTime)); - - DWORD count = 0; - BREAK_ON_FAIL(hr = _spPresentationDescriptor->GetStreamDescriptorCount(&count)); - // Deselect the streams and send the stream stopped events. - MF_STREAM_STATE state; - hr = _stream.Get()->GetStreamState(&state); - if (FAILED(hr)) - { - continue; - } - _wasStreamPreviouslySelected = (state == MF_STREAM_STATE_RUNNING); - hr = _stream.Get()->SetStreamState(MF_STREAM_STATE_STOPPED); - if (FAILED(hr)) - { - continue; - } - _spPresentationDescriptor->DeselectStream(0); - hr = _stream.Get()->QueueEvent(MEStreamStopped, GUID_NULL, hr, &stopTime); - if (FAILED(hr)) - { - continue; - } + return MF_E_INVALID_STATE_TRANSITION; + } - BREAK_ON_FAIL(hr = _spEventQueue->QueueEventParamVar(MESourceStopped, GUID_NULL, hr, &stopTime)); + RETURN_IF_FAILED (_CheckShutdownRequiresLock()); + RETURN_IF_FAILED (InitPropVariantFromInt64(MFGetSystemTime(), &stopTime)); + RETURN_IF_FAILED (_spPresentationDescriptor->GetStreamDescriptorCount(&count)); - } while (false); + // Deselect the streams and send the stream stopped events. + RETURN_IF_FAILED (_stream.Get()->GetStreamState(&state)); + _wasStreamPreviouslySelected = (state == MF_STREAM_STATE_RUNNING); + RETURN_IF_FAILED (_stream.Get()->SetStreamState(MF_STREAM_STATE_STOPPED)); + _spPresentationDescriptor->DeselectStream(0); + RETURN_IF_FAILED (_stream.Get()->QueueEvent(MEStreamStopped, GUID_NULL, hr, &stopTime)); + RETURN_IF_FAILED (_spEventQueue->QueueEventParamVar(MESourceStopped, GUID_NULL, hr, &stopTime)); return hr; } // IMFMediaSourceEx -/////////////////////////////////////////////////////////////////////////////// -IFACEMETHODIMP SimpleMediaSource::GetSourceAttributes(_Outptr_ IMFAttributes **ppAttributes) +IFACEMETHODIMP +SimpleMediaSource::GetSourceAttributes( + _COM_Outptr_ IMFAttributes** sourceAttributes + ) { - if (ppAttributes == nullptr) + HRESULT hr = S_OK; + auto lock = _critSec.Lock(); + + if (nullptr == sourceAttributes) { return E_POINTER; } - auto lock = _critSec.Lock(); + RETURN_IF_FAILED (_CheckShutdownRequiresLock()); - HRESULT hr = _CheckShutdownRequiresLock(); - if (SUCCEEDED(hr)) + *sourceAttributes = nullptr; + if (_spAttributes.Get() == nullptr) { - *ppAttributes = _spAttributes.Get(); - (*ppAttributes)->AddRef(); - } - else - { - hr = E_UNEXPECTED; + ComPtr profileCollection; + ComPtr profile; + + // Create our source attribute store. + RETURN_IF_FAILED (MFCreateAttributes(_spAttributes.GetAddressOf(), 1)); + + // Create an empty profile collection... + RETURN_IF_FAILED (MFCreateSensorProfileCollection(&profileCollection)); + + // In this example since we have just one stream, we only have one + // pin to add: Pin0. + + // Legacy profile is mandatory. This is to ensure non-profile + // aware applications can still function, but with degraded + // feature sets. + RETURN_IF_FAILED (MFCreateSensorProfile(KSCAMERAPROFILE_Legacy, 0, nullptr, + profile.ReleaseAndGetAddressOf())); + RETURN_IF_FAILED (profile->AddProfileFilter(0, L"((RES==;FRT<=30,1;SUT==))")); + RETURN_IF_FAILED (profileCollection->AddProfile(profile.Get())); + + // High Frame Rate profile will only allow >=60fps. + RETURN_IF_FAILED (MFCreateSensorProfile(KSCAMERAPROFILE_HighFrameRate, 0, nullptr, + profile.ReleaseAndGetAddressOf())); + RETURN_IF_FAILED (profile->AddProfileFilter(0, L"((RES==;FRT>=60,1;SUT==))")); + RETURN_IF_FAILED (profileCollection->AddProfile(profile.Get())); + + + // Se the profile collection to the attribute store of the IMFTransform. + RETURN_IF_FAILED (_spAttributes->SetUnknown(MF_DEVICEMFT_SENSORPROFILE_COLLECTION, + profileCollection.Get())); } - return hr; + return _spAttributes.CopyTo(sourceAttributes); } -/////////////////////////////////////////////////////////////////////////////// -IFACEMETHODIMP SimpleMediaSource::GetStreamAttributes(DWORD dwStreamIdentifier, _Outptr_ IMFAttributes **ppAttributes) + +IFACEMETHODIMP +SimpleMediaSource::GetStreamAttributes( + DWORD dwStreamIdentifier, + _COM_Outptr_ IMFAttributes **ppAttributes + ) { + HRESULT hr = S_OK; + auto lock = _critSec.Lock(); + if (ppAttributes == nullptr) { return E_POINTER; } - - auto lock = _critSec.Lock(); - *ppAttributes = nullptr; - HRESULT hr = _CheckShutdownRequiresLock(); - if (SUCCEEDED(hr)) + RETURN_IF_FAILED (_CheckShutdownRequiresLock()); + if (dwStreamIdentifier >= NUM_STREAMS) { - if (dwStreamIdentifier >= NUM_STREAMS) - { - hr = MF_E_INVALIDSTREAMNUMBER; - } - else - { - *ppAttributes = _stream.Get()->_spAttributes.Get(); - (*ppAttributes)->AddRef(); - } + return MF_E_INVALIDSTREAMNUMBER; } else { - hr = E_UNEXPECTED; + *ppAttributes = _stream.Get()->_spAttributes.Get(); + (*ppAttributes)->AddRef(); } return hr; } -/////////////////////////////////////////////////////////////////////////////// -IFACEMETHODIMP SimpleMediaSource::SetD3DManager(_In_opt_ IUnknown* /*pManager*/) +IFACEMETHODIMP +SimpleMediaSource::SetD3DManager( + _In_opt_ IUnknown* /*pManager*/ + ) { - // No need to implement this method in our case. - HRESULT hr = E_NOTIMPL; - return hr; + // Return code is ignored by the frame work, this is a + // best effort attempt to inform the media source of the + // DXGI manager to use if DX surface support is available. + + return E_NOTIMPL; } // IMFGetService methods -/////////////////////////////////////////////////////////////////////////////// _Use_decl_annotations_ -IFACEMETHODIMP SimpleMediaSource::GetService(REFGUID guidService, REFIID riid, LPVOID * ppvObject) +IFACEMETHODIMP +SimpleMediaSource::GetService( + _In_ REFGUID guidService, + _In_ REFIID riid, + _Out_ LPVOID * ppvObject + ) { - HRESULT hr = _CheckShutdownRequiresLock(); - if (SUCCEEDED(hr)) - { - if (!ppvObject) - { - hr = E_INVALIDARG; - } - else - { - *ppvObject = NULL; - } + HRESULT hr = S_OK; + auto lock = _critSec.Lock(); + + RETURN_IF_FAILED (_CheckShutdownRequiresLock()); - hr = MF_E_UNSUPPORTED_SERVICE; + if (!ppvObject) + { + return E_POINTER; } + *ppvObject = NULL; - return hr; + // We have no supported service, just return + // MF_E_UNSUPPORTED_SERVICE for all calls. + + return MF_E_UNSUPPORTED_SERVICE; } // IKsControl methods _Use_decl_annotations_ -IFACEMETHODIMP SimpleMediaSource::KsProperty( - PKSPROPERTY pProperty, - ULONG ulPropertyLength, - LPVOID pPropertyData, - ULONG ulDataLength, - ULONG* pBytesReturned) +IFACEMETHODIMP +SimpleMediaSource::KsProperty( + _In_reads_bytes_(ulPropertyLength) PKSPROPERTY pProperty, + _In_ ULONG ulPropertyLength, + _Inout_updates_to_(ulDataLength, *pBytesReturned) LPVOID pPropertyData, + _In_ ULONG ulDataLength, + _Out_ ULONG* pBytesReturned + ) { - return E_NOTIMPL; + // ERROR_SET_NOT_FOUND is the standard error code returned + // by the AV Stream driver framework when a miniport + // driver does not register a handler for a KS operation. + // We want to mimic the driver behavior here if we don't + // support controls. + return HRESULT_FROM_WIN32(ERROR_SET_NOT_FOUND); } -/////////////////////////////////////////////////////////////////////////////// _Use_decl_annotations_ IFACEMETHODIMP SimpleMediaSource::KsMethod( - PKSMETHOD pMethod, - ULONG ulMethodLength, - LPVOID pMethodData, - ULONG ulDataLength, - ULONG* pBytesReturned) + _In_reads_bytes_(ulMethodLength) PKSMETHOD pMethod, + _In_ ULONG ulMethodLength, + _Inout_updates_to_(ulDataLength, *pBytesReturned) LPVOID pMethodData, + _In_ ULONG ulDataLength, + _Out_ ULONG* pBytesReturned + ) { - return E_NOTIMPL; + return HRESULT_FROM_WIN32(ERROR_SET_NOT_FOUND); } -/////////////////////////////////////////////////////////////////////////////// _Use_decl_annotations_ IFACEMETHODIMP SimpleMediaSource::KsEvent( - _In_opt_ PKSEVENT pEvent, + _In_reads_bytes_opt_(ulEventLength) PKSEVENT pEvent, _In_ ULONG ulEventLength, - _Inout_opt_ LPVOID pEventData, + _Inout_updates_to_(ulDataLength, *pBytesReturned) LPVOID pEventData, _In_ ULONG ulDataLength, - _Out_opt_ ULONG* pBytesReturned) + _Out_opt_ ULONG* pBytesReturned + ) { - return E_NOTIMPL; + return HRESULT_FROM_WIN32(ERROR_SET_NOT_FOUND); } -/////////////////////////////////////////////////////////////////////////////// -HRESULT SimpleMediaSource::_CheckShutdownRequiresLock() +/// Internal methods. +HRESULT +SimpleMediaSource::_CheckShutdownRequiresLock( + ) { if (_sourceState == SourceState::Shutdown) { @@ -456,51 +475,50 @@ HRESULT SimpleMediaSource::_CheckShutdownRequiresLock() return S_OK; } -/////////////////////////////////////////////////////////////////////////////// -HRESULT SimpleMediaSource::_ValidatePresentationDescriptor(IMFPresentationDescriptor *pPD) +HRESULT +SimpleMediaSource::_ValidatePresentationDescriptor( + _In_ IMFPresentationDescriptor *pPD + ) { + HRESULT hr = S_OK; + DWORD cStreams = 0; + bool anySelected = false; + if (pPD == nullptr) { return E_INVALIDARG; } - HRESULT hr = S_OK; - DWORD cStreams = 0; - bool anySelected = false; - // The caller's PD must have the same number of streams as ours. - hr = pPD->GetStreamDescriptorCount(&cStreams); - + RETURN_IF_FAILED (pPD->GetStreamDescriptorCount(&cStreams)); if (SUCCEEDED(hr) && (cStreams != NUM_STREAMS)) { - hr = E_INVALIDARG; + return E_INVALIDARG; } // The caller must select at least one stream. - for (UINT32 i = 0; SUCCEEDED(hr) && i < cStreams; ++i) + for (UINT32 i = 0; i < cStreams; ++i) { ComPtr spSD; BOOL fSelected = FALSE; - hr = pPD->GetStreamDescriptorByIndex(i, &fSelected, &spSD); + DWORD dwId = 0; - if (SUCCEEDED(hr)) - { - anySelected |= !!fSelected; + RETURN_IF_FAILED (pPD->GetStreamDescriptorByIndex(i, &fSelected, &spSD)); - DWORD dwId = 0; - hr = spSD->GetStreamIdentifier(&dwId); + anySelected |= !!fSelected; - if (SUCCEEDED(hr) && dwId >= NUM_STREAMS) - { - hr = E_INVALIDARG; - } + RETURN_IF_FAILED (spSD->GetStreamIdentifier(&dwId)); + if (dwId >= NUM_STREAMS) + { + return E_INVALIDARG; } } if (!anySelected) { - hr = E_INVALIDARG; + return E_INVALIDARG; } return hr; -} \ No newline at end of file +} + -- cgit v1.3.1