Webcam.h

Go to the documentation of this file.

#pragma once

// have to include these in this order because bass.h refers to something that screws it up
#include <WinSock2.h>
#include <Windows.h>
//#include <WS2tcpip.h>

#include <mfapi.h>
#include <mfidl.h>
#include <mfreadwrite.h>
//#include <Wmcodecdsp.h>

#include "Bus.h"

namespace Devices
{
        class WebcamConfig
        {
        public:
                bool enabled = false;
                std::wstring videoDevice;
                std::wstring audioDevice;

                UINT width = 640;
                UINT height = 480;
                UINT frequency = 44100;
                UINT channels = 1;
                UINT numerator = 24;
                UINT denominator = 1;
        };

        class DeviceList
        {
        private:
                UINT32 m_cDevices;
                IMFActivate** m_ppDevices;
                GUID m_guidDevice;

        public:
                DeviceList(GUID guidDevice);

                ~DeviceList()
                {
                        Clear();
                }

                UINT32 Count() const
                {
                        return m_cDevices;
                }

                void Clear();
                HRESULT EnumerateDevices(Logger* logger, WebcamConfig* config);
                HRESULT GetDevicebyID(std::wstring id, IMFActivate** ppActivate) const;
        };

        class Webcam : public IMFSourceReaderCallback
        {
        private:
                Logger* logger = nullptr;
                WebcamConfig* config = nullptr;
                Bus* bus = nullptr;

                bool initialized = false;
                std::wstring pathAndFileName;
                std::string pathAndFileNameA;

                DeviceList* videoDevices = nullptr;
                DeviceList* audioDevices = nullptr;

                IMFActivate* pVideoActivate = nullptr;
                IMFActivate* pAudioActivate = nullptr;

                IMFMediaSource* pVideoSource = nullptr;
                IMFMediaSource* pAudioSource = nullptr;
                IMFMediaSource* pSource = nullptr;

                long m_nRefCount = 0; // Reference count.
                CRITICAL_SECTION m_critsec;

                IMFSourceReader* m_pReader = nullptr;
                IMFSinkWriter* m_pWriter = nullptr;

                BOOL m_bVideoFirstSample = false;
                BOOL m_bAudioFirstSample = false;
                LONGLONG m_llVideoBaseTime = 0;
                LONGLONG m_llAudioBaseTime = 0;
                DWORD sink_video_stream = 0;
                DWORD sink_audio_stream = 1;


                // IUnknown methods
                STDMETHODIMP QueryInterface(REFIID iid, void** ppv);
                STDMETHODIMP_(ULONG) AddRef();
                STDMETHODIMP_(ULONG) Release();

                // IMFSourceReaderCallback methods
                STDMETHODIMP OnReadSample(
                        HRESULT hrStatus,
                        DWORD dwStreamIndex,
                        DWORD dwStreamFlags,
                        LONGLONG llTimestamp,
                        IMFSample* pSample
                );

                STDMETHODIMP OnEvent(DWORD, IMFMediaEvent*)
                {
                        return S_OK;
                }

                STDMETHODIMP OnFlush(DWORD)
                {
                        return S_OK;
                }

                HRESULT CreateAggregatedSource(IMFMediaSource* pSource1, IMFMediaSource* pSource2, IMFMediaSource** ppAggSource) const;

                HRESULT OpenMediaSource(IMFMediaSource* pSource);

                HRESULT ConfigureCapture();

                HRESULT CreateTargetVideoMediaType(IMFMediaType* pNativeMediaType, IMFMediaType** ppTargetMediaType) const;
                HRESULT CreateTargetAudioMediaType(IMFMediaType* pNativeMediaType, IMFMediaType** ppTargetMediaType) const;

                HRESULT NegotiateStreamFormat(DWORD dwStreamIndex, REFGUID guidMajorType, DWORD cFormats, const GUID** paFormats) const;

                HRESULT NegotiateVideoStreamFormat(DWORD dwStreamIndex) const;
                HRESULT NegotiateAudioStreamFormat(DWORD dwStreamIndex) const;

                BOOL IsCapturing();

                int recordingNumber = 0;

        public:

                Webcam();
                void Initialize(Logger* prmLogger, WebcamConfig* prmConfig, Bus* prmBus);
                void FrameMove();
                void StartRecord();
                void StopRecord();
                void Destroy();
                virtual ~Webcam();
        };
}