Win Video Capture: add support for WDM capture devices using a WDM Crossbar filter.

media/video/capture/win/video_capture_device_win.cc

 // Copyright (c) 2012 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_win.h"
 
 #include <ks.h>
 #include <ksmedia.h>
 
 #include <algorithm>
 #include <list>
 
+#include "base/strings/string_tokenizer.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/win/scoped_co_mem.h"
 #include "base/win/scoped_variant.h"
 #include "media/video/capture/win/video_capture_device_mf_win.h"
 
 using base::win::ScopedCoMem;
 using base::win::ScopedComPtr;
 using base::win::ScopedVariant;
 
 namespace media {
 
-// Finds and creates a DirectShow Video Capture filter matching the device_name.
+// Tries to find a |device_id| of class |device_class_id|. For this, it
+// enumerates all system devices of the given class and does a string comparison
+// of its |property_name| tag. This comparison can be exact or substring-wise
+// depending on |exact_name_comparison|.  If such a device is found, a moniker
+// to it is returned.
 // static
-HRESULT VideoCaptureDeviceWin::GetDeviceFilter(const std::string& device_id,
-                                               IBaseFilter** filter) {
-  DCHECK(filter);
+ScopedComPtr<IMoniker> FindDeviceAndReturnMoniker(const std::string& device_id,
+                                                  const CLSID device_class_id,
+                                                  const wchar_t* property_name,
+                                                  bool exact_name_comparison) {
 
+  ScopedComPtr<IMoniker> moniker;
   ScopedComPtr<ICreateDevEnum> dev_enum;
   HRESULT hr = dev_enum.CreateInstance(CLSID_SystemDeviceEnum, NULL,
                                        CLSCTX_INPROC);
+  DPLOG_IF(ERROR, FAILED(hr)) << "Create SystemDeviceEnum";
   if (FAILED(hr))
-    return hr;
+    return moniker;
 
   ScopedComPtr<IEnumMoniker> enum_moniker;
-  hr = dev_enum->CreateClassEnumerator(CLSID_VideoInputDeviceCategory,
+  hr = dev_enum->CreateClassEnumerator(device_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.
+  // CreateClassEnumerator returns S_FALSE on some Windows OS when no camera
+  // exist. Therefore the FAILED macro can't be used.
+  DPLOG_IF(ERROR, hr != S_OK) << "CreateClassEnumerator";
   if (hr != S_OK)
-    return NULL;
+    return moniker;
 
-  ScopedComPtr<IMoniker> moniker;
-  ScopedComPtr<IBaseFilter> capture_filter;
   DWORD fetched = 0;
   while (enum_moniker->Next(1, moniker.Receive(), &fetched) == S_OK) {
     ScopedComPtr<IPropertyBag> prop_bag;
     hr = moniker->BindToStorage(0, 0, IID_IPropertyBag, prop_bag.ReceiveVoid());
     if (FAILED(hr)) {
       moniker.Release();
       continue;
     }
 
-    // Find the device via DevicePath, Description or FriendlyName, whichever is
-    // available first.
-    static const wchar_t* kPropertyNames[] = {
-      L"DevicePath", L"Description", L"FriendlyName"
-    };
     ScopedVariant name;
-    for (size_t i = 0;
-         i < arraysize(kPropertyNames) && name.type() != VT_BSTR; ++i) {
-      prop_bag->Read(kPropertyNames[i], name.Receive(), 0);
-    }
+    prop_bag->Read(property_name, name.Receive(), 0);
+
     if (name.type() == VT_BSTR) {
       std::string device_path(base::SysWideToUTF8(V_BSTR(&name)));
-      if (device_path.compare(device_id) == 0) {
-        // We have found the requested device
-        hr = moniker->BindToObject(0, 0, IID_IBaseFilter,
-                                   capture_filter.ReceiveVoid());
-        DLOG_IF(ERROR, FAILED(hr)) << "Failed to bind camera filter: "
-                                   << logging::SystemErrorCodeToString(hr);
-        break;
+      if ((exact_name_comparison && device_path.compare(device_id) == 0) ||

[perkj_chrome, 2014/09/05 15:04:21]

device_path == device_id

[mcasas, 2014/09/08 09:16:30]

Done.

+          (!exact_name_comparison && (device_path.find(device_id)

[perkj_chrome, 2014/09/05 15:04:21]

nit 

(!exact_name_comparison && 
 (device_path.find(device_id) != std::string::npos))

[mcasas, 2014/09/08 09:16:30]

Done.

+              != std::string::npos))) {
+        return moniker;
       }
     }
     moniker.Release();
   }
+  return moniker;
+}
 
-  *filter = capture_filter.Detach();
-  if (!*filter && SUCCEEDED(hr))
-    hr = HRESULT_FROM_WIN32(ERROR_NOT_FOUND);
+// Finds and creates a DirectShow Video Capture filter matching the device_name.
+// |class_id| is usually CLSID_VideoInputDeviceCategory for standard DirectShow
+// device but might also be AM_KSCATEGORY_CAPTURE or AM_KSCATEGORY_CROSSBAR, to
+// enumerate WDM capture devices or WDM crossbars, respectively.
+// static
+HRESULT VideoCaptureDeviceWin::GetDeviceFilter(const std::string& device_id,
+                                               const CLSID device_class_id,
+                                               IBaseFilter** filter) {
+  DCHECK(filter);
+  const bool kExactNameComparison = true;
+  ScopedComPtr<IMoniker> moniker;
 
-  return hr;
+  static const wchar_t* kPropertyNames[] = {
+    L"DevicePath", L"Description", L"FriendlyName"
+  };
+  for (size_t i = 0; i < arraysize(kPropertyNames); ++i) {
+    moniker = FindDeviceAndReturnMoniker(device_id, device_class_id,
+        kPropertyNames[i], kExactNameComparison);
+    if (!moniker)
+      continue;
+    ScopedComPtr<IBaseFilter> capture_filter;
+    HRESULT hr = moniker->BindToObject(0, 0, IID_IBaseFilter,
+                                       capture_filter.ReceiveVoid());
+    *filter = capture_filter.Detach();
+    return hr && (!*filter ? E_FAIL : S_OK);

[perkj_chrome, 2014/09/05 15:04:21]

This looks dangerous and hard to read.  I don't think you should call 
capture_filter.Detach() if moniker->BindToObject fails right? 

Can capture_filter.Detach() fail? If so can you keep the old code for generating
the error.

[mcasas, 2014/09/08 09:16:31]

Reverted to previous code.

+  }
+  DLOG(ERROR) << "Failed to find device " << device_id;
+  return E_FAIL;
 }
 
 // Check if a Pin matches a category.
 // static
 bool VideoCaptureDeviceWin::PinMatchesCategory(IPin* pin, REFGUID category) {
   DCHECK(pin);
   bool found = false;
   ScopedComPtr<IKsPropertySet> ks_property;
   HRESULT hr = ks_property.QueryFrom(pin);
   if (SUCCEEDED(hr)) {
@@ skipping 117 matching lines @@
     if (sink_filter_) {
       graph_builder_->RemoveFilter(sink_filter_);
       sink_filter_ = NULL;
     }
 
     if (capture_filter_)
       graph_builder_->RemoveFilter(capture_filter_);
 
     if (mjpg_filter_)
       graph_builder_->RemoveFilter(mjpg_filter_);
+
+    if(crossbar_filter_)
+      graph_builder_->RemoveFilter(crossbar_filter_);
   }
 }
 
 bool VideoCaptureDeviceWin::Init() {
   DCHECK(CalledOnValidThread());
-  HRESULT hr = GetDeviceFilter(device_name_.id(), capture_filter_.Receive());
+  HRESULT hr;
+
+  if (device_name_.capture_api_type() == Name::DIRECT_SHOW_WDM_CROSSBAR) {
+    hr = InstantiateWDMFiltersAndPins();
+  } else {
+    hr = GetDeviceFilter(device_name_.id(), CLSID_VideoInputDeviceCategory,
+                         capture_filter_.Receive());
+  }
   if (!capture_filter_) {
-    DLOG(ERROR) << "Failed to create capture filter: "
-                << logging::SystemErrorCodeToString(hr);
+    DVLOG(2) << "Failed to create capture filter.";
     return false;
   }
 
   output_capture_pin_ =
       GetPin(capture_filter_, PINDIR_OUTPUT, PIN_CATEGORY_CAPTURE);
   if (!output_capture_pin_) {
-    DLOG(ERROR) << "Failed to get capture output pin";
+    DVLOG(2) << "Failed to get capture output pin";
     return false;
   }
 
   // Create the sink filter used for receiving Captured frames.
   sink_filter_ = new SinkFilter(this);
   if (sink_filter_ == NULL) {
-    DLOG(ERROR) << "Failed to create send filter";
+    DVLOG(2) << "Failed to create send filter";
     return false;
   }
 
   input_sink_pin_ = sink_filter_->GetPin(0);
 
   hr = graph_builder_.CreateInstance(CLSID_FilterGraph, NULL,
                                      CLSCTX_INPROC_SERVER);
   if (FAILED(hr)) {
-    DLOG(ERROR) << "Failed to create graph builder: "
-                << logging::SystemErrorCodeToString(hr);
+    DVLOG(2) << "Failed to create graph builder.";
     return false;
   }
 
   hr = graph_builder_.QueryInterface(media_control_.Receive());
   if (FAILED(hr)) {
-    DLOG(ERROR) << "Failed to create media control builder: "
-                << logging::SystemErrorCodeToString(hr);
+    DVLOG(2) << "Failed to create media control builder.";
     return false;
   }
 
   hr = graph_builder_->AddFilter(capture_filter_, NULL);
   if (FAILED(hr)) {
-    DLOG(ERROR) << "Failed to add the capture device to the graph: "
-                << logging::SystemErrorCodeToString(hr);
+    DVLOG(2) << "Failed to add the capture device to the graph.";
+    return false;
+  }
+
+  if (device_name_.capture_api_type() == Name::DIRECT_SHOW_WDM_CROSSBAR &&
+      FAILED(AddWDMCrossbarFilterToGraphAndConnect())) {
+    DVLOG(2)<< "Failed to add/connect the WDM Crossbar filter to the graph.";
     return false;
   }
 
   hr = graph_builder_->AddFilter(sink_filter_, NULL);
   if (FAILED(hr)) {
-    DLOG(ERROR) << "Failed to add the send filter to the graph: "
-                << logging::SystemErrorCodeToString(hr);
+    DVLOG(2)<< "Failed to add the send filter to the graph.";
     return false;
   }
 
   return CreateCapabilityMap();
 }
 
 void VideoCaptureDeviceWin::AllocateAndStart(
     const VideoCaptureParams& params,
     scoped_ptr<VideoCaptureDevice::Client> client) {
   DCHECK(CalledOnValidThread());
@@ skipping 131 matching lines @@
   }
 
   graph_builder_->Disconnect(output_capture_pin_);
   graph_builder_->Disconnect(input_sink_pin_);
 
   // If the _mjpg filter exist disconnect it even if it has not been used.
   if (mjpg_filter_) {
     graph_builder_->Disconnect(input_mjpg_pin_);
     graph_builder_->Disconnect(output_mjpg_pin_);
   }
+  if (crossbar_filter_) {
+    graph_builder_->Disconnect(analog_video_input_pin_);
+    graph_builder_->Disconnect(crossbar_video_output_pin_);
+  }
 
   if (FAILED(hr)) {
     SetErrorState("Failed to Stop the Capture device");
     return;
   }
   client_.reset();
   state_ = kIdle;
 }
 
 // Implements SinkFilterObserver::SinkFilterObserver.
 void VideoCaptureDeviceWin::FrameReceived(const uint8* buffer,
                                           int length) {
   client_->OnIncomingCapturedData(
       buffer, length, capture_format_, 0, base::TimeTicks::Now());
 }
 
 bool VideoCaptureDeviceWin::CreateCapabilityMap() {
   DCHECK(CalledOnValidThread());
   ScopedComPtr<IAMStreamConfig> stream_config;
   HRESULT hr = output_capture_pin_.QueryInterface(stream_config.Receive());
   if (FAILED(hr)) {
-    DPLOG(ERROR) << "Failed to get IAMStreamConfig interface from "
-                    "capture device: " << logging::SystemErrorCodeToString(hr);
+    DVLOG(2) << "Failed to get IAMStreamConfig interface from "
+                "capture device";
     return false;
   }
 
   // Get interface used for getting the frame rate.
   ScopedComPtr<IAMVideoControl> video_control;
   hr = capture_filter_.QueryInterface(video_control.Receive());
-  DLOG_IF(WARNING, FAILED(hr)) << "IAMVideoControl Interface NOT SUPPORTED: "
-                               << logging::SystemErrorCodeToString(hr);
+  DVLOG_IF(2, FAILED(hr)) << "IAMVideoControl Interface NOT SUPPORTED";
 
   int count = 0, size = 0;
   hr = stream_config->GetNumberOfCapabilities(&count, &size);
   if (FAILED(hr)) {
-    DLOG(ERROR) << "Failed to GetNumberOfCapabilities: "
-                << logging::SystemErrorCodeToString(hr);
+    DVLOG(2) << "Failed to GetNumberOfCapabilities";
     return false;
   }
 
   scoped_ptr<BYTE[]> caps(new BYTE[size]);
   for (int i = 0; i < count; ++i) {
     ScopedMediaType media_type;
     hr = stream_config->GetStreamCaps(i, media_type.Receive(), caps.get());
     // GetStreamCaps() may return S_FALSE, so don't use FAILED() or SUCCEED()
     // macros here since they'll trigger incorrectly.
     if (hr != S_OK) {
-      DLOG(ERROR) << "Failed to GetStreamCaps: "
-                  << logging::SystemErrorCodeToString(hr);
+      DVLOG(2) << "Failed to GetStreamCaps";
       return false;
     }
 
     if (media_type->majortype == MEDIATYPE_Video &&
         media_type->formattype == FORMAT_VideoInfo) {
       VideoCaptureCapabilityWin capability(i);
       capability.supported_format.pixel_format =
           TranslateMediaSubtypeToPixelFormat(media_type->subtype);
       if (capability.supported_format.pixel_format == PIXEL_FORMAT_UNKNOWN)
         continue;
@@ skipping 61 matching lines @@
       (type_support & KSPROPERTY_SUPPORT_SET)) {
     KSPROPERTY_VIDEOPROCAMP_S data = {};
     data.Property.Set = PROPSETID_VIDCAP_VIDEOPROCAMP;
     data.Property.Id = KSPROPERTY_VIDEOPROCAMP_POWERLINE_FREQUENCY;
     data.Property.Flags = KSPROPERTY_TYPE_SET;
     data.Value = (power_line_frequency == kPowerLine50Hz) ? 1 : 2;
     data.Flags = KSPROPERTY_VIDEOPROCAMP_FLAGS_MANUAL;
     hr = ks_propset->Set(PROPSETID_VIDCAP_VIDEOPROCAMP,
                          KSPROPERTY_VIDEOPROCAMP_POWERLINE_FREQUENCY,
                          &data, sizeof(data), &data, sizeof(data));
-    DLOG_IF(ERROR, FAILED(hr)) << "Anti-flicker setting failed: "
-                               << logging::SystemErrorCodeToString(hr);
+    DVLOG_IF(ERROR, FAILED(hr)) << "Anti-flicker setting failed.";
     DVLOG_IF(2, SUCCEEDED(hr)) << "Anti-flicker set correctly.";
   } else {
     DVLOG(2) << "Anti-flicker setting not supported.";
   }
 }
 
+

[mcasas, 2014/09/08 09:16:31]

nit: remove extra line.

+// Instantiate a WDM Crossbar Filter and the associated WDM Capture Filter,
+// extract the correct pins from each. The necessary pins are device specific

[perkj_chrome, 2014/09/05 15:04:21]

This is confusing sentence to read and saying that its expertmental scares me.

[mcasas, 2014/09/08 09:16:30]

Rewritten.

+// but, experimentally, they usually are the first Crossbar output pin and the
+// first Capture input pin.
+HRESULT VideoCaptureDeviceWin::InstantiateWDMFiltersAndPins() {
+  ScopedComPtr<IMoniker> crossbar_moniker = FindDeviceAndReturnMoniker(
+      device_name_.name(), AM_KSCATEGORY_CROSSBAR, L"FriendlyName", false);

[perkj_chrome, 2014/09/05 15:04:21]

Which filter uses the device_name.id() ? Ie, what if you have two capture cards
installed? 

[mcasas, 2014/09/08 09:16:30]

You're right, here I should search for the exact device.id(),
which is unique.

+  if (!crossbar_moniker)
+    return E_FAIL;
+
+  HRESULT hr = crossbar_moniker->BindToObject(0, 0, IID_IBaseFilter,
+                                              crossbar_filter_.ReceiveVoid());
+  DPLOG_IF(ERROR, FAILED(hr)) << "Failed to bind crossbar filter";

[perkj_chrome, 2014/09/05 15:04:21]

nit: can we remove one of this log lines and only log the error case. 

[mcasas, 2014/09/08 09:16:30]

Done.

+  DVLOG_IF(1, SUCCEEDED(hr)) << "Crossbar filter instantiated OK.";
+  if (FAILED(hr) || !crossbar_filter_)
+    return E_FAIL;
+
+  // Find Crossbar Video Output Pin: This is usually the first output pin.
+  crossbar_video_output_pin_ = GetPin(
+      crossbar_filter_, PINDIR_OUTPUT, GUID_NULL);

[perkj_chrome, 2014/09/05 15:04:21]

GetPin finds the first output pin right? Isn't there a pin type you can check as
well?

[mcasas, 2014/09/08 09:16:31]

I'm afraid not. I printed out all Crossbar Pin types
and they are empty just like for the MJPEG filter[1];
you are most welcome to double check in GraphEdit.


[1]
https://code.google.com/p/chromium/codesearch#chromium/src/media/video/captur...

+  DLOG_IF(ERROR, !crossbar_video_output_pin_)
+      << "Failed to find Crossbar Video Output pin";
+  DVLOG_IF(1, crossbar_video_output_pin_)

[perkj_chrome, 2014/09/05 15:04:21]

dito - please remove one log line.

[mcasas, 2014/09/08 09:16:31]

Done.

+      << "Crossbar Video Output pin created OK.";
+  if (!crossbar_video_output_pin_)
+    return E_FAIL;
+
+  // Find the WDM capture filter associated to the WDM Crossbar filter. This
+  // is a fuzzy matching: they have similar names to the naked eye. Empirically,
+  // use the words of the Crossbar Filter name one by one; they are usually
+  // Vendor, Chip model etc to search in the WDM Filters list.
+  base::StringTokenizer t(device_name_.name(), " ");
+  ScopedComPtr<IMoniker> wdm_source_moniker;
+  while (!wdm_source_moniker && t.GetNext()) {
+    wdm_source_moniker = FindDeviceAndReturnMoniker(
+        t.token(), AM_KSCATEGORY_CAPTURE, L"FriendlyName", false);
+  }
+  DLOG_IF(ERROR, wdm_source_moniker) << "Couldn't find WDM device named";
+  if (!wdm_source_moniker)
+    return E_FAIL;
+
+  hr = wdm_source_moniker->BindToObject(0, 0, IID_IBaseFilter,
+                                        capture_filter_.ReceiveVoid());
+  DPLOG_IF(ERROR, FAILED(hr)) << "Failed to bind WDM filter";
+  DVLOG_IF(1, SUCCEEDED(hr)) << "WDM filter instantiated OK.";

[perkj_chrome, 2014/09/05 15:04:21]

dito

[mcasas, 2014/09/08 09:16:30]

Done.

(Removed all the positive cases' logging).

+  if (FAILED(hr) || !capture_filter_)
+    return E_FAIL;
+
+  // Find the WDM Capture Filter's Analog Video input Pin: usually the first
+  // input pin.
+  analog_video_input_pin_ = GetPin(capture_filter_, PINDIR_INPUT, GUID_NULL);
+  DLOG_IF(ERROR, !analog_video_input_pin_) << "Failed to find WDM Video Input";
+  DVLOG_IF(1, analog_video_input_pin_) << "WDM Video Input pin created OK.";
+  if (!analog_video_input_pin_)
+    return E_FAIL;
+  return S_OK;
+}
+
+// Add the WDM Crossbar filter to the Graph and connect the pins previously
+// found.
+HRESULT VideoCaptureDeviceWin::AddWDMCrossbarFilterToGraphAndConnect() {
+  HRESULT hr = graph_builder_->AddFilter(crossbar_filter_, NULL);
+  DPLOG_IF(ERROR, FAILED(hr)) << "Failed to add Crossbar filter to the graph";
+  DVPLOG_IF(1, SUCCEEDED(hr)) << "Crossbar filter added OK to the graph";
+  if (FAILED(hr))
+    return E_FAIL;
+
+  hr = graph_builder_->ConnectDirect(
+      crossbar_video_output_pin_, analog_video_input_pin_, NULL);
+  DPLOG_IF(ERROR, FAILED(hr)) << "Failed to plug WDM filters to each other";
+  DVPLOG_IF(1, SUCCEEDED(hr)) << "WDM filters plugged OK";
+  if (FAILED(hr))
+    return E_FAIL;
+  return S_OK;
+}
+
 void VideoCaptureDeviceWin::SetErrorState(const std::string& reason) {
   DCHECK(CalledOnValidThread());
+  DVLOG(1) << reason;
   state_ = kError;
   client_->OnError(reason);
 }
 }  // namespace media