Reconnect support for DirectShow video capture devices in parallel to MediaFoundation ones.

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 <algorithm>
 #include <list>
 
 #include "base/strings/string_util.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/win/scoped_variant.h"
 #include "media/video/capture/win/video_capture_device_mf_win.h"
 
 using base::win::ScopedComPtr;
 using base::win::ScopedVariant;
 
 namespace {
 
+enum DeviceDriverType {
+  kDirectShow,  // DirectShow driver type

[tommi (sloooow) - chröme, 2013/06/24 11:09:27]

Some style issues but since we're switching on the API used and not necessarily
the device driver type (they both support UVC, right?), what about something
like:

enum CaptureApiType {
  DIRECT_SHOW,
  MEDIA_FOUNDATION,
};

[mcasas, 2013/06/25 07:04:36]

Done.

+  kMF,  // Media Foundation type
+};
+// Type of Device Driver (DirectShow, MediaFoundation) map and attribute.
+typedef std::map<std::string, DeviceDriverType> DeviceDriverTypeMap;
+DeviceDriverTypeMap device_driver_type_;

[tommi (sloooow) - chröme, 2013/06/24 11:09:27]

sorry, no global variables that require construction.  This impacts Chrome's
startup cost and the cl would be reverted due to breaking the performance bots
(we actually keep count of how many global variables we allow, so adding one
more breaks the build).

Btw, naming of global variables differ from naming of member variables.  should
be g_device_driver_type.

[mcasas, 2013/06/25 07:04:36]

All right, quote our conversation later on, it should be gone.

+

[tommi (sloooow) - chröme, 2013/06/24 11:09:27]

nit: one empty line

[mcasas, 2013/06/25 07:04:36]

Done.

+
 // Finds and creates a DirectShow Video Capture filter matching the device_name.
 HRESULT GetDeviceFilter(const media::VideoCaptureDevice::Name& device_name,
                         IBaseFilter** filter) {
   DCHECK(filter);
 
   ScopedComPtr<ICreateDevEnum> dev_enum;
   HRESULT hr = dev_enum.CreateInstance(CLSID_SystemDeviceEnum, NULL,
                                        CLSCTX_INPROC);
   if (FAILED(hr))
     return hr;
@@ skipping 112 matching lines @@
     CoTaskMemFree(mt);
   }
 }
 
 }  // namespace
 
 namespace media {
 
 // static
 void VideoCaptureDevice::GetDeviceNames(Names* device_names) {
+  Names::iterator it;
+
   if (VideoCaptureDeviceMFWin::PlatformSupported()) {
     VideoCaptureDeviceMFWin::GetDeviceNames(device_names);
-  } else {
-    VideoCaptureDeviceWin::GetDeviceNames(device_names);
+    it = device_names->begin();
+    for (; it != device_names->end(); ++it)
+      device_driver_type_[it->unique_id] = kMF;

[tommi (sloooow) - chröme, 2013/06/24 11:09:27]

instead of the global map, what do you think about moving the enum into the
Names structure (it's ok to make it #ifdef'ed for Windows) and store the API
type as a member of that structure?
I think that should make this a bit simpler and avoid having to do any operator
overloading etc.

[mcasas, 2013/06/25 07:04:36]

I added the Capture Api type to VideoCaptureDevice::Name, for OS_WIN compilation
only. However, the gap between GetDeviceNames() and Create() cannot be easily
jumped since VideoCaptureManager,     "parent" of VideoCaptureDeviceWin, cherry
picks attributes from the mentioned struct Name, instead of copying it all, and
stores them into a StreamDeviceInfo Array, and it would get very ugly if OS_WIN
parts would proliferate...

+  }
+  // Retrieve the devices with DirectShow interface. They might (partially)
+  // overlap, so the list has to be consolidated.
+  Names temp_names;
+  VideoCaptureDeviceWin::GetDeviceNames(&temp_names);
+
+  // We need to merge the DS devices into the MF device list, and next remove
+  // the duplicates, giving priority to the MF "versions".
+  device_names->merge(temp_names);
+  device_names->unique();
+
+  it = device_names->begin();
+  // Walk the device_names list and mark those not found in device_driver_
+  for (; it != device_names->end(); ++it) {
+    if (device_driver_type_.find(it->unique_id) == device_driver_type_.end())
+      device_driver_type_[it->unique_id] = kDirectShow;
+  }
+
+  it = device_names->begin();
+  for (; it != device_names->end(); ++it) {
+    DLOG(WARNING)
+        << " Device " << it->unique_id << " is of type"
+        << ((device_driver_type_[it->unique_id] == kMF) ? "MediaFoundation"
+                                                        : "DirectShow");
   }
 }
 
 // static
 VideoCaptureDevice* VideoCaptureDevice::Create(const Name& device_name) {
   VideoCaptureDevice* ret = NULL;
-  if (VideoCaptureDeviceMFWin::PlatformSupported()) {
+  if (device_driver_type_.find(device_name.unique_id) !=
+         device_driver_type_.end())
+    return ret;
+
+  if (device_driver_type_[device_name.unique_id] == kMF) {
     scoped_ptr<VideoCaptureDeviceMFWin> device(
         new VideoCaptureDeviceMFWin(device_name));
     if (device->Init())
       ret = device.release();
-  } else {
+  } else if (device_driver_type_[device_name.unique_id] == kDirectShow) {
     scoped_ptr<VideoCaptureDeviceWin> device(
         new VideoCaptureDeviceWin(device_name));
     if (device->Init())
       ret = device.release();
+  } else {
+    DLOG(ERROR) << "Couldn't recognize VideoCaptureDevice type!";
   }
-
   return ret;
 }
 
 // static
 void VideoCaptureDeviceWin::GetDeviceNames(Names* device_names) {
   DCHECK(device_names);
 
   ScopedComPtr<ICreateDevEnum> dev_enum;
   HRESULT hr = dev_enum.CreateInstance(CLSID_SystemDeviceEnum, NULL,
                                        CLSCTX_INPROC);
@@ skipping 384 matching lines @@
         capability.color = VideoCaptureCapability::kI420;
       } else if (media_type->subtype == MEDIASUBTYPE_IYUV) {
         // This is identical to kI420.
         capability.color = VideoCaptureCapability::kI420;
       } else if (media_type->subtype == MEDIASUBTYPE_RGB24) {
         capability.color = VideoCaptureCapability::kRGB24;
       } else if (media_type->subtype == MEDIASUBTYPE_YUY2) {
         capability.color = VideoCaptureCapability::kYUY2;
       } else if (media_type->subtype == MEDIASUBTYPE_MJPG) {
         capability.color = VideoCaptureCapability::kMJPEG;
+      } else if (media_type->subtype == MEDIASUBTYPE_UYVY) {
+        capability.color = VideoCaptureCapability::kUYVY;
+      } else if (media_type->subtype == MEDIASUBTYPE_ARGB32) {
+        capability.color = VideoCaptureCapability::kARGB;
       } else {
         WCHAR guid_str[128];
         StringFromGUID2(media_type->subtype, guid_str, arraysize(guid_str));
         DVLOG(2) << "Device support unknown media type " << guid_str;
         continue;
       }
       capabilities_.Add(capability);
     }
     DeleteMediaType(media_type);
     media_type = NULL;
   }
 
   return !capabilities_.empty();
 }
 
 void VideoCaptureDeviceWin::SetErrorState(const char* reason) {
   DCHECK(CalledOnValidThread());
   DVLOG(1) << reason;
   state_ = kError;
   observer_->OnError();
 }
-
 }  // namespace media