Change class VideoCaptureDevice::Name to struct VideoCaptureDeviceDescriptor

media/capture/video/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/capture/video/win/video_capture_device_factory_win.h"
 
 #include <mfapi.h>
 #include <mferror.h>
 #include <stddef.h>
 
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_util.h"
 #include "base/strings/sys_string_conversions.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/base/win/mf_initializer.h"
 #include "media/capture/video/win/video_capture_device_mf_win.h"
 #include "media/capture/video/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;
+using Descriptor = media::VideoCaptureDeviceDescriptor;
+using Descriptors = media::VideoCaptureDeviceDescriptors;
 
 namespace media {
 
+// In Windows device identifiers, the USB VID and PID are preceded by the string
+// "vid_" or "pid_".  The identifiers are each 4 bytes long.
+const char kVidPrefix[] = "vid_";  // Also contains '\0'.
+const char kPidPrefix[] = "pid_";  // Also contains '\0'.
+const size_t kVidPidSize = 4;

[mcasas, 2016/07/26 23:52:04]

Maybe we can use arraysize() here? (It might
need |kVidPrefix|, |kPidPrefix| to be static).

Otherwise, add DCHECK_EQ(sizeof(bla) - 1, bla);
where you use these, to catch regressions down the
line.

https://cs.chromium.org/chromium/src/third_party/webrtc/base/arraysize.h?dr=S...

[chfremer, 2016/07/27 23:10:18]

By "here" do you mean on the right hand sight of line 36?
It seems the number 4 is referring to the size of the identifiers, not the size
of the prefixes (which also happen to be 4 bytes long).

[mcasas, 2016/07/28 00:05:42]

Oh I see :)
What about calling l.36 |kVidPidFieldSize| ?

Also, consider using arraysize(kVidPrefix) (resp., |kPidPrefix|)
since arraysize is a compile-time constant (but might need
the variable to be static, don't remember exactly).
 

+
 // Avoid enumerating and/or using certain devices due to they provoking crashes
 // or any other reason (http://crbug.com/378494). This enum is defined for the
 // purposes of UMA collection. Existing entries cannot be removed.
 enum BlacklistedCameraNames {
   BLACKLISTED_CAMERA_GOOGLE_CAMERA_ADAPTER = 0,
   BLACKLISTED_CAMERA_IP_CAMERA = 1,
   BLACKLISTED_CAMERA_CYBERLINK_WEBCAM_SPLITTER = 2,
   BLACKLISTED_CAMERA_EPOCCAM = 3,
   // This one must be last, and equal to the previous enumerated value.
   BLACKLISTED_CAMERA_MAX = BLACKLISTED_CAMERA_EPOCCAM,
 };
 
 // Blacklisted devices are identified by a characteristic prefix of the name.
 // This prefix is used case-insensitively. This list must be kept in sync with
 // |BlacklistedCameraNames|.
 static const char* const kBlacklistedCameraNames[] = {
     // Name of a fake DirectShow filter on computers with GTalk installed.
     "Google Camera Adapter",
     // The following software WebCams cause crashes.
-    "IP Camera [JPEG/MJPEG]",
-    "CyberLink Webcam Splitter",
-    "EpocCam",
+    "IP Camera [JPEG/MJPEG]", "CyberLink Webcam Splitter", "EpocCam",
 };
 static_assert(arraysize(kBlacklistedCameraNames) == BLACKLISTED_CAMERA_MAX + 1,
               "kBlacklistedCameraNames should be same size as "
               "BlacklistedCameraNames enum");
 
 static bool LoadMediaFoundationDlls() {
   static const wchar_t* const kMfDLLs[] = {
       L"%WINDIR%\\system32\\mf.dll",
       L"%WINDIR%\\system32\\mfplat.dll",
       L"%WINDIR%\\system32\\mfreadwrite.dll",
@@ skipping 51 matching lines @@
                          base::CompareCase::INSENSITIVE_ASCII)) {
       DVLOG(1) << "Enumerated blacklisted device: " << name;
       UMA_HISTOGRAM_ENUMERATION("Media.VideoCapture.BlacklistedDevice", i,
                                 BLACKLISTED_CAMERA_MAX + 1);
       return true;
     }
   }
   return false;
 }
 
