Webcam.cpp

Go to the documentation of this file.

#include "Webcam.h"

#include <Shlwapi.h>

namespace Devices
{
        Webcam::Webcam()
        {
                initialized = false;

                videoDevices = nullptr;
                audioDevices = nullptr;

                pVideoActivate = nullptr;
                pAudioActivate = nullptr;

                pVideoSource = nullptr;
                pAudioSource = nullptr;
                pSource = nullptr;

                m_pReader = nullptr;
                m_pWriter = nullptr;

                InitializeCriticalSection(&m_critsec);
        }

        Webcam::~Webcam()
        {
                DeleteCriticalSection(&m_critsec);
        }

        ULONG Webcam::AddRef()
        {
                return InterlockedIncrement(&m_nRefCount);
        }

        ULONG Webcam::Release()
        {
                ULONG uCount = InterlockedDecrement(&m_nRefCount);
                if (uCount == 0)
                {
                        //delete this;
                }
                return uCount;
        }

        HRESULT Webcam::QueryInterface(REFIID riid, void** ppv)
        {
                static const QITAB qit[] = {QITABENT(Webcam, IMFSourceReaderCallback),{nullptr},};
                return QISearch(this, qit, riid, ppv);
        }

        HRESULT Webcam::OnReadSample(HRESULT hrStatus, DWORD dwStreamIndex, DWORD dwStreamFlags, LONGLONG llTimeStamp, IMFSample* pSample)
        {
                EnterCriticalSection(&m_critsec);

                if (!IsCapturing())
                {
                        LeaveCriticalSection(&m_critsec);
                        return S_OK;
                }

                HRESULT hr = S_OK;

                if (FAILED(hrStatus))
                {
                        hr = hrStatus;
                        goto done;
                }

                if (dwStreamIndex == 0)
                {
                        if (pSample)
                        {
                                if (m_bVideoFirstSample)
                                {
                                        m_llVideoBaseTime = llTimeStamp;
                                        m_bVideoFirstSample = FALSE;
                                }

                                // rebase the time stamp
                                llTimeStamp -= m_llVideoBaseTime;

                                hr = pSample->SetSampleTime(llTimeStamp);

                                if (FAILED(hr))
                                {
                                        goto done;
                                }

                                hr = m_pWriter->WriteSample(sink_video_stream, pSample);

                                if (FAILED(hr))
                                {
                                        goto done;
                                }
                        }

                        // Read another sample.
                        hr = m_pReader->ReadSample(static_cast<DWORD>(MF_SOURCE_READER_ANY_STREAM), 0, nullptr, nullptr, nullptr, nullptr);
                }
                else
                {
                        if (pSample)
                        {
                                if (m_bAudioFirstSample)
                                {
                                        m_llAudioBaseTime = llTimeStamp;
                                        m_bAudioFirstSample = FALSE;
                                }

                                // rebase the time stamp
                                llTimeStamp -= m_llAudioBaseTime;

                                hr = pSample->SetSampleTime(llTimeStamp);

                                if (FAILED(hr))
                                {
                                        goto done;
                                }

                                hr = m_pWriter->WriteSample(sink_audio_stream, pSample);

                                if (FAILED(hr))
                                {
                                        goto done;
                                }
                        }

                        // Read another sample.
                        hr = m_pReader->ReadSample(static_cast<DWORD>(MF_SOURCE_READER_ANY_STREAM), 0, nullptr, nullptr, nullptr, nullptr);
                }

        done:
                LeaveCriticalSection(&m_critsec);
                return hr;
        }


        HRESULT Webcam::CreateAggregatedSource(IMFMediaSource* pSource1, IMFMediaSource* pSource2, IMFMediaSource** ppAggSource) const
        {
                *ppAggSource = nullptr;

                IMFCollection* pCollection = nullptr;
                HRESULT hr;

                if (FAILED(hr = MFCreateCollection(&pCollection)))
                {
                        logger->Log("Webcam::CreateAggregatedSource MFCreateCollection failed!", Logger::Error, hr);
                        return hr;
                }

                if (FAILED(hr = pCollection->AddElement(pSource1)))
                {
                        logger->Log("Webcam::CreateAggregatedSource AddElement video failed!", Logger::Error, hr);
                        return hr;
                }

                if (FAILED(hr = pCollection->AddElement(pSource2)))
                {
                        logger->Log("Webcam::CreateAggregatedSource AddElement audio failed!", Logger::Error, hr);
                        return hr;
                }

                if (FAILED(hr = MFCreateAggregateSource(pCollection, ppAggSource)))
                {
                        logger->Log("Webcam::CreateAggregatedSource MFCreateAggregateSource failed!", Logger::Error, hr);
                        return hr;
                }

                SAFE_RELEASE(pCollection);
                return hr;
        }

