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"
@@ skipping 130 matching lines @@
   if (mt != NULL) {
     FreeMediaType(mt);
     CoTaskMemFree(mt);
   }
 }
 
 }  // namespace
 
 // static
 void VideoCaptureDevice::GetDeviceNames(Names* device_names) {
+  Names::iterator it;
+
   if (VideoCaptureDeviceMFWin::PlatformSupported()) {
     VideoCaptureDeviceMFWin::GetDeviceNames(device_names);
-  } else {
-    VideoCaptureDeviceWin::GetDeviceNames(device_names);
   }
+  // Retrieve the devices with DirectShow (DS) interface. They might (partially)
+  // overlap with the MediaFoundation (MF), so the list has to be consolidated.
+  Names temp_names;
+  VideoCaptureDeviceWin::GetDeviceNames(&temp_names);
+
+  // 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();
 }
 
 // static
 VideoCaptureDevice* VideoCaptureDevice::Create(const Name& device_name) {
   VideoCaptureDevice* ret = NULL;
-  if (VideoCaptureDeviceMFWin::PlatformSupported()) {
+  if ((device_name.capture_api_type() == Name::MEDIA_FOUNDATION) &&
+      VideoCaptureDeviceMFWin::PlatformSupported()) {

[tommi (sloooow) - chröme, 2013/07/03 15:27:26]

the second check shouldn't be necessary anymore so you could change this to be:

if (device_name.capture_api_type() == Name::MEDIA_FOUNDATION) {
  DCHECK(VideoCaptureDeviceMFWin::PlatformSupported());
  ...

[mcasas, 2013/07/04 10:40:42]

Done.

     scoped_ptr<VideoCaptureDeviceMFWin> device(
         new VideoCaptureDeviceMFWin(device_name));
+    DLOG(INFO) << " MediaFoundation Device: " << device_name.name();
     if (device->Init())
       ret = device.release();
-  } else {
+  } else if (device_name.capture_api_type() == Name::DIRECT_SHOW) {
     scoped_ptr<VideoCaptureDeviceWin> device(
         new VideoCaptureDeviceWin(device_name));
+    DLOG(INFO) << " DirectShow Device: " << device_name.name();

[tommi (sloooow) - chröme, 2013/07/03 15:27:26]

Change all DLOG(INFO)s to DVLOG(1).
(we don't use DLOG(INFO) anymore)

[mcasas, 2013/07/04 10:40:42]

Done.

     if (device->Init())
       ret = device.release();
+  } else{
+    NOTREACHED() << " Couldn't recognize VideoCaptureDevice type";
   }
 
   return ret;
 }
 
 // static
 void VideoCaptureDeviceWin::GetDeviceNames(Names* device_names) {
   DCHECK(device_names);
 
   ScopedComPtr<ICreateDevEnum> dev_enum;
@@ skipping 48 matching lines @@
         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));
+        device_names->push_back(Name(device_name, id, Name::DIRECT_SHOW));
       }
     }
     moniker.Release();
   }
 }
 
 VideoCaptureDeviceWin::VideoCaptureDeviceWin(const Name& device_name)
     : device_name_(device_name),
       state_(kIdle),
       observer_(NULL) {
@@ skipping 318 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;
+        DVLOG(2) << "Device supports (also) an 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