Win Video Capture: add DirectShow WDM devices capabilities enumeration.

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"
@@ skipping 72 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(Names* device_names) {
+static void GetDeviceNamesDirectShow(
+    const CLSID class_id,
+    const Name::CaptureApiType capture_api_type,
+    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;
 
-  static const struct{
-    CLSID class_id;
-    Name::CaptureApiType capture_api_type;
-  } kDirectShowFilterClasses[] = {
-    { CLSID_VideoInputDeviceCategory, Name::DIRECT_SHOW },
-    { AM_KSCATEGORY_CROSSBAR, Name::DIRECT_SHOW_WDM}
-  };
+  ScopedComPtr<IEnumMoniker> enum_moniker;
+  hr = dev_enum->CreateClassEnumerator(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)
+    return;
 
+  // Name of a fake DirectShow filter that exist on computers with
+  // GTalk installed.
+  static const char kGoogleCameraAdapter[] = "google camera adapter";
 
-  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;
+  // 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();
+      return;
+    }
 
-    // Name of a fake DirectShow filter that exist on computers with
-    // GTalk installed.
-    static const char kGoogleCameraAdapter[] = "google camera adapter";
+    // 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);
 
-    // 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;
+    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, capture_api_type));
       }
-
-      // 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();
     }
+    moniker.Release();
   }
 }
 
 static void GetDeviceNamesMediaFoundation(Names* device_names) {
   DVLOG(1) << " GetDeviceNamesMediaFoundation";
   ScopedCoMem<IMFActivate*> devices;
   UINT32 count;
   if (!EnumerateVideoDevicesMediaFoundation(&devices, &count))
     return;
 
@@ skipping 31 matching lines @@
     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
   // exists. Therefore the FAILED macro can't be used.
   if (hr != S_OK)
     return;
 
-  // Walk the capture devices. No need to check for device presence again, that
-  // is caught in GetDeviceFilter(). "google camera adapter" and old VFW devices
-  // are already skipped in the previous GetDeviceNames() enumeration.
+  // Walk the capture devices. No need to check for device presence again since
+  // that is anyway needed in GetDeviceFilter(). "google camera adapter" and old
+  // VFW devices are already skipped previously in GetDeviceNames() enumeration.
   base::win::ScopedComPtr<IBaseFilter> capture_filter;
-  hr = VideoCaptureDeviceWin::GetDeviceFilter(device,
+  hr = VideoCaptureDeviceWin::GetDeviceFilter(device.capabilities_id(),
                                               capture_filter.Receive());
   if (!capture_filter) {
     DLOG(ERROR) << "Failed to create capture filter: "
                 << logging::SystemErrorCodeToString(hr);
     return;
   }
 
   base::win::ScopedComPtr<IPin> output_capture_pin(
       VideoCaptureDeviceWin::GetPin(capture_filter,
                                     PINDIR_OUTPUT,
@@ skipping 157 matching lines @@
     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(device_name.capture_api_type() == Name::DIRECT_SHOW ||
-           device_name.capture_api_type() == Name::DIRECT_SHOW_WDM);
+           device_name.capture_api_type() == Name::DIRECT_SHOW_WDM_CROSSBAR);
     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(Names* device_names) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (use_media_foundation_)
+  if (use_media_foundation_) {
     GetDeviceNamesMediaFoundation(device_names);
-  else
-    GetDeviceNamesDirectShow(device_names);
+  } else {
+    GetDeviceNamesDirectShow(CLSID_VideoInputDeviceCategory,
+                             Name::DIRECT_SHOW,
+                             device_names);
+
+    Names crossbar_device_names;
+    GetDeviceNamesDirectShow(AM_KSCATEGORY_CROSSBAR,
+                             Name::DIRECT_SHOW_WDM_CROSSBAR,
+                             &crossbar_device_names);
+    // Search in the listed |device_names| to find a device with matching USB ID
+    // to each device in |crossbar_device_names|.
+    for (Names::iterator crossbar_device_it = crossbar_device_names.begin();
+         crossbar_device_it != crossbar_device_names.end();
+         ++crossbar_device_it) {
+      const std::string& crossbar_device_model = crossbar_device_it->GetModel();
+      for (Names::const_iterator device_it = device_names->begin();
+           device_it != device_names->end(); ++device_it) {
+        if (crossbar_device_model == device_it->GetModel()) {
+          crossbar_device_it->set_capabilities_id(device_it->id());
+          device_names->push_back(*crossbar_device_it);
+          break;
+        }
+      }
+    }
+  }
 }
 
 void VideoCaptureDeviceFactoryWin::GetDeviceSupportedFormats(
     const Name& device,
     VideoCaptureFormats* formats) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (use_media_foundation_)
     GetDeviceSupportedFormatsMediaFoundation(device, formats);
   else
     GetDeviceSupportedFormatsDirectShow(device, formats);
 }
 
 }  // namespace media