        HRESULT Webcam::OpenMediaSource(IMFMediaSource* pSource)
        {
                IMFAttributes* pAttributes = nullptr;
                HRESULT hr;

                if (FAILED(hr = MFCreateAttributes(&pAttributes, 2)))
                {
                        logger->Log("Webcam::OpenMediaSource MFCreateAttributes failed!", Logger::Error, hr);
                        return hr;
                }

                if (FAILED(hr = pAttributes->SetUnknown(MF_SOURCE_READER_ASYNC_CALLBACK, this)))
                {
                        logger->Log("Webcam::OpenMediaSource SetUnknown failed!", Logger::Error, hr);
                        SAFE_RELEASE(pAttributes);
                        return hr;
                }

                if (FAILED(hr = MFCreateSourceReaderFromMediaSource(pSource, pAttributes, &m_pReader)))
                {
                        logger->Log("Webcam::OpenMediaSource MFCreateSourceReaderFromMediaSource failed!", Logger::Error, hr);
                }

                SAFE_RELEASE(pAttributes);
                return hr;
        }

        HRESULT Webcam::ConfigureCapture()
        {
                HRESULT hr;

                IMFMediaType* pVideoNativeMediaType = nullptr;
                IMFMediaType* pVideoTargetMediaType = nullptr;
                IMFMediaType* pAudioNativeMediaType = nullptr;
                IMFMediaType* pAudioTargetMediaType = nullptr;

#pragma region Configure Video

                // Get Native Media Type for Video
                if (FAILED(hr = m_pReader->GetNativeMediaType(static_cast<DWORD>(MF_SOURCE_READER_FIRST_VIDEO_STREAM), 0, &pVideoNativeMediaType)))
                {
                        logger->Log("Webcam::ConfigureCapture GetNativeMediaType video failed!", Logger::Error, hr);
                        return hr;
                }

                // Create Video Target Media Type
                if (FAILED(hr = CreateTargetVideoMediaType(pVideoNativeMediaType, &pVideoTargetMediaType)))
                {
                        logger->Log("Webcam::ConfigureCapture CreateTargetVideoMediaType failed!", Logger::Error, hr);
                        return hr;
                }

                // Add Video stream to output file
                if (FAILED(hr = m_pWriter->AddStream(pVideoTargetMediaType, &sink_video_stream)))
                {
                        logger->Log("Webcam::ConfigureCapture AddStream video failed!", Logger::Error, hr);
                        return hr;
                }

                // Negotiate
                if (FAILED(hr = NegotiateVideoStreamFormat(sink_video_stream)))
                {
                        logger->Log("Webcam::ConfigureCapture NegotiateVideoStreamFormat failed!", Logger::Error, hr);
                        return hr;
                }

#pragma endregion

#pragma region Configure Audio

                // Get Natvie Media Type for Audio
                if (FAILED(hr = m_pReader->GetNativeMediaType(static_cast<DWORD>(MF_SOURCE_READER_FIRST_AUDIO_STREAM), 0, &pAudioNativeMediaType)))
                {
                        logger->Log("Webcam::ConfigureCapture GetNativeMediaType audio failed!", Logger::Error, hr);
                        return hr;
                }

                // Create Audio Media Type Target
                if (FAILED(hr = CreateTargetAudioMediaType(pAudioNativeMediaType, &pAudioTargetMediaType)))
                {
                        logger->Log("Webcam::ConfigureCapture CreateTargetAudioMediaType failed!", Logger::Error, hr);
                        return hr;
                }

                // Add audio stream to output file
                if (FAILED(hr = m_pWriter->AddStream(pAudioTargetMediaType, &sink_audio_stream)))
                {
                        logger->Log("Webcam::ConfigureCapture AddStream audio failed!", Logger::Error, hr);
                        return hr;
                }

                // Negotiate Audio
                if (FAILED(hr = NegotiateAudioStreamFormat(sink_audio_stream)))
                {
                        logger->Log("Webcam::ConfigureCapture NegotiateAudioStreamFormat failed!", Logger::Error, hr);
                        return hr;
                }

#pragma endregion

                // Begin writing ------------------------------------------
                if (FAILED(hr = m_pWriter->BeginWriting()))
                {
                        logger->Log("Webcam::ConfigureCapture BeginWriting failed!", Logger::Error, hr);
                        return hr;
                }

                SAFE_RELEASE(pVideoTargetMediaType);
                SAFE_RELEASE(pVideoNativeMediaType);
                SAFE_RELEASE(pAudioTargetMediaType);
                SAFE_RELEASE(pAudioNativeMediaType);

                return hr;
        }