-static void GetDeviceNamesDirectShow(Names* device_names) {
-  DCHECK(device_names);
-  DVLOG(1) << " GetDeviceNamesDirectShow";
+static void GetDeviceDescriptorsDirectShow(Descriptors* device_descriptors) {
+  DCHECK(device_descriptors);
+  DVLOG(1) << __FUNCTION__;
 
   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 26 matching lines @@
 
     name.Reset();
     hr = prop_bag->Read(L"DevicePath", name.Receive(), 0);
     std::string id;
     if (FAILED(hr) || name.type() != VT_BSTR) {
       id = device_name;
     } else {
       DCHECK_EQ(name.type(), VT_BSTR);
       id = base::SysWideToUTF8(V_BSTR(name.ptr()));
     }
-    device_names->push_back(Name(device_name, id, Name::DIRECT_SHOW));
+    device_descriptors->emplace_back(device_name, id,
+                                     VideoCaptureApiType::WINDOWS_DIRECT_SHOW);
   }
 }
 
-static void GetDeviceNamesMediaFoundation(Names* device_names) {
-  DVLOG(1) << " GetDeviceNamesMediaFoundation";
+static void GetDeviceDescriptorsMediaFoundation(
+    Descriptors* device_descriptors) {
+  DVLOG(1) << " GetDeviceDescriptorsMediaFoundation";
   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(
-            Name(base::SysWideToUTF8(std::wstring(name, name_size)),
-                 base::SysWideToUTF8(std::wstring(id, id_size)),
-                 Name::MEDIA_FOUNDATION));
+        device_descriptors->emplace_back(
+            base::SysWideToUTF8(std::wstring(name, name_size)),
+            base::SysWideToUTF8(std::wstring(id, id_size)),
+            VideoCaptureApiType::WINDOWS_MEDIA_FOUNDATION);
       }
     }
     DLOG_IF(ERROR, FAILED(hr)) << "GetAllocatedString failed: "
                                << logging::SystemErrorCodeToString(hr);
     devices[i]->Release();
   }
 }
 
