fix up of media source

1 files changed, 302 insertions, 284 deletions

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<SimpleMediaStream>(&_stream, this);
-    }
-
-    if (SUCCEEDED(hr))
+    RETURN_IF_FAILED (MFCreateAttributes(&_spAttributes, 10));
+    RETURN_IF_FAILED (MFCreateEventQueue(&_spEventQueue));
+    RETURN_IF_FAILED (MakeAndInitialize<SimpleMediaStream>(&_stream, this));
     {
         ComPtr<IMFStreamDescriptor> 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<IMFStreamDescriptor> 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;
+    RETURN_IF_FAILED (_CheckShutdownRequiresLock());
 
-        // 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));
+    if (_sourceState != SourceState::Stopped)
+    {
+        return MF_E_INVALID_STATE_TRANSITION;
+    }
 
-        // Send event that the source started. Include error code in case it failed.
-        BREAK_ON_FAIL(hr = _spEventQueue->QueueEventParamVar(MESourceStarted, GUID_NULL, hr, &startTime));
+    _sourceState = SourceState::Started;
 
-        // Open and un-pause the selected stream(s)
-        BOOL selected = false;
-        ComPtr<IMFStreamDescriptor> spStreamDescriptor;
-        BREAK_ON_FAIL(hr = pPresentationDescriptor->GetStreamDescriptorByIndex(0, &selected, &spStreamDescriptor));
+    // 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));
 
-        DWORD streamIndex = 0;
-        BREAK_ON_FAIL(hr = spStreamDescriptor->GetStreamIdentifier(&streamIndex));
+    // Send event that the source started. Include error code in case it failed.
+    RETURN_IF_FAILED (_spEventQueue->QueueEventParamVar(MESourceStarted,
+                                                        GUID_NULL,
+                                                        hr,
+                                                        &startTime));
 
-        if (streamIndex >= NUM_STREAMS)
-        {
-            hr = MF_E_INVALIDSTREAMNUMBER;
-            break;
-        }
+    // 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;
+    }
 
-        if (selected)
-        {
-            // Update our internal PresentationDescriptor
-            BREAK_ON_FAIL(hr = _spPresentationDescriptor->SelectStream(streamIndex));
-            BREAK_ON_FAIL(hr = _stream.Get()->SetStreamState(MF_STREAM_STATE_RUNNING));
+    if (selected)
+    {
+        ComPtr<IUnknown> spunkStream;
+        MediaEventType met = (_wasStreamPreviouslySelected ? MEUpdatedStream : MENewStream);
 
-            ComPtr<IUnknown> spunkStream;
-            BREAK_ON_FAIL(hr = _stream.As(&spunkStream));
+        // 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));
 
-            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;
+        // Send the MEUpdatedStream/MENewStream to our source event
+        // queue.
+        RETURN_IF_FAILED (_spEventQueue->QueueEventParamUnk(met,
+                                                            GUID_NULL,
+                                                            S_OK,
+                                                            spunkStream.Get()));
 
-    } while (false);
+        // 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<IMFSensorProfileCollection>  profileCollection;
+        ComPtr<IMFSensorProfile> 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<IMFStreamDescriptor> 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
+}
+