        HRESULT Webcam::CreateTargetVideoMediaType(__in IMFMediaType* pNativeMediaType, __out IMFMediaType** ppTargetMediaType) const
        {
                IMFMediaType* pTargetMediaType = nullptr;

                UINT32 unWidth = 0;
                UINT32 unHeight = 0;
                UINT32 unNumerator;
                UINT32 unDenominator;
                UINT32 unAspectX;
                UINT32 unAspectY;
                UINT32 unInterlaceMode;
                UINT32 unBitrate;

                *ppTargetMediaType = nullptr;

                HRESULT hr = MFCreateMediaType(&pTargetMediaType);
                if (SUCCEEDED(hr))
                {
                        hr = pTargetMediaType->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Video);
                }

                if (SUCCEEDED(hr))
                {
                        hr = pTargetMediaType->SetGUID(MF_MT_SUBTYPE, MFVideoFormat_H264);
                }

                if (SUCCEEDED(hr))
                {
                        hr = MFGetAttributeSize(pNativeMediaType, MF_MT_FRAME_SIZE, &unWidth, &unHeight);
                }

                if (SUCCEEDED(hr))
                {
                        char msg[99];
                        sprintf_s(msg, 99, "Webcam::CreateTargetVideoMediaType Native unWidth: %i unHeight: %i", unWidth, unHeight);
                        logger->Log(msg);

                        unWidth = config->width;
                        unHeight = config->height;
                        //      hr = MFSetAttributeSize(pNativeMediaType, MF_MT_FRAME_SIZE, unWidth, unHeight);
                }

                if (SUCCEEDED(hr))
                {
                        hr = MFGetAttributeRatio(pNativeMediaType, MF_MT_FRAME_RATE, &unNumerator, &unDenominator);
                }

                if (SUCCEEDED(hr))
                {
                        char msg[99];
                        sprintf_s(msg, 99, "Webcam::CreateTargetVideoMediaType Native unNumerator: %i  unDenominator: %i", unNumerator, unDenominator);
                        logger->Log(msg);

                        unNumerator = config->numerator;
                        unDenominator = config->denominator;
                        hr = MFSetAttributeRatio(pNativeMediaType, MF_MT_FRAME_RATE, unNumerator, unDenominator);
                }

                if (SUCCEEDED(hr))
                {
                        hr = MFGetAttributeRatio(pNativeMediaType, MF_MT_PIXEL_ASPECT_RATIO, &unAspectX, &unAspectY);
                }

                if (SUCCEEDED(hr))
                {
                        hr = pNativeMediaType->GetUINT32(MF_MT_INTERLACE_MODE, &unInterlaceMode);
                        char msg[99];
                        sprintf_s(msg, 99, "Webcam::CreateTargetVideoMediaType Native GetUINT32 MF_MT_INTERLACE_MODE: %i", unInterlaceMode);
                        logger->Log(msg);
                }

                if (SUCCEEDED(hr))
                {
                        //      unInterlaceMode = MFVideoInterlace_Progressive;
                        //      hr = pNativeMediaType->SetUINT32(MF_MT_INTERLACE_MODE, unInterlaceMode);
                }

                if (SUCCEEDED(hr))
                {
                        hr = pNativeMediaType->GetUINT32(MF_MT_AVG_BITRATE, &unBitrate);
                        char msg[99];
                        sprintf_s(msg, 99, "Webcam::CreateTargetVideoMediaType Native unBitrate: %i", unBitrate);
                        logger->Log(msg);
                }

                if (SUCCEEDED(hr))
                {
                        //unBitrate = 5000000; // based on 720p
                        //hr = pNativeMediaType->SetUINT32(MF_MT_AVG_BITRATE, unBitrate);
                }


                //Videotypes

                if (SUCCEEDED(hr))
                {
                        hr = MFSetAttributeSize(pTargetMediaType, MF_MT_FRAME_SIZE, unWidth, unHeight);
                }

                if (SUCCEEDED(hr))
                {
                        hr = MFSetAttributeRatio(pTargetMediaType, MF_MT_FRAME_RATE, unNumerator, unDenominator);
                }
                if (SUCCEEDED(hr))
                {
                        hr = MFSetAttributeRatio(pTargetMediaType, MF_MT_PIXEL_ASPECT_RATIO, unAspectX, unAspectY);
                }