-static void GetDeviceSupportedFormatsDirectShow(const Name& device,
+static void GetDeviceSupportedFormatsDirectShow(const Descriptor& descriptor,
                                                 VideoCaptureFormats* formats) {
-  DVLOG(1) << "GetDeviceSupportedFormatsDirectShow for " << device.name();
+  DVLOG(1) << "GetDeviceSupportedFormatsDirectShow for "
+           << descriptor.friendly_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);
   // 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 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.capabilities_id(),
+  hr = VideoCaptureDeviceWin::GetDeviceFilter(descriptor.device_id,
                                               capture_filter.Receive());
   if (!capture_filter.get()) {
     DLOG(ERROR) << "Failed to create capture filter: "
                 << logging::SystemErrorCodeToString(hr);
     return;
   }
 
   base::win::ScopedComPtr<IPin> output_capture_pin(
       VideoCaptureDeviceWin::GetPin(capture_filter.get(), PINDIR_OUTPUT,
                                     PIN_CATEGORY_CAPTURE, GUID_NULL));
@@ skipping 40 matching lines @@
         continue;
       VIDEOINFOHEADER* h =
           reinterpret_cast<VIDEOINFOHEADER*>(media_type->pbFormat);
       format.frame_size.SetSize(h->bmiHeader.biWidth, h->bmiHeader.biHeight);
       // Trust the frame rate from the VIDEOINFOHEADER.
       format.frame_rate =
           (h->AvgTimePerFrame > 0)
               ? kSecondsToReferenceTime / static_cast<float>(h->AvgTimePerFrame)
               : 0.0f;
       formats->push_back(format);
-      DVLOG(1) << device.name() << " " << VideoCaptureFormat::ToString(format);
+      DVLOG(1) << descriptor.friendly_name << " "
+               << VideoCaptureFormat::ToString(format);
     }
   }
 }
 
 static void GetDeviceSupportedFormatsMediaFoundation(
-    const Name& device,
+    const Descriptor& descriptor,
     VideoCaptureFormats* formats) {
-  DVLOG(1) << "GetDeviceSupportedFormatsMediaFoundation for " << device.name();
+  DVLOG(1) << "GetDeviceSupportedFormatsMediaFoundation for "
+           << descriptor.friendly_name;
   ScopedComPtr<IMFMediaSource> source;
-  if (!CreateVideoCaptureDeviceMediaFoundation(device.id().c_str(),
+  if (!CreateVideoCaptureDeviceMediaFoundation(descriptor.device_id.c_str(),
                                                source.Receive())) {
     return;
   }
 
   base::win::ScopedComPtr<IMFSourceReader> reader;
   HRESULT hr =
       MFCreateSourceReaderFromMediaSource(source.get(), NULL, reader.Receive());
   if (FAILED(hr)) {
     DLOG(ERROR) << "MFCreateSourceReaderFromMediaSource failed: "
                 << logging::SystemErrorCodeToString(hr);
@@ skipping 30 matching lines @@
     if (FAILED(hr)) {
       DLOG(ERROR) << "GetGUID failed: " << logging::SystemErrorCodeToString(hr);
       return;
     }
     VideoCaptureDeviceMFWin::FormatFromGuid(type_guid,
                                             &capture_format.pixel_format);
     type.Release();
     formats->push_back(capture_format);
     ++stream_index;
 
-    DVLOG(1) << device.name() << " "
+    DVLOG(1) << descriptor.friendly_name << " "
              << VideoCaptureFormat::ToString(capture_format);
   }
 }
 
 // Returns true iff the current platform supports the Media Foundation API
 // and that the DLLs are available.  On Vista this API is an optional download
 // but the API is advertised as a part of Windows 7 and onwards.  However,
 // we've seen that the required DLLs are not available in some Win7
 // distributions such as Windows 7 N and Windows 7 KN.
 // static
 bool VideoCaptureDeviceFactoryWin::PlatformSupportsMediaFoundation() {
   // Even though the DLLs might be available on Vista, we get crashes
   // when running our tests on the build bots.
   if (base::win::GetVersion() < base::win::VERSION_WIN7)
     return false;
 
   static bool g_dlls_available = LoadMediaFoundationDlls();
   return g_dlls_available;
 }
 
 VideoCaptureDeviceFactoryWin::VideoCaptureDeviceFactoryWin()
     : use_media_foundation_(base::win::GetVersion() >=
                                 base::win::VERSION_WIN7 &&
                             base::CommandLine::ForCurrentProcess()->HasSwitch(
                                 switches::kForceMediaFoundationVideoCapture)) {}
 
 std::unique_ptr<VideoCaptureDevice> VideoCaptureDeviceFactoryWin::Create(
-    const Name& device_name) {
+    const Descriptor& device_descriptor) {
   DCHECK(thread_checker_.CalledOnValidThread());
   std::unique_ptr<VideoCaptureDevice> device;
-  if (device_name.capture_api_type() == Name::MEDIA_FOUNDATION) {
+  if (device_descriptor.capture_api ==
+      VideoCaptureApiType::WINDOWS_MEDIA_FOUNDATION) {
     DCHECK(PlatformSupportsMediaFoundation());
-    device.reset(new VideoCaptureDeviceMFWin(device_name));
-    DVLOG(1) << " MediaFoundation Device: " << device_name.name();
+    device.reset(new VideoCaptureDeviceMFWin(device_descriptor));
+    DVLOG(1) << " MediaFoundation Device: " << device_descriptor.friendly_name;
     ScopedComPtr<IMFMediaSource> source;
-    if (!CreateVideoCaptureDeviceMediaFoundation(device_name.id().c_str(),
-                                                 source.Receive())) {
+    if (!CreateVideoCaptureDeviceMediaFoundation(
+            device_descriptor.device_id.c_str(), source.Receive())) {
       return std::unique_ptr<VideoCaptureDevice>();
     }
     if (!static_cast<VideoCaptureDeviceMFWin*>(device.get())->Init(source))
       device.reset();
-  } else {
-    DCHECK(device_name.capture_api_type() == Name::DIRECT_SHOW);
-    device.reset(new VideoCaptureDeviceWin(device_name));
-    DVLOG(1) << " DirectShow Device: " << device_name.name();
+  } else if (device_descriptor.capture_api ==
+             VideoCaptureApiType::WINDOWS_DIRECT_SHOW) {
+    device.reset(new VideoCaptureDeviceWin(device_descriptor));
+    DVLOG(1) << " DirectShow Device: " << device_descriptor.friendly_name;
     if (!static_cast<VideoCaptureDeviceWin*>(device.get())->Init())
       device.reset();
+  } else {
+    NOTREACHED();
   }
   return device;
 }
 
-void VideoCaptureDeviceFactoryWin::GetDeviceNames(Names* device_names) {
+void VideoCaptureDeviceFactoryWin::GetDeviceDescriptors(
+    VideoCaptureDeviceDescriptors* device_descriptors) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (use_media_foundation_)
-    GetDeviceNamesMediaFoundation(device_names);
+    GetDeviceDescriptorsMediaFoundation(device_descriptors);
   else
-    GetDeviceNamesDirectShow(device_names);
+    GetDeviceDescriptorsDirectShow(device_descriptors);
+}
+
+void VideoCaptureDeviceFactoryWin::GetDeviceInfo(
+    const VideoCaptureDeviceDescriptor& device_descriptor,
+    VideoCaptureDeviceInfo* device_info) {
+  DCHECK(device_info);
+  device_info->descriptor = device_descriptor;
+  GetDeviceSupportedFormats(device_descriptor,
+                            &(device_info->supported_formats));
+  device_info->model_id = GetDeviceModelId(device_descriptor);
 }
 
 void VideoCaptureDeviceFactoryWin::GetDeviceSupportedFormats(
-    const Name& device,
+    const Descriptor& device,
     VideoCaptureFormats* formats) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (use_media_foundation_)
+  if (use_media_foundation_) {
     GetDeviceSupportedFormatsMediaFoundation(device, formats);
-  else
+  } else {
     GetDeviceSupportedFormatsDirectShow(device, formats);
+  }
+}
+
+std::string VideoCaptureDeviceFactoryWin::GetDeviceModelId(
+    const Descriptor& device_descriptor) {
+  const size_t vid_prefix_size = sizeof(kVidPrefix) - 1;

[mcasas, 2016/07/26 23:52:04]

I thought sizeof(kVidPrefix) - 1 was called
|kVidPidSize| ?

[chfremer, 2016/07/27 23:10:18]

That also confused me at first. It is because there is a size for the prefixes
and a size for the actual vid/pid.

[mcasas, 2016/07/28 00:05:42]

Acknowledged.

+  const size_t pid_prefix_size = sizeof(kPidPrefix) - 1;
+  const size_t vid_location = device_descriptor.device_id.find(kVidPrefix);
+  if (vid_location == std::string::npos ||
+      vid_location + vid_prefix_size + kVidPidSize >
+          device_descriptor.device_id.size()) {
+    return std::string();
+  }
+  const size_t pid_location = device_descriptor.device_id.find(kPidPrefix);
+  if (pid_location == std::string::npos ||
+      pid_location + pid_prefix_size + kVidPidSize >
+          device_descriptor.device_id.size()) {
+    return std::string();
+  }
+  const std::string id_vendor = device_descriptor.device_id.substr(
+      vid_location + vid_prefix_size, kVidPidSize);
+  const std::string id_product = device_descriptor.device_id.substr(
+      pid_location + pid_prefix_size, kVidPidSize);
+  return id_vendor + ":" + id_product;
 }
 
 // static
 VideoCaptureDeviceFactory*
 VideoCaptureDeviceFactory::CreateVideoCaptureDeviceFactory(
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner) {
   return new VideoCaptureDeviceFactoryWin();
 }
 
 }  // namespace media