Win Video Capture: add support for enumerating DirectShow WDM devices

media/video/capture/win/video_capture_device_factory_win.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/video/capture/win/video_capture_device_factory_win.h"
 
 #include <mfapi.h>
 #include <mferror.h>
 
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/strings/string_util.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/win/metro.h"
 #include "base/win/scoped_co_mem.h"
 #include "base/win/scoped_variant.h"
 #include "base/win/windows_version.h"
 #include "media/base/media_switches.h"
 #include "media/video/capture/win/video_capture_device_mf_win.h"
 #include "media/video/capture/win/video_capture_device_win.h"
 
 using base::win::ScopedCoMem;
 using base::win::ScopedComPtr;
 using base::win::ScopedVariant;
+using Name = media::VideoCaptureDevice::Name;
+using Names = media::VideoCaptureDevice::Names;

[mcasas, 2014/08/28 11:53:41]

Comment: since Name is a nested class inside VCD,
this is the needed syntax.

 
 namespace media {
 
 // Lazy Instance to initialize the MediaFoundation Library.
 class MFInitializerSingleton {
  public:
   MFInitializerSingleton() { MFStartup(MF_VERSION, MFSTARTUP_LITE); }
   ~MFInitializerSingleton() { MFShutdown(); }
 };
 
@@ skipping 46 matching lines @@
 
 static bool EnumerateVideoDevicesMediaFoundation(IMFActivate*** devices,
                                                  UINT32* count) {
   ScopedComPtr<IMFAttributes> attributes;
   if (!PrepareVideoCaptureAttributesMediaFoundation(attributes.Receive(), 1))
     return false;
 
   return SUCCEEDED(MFEnumDeviceSources(attributes, devices, count));
 }
 
-static void GetDeviceNamesDirectShow(VideoCaptureDevice::Names* device_names) {
+static void GetDeviceNamesDirectShow(Names* device_names) {
   DCHECK(device_names);
   DVLOG(1) << " GetDeviceNamesDirectShow";
 
   ScopedComPtr<ICreateDevEnum> dev_enum;
   HRESULT hr = dev_enum.CreateInstance(CLSID_SystemDeviceEnum, NULL,
                                        CLSCTX_INPROC);
   if (FAILED(hr))
     return;
 
-  ScopedComPtr<IEnumMoniker> enum_moniker;
-  hr = dev_enum->CreateClassEnumerator(CLSID_VideoInputDeviceCategory,
-                                       enum_moniker.Receive(), 0);
-  // CreateClassEnumerator returns S_FALSE on some Windows OS
-  // when no camera exist. Therefore the FAILED macro can't be used.
-  if (hr != S_OK)
-    return;
+  static const struct{
+    CLSID class_id;
+    Name::CaptureApiType capture_api_type;
+  } kDirectShowFilterClasses[] = {
+    { CLSID_VideoInputDeviceCategory, Name::DIRECT_SHOW },
+    { AM_KSCATEGORY_CROSSBAR, Name::DIRECT_SHOW_WDM}
+  };
+
 
   device_names->clear();
+  for (int class_index = 0; class_index < arraysize(kDirectShowFilterClasses);
+      ++class_index) {
+    ScopedComPtr<IEnumMoniker> enum_moniker;
+    hr = dev_enum->CreateClassEnumerator(
+        kDirectShowFilterClasses[class_index].class_id,
+        enum_moniker.Receive(),
+        0);
+    // CreateClassEnumerator returns S_FALSE on some Windows OS
+    // when no camera exist. Therefore the FAILED macro can't be used.
+    if (hr != S_OK)
+      continue;
 
-  // Name of a fake DirectShow filter that exist on computers with
-  // GTalk installed.
-  static const char kGoogleCameraAdapter[] = "google camera adapter";
+    // Name of a fake DirectShow filter that exist on computers with
+    // GTalk installed.
+    static const char kGoogleCameraAdapter[] = "google camera adapter";
 
-  // Enumerate all video capture devices.
-  ScopedComPtr<IMoniker> moniker;
-  int index = 0;
-  while (enum_moniker->Next(1, moniker.Receive(), NULL) == S_OK) {
-    ScopedComPtr<IPropertyBag> prop_bag;
-    hr = moniker->BindToStorage(0, 0, IID_IPropertyBag, prop_bag.ReceiveVoid());
-    if (FAILED(hr)) {
+    // Enumerate all video capture devices.
+    ScopedComPtr<IMoniker> moniker;
+    int index = 0;
+    while (enum_moniker->Next(1, moniker.Receive(), NULL) == S_OK) {
+      ScopedComPtr<IPropertyBag> prop_bag;
+      hr = moniker->BindToStorage(0, 0, IID_IPropertyBag,
+          prop_bag.ReceiveVoid());
+      if (FAILED(hr)) {
+        moniker.Release();
+        continue;
+      }
+
+      // Find the description or friendly name.
+      ScopedVariant name;
+      hr = prop_bag->Read(L"Description", name.Receive(), 0);
+      if (FAILED(hr))
+        hr = prop_bag->Read(L"FriendlyName", name.Receive(), 0);
+
+      if (SUCCEEDED(hr) && name.type() == VT_BSTR) {
+        // Ignore all VFW drivers and the special Google Camera Adapter.
+        // Google Camera Adapter is not a real DirectShow camera device.
+        // VFW are very old Video for Windows drivers that can not be used.
+        const wchar_t* str_ptr = V_BSTR(&name);
+        const int name_length = arraysize(kGoogleCameraAdapter) - 1;
+
+        if ((wcsstr(str_ptr, L"(VFW)") == NULL) &&
+            lstrlenW(str_ptr) < name_length ||
+            (!(LowerCaseEqualsASCII(str_ptr, str_ptr + name_length,
+                                    kGoogleCameraAdapter)))) {
+          std::string id;
+          std::string device_name(base::SysWideToUTF8(str_ptr));
+          name.Reset();
+          hr = prop_bag->Read(L"DevicePath", name.Receive(), 0);
+          if (FAILED(hr) || name.type() != VT_BSTR) {
+            id = device_name;
+          } else {
+            DCHECK_EQ(name.type(), VT_BSTR);
+            id = base::SysWideToUTF8(V_BSTR(&name));
+          }
+          device_names->push_back(Name(device_name, id,
+              kDirectShowFilterClasses[class_index].capture_api_type));
+        }
+      }
       moniker.Release();
-      continue;
     }
-
-    // Find the description or friendly name.
-    ScopedVariant name;
-    hr = prop_bag->Read(L"Description", name.Receive(), 0);
-    if (FAILED(hr))
-      hr = prop_bag->Read(L"FriendlyName", name.Receive(), 0);
-
-    if (SUCCEEDED(hr) && name.type() == VT_BSTR) {
-      // Ignore all VFW drivers and the special Google Camera Adapter.
-      // Google Camera Adapter is not a real DirectShow camera device.
-      // VFW are very old Video for Windows drivers that can not be used.
-      const wchar_t* str_ptr = V_BSTR(&name);
-      const int name_length = arraysize(kGoogleCameraAdapter) - 1;
-
-      if ((wcsstr(str_ptr, L"(VFW)") == NULL) &&
-          lstrlenW(str_ptr) < name_length ||
-          (!(LowerCaseEqualsASCII(str_ptr, str_ptr + name_length,
-                                  kGoogleCameraAdapter)))) {
-        std::string id;
-        std::string device_name(base::SysWideToUTF8(str_ptr));
-        name.Reset();
-        hr = prop_bag->Read(L"DevicePath", name.Receive(), 0);
-        if (FAILED(hr) || name.type() != VT_BSTR) {
-          id = device_name;
-        } else {
-          DCHECK_EQ(name.type(), VT_BSTR);
-          id = base::SysWideToUTF8(V_BSTR(&name));
-        }
-
-        device_names->push_back(VideoCaptureDevice::Name(device_name, id,
-            VideoCaptureDevice::Name::DIRECT_SHOW));
-      }
-    }
-    moniker.Release();
   }
 }
 
-static void GetDeviceNamesMediaFoundation(
-    VideoCaptureDevice::Names* device_names) {
+static void GetDeviceNamesMediaFoundation(Names* device_names) {
   DVLOG(1) << " GetDeviceNamesMediaFoundation";
   ScopedCoMem<IMFActivate*> devices;
   UINT32 count;
   if (!EnumerateVideoDevicesMediaFoundation(&devices, &count))
     return;
 
   for (UINT32 i = 0; i < count; ++i) {
     ScopedCoMem<wchar_t> name;
     UINT32 name_size;
     HRESULT hr = devices[i]->GetAllocatedString(
         MF_DEVSOURCE_ATTRIBUTE_FRIENDLY_NAME, &name, &name_size);
     if (SUCCEEDED(hr)) {
       ScopedCoMem<wchar_t> id;
       UINT32 id_size;
       hr = devices[i]->GetAllocatedString(
           MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_SYMBOLIC_LINK, &id,
           &id_size);
       if (SUCCEEDED(hr)) {
-        device_names->push_back(VideoCaptureDevice::Name(
+        device_names->push_back(Name(
             base::SysWideToUTF8(std::wstring(name, name_size)),
             base::SysWideToUTF8(std::wstring(id, id_size)),
-            VideoCaptureDevice::Name::MEDIA_FOUNDATION));
+            Name::MEDIA_FOUNDATION));
       }
     }
     if (FAILED(hr))
       DLOG(WARNING) << "GetAllocatedString failed: " << std::hex << hr;
     devices[i]->Release();
   }
 }
 
-static void GetDeviceSupportedFormatsDirectShow(
-    const VideoCaptureDevice::Name& device,
-    VideoCaptureFormats* formats) {
+static void GetDeviceSupportedFormatsDirectShow(const Name& device,
+                                                VideoCaptureFormats* formats) {
   DVLOG(1) << "GetDeviceSupportedFormatsDirectShow for " << device.name();
   ScopedComPtr<ICreateDevEnum> dev_enum;
   HRESULT hr = dev_enum.CreateInstance(CLSID_SystemDeviceEnum, NULL,
                                        CLSCTX_INPROC);
   if (FAILED(hr))
     return;
 
   ScopedComPtr<IEnumMoniker> enum_moniker;
   hr = dev_enum->CreateClassEnumerator(CLSID_VideoInputDeviceCategory,
                                        enum_moniker.Receive(), 0);
@@ skipping 66 matching lines @@
           0.0f;
       formats->push_back(format);
       DVLOG(1) << device.name() << " resolution: "
           << format.frame_size.ToString() << ", fps: " << format.frame_rate
           << ", pixel format: " << format.pixel_format;
     }
   }
 }
 
 static void GetDeviceSupportedFormatsMediaFoundation(
-    const VideoCaptureDevice::Name& device,
+    const Name& device,
     VideoCaptureFormats* formats) {
   DVLOG(1) << "GetDeviceSupportedFormatsMediaFoundation for " << device.name();
   ScopedComPtr<IMFMediaSource> source;
   if (!CreateVideoCaptureDeviceMediaFoundation(device.id().c_str(),
                                                source.Receive())) {
     return;
   }
 
   base::win::ScopedComPtr<IMFSourceReader> reader;
   HRESULT hr =
@@ skipping 70 matching lines @@
   // 8 in non-Metro mode.
   const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
   use_media_foundation_ = (base::win::IsMetroProcess() &&
       !cmd_line->HasSwitch(switches::kForceDirectShowVideoCapture)) ||
      (base::win::GetVersion() >= base::win::VERSION_WIN7 &&
       cmd_line->HasSwitch(switches::kForceMediaFoundationVideoCapture));
 }
 
 
 scoped_ptr<VideoCaptureDevice> VideoCaptureDeviceFactoryWin::Create(
-    const VideoCaptureDevice::Name& device_name) {
+    const Name& device_name) {
   DCHECK(thread_checker_.CalledOnValidThread());
   scoped_ptr<VideoCaptureDevice> device;
-  if (device_name.capture_api_type() ==
-      VideoCaptureDevice::Name::MEDIA_FOUNDATION) {
+  if (device_name.capture_api_type() == Name::MEDIA_FOUNDATION) {
     DCHECK(PlatformSupportsMediaFoundation());
     device.reset(new VideoCaptureDeviceMFWin(device_name));
     DVLOG(1) << " MediaFoundation Device: " << device_name.name();
     ScopedComPtr<IMFMediaSource> source;
     if (!CreateVideoCaptureDeviceMediaFoundation(device_name.id().c_str(),
                                                  source.Receive())) {
       return scoped_ptr<VideoCaptureDevice>();
     }
     if (!static_cast<VideoCaptureDeviceMFWin*>(device.get())->Init(source))
       device.reset();
   } else {
-    DCHECK_EQ(device_name.capture_api_type(),
-              VideoCaptureDevice::Name::DIRECT_SHOW);
+    DCHECK(device_name.capture_api_type() == Name::DIRECT_SHOW ||
+           device_name.capture_api_type() == Name::DIRECT_SHOW_WDM);
     device.reset(new VideoCaptureDeviceWin(device_name));
     DVLOG(1) << " DirectShow Device: " << device_name.name();
     if (!static_cast<VideoCaptureDeviceWin*>(device.get())->Init())
       device.reset();
   }
   return device.Pass();
 }
 
-void VideoCaptureDeviceFactoryWin::GetDeviceNames(
-    VideoCaptureDevice::Names* device_names) {
+void VideoCaptureDeviceFactoryWin::GetDeviceNames(Names* device_names) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (use_media_foundation_)
     GetDeviceNamesMediaFoundation(device_names);
   else
     GetDeviceNamesDirectShow(device_names);
 }
 
 void VideoCaptureDeviceFactoryWin::GetDeviceSupportedFormats(
-    const VideoCaptureDevice::Name& device,
+    const Name& device,
     VideoCaptureFormats* formats) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (use_media_foundation_)
     GetDeviceSupportedFormatsMediaFoundation(device, formats);
   else
     GetDeviceSupportedFormatsDirectShow(device, formats);
 }
 
 }  // namespace media