                if (SUCCEEDED(hr))
                {
                        hr = pTargetMediaType->SetUINT32(MF_MT_INTERLACE_MODE, unInterlaceMode);
                }

                if (SUCCEEDED(hr))
                {
                        hr = pTargetMediaType->SetUINT32(MF_MT_AVG_BITRATE, unBitrate);
                }
                *ppTargetMediaType = pTargetMediaType;
                pTargetMediaType = nullptr;

                SAFE_RELEASE(pTargetMediaType);

                return hr;
        }

        HRESULT Webcam::CreateTargetAudioMediaType(__in IMFMediaType* pNativeMediaType, __out IMFMediaType** ppTargetMediaType) const
        {
                HRESULT hr;

                IMFMediaType* pTargetMediaType = nullptr;
                IMFCollection* pAvailableTypes = nullptr;
                IUnknown* punkObject = nullptr;
                IMFMediaType* pMediaType = nullptr;

                DWORD dwAvailableTypes = 0;

                UINT32 unNumChannels;
                UINT32 unSampleRate;

                BOOL fFoundMediaType = FALSE;

                *ppTargetMediaType = nullptr;

                // get a list of available media types by subtype
                // tried hardware encoding filter, no dice... tried transcode_only and it didn't remove any results (32 total)
                if (FAILED(hr = MFTranscodeGetAudioOutputAvailableTypes(MFAudioFormat_AAC, MFT_ENUM_FLAG_ALL, nullptr, &pAvailableTypes)))
                {
                        logger->Log("Webcam::CreateTargetAudioMediaType MFTranscodeGetAudioOutputAvailableTypes failed!", Logger::Error, hr);
                        return hr;
                }

                if (FAILED(hr = pAvailableTypes->GetElementCount(&dwAvailableTypes)))
                {
                        logger->Log("Webcam::CreateTargetAudioMediaType GetElementCount failed!", Logger::Error, hr);
                        return hr;
                }

                //
                // loop through the available media types looking for one that
                // matches the desired number of channels and sampling rate
                //
                for (DWORD ii = 0; ii < dwAvailableTypes; ii++)
                {
                        SAFE_RELEASE(punkObject);
                        SAFE_RELEASE(pMediaType);

                        if (FAILED(hr = pAvailableTypes->GetElement(ii, &punkObject)))
                        {
                                logger->Log("Webcam::CreateTargetAudioMediaType GetElement failed!", Logger::Error, hr);
                                return hr;
                        }

                        if (FAILED(hr = punkObject->QueryInterface(IID_PPV_ARGS(&pMediaType))))
                        {
                                logger->Log("Webcam::CreateTargetAudioMediaType QueryInterface failed!", Logger::Error, hr);
                                return hr;
                        }

                        if (FAILED(hr = pMediaType->GetUINT32(MF_MT_AUDIO_NUM_CHANNELS, &unNumChannels)))
                        {
                                logger->Log("Webcam::CreateTargetAudioMediaType MF_MT_AUDIO_NUM_CHANNELS failed!", Logger::Error, hr);
                                return hr;
                        }

                        if (FAILED(hr = pMediaType->GetUINT32(MF_MT_AUDIO_SAMPLES_PER_SECOND, &unSampleRate)))
                        {
                                logger->Log("Webcam::CreateTargetAudioMediaType MF_MT_AUDIO_SAMPLES_PER_SECOND failed!", Logger::Error, hr);
                                return hr;
                        }

                        if (unNumChannels == config->channels && unSampleRate == config->frequency)
                        {
                                fFoundMediaType = TRUE;
                                break;
                        }
                }

                if (!fFoundMediaType)
                {
                        logger->Log("Webcam::CreateTargetAudioMediaType Did not find media type!", Logger::Error, hr);
                        return E_FAIL;
                }

                if (FAILED(hr = MFCreateMediaType(&pTargetMediaType)))
                {
                        logger->Log("Webcam::CreateTargetAudioMediaType MFCreateMediaType failed!", Logger::Error, hr);
                        return hr;
                }

                if (FAILED(hr = pMediaType->CopyAllItems(pTargetMediaType)))
                {
                        logger->Log("Webcam::CreateTargetAudioMediaType CopyAllItems failed!", Logger::Error, hr);
                        return hr;
                }

                *ppTargetMediaType = pTargetMediaType;

                pTargetMediaType = nullptr;

                SAFE_RELEASE(pTargetMediaType);
                SAFE_RELEASE(pAvailableTypes);
                SAFE_RELEASE(punkObject);
                SAFE_RELEASE(pMediaType);

                return (hr);
        }

        HRESULT Webcam::NegotiateStreamFormat(__in DWORD dwStreamIndex, __in REFGUID guidMajorType, __in DWORD cFormats, __in_ecount(cFormats) const GUID** paFormats) const
        {
                HRESULT hr;

                IMFMediaType* pPartialMediaType = nullptr;
                IMFMediaType* pFullMediaType = nullptr;

                BOOL fConfigured = FALSE;

                if (FAILED(hr = MFCreateMediaType(&pPartialMediaType)))
                {
                        logger->Log("Webcam::NegotiateStreamFormat MFCreateMediaType failed!", Logger::Error, hr);
                        return hr;
                }

                if (FAILED(hr = pPartialMediaType->SetGUID(MF_MT_MAJOR_TYPE, guidMajorType)))
                {
                        logger->Log("Webcam::NegotiateStreamFormat MF_MT_MAJOR_TYPE failed!", Logger::Error, hr);
                        return hr;
                }

                if (dwStreamIndex == sink_video_stream)
                {
                        char msg[99];
                        sprintf_s(msg, 99, "Webcam::NegotiateStreamFormat sink_video_stream cFormats count: %i", cFormats);
                        logger->Log(msg);
                }

                for (DWORD ii = 0; ii < cFormats; ii++)
                {
                        SAFE_RELEASE(pFullMediaType);

                        if (FAILED(hr = pPartialMediaType->SetGUID(MF_MT_SUBTYPE, *paFormats[ii])))
                        {
                                logger->Log("Webcam::NegotiateStreamFormat MF_MT_SUBTYPE failed!", Logger::Error, hr);
                                return hr;
                        }


                        // ***
                        if (dwStreamIndex == sink_video_stream)
                        {
                                if (FAILED(hr = MFSetAttributeSize(pPartialMediaType, MF_MT_FRAME_SIZE, config->width, config->height)))
                                {
                                        logger->Log("Webcam::NegotiateStreamFormat MF_MT_FRAME_SIZE failed!", Logger::Error, hr);
                                        return hr;
                                }
                        }


                        // try to set the partial media type on the source reader
                        if (dwStreamIndex == sink_video_stream)
                        {
                                hr = m_pReader->SetCurrentMediaType(static_cast<DWORD>(MF_SOURCE_READER_FIRST_VIDEO_STREAM), nullptr, pPartialMediaType);
                        }
                        else
                        {
                                hr = m_pReader->SetCurrentMediaType(static_cast<DWORD>(MF_SOURCE_READER_FIRST_AUDIO_STREAM), nullptr, pPartialMediaType);
                        }

                        if (S_OK != hr)
                        {
                                // format is not supported by the source reader, try the next on the list
                                hr = S_OK;
                                continue;
                        }

                        // get the full media type from the source reader
                        if (dwStreamIndex == sink_video_stream)
                        {
                                hr = m_pReader->GetCurrentMediaType(static_cast<DWORD>(MF_SOURCE_READER_FIRST_VIDEO_STREAM), &pFullMediaType);
                        }
                        else
                        {
                                hr = m_pReader->GetCurrentMediaType(static_cast<DWORD>(MF_SOURCE_READER_FIRST_AUDIO_STREAM), &pFullMediaType);
                        }

                        // try to set the input media type on the sink writer
                        if (SUCCEEDED(hr))
                        {
                                hr = m_pWriter->SetInputMediaType(dwStreamIndex, pFullMediaType, nullptr);
                        }

                        if (S_OK != hr)
                        {
                                // format is not supported by the sink writer, try the next on the list
                                hr = S_OK;
                                continue;
                        }

                        fConfigured = TRUE;
                        break;
                }

                if (!fConfigured)
                {
                        hr = E_FAIL;
                }

                SAFE_RELEASE(pPartialMediaType);
                SAFE_RELEASE(pFullMediaType);

                return (hr);
        }

        HRESULT Webcam::NegotiateVideoStreamFormat(__in DWORD dwStreamIndex) const
        {
                /*
                MFVideoFormat_I420
                MFVideoFormat_IYUV
                MFVideoFormat_NV12
                MFVideoFormat_YUY2
                MFVideoFormat_YV12
                */
                static const GUID* aVideoFormats[] =
                        {
                                &MFVideoFormat_NV12,
                                &MFVideoFormat_YV12,
                                &MFVideoFormat_YUY2,
                                &MFVideoFormat_RGB32,
                                &MFVideoFormat_UYVY,
                                &MFVideoFormat_RGB24,
                                &MFVideoFormat_IYUV,
                        };

                return NegotiateStreamFormat(dwStreamIndex, MFMediaType_Video, ARRAYSIZE(aVideoFormats), aVideoFormats);
        }

        HRESULT Webcam::NegotiateAudioStreamFormat(__in DWORD dwStreamIndex) const
        {
                static const GUID* aAudioFormats[] =
                        {
                                &MFAudioFormat_Float,
                                &MFAudioFormat_PCM,
                        };

                return NegotiateStreamFormat(dwStreamIndex, MFMediaType_Audio, ARRAYSIZE(aAudioFormats), aAudioFormats);
        }

        BOOL Webcam::IsCapturing()
        {
                EnterCriticalSection(&m_critsec);

                BOOL bIsCapturing = (m_pWriter != nullptr);

                LeaveCriticalSection(&m_critsec);

                return bIsCapturing;
        }

        void Webcam::Initialize(Logger* prmLogger, WebcamConfig* prmConfig, Bus* prmBus)
        {
                if (!prmConfig->enabled) return;

                initialized = false;
                prmConfig->enabled = false;

                logger = prmLogger;
                config = prmConfig;
                bus = prmBus;

                CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED | COINIT_DISABLE_OLE1DDE);
                MFStartup(MF_VERSION);

                initialized = true;
                prmConfig->enabled = true;
        }

        void Webcam::StartRecord()
        {
                logger->Log("Webcam::StartRecord Entering...");

                if (initialized == false)
                {
                        logger->Log("Webcam::StartRecord Not initialized!", Logger::Error);
                        return;
                }

                if (IsCapturing())
                {
                        logger->Log("Webcam::StartRecord Already recording!", Logger::Error);
                        return;
                }

                HRESULT hr;

                EnterCriticalSection(&m_critsec);


                videoDevices = new DeviceList(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID);
                if (FAILED(hr = videoDevices->EnumerateDevices(logger, config)) || videoDevices->Count() == 0)
                {
                        logger->Log("Webcam::Initialize No video device or EnumerateDevices failed!", Logger::Error, hr);
                        return;
                }

                audioDevices = new DeviceList(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_AUDCAP_GUID);
                if (FAILED(hr = audioDevices->EnumerateDevices(logger, config)) || audioDevices->Count() == 0)
                {
                        logger->Log("Webcam::Initialize No audio device or EnumerateDevices failed!", Logger::Error, hr);
                        return;
                }

                char msg[199];

                sprintf_s(msg, 199, "Webcam::Initialize Searching for video device: %S", config->videoDevice.c_str());
                logger->Log(msg);
                if (FAILED(hr = videoDevices->GetDevicebyID(config->videoDevice, &pVideoActivate)))
                {
                        logger->Log("Webcam::Initialize GetDevicebyID video failed!", Logger::Error, hr);
                        return;
                }

                sprintf_s(msg, 199, "Webcam::Initialize Searching for audio device: %S", config->audioDevice.c_str());
                logger->Log(msg);
                if (FAILED(hr = audioDevices->GetDevicebyID(config->audioDevice, &pAudioActivate)))
                {
                        logger->Log("Webcam::Initialize GetDevicebyID audio failed!", Logger::Error, hr);
                        return;
                }

                // Create the media source for the device.
                if (FAILED(hr = pVideoActivate->ActivateObject(__uuidof(IMFMediaSource), reinterpret_cast<void**>(&pVideoSource))))
                {
                        logger->Log("Webcam::StartRecord ActivateObject failed video!", Logger::Error, hr);
                        LeaveCriticalSection(&m_critsec);
                        return;
                }

                if (FAILED(hr = pAudioActivate->ActivateObject(__uuidof(IMFMediaSource), reinterpret_cast<void**>(&pAudioSource))))
                {
                        logger->Log("Webcam::StartRecord ActivateObject failed audio!", Logger::Error, hr);
                        LeaveCriticalSection(&m_critsec);
                        return;
                }

                if (FAILED(hr = CreateAggregatedSource(pVideoSource, pAudioSource, &pSource)))
                {
                        LeaveCriticalSection(&m_critsec);
                        return;
                }

                if (FAILED(hr = OpenMediaSource(pSource)))
                {
                        LeaveCriticalSection(&m_critsec);
                        return;
                }


                // create unique filename based on timestamp
                WCHAR fileName[99];
                char fileNameA[99];

                recordingNumber++;

                swprintf_s(fileName, 99, L"%S %i %.0f.mp4", bus->receiptNumber.c_str(), recordingNumber, bus->ScenarioScore);
                sprintf_s(fileNameA, 99, "%s %i %.0f.mp4", bus->receiptNumber.c_str(), recordingNumber, bus->ScenarioScore);
                pathAndFileName = fileName;
                pathAndFileNameA = fileNameA;

                if (FAILED(hr = MFCreateSinkWriterFromURL(pathAndFileName.c_str(), NULL, NULL, &m_pWriter)))
                {
                        logger->Log("Webcam::StartRecord MFCreateSinkWriterFromURL failed!", Logger::Error, hr);
                        LeaveCriticalSection(&m_critsec);
                        return;
                }

                // Set up the encoding parameters.
                if (FAILED(hr = ConfigureCapture()))
                {
                        logger->Log("Webcam::StartRecord ConfigureCapture failed!", Logger::Error, hr);
                        LeaveCriticalSection(&m_critsec);
                        return;
                }

                m_bVideoFirstSample = TRUE;
                m_bAudioFirstSample = TRUE;
                m_llVideoBaseTime = 0;
                m_llAudioBaseTime = 0;

                // Request the first frame.
                if (FAILED(hr = m_pReader->ReadSample(static_cast<DWORD>(MF_SOURCE_READER_ANY_STREAM), 0, nullptr, nullptr, nullptr, nullptr)))
                {
                        logger->Log("Webcam::StartRecord ReadSample!", Logger::Error, hr);
                        LeaveCriticalSection(&m_critsec);
                        return;
                }

                SAFE_RELEASE(pVideoSource);
                SAFE_RELEASE(pAudioSource);
                SAFE_RELEASE(pSource);

                LeaveCriticalSection(&m_critsec);

                logger->Log("Webcam::StartRecord Successful!");
        }

        void Webcam::StopRecord()
        {
                logger->Log("Webcam::StopRecord Entering...");

                if (!IsCapturing())
                {
                        logger->Log("Webcam::StopRecord Was not capturing!", Logger::Error);
                        return;
                }

                EnterCriticalSection(&m_critsec);

                HRESULT hr;
                if (FAILED(hr = m_pWriter->Finalize()))
                {
                        if (hr == 0xc00d4a44)
                                logger->Log("Webcam::StopRecord Finalize failed because no samples were processed by the sink!", Logger::Error, hr);
                        else
                                logger->Log("Webcam::StopRecord Finalize failed!", Logger::Error, hr);

                        LeaveCriticalSection(&m_critsec);
                        return;
                }

                SAFE_DELETE(videoDevices);
                SAFE_DELETE(audioDevices);

                SAFE_RELEASE(pVideoActivate);
                SAFE_RELEASE(pAudioActivate);

                SAFE_RELEASE(pVideoSource);
                SAFE_RELEASE(pAudioSource);
                SAFE_RELEASE(pSource);

                SAFE_RELEASE(m_pReader);
                SAFE_RELEASE(m_pWriter);

                LeaveCriticalSection(&m_critsec);

                // log filename
                char msg[99];
                sprintf_s(msg, 99, "Webcam::StopRecord Success, returning: %s", pathAndFileNameA.c_str());
                logger->Log(msg);
        }

        void Webcam::Destroy()
        {
                if (IsCapturing())
                {
                        StopRecord();
                }

                MFShutdown();
                CoUninitialize();
        }

        DeviceList::DeviceList(GUID guidDevice): m_cDevices(0), m_ppDevices(nullptr)
        {
                m_guidDevice = guidDevice;
        }

        void DeviceList::Clear()
        {
                for (UINT32 i = 0; i < m_cDevices; i++)
                {
                        SAFE_RELEASE(m_ppDevices[i]);
                }
                CoTaskMemFree(m_ppDevices);
                m_ppDevices = nullptr;

                m_cDevices = 0;
        }

        HRESULT DeviceList::EnumerateDevices(Logger* logger, WebcamConfig* config)
        {
                HRESULT hr;
                IMFAttributes* pAttributes = nullptr;

                Clear();

                // Initialize an attribute store. We will use this to 
                // specify the enumeration parameters.

                if (FAILED(hr = MFCreateAttributes(&pAttributes, 1)))
                {
                        logger->Log("Webcam::DeviceList::EnumerateDevices MFCreateAttributes failed!", Logger::Error, hr);
                        return hr;
                }

                // Ask for source type = video capture devices
                if (FAILED(hr = pAttributes->SetGUID(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE, m_guidDevice)))
                {
                        logger->Log("Webcam::DeviceList::EnumerateDevices SetGUID MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE failed!", Logger::Error, hr);
                        return hr;
                }

                // Enumerate devices.
                if (FAILED(hr = MFEnumDeviceSources(pAttributes, &m_ppDevices, &m_cDevices)))
                {
                        logger->Log("Webcam::DeviceList::EnumerateDevices MFEnumDeviceSources failed!", Logger::Error, hr);
                        return hr;
                }

                SAFE_RELEASE(pAttributes);

                for (DWORD i = 0; i < m_cDevices; i++)
                {
                        UINT32 cchName;

                        // Try to get the display name.
                        WCHAR* szFriendlyName = nullptr;
                        if (FAILED(hr = m_ppDevices[i]->GetAllocatedString(MF_DEVSOURCE_ATTRIBUTE_FRIENDLY_NAME, &szFriendlyName, &cchName)))
                        {
                                logger->Log("Webcam::DeviceList::EnumerateDevices GetAllocatedString MF_DEVSOURCE_ATTRIBUTE_FRIENDLY_NAME failed!", Logger::Error, hr);
                                return hr;
                        }

                        // Try to get the guid.
                        WCHAR* szFriendlyName2 = nullptr;
                        if (m_guidDevice == MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID)
                                hr = m_ppDevices[i]->GetAllocatedString(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_SYMBOLIC_LINK, &szFriendlyName2, &cchName);
                        else
                                hr = m_ppDevices[i]->GetAllocatedString(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_AUDCAP_ENDPOINT_ID, &szFriendlyName2, &cchName);
                        if (FAILED(hr))
                        {
                                logger->Log("Webcam::DeviceList::EnumerateDevices GetAllocatedString m_guidDevice failed!", Logger::Error, hr);
                                return hr;
                        }

                        char msg[199];
                        if (m_guidDevice == MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID)
                                sprintf_s(msg, 199, "WebCam::DeviceList::EnumerateDevices Available video capture device %S: %S", szFriendlyName, szFriendlyName2);
                        else
                                sprintf_s(msg, 199, "WebCam::DeviceList::EnumerateDevices Available audio capture device %S: %S", szFriendlyName, szFriendlyName2);
                        logger->Log(msg);

                        if (m_guidDevice == MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID)
                        {
                                if (config->videoDevice.empty())
                                {
                                        config->videoDevice = szFriendlyName2;
                                        sprintf_s(msg, 199, "WebCam::DeviceList::EnumerateDevices Defaulted video capture device %S", config->videoDevice.c_str());
                                }
                        }
                        else
                        {
                                if (config->audioDevice.empty())
                                {
                                        config->audioDevice = szFriendlyName2;
                                        sprintf_s(msg, 199, "WebCam::DeviceList::EnumerateDevices Defaulted audio capture device %S", config->audioDevice.c_str());
                                }
                        }

                        CoTaskMemFree(szFriendlyName);
                        CoTaskMemFree(szFriendlyName2);
                }

                return hr;
        }

        HRESULT DeviceList::GetDevicebyID(std::wstring id, IMFActivate** ppActivate) const
        {
                if (m_guidDevice == MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID)
                {
                        for (UINT i = 0; i < Count(); i++)
                        {
                                WCHAR* sympolicLink = nullptr;
                                m_ppDevices[i]->GetAllocatedString(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_SYMBOLIC_LINK, &sympolicLink, nullptr);
                                if (id == sympolicLink)
                                {
                                        *ppActivate = m_ppDevices[i];
                                        (*ppActivate)->AddRef();
                                        return S_OK;
                                }
                        }
                }
                else if (m_guidDevice == MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_AUDCAP_GUID)
                {
                        for (UINT i = 0; i < Count(); i++)
                        {
                                WCHAR* emdPointID = nullptr;
                                m_ppDevices[i]->GetAllocatedString(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_AUDCAP_ENDPOINT_ID, &emdPointID, nullptr);
                                if (id == emdPointID)
                                {
                                        *ppActivate = m_ppDevices[i];
                                        (*ppActivate)->AddRef();
                                        return S_OK;
                                }
                        }
                }
                return E_FAIL;
        }

        void Webcam::FrameMove()
        {
                for (UINT i = 0; i < bus->commandStream.size(); i++)
                {
                        Command command = bus->commandStream.at(i);
                        if (command.delay != 0.0f) continue;

                        if (command.name == "StartRecord")
                        {
                                StartRecord();
                                bus->commandStream.erase(bus->commandStream.begin() + i);
                                break;
                        }
                        else if (command.name == "StopRecord")
                        {
                                StopRecord();
                                bus->commandStream.erase(bus->commandStream.begin() + i);
                                break;
                        }
                }
        }
}