Add feature to detect device's remove/insert events.

dshowcapture.hpp

@@ -204,11 +204,20 @@ struct AudioConfig : Config {
 	AudioMode mode = AudioMode::Capture;
 };
 
+class IDeviceCallback {
+public:
+	virtual ~IDeviceCallback() {}
+
+	virtual void OnDeviceRemoved() = 0;
+	virtual void OnDeviceInserted() = 0;
+};
+
 class DSHOWCAPTURE_EXPORT Device {
 	HDevice *context;
+	IDeviceCallback *callback;
 
 public:
-	Device(InitGraph initialize = InitGraph::False);
+	Device(InitGraph initialize = InitGraph::False, IDeviceCallback *cb = NULL);
 	~Device();
 
 	bool Valid() const;

source/device.cpp

@@ -30,13 +30,24 @@ namespace DShow {
 
 bool SetRocketEnabled(IBaseFilter *encoder, bool enable);
 
-HDevice::HDevice() : initialized(false), active(false) {}
+HDevice::HDevice(IDeviceCallback *cb)
+	: initialized(false),
+	  active(false),
+	  callback(cb),
+	  msgEvt(0),
+	  msgThread(0)
+{
+	exitEvt = ::CreateEvent(NULL, TRUE, FALSE, NULL);
+}
 
 HDevice::~HDevice()
 {
 	if (active)
 		Stop();
 
+	StopEventThread();
+	CloseHandle(exitEvt);
+
 	DisconnectFilters();
 
 	/*
@@ -53,6 +64,90 @@ HDevice::~HDevice()
 	}
 }
 
+unsigned __stdcall HDevice::EventThread(void *pParam)
+{
+	HDevice *self = reinterpret_cast<HDevice *>(pParam);
+	CoInitialize(nullptr);
+	self->EventThreadInner();
+	CoUninitialize();
+	return 0;
+}
+
+void HDevice::EventThreadInner()
+{
+	HANDLE events[] = {
+		exitEvt, // must be first one
+		msgEvt,
+	};
+
+	DWORD count = sizeof(events) / sizeof(HANDLE);
+
+	while (true) {
+		DWORD res =
+			WaitForMultipleObjects(count, events, FALSE, INFINITE);
+		if (res == WAIT_OBJECT_0)
+			break; // exitEvt is set for exiting thread
+
+		if (!ReadAllEvents())
+			break;
+	}
+}
+
+#define FLAG_REMOVE_DEVICE 0
+#define FLAG_INSERT_DEVICE 1
+
+bool HDevice::ReadAllEvents()
+{
+	long eventCode = 0;
+	LONG_PTR param1 = 0;
+	LONG_PTR param2 = 0;
+
+	while (SUCCEEDED(eventEx->GetEvent(&eventCode, &param1, &param2, 0))) {
+		if (EC_DEVICE_LOST == eventCode) {
+			if (FLAG_REMOVE_DEVICE == param2) {
+				Warning(L"Device is removed.");
+				callback->OnDeviceRemoved();
+			} else if (FLAG_INSERT_DEVICE == param2) {
+				Info(L"Device is inserted again.");
+				callback->OnDeviceInserted();
+			}
+		}
+
+		eventEx->FreeEventParams(eventCode, param1, param2);
+
+		if (WAIT_OBJECT_0 == WaitForSingleObject(exitEvt, 0))
+			return false;
+	}
+
+	return true;
+}
+
+void HDevice::StartEventThread()
+{
+	if (msgThread && (msgThread != INVALID_HANDLE_VALUE)) {
+		Warning(L"Message thread is running!");
+		return;
+	}
+
+	if (!callback) {
+		Info(L"Won't create message thread because no callback.");
+		return;
+	}
+
+	::ResetEvent(exitEvt);
+	msgThread = (HANDLE)_beginthreadex(0, 0, EventThread, this, 0, 0);
+}
+
+void HDevice::StopEventThread()
+{
+	::SetEvent(exitEvt);
+	if (msgThread && (msgThread != INVALID_HANDLE_VALUE)) {
+		WaitForSingleObject(msgThread, INFINITE);
+		CloseHandle(msgThread);
+		msgThread = 0;
+	}
+}
+
 bool HDevice::EnsureInitialized(const wchar_t *func)
 {
 	if (!initialized) {
@@ -601,9 +696,19 @@ bool HDevice::CreateGraph()
 		return false;
 	}
 
-	if (!CreateFilterGraph(&graph, &builder, &control))
+	StopEventThread();
+
+	if (!CreateFilterGraph(&graph, &builder, &control, &eventEx))
 		return false;
 
+	HRESULT hr = eventEx->GetEventHandle((OAEVENT *)&msgEvt);
+	if (FAILED(hr)) {
+		ErrorHR(L"Failed to get event handle", hr);
+		return false;
+	}
+
+	StartEventThread();
+
 	initialized = true;
 	return true;
 }

source/device.hpp

@@ -21,7 +21,8 @@
 
 #include "../dshowcapture.hpp"
 #include "capture-filter.hpp"
-
+#include <Windows.h>
+#include <process.h>
 #include <string>
 #include <vector>
 using namespace std;
@@ -50,6 +51,7 @@ struct HDevice {
 	ComPtr<IGraphBuilder> graph;
 	ComPtr<ICaptureGraphBuilder2> builder;
 	ComPtr<IMediaControl> control;
+	ComPtr<IMediaEventEx> eventEx;
 
 	ComPtr<IBaseFilter> videoFilter;
 	ComPtr<IBaseFilter> audioFilter;
@@ -70,9 +72,22 @@ struct HDevice {
 	EncodedData encodedVideo;
 	EncodedData encodedAudio;
 
-	HDevice();
+	// handle insert/remove events
+	HANDLE msgEvt;
+	HANDLE exitEvt;
+	HANDLE msgThread;
+	IDeviceCallback *callback;
+
+	HDevice(IDeviceCallback *cb);
 	~HDevice();
 
+	// handle insert/remove events
+	static unsigned __stdcall EventThread(void *pParam);
+	void EventThreadInner();
+	bool ReadAllEvents();
+	void StartEventThread();
+	void StopEventThread();
+
 	void ConvertVideoSettings();
 	void ConvertAudioSettings();
 

source/dshow-base.cpp

@@ -39,11 +39,12 @@ using namespace std;
 namespace DShow {
 
 bool CreateFilterGraph(IGraphBuilder **pgraph, ICaptureGraphBuilder2 **pbuilder,
-		       IMediaControl **pcontrol)
+		       IMediaControl **pcontrol, IMediaEventEx **pevent)
 {
 	ComPtr<IGraphBuilder> graph;
 	ComPtr<ICaptureGraphBuilder2> builder;
 	ComPtr<IMediaControl> control;
+	ComPtr<IMediaEventEx> event;
 	HRESULT hr;
 
 	hr = CoCreateInstance(CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER,
@@ -73,6 +74,16 @@ bool CreateFilterGraph(IGraphBuilder **pgraph, ICaptureGraphBuilder2 **pbuilder,
 		return false;
 	}
 
+	if (pevent) {
+		hr = graph->QueryInterface(IID_IMediaEventEx, (void **)&event);
+		if (FAILED(hr)) {
+			ErrorHR(L"Failed to get media event interface", hr);
+			return false;
+		}
+
+		*pevent = event.Detach();
+	}
+
 	*pgraph = graph.Detach();
 	*pbuilder = builder.Detach();
 	*pcontrol = control.Detach();

source/dshow-base.hpp

@@ -40,7 +40,7 @@ using namespace std;
 namespace DShow {
 
 bool CreateFilterGraph(IGraphBuilder **graph, ICaptureGraphBuilder2 **builder,
-		       IMediaControl **control);
+		       IMediaControl **control, IMediaEventEx **pevent);
 
 void LogFilters(IGraphBuilder *graph);
 

source/dshowcapture.cpp

@@ -28,7 +28,8 @@
 
 namespace DShow {
 
-Device::Device(InitGraph initialize) : context(new HDevice)
+Device::Device(InitGraph initialize, IDeviceCallback *cb)
+	: context(new HDevice(cb)), callback(cb)
 {
 	if (initialize == InitGraph::True)
 		context->CreateGraph();
@@ -48,15 +49,15 @@ bool Device::ResetGraph()
 {
 	/* cheap and easy way to clear all the filters */
 	delete context;
-	context = new HDevice;
+	context = new HDevice(callback);
 
 	return context->CreateGraph();
 }
 
 void Device::ShutdownGraph()
 {
 	delete context;
-	context = new HDevice;
+	context = new HDevice(callback);
 }
 
 bool Device::SetVideoConfig(VideoConfig *config)

source/encoder.cpp

@@ -25,7 +25,7 @@ namespace DShow {
 
 HVideoEncoder::HVideoEncoder()
 {
-	initialized = CreateFilterGraph(&graph, &builder, &control);
+	initialized = CreateFilterGraph(&graph, &builder, &control, NULL);
 }
 
 HVideoEncoder::~HVideoEncoder()

source/output-filter.cpp

@@ -22,6 +22,7 @@
 #include "log.hpp"
 
 #include <strsafe.h>
+#include <stdint.h>
 
 namespace DShow {