VideoCaptureDeviceWin: Extract class-static method into a Factory (both MF/DS)

media/video/capture/win/video_capture_device_factory_win.cc

-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// 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_win.h"
+#include "media/video/capture/win/video_capture_device_factory_win.h"
 
-#include <ks.h>
-#include <ksmedia.h>
-
-#include <algorithm>
-#include <list>
+#include <mfapi.h>
+#include <mferror.h>
 
 #include "base/command_line.h"
+#include "base/lazy_instance.h"
 #include "base/strings/string_util.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/win/metro.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/video/capture/win/video_capture_device_mf_win.h"
+#include "media/video/capture/win/video_capture_device_win.h"
 
 using base::win::ScopedCoMem;
 using base::win::ScopedComPtr;
 using base::win::ScopedVariant;
 
 namespace media {
-namespace {
 
-// Finds and creates a DirectShow Video Capture filter matching the device_name.
-HRESULT GetDeviceFilter(const VideoCaptureDevice::Name& device_name,
-                        IBaseFilter** filter) {
-  DCHECK(filter);
+// Lazy Instance to initialize the MediaFoundation Library.
+class MFInitializerSingleton {
+ public:
+  MFInitializerSingleton() { MFStartup(MF_VERSION, MFSTARTUP_LITE); }
+  ~MFInitializerSingleton() { MFShutdown(); }
+};
+
+static base::LazyInstance<MFInitializerSingleton> g_mf_initialize =
+    LAZY_INSTANCE_INITIALIZER;
+
+static void EnsureMediaFoundationInit() {
+  g_mf_initialize.Get();
+}
+
+// TODO(mcasas): This method is only used from PlatformSupportsMediaFoundation,
+// who is either hiding behind a DCHECK or used from tests only. Consider
+// removing this function altogether and rely only on MFInitializerSingleton for
+// initializing MF.

[tommi (sloooow) - chröme, 2014/05/15 15:18:33]

See the comments where LoadMediaFoundationDlls is called which explains why this
list is here.  It is not here to initialize MF actually, so you can't remove it
(unless you've otherwise addressed the problems described below first).

[mcasas, 2014/05/15 16:03:23]

Works for me!

+static bool LoadMediaFoundationDlls() {
+  static const wchar_t* const kMfDLLs[] = {
+    L"%WINDIR%\\system32\\mf.dll",
+    L"%WINDIR%\\system32\\mfplat.dll",
+    L"%WINDIR%\\system32\\mfreadwrite.dll",
+  };
+
+  for (int i = 0; i < arraysize(kMfDLLs); ++i) {
+    wchar_t path[MAX_PATH] = {0};
+    ExpandEnvironmentStringsW(kMfDLLs[i], path, arraysize(path));
+    if (!LoadLibraryExW(path, NULL, LOAD_WITH_ALTERED_SEARCH_PATH))
+      return false;
+  }
+  return true;
+}
+
+static bool PrepareVideoCaptureAttributesMediaFoundation(
+    IMFAttributes** attributes,
+    int count) {
+  EnsureMediaFoundationInit();
+
+  if (FAILED(MFCreateAttributes(attributes, count)))
+    return false;
+
+  return SUCCEEDED((*attributes)->SetGUID(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE,
+      MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID));
+}
+
+static bool CreateVideoCaptureDeviceMediaFoundation(const char* sym_link,
+                                                    IMFMediaSource** source) {
+  ScopedComPtr<IMFAttributes> attributes;
+  if (!PrepareVideoCaptureAttributesMediaFoundation(attributes.Receive(), 2))
+    return false;
+
+  attributes->SetString(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_SYMBOLIC_LINK,
+                        base::SysUTF8ToWide(sym_link).c_str());
+
+  return SUCCEEDED(MFCreateDeviceSource(attributes, source));
+}
+
+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(VideoCaptureDevice::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 hr;
-
-  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 exist. Therefore the FAILED macro can't be used.
-  if (hr != S_OK)
-    return NULL;
-
-  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 description or friendly name.
-    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);
-    }
-    if (name.type() == VT_BSTR) {
-      std::string device_path(base::SysWideToUTF8(V_BSTR(&name)));
-      if (device_path.compare(device_name.id()) == 0) {
-        // We have found the requested device
-        hr = moniker->BindToObject(0, 0, IID_IBaseFilter,
-                                   capture_filter.ReceiveVoid());
-        DVPLOG_IF(2, FAILED(hr)) << "Failed to bind camera filter.";
-        break;
-      }
-    }
-    moniker.Release();
-  }
-
-  *filter = capture_filter.Detach();
-  if (!*filter && SUCCEEDED(hr))
-    hr = HRESULT_FROM_WIN32(ERROR_NOT_FOUND);
-
-  return hr;
-}
-
-// Check if a Pin matches a category.
-bool PinMatchesCategory(IPin* pin, REFGUID category) {
-  DCHECK(pin);
-  bool found = false;
-  ScopedComPtr<IKsPropertySet> ks_property;
-  HRESULT hr = ks_property.QueryFrom(pin);
-  if (SUCCEEDED(hr)) {
-    GUID pin_category;
-    DWORD return_value;
-    hr = ks_property->Get(AMPROPSETID_Pin, AMPROPERTY_PIN_CATEGORY, NULL, 0,
-                          &pin_category, sizeof(pin_category), &return_value);
-    if (SUCCEEDED(hr) && (return_value == sizeof(pin_category))) {
-      found = (pin_category == category);
-    }
-  }
-  return found;
-}
-
-// Finds a IPin on a IBaseFilter given the direction an category.
-ScopedComPtr<IPin> GetPin(IBaseFilter* filter, PIN_DIRECTION pin_dir,
-                          REFGUID category) {
-  ScopedComPtr<IPin> pin;
-  ScopedComPtr<IEnumPins> pin_emum;
-  HRESULT hr = filter->EnumPins(pin_emum.Receive());
-  if (pin_emum == NULL)
-    return pin;
-
-  // Get first unconnected pin.
-  hr = pin_emum->Reset();  // set to first pin
-  while ((hr = pin_emum->Next(1, pin.Receive(), NULL)) == S_OK) {
-    PIN_DIRECTION this_pin_dir = static_cast<PIN_DIRECTION>(-1);
-    hr = pin->QueryDirection(&this_pin_dir);
-    if (pin_dir == this_pin_dir) {
-      if (category == GUID_NULL || PinMatchesCategory(pin, category))
-        return pin;
-    }
-    pin.Release();
-  }
-
-  DCHECK(!pin);
-  return pin;
-}
-
-// Release the format block for a media type.
-// http://msdn.microsoft.com/en-us/library/dd375432(VS.85).aspx
-void FreeMediaType(AM_MEDIA_TYPE* mt) {
-  if (mt->cbFormat != 0) {
-    CoTaskMemFree(mt->pbFormat);
-    mt->cbFormat = 0;
-    mt->pbFormat = NULL;
-  }
-  if (mt->pUnk != NULL) {
-    NOTREACHED();
-    // pUnk should not be used.
-    mt->pUnk->Release();
-    mt->pUnk = NULL;
-  }
-}
-
-// Delete a media type structure that was allocated on the heap.
-// http://msdn.microsoft.com/en-us/library/dd375432(VS.85).aspx
-void DeleteMediaType(AM_MEDIA_TYPE* mt) {
-  if (mt != NULL) {
-    FreeMediaType(mt);
-    CoTaskMemFree(mt);
-  }
-}
-
-// A utility class that wraps the AM_MEDIA_TYPE type and guarantees that
-// we free the structure when exiting the scope.  DCHECKing is also done to
-// avoid memory leaks.
-class ScopedMediaType {
- public:
-  ScopedMediaType() : media_type_(NULL) {}
-  ~ScopedMediaType() { Free(); }
-
-  AM_MEDIA_TYPE* operator->() { return media_type_; }
-  AM_MEDIA_TYPE* get() { return media_type_; }
-
-  void Free() {
-    if (!media_type_)
-      return;
-
-    DeleteMediaType(media_type_);
-    media_type_= NULL;
-  }
-
-  AM_MEDIA_TYPE** Receive() {
-    DCHECK(!media_type_);
-    return &media_type_;
-  }
-
- private:
-  AM_MEDIA_TYPE* media_type_;
-};
-
-VideoPixelFormat TranslateMediaSubtypeToPixelFormat(const GUID& sub_type) {
-  static struct {
-    const GUID& sub_type;
-    VideoPixelFormat format;
-  } pixel_formats[] = {
-    { kMediaSubTypeI420, PIXEL_FORMAT_I420 },
-    { MEDIASUBTYPE_IYUV, PIXEL_FORMAT_I420 },
-    { MEDIASUBTYPE_RGB24, PIXEL_FORMAT_RGB24 },
-    { MEDIASUBTYPE_YUY2, PIXEL_FORMAT_YUY2 },
-    { MEDIASUBTYPE_MJPG, PIXEL_FORMAT_MJPEG },
-    { MEDIASUBTYPE_UYVY, PIXEL_FORMAT_UYVY },
-    { MEDIASUBTYPE_ARGB32, PIXEL_FORMAT_ARGB },
-  };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(pixel_formats); ++i) {
-    if (sub_type == pixel_formats[i].sub_type)
-      return pixel_formats[i].format;
-  }
-#ifndef NDEBUG
-  WCHAR guid_str[128];
-  StringFromGUID2(sub_type, guid_str, arraysize(guid_str));
-  DVLOG(2) << "Device (also) supports an unknown media type " << guid_str;
-#endif
-  return PIXEL_FORMAT_UNKNOWN;
-}
-
-}  // namespace
-
-// static
-void VideoCaptureDevice::GetDeviceNames(Names* device_names) {
-  const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
-  // Use Media Foundation for Metro processes (after and including Win8) and
-  // DirectShow for any other versions, unless forced via flag. Media Foundation
-  // can also be forced if appropriate flag is set and we are in Windows 7 or
-  // 8 in non-Metro mode.
-  if ((base::win::IsMetroProcess() &&
-      !cmd_line->HasSwitch(switches::kForceDirectShowVideoCapture)) ||
-      (base::win::GetVersion() >= base::win::VERSION_WIN7 &&
-      cmd_line->HasSwitch(switches::kForceMediaFoundationVideoCapture))) {
-    VideoCaptureDeviceMFWin::GetDeviceNames(device_names);
-  } else {
-    VideoCaptureDeviceWin::GetDeviceNames(device_names);
-  }
-}
-
-// static
-void VideoCaptureDevice::GetDeviceSupportedFormats(const Name& device,
-    VideoCaptureFormats* formats) {
-  const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
-  // Use Media Foundation for Metro processes (after and including Win8) and
-  // DirectShow for any other versions, unless forced via flag. Media Foundation
-  // can also be forced if appropriate flag is set and we are in Windows 7 or
-  // 8 in non-Metro mode.
-  if ((base::win::IsMetroProcess() &&
-      !cmd_line->HasSwitch(switches::kForceDirectShowVideoCapture)) ||
-      (base::win::GetVersion() >= base::win::VERSION_WIN7 &&
-      cmd_line->HasSwitch(switches::kForceMediaFoundationVideoCapture))) {
-    VideoCaptureDeviceMFWin::GetDeviceSupportedFormats(device, formats);
-  } else {
-    VideoCaptureDeviceWin::GetDeviceSupportedFormats(device, formats);
-  }
-}
-
-// static
-VideoCaptureDevice* VideoCaptureDevice::Create(const Name& device_name) {
-  VideoCaptureDevice* ret = NULL;
-  if (device_name.capture_api_type() == Name::MEDIA_FOUNDATION) {
-    DCHECK(VideoCaptureDeviceMFWin::PlatformSupported());
-    scoped_ptr<VideoCaptureDeviceMFWin> device(
-        new VideoCaptureDeviceMFWin(device_name));
-    DVLOG(1) << " MediaFoundation Device: " << device_name.name();
-    if (device->Init())
-      ret = device.release();
-  } else if (device_name.capture_api_type() == Name::DIRECT_SHOW) {
-    scoped_ptr<VideoCaptureDeviceWin> device(
-        new VideoCaptureDeviceWin(device_name));
-    DVLOG(1) << " DirectShow Device: " << device_name.name();
-    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;
-  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 exist. Therefore the FAILED macro can't be used.
   if (hr != S_OK)
@@ skipping 37 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, Name::DIRECT_SHOW));
+        device_names->push_back(VideoCaptureDevice::Name(device_name, id,
+            VideoCaptureDevice::Name::DIRECT_SHOW));
       }
     }
     moniker.Release();
   }
 }
 
-// static
-void VideoCaptureDeviceWin::GetDeviceSupportedFormats(const Name& device,
+static void GetDeviceNamesMediaFoundation(
+    VideoCaptureDevice::Names* device_names) {
+  DVLOG(1) << " GetDeviceNamesMediaFoundation";
+  ScopedCoMem<IMFActivate*> devices;
+  UINT32 count;
+  if (!EnumerateVideoDevicesMediaFoundation(&devices, &count))
+    return;
+
+  HRESULT hr;
+  for (UINT32 i = 0; i < count; ++i) {
+    UINT32 name_size, id_size;
+    ScopedCoMem<wchar_t> name, id;
+    if (SUCCEEDED(hr = devices[i]->GetAllocatedString(
+            MF_DEVSOURCE_ATTRIBUTE_FRIENDLY_NAME, &name, &name_size)) &&
+        SUCCEEDED(hr = devices[i]->GetAllocatedString(
+            MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_SYMBOLIC_LINK, &id,
+            &id_size))) {
+      std::wstring name_w(name, name_size), id_w(id, id_size);
+      VideoCaptureDevice::Name device(base::SysWideToUTF8(name_w),
+          base::SysWideToUTF8(id_w),
+          VideoCaptureDevice::Name::MEDIA_FOUNDATION);
+      device_names->push_back(device);
+    } else {
+      DLOG(WARNING) << "GetAllocatedString failed: " << std::hex << hr;
+    }
+    devices[i]->Release();
+  }
+}
+
+static void GetDeviceSupportedFormatsDirectShow(
+    const VideoCaptureDevice::Name& device,
     VideoCaptureFormats* formats) {
-  DVLOG(1) << "GetDeviceSupportedFormats for " << device.name();
+  DVLOG(1) << "GetDeviceSupportedFormatsDirectShow for " << device.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
@@ skipping 20 matching lines @@
       DVLOG(1) << "Couldn't read a device's DevicePath.";
       return;
     }
     if (device.id() == base::SysWideToUTF8(V_BSTR(&device_id)))
       break;
     moniker.Release();
   }
 
   if (moniker.get()) {
     base::win::ScopedComPtr<IBaseFilter> capture_filter;
-    hr = GetDeviceFilter(device, capture_filter.Receive());
+    hr = VideoCaptureDeviceWin::GetDeviceFilter(device,
+                                                capture_filter.Receive());
     if (!capture_filter) {
       DVLOG(2) << "Failed to create capture filter.";
       return;
     }
 
     base::win::ScopedComPtr<IPin> output_capture_pin(
-        GetPin(capture_filter, PINDIR_OUTPUT, PIN_CATEGORY_CAPTURE));
+        VideoCaptureDeviceWin::GetPin(capture_filter,
+                                      PINDIR_OUTPUT,
+                                      PIN_CATEGORY_CAPTURE));
     if (!output_capture_pin) {
       DVLOG(2) << "Failed to get capture output pin";
       return;
     }
 
     ScopedComPtr<IAMStreamConfig> stream_config;
     hr = output_capture_pin.QueryInterface(stream_config.Receive());
     if (FAILED(hr)) {
       DVLOG(2) << "Failed to get IAMStreamConfig interface from "
                   "capture device";
       return;
     }
 
     int count = 0, size = 0;
     hr = stream_config->GetNumberOfCapabilities(&count, &size);
     if (FAILED(hr)) {
       DVLOG(2) << "Failed to GetNumberOfCapabilities";
       return;
     }
 
     scoped_ptr<BYTE[]> caps(new BYTE[size]);
     for (int i = 0; i < count; ++i) {
-      ScopedMediaType media_type;
+      VideoCaptureDeviceWin::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) {
         DVLOG(2) << "Failed to GetStreamCaps";
         return;
       }
 
       if (media_type->majortype == MEDIATYPE_Video &&
           media_type->formattype == FORMAT_VideoInfo) {
         VideoCaptureFormat format;
         format.pixel_format =
-            TranslateMediaSubtypeToPixelFormat(media_type->subtype);
+            VideoCaptureDeviceWin::TranslateMediaSubtypeToPixelFormat(
+                media_type->subtype);
         if (format.pixel_format == PIXEL_FORMAT_UNKNOWN)
           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) ?
             static_cast<int>(kSecondsToReferenceTime / h->AvgTimePerFrame) :
             0;
         formats->push_back(format);
         DVLOG(1) << device.name() << " resolution: "
              << format.frame_size.ToString() << ", fps: " << format.frame_rate
              << ", pixel format: " << format.pixel_format;
       }
     }
   }
 }
 
-VideoCaptureDeviceWin::VideoCaptureDeviceWin(const Name& device_name)
-    : device_name_(device_name),
-      state_(kIdle) {
-  DetachFromThread();
-}
+static void GetDeviceSupportedFormatsMediaFoundation(
+    const VideoCaptureDevice::Name& device,
+    VideoCaptureFormats* formats) {
+  DVLOG(1) << "GetDeviceSupportedFormatsMediaFoundation for " << device.name();
+  ScopedComPtr<IMFMediaSource> source;
+  if (!CreateVideoCaptureDeviceMediaFoundation(device.id().c_str(),
+                                               source.Receive())) {
+    return;
+  }
 
-VideoCaptureDeviceWin::~VideoCaptureDeviceWin() {
-  DCHECK(CalledOnValidThread());
-  if (media_control_)
-    media_control_->Stop();
+  HRESULT hr;
+  base::win::ScopedComPtr<IMFSourceReader> reader;
+  if (FAILED(hr = MFCreateSourceReaderFromMediaSource(source, NULL,
+                                                      reader.Receive()))) {
+    DLOG(ERROR) << "MFCreateSourceReaderFromMediaSource: " << std::hex << hr;
+    return;
+  }
 
-  if (graph_builder_) {
-    if (sink_filter_) {
-      graph_builder_->RemoveFilter(sink_filter_);
-      sink_filter_ = NULL;
+  DWORD stream_index = 0;
+  ScopedComPtr<IMFMediaType> type;
+  while (SUCCEEDED(hr = reader->GetNativeMediaType(
+         MF_SOURCE_READER_FIRST_VIDEO_STREAM, stream_index, type.Receive()))) {
+    UINT32 width, height;
+    hr = MFGetAttributeSize(type, MF_MT_FRAME_SIZE, &width, &height);
+    if (FAILED(hr)) {
+      DLOG(ERROR) << "MFGetAttributeSize: " << std::hex << hr;
+      return;
     }
+    VideoCaptureFormat capture_format;
+    capture_format.frame_size.SetSize(width, height);
 
-    if (capture_filter_)
-      graph_builder_->RemoveFilter(capture_filter_);
+    UINT32 numerator, denominator;
+    hr = MFGetAttributeRatio(type, MF_MT_FRAME_RATE, &numerator, &denominator);
+    if (FAILED(hr)) {
+      DLOG(ERROR) << "MFGetAttributeSize: " << std::hex << hr;
+      return;
+    }
+    capture_format.frame_rate = denominator ? numerator / denominator : 0;
 
-    if (mjpg_filter_)
-      graph_builder_->RemoveFilter(mjpg_filter_);
+    GUID type_guid;
+    hr = type->GetGUID(MF_MT_SUBTYPE, &type_guid);
+    if (FAILED(hr)) {
+      DLOG(ERROR) << "GetGUID: " << std::hex << hr;
+      return;
+    }
+    VideoCaptureDeviceMFWin::FormatFromGuid(type_guid,
+                                            &capture_format.pixel_format);
+    type.Release();
+    formats->push_back(capture_format);
+    ++stream_index;
+
+    DVLOG(1) << device.name() << " resolution: "
+             << capture_format.frame_size.ToString() << ", fps: "
+             << capture_format.frame_rate << ", pixel format: "
+             << capture_format.pixel_format;
   }
 }
 
-bool VideoCaptureDeviceWin::Init() {
-  DCHECK(CalledOnValidThread());
-  HRESULT hr = GetDeviceFilter(device_name_, capture_filter_.Receive());
-  if (!capture_filter_) {
-    DVLOG(2) << "Failed to create capture filter.";
+// 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;
-  }
 
-  output_capture_pin_ =
-      GetPin(capture_filter_, PINDIR_OUTPUT, PIN_CATEGORY_CAPTURE);
-  if (!output_capture_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) {
-    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)) {
-    DVLOG(2) << "Failed to create graph builder.";
-    return false;
-  }
-
-  hr = graph_builder_.QueryInterface(media_control_.Receive());
-  if (FAILED(hr)) {
-    DVLOG(2) << "Failed to create media control builder.";
-    return false;
-  }
-
-  hr = graph_builder_->AddFilter(capture_filter_, NULL);
-  if (FAILED(hr)) {
-    DVLOG(2) << "Failed to add the capture device to the graph.";
-    return false;
-  }
-
-  hr = graph_builder_->AddFilter(sink_filter_, NULL);
-  if (FAILED(hr)) {
-    DVLOG(2)<< "Failed to add the send filter to the graph.";
-    return false;
-  }
-
-  return CreateCapabilityMap();
+  static bool g_dlls_available = LoadMediaFoundationDlls();
+  return g_dlls_available;
 }
 
-void VideoCaptureDeviceWin::AllocateAndStart(
-    const VideoCaptureParams& params,
-    scoped_ptr<VideoCaptureDevice::Client> client) {
-  DCHECK(CalledOnValidThread());
-  if (state_ != kIdle)
-    return;
-
-  client_ = client.Pass();
-
-  // Get the camera capability that best match the requested resolution.
-  const VideoCaptureCapabilityWin& found_capability =
-      capabilities_.GetBestMatchedFormat(
-          params.requested_format.frame_size.width(),
-          params.requested_format.frame_size.height(),
-          params.requested_format.frame_rate);
-  VideoCaptureFormat format = found_capability.supported_format;
-
-  // Reduce the frame rate if the requested frame rate is lower
-  // than the capability.
-  if (format.frame_rate > params.requested_format.frame_rate)
-    format.frame_rate = params.requested_format.frame_rate;
-
-  ScopedComPtr<IAMStreamConfig> stream_config;
-  HRESULT hr = output_capture_pin_.QueryInterface(stream_config.Receive());
-  if (FAILED(hr)) {
-    SetErrorState("Can't get the Capture format settings");
-    return;
+scoped_ptr<VideoCaptureDevice> VideoCaptureDeviceFactoryWin::Create(
+    const VideoCaptureDevice::Name& device_name) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  scoped_ptr<VideoCaptureDevice> device;
+  if (device_name.capture_api_type() ==
+      VideoCaptureDevice::Name::MEDIA_FOUNDATION) {
+    DCHECK(PlatformSupportsMediaFoundation());
+    device.reset(new VideoCaptureDeviceMFWin(device_name));
+    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 if (device_name.capture_api_type() ==
+             VideoCaptureDevice::Name::DIRECT_SHOW) {
+    device.reset(new VideoCaptureDeviceWin(device_name));
+    DVLOG(1) << " DirectShow Device: " << device_name.name();
+    if (!static_cast<VideoCaptureDeviceWin*>(device.get())->Init())
+      device.reset();
+  } else {
+    NOTREACHED() << " Couldn't recognize VideoCaptureDevice type";
   }
-
-  int count = 0, size = 0;
-  hr = stream_config->GetNumberOfCapabilities(&count, &size);
-  if (FAILED(hr)) {
-    DVLOG(2) << "Failed to GetNumberOfCapabilities";
-    return;
-  }
-
-  scoped_ptr<BYTE[]> caps(new BYTE[size]);
-  ScopedMediaType media_type;
-
-  // Get the windows capability from the capture device.
-  hr = stream_config->GetStreamCaps(
-      found_capability.stream_index, media_type.Receive(), caps.get());
-  if (SUCCEEDED(hr)) {
-    if (media_type->formattype == FORMAT_VideoInfo) {
-      VIDEOINFOHEADER* h =
-          reinterpret_cast<VIDEOINFOHEADER*>(media_type->pbFormat);
-      if (format.frame_rate > 0)
-        h->AvgTimePerFrame = kSecondsToReferenceTime / format.frame_rate;
-    }
-    // Set the sink filter to request this format.
-    sink_filter_->SetRequestedMediaFormat(format);
-    // Order the capture device to use this format.
-    hr = stream_config->SetFormat(media_type.get());
-  }
-
-  if (FAILED(hr))
-    SetErrorState("Failed to set capture device output format");
-
-  if (format.pixel_format == PIXEL_FORMAT_MJPEG && !mjpg_filter_.get()) {
-    // Create MJPG filter if we need it.
-    hr = mjpg_filter_.CreateInstance(CLSID_MjpegDec, NULL, CLSCTX_INPROC);
-
-    if (SUCCEEDED(hr)) {
-      input_mjpg_pin_ = GetPin(mjpg_filter_, PINDIR_INPUT, GUID_NULL);
-      output_mjpg_pin_ = GetPin(mjpg_filter_, PINDIR_OUTPUT, GUID_NULL);
-      hr = graph_builder_->AddFilter(mjpg_filter_, NULL);
-    }
-
-    if (FAILED(hr)) {
-      mjpg_filter_.Release();
-      input_mjpg_pin_.Release();
-      output_mjpg_pin_.Release();
-    }
-  }
-
-  SetAntiFlickerInCaptureFilter();
-
-  if (format.pixel_format == PIXEL_FORMAT_MJPEG && mjpg_filter_.get()) {
-    // Connect the camera to the MJPEG decoder.
-    hr = graph_builder_->ConnectDirect(output_capture_pin_, input_mjpg_pin_,
-                                       NULL);
-    // Connect the MJPEG filter to the Capture filter.
-    hr += graph_builder_->ConnectDirect(output_mjpg_pin_, input_sink_pin_,
-                                        NULL);
-  } else {
-    hr = graph_builder_->ConnectDirect(output_capture_pin_, input_sink_pin_,
-                                       NULL);
-  }
-
-  if (FAILED(hr)) {
-    SetErrorState("Failed to connect the Capture graph.");
-    return;
-  }
-
-  hr = media_control_->Pause();
-  if (FAILED(hr)) {
-    SetErrorState("Failed to Pause the Capture device. "
-                  "Is it already occupied?");
-    return;
-  }
-
-  // Get the format back from the sink filter after the filter have been
-  // connected.
-  capture_format_ = sink_filter_->ResultingFormat();
-
-  // Start capturing.
-  hr = media_control_->Run();
-  if (FAILED(hr)) {
-    SetErrorState("Failed to start the Capture device.");
-    return;
-  }
-
-  state_ = kCapturing;
+  return device.Pass();
 }
 
-void VideoCaptureDeviceWin::StopAndDeAllocate() {
-  DCHECK(CalledOnValidThread());
-  if (state_ != kCapturing)
-    return;
-
-  HRESULT hr = media_control_->Stop();
-  if (FAILED(hr)) {
-    SetErrorState("Failed to stop the capture graph.");
-    return;
-  }
-
-  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 (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)) {
-    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());
-  DVLOG_IF(2, FAILED(hr)) << "IAMVideoControl Interface NOT SUPPORTED";
-
-  int count = 0, size = 0;
-  hr = stream_config->GetNumberOfCapabilities(&count, &size);
-  if (FAILED(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) {
-      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;
-
-      VIDEOINFOHEADER* h =
-          reinterpret_cast<VIDEOINFOHEADER*>(media_type->pbFormat);
-      capability.supported_format.frame_size.SetSize(h->bmiHeader.biWidth,
-                                                     h->bmiHeader.biHeight);
-
-      // Try to get a better |time_per_frame| from IAMVideoControl.  If not, use
-      // the value from VIDEOINFOHEADER.
-      REFERENCE_TIME time_per_frame = h->AvgTimePerFrame;
-      if (video_control) {
-        ScopedCoMem<LONGLONG> max_fps;
-        LONG list_size = 0;
-        SIZE size = {capability.supported_format.frame_size.width(),
-                     capability.supported_format.frame_size.height()};
-
-        // GetFrameRateList doesn't return max frame rate always
-        // eg: Logitech Notebook. This may be due to a bug in that API
-        // because GetFrameRateList array is reversed in the above camera. So
-        // a util method written. Can't assume the first value will return
-        // the max fps.
-        hr = video_control->GetFrameRateList(output_capture_pin_, i, size,
-                                             &list_size, &max_fps);
-        // Sometimes |list_size| will be > 0, but max_fps will be NULL.  Some
-        // drivers may return an HRESULT of S_FALSE which SUCCEEDED() translates
-        // into success, so explicitly check S_OK.  See http://crbug.com/306237.
-        if (hr == S_OK && list_size > 0 && max_fps) {
-          time_per_frame = *std::min_element(max_fps.get(),
-                                             max_fps.get() + list_size);
-        }
-      }
-
-      capability.supported_format.frame_rate =
-          (time_per_frame > 0)
-              ? static_cast<int>(kSecondsToReferenceTime / time_per_frame)
-              : 0;
-
-      // DirectShow works at the moment only on integer frame_rate but the
-      // best capability matching class works on rational frame rates.
-      capability.frame_rate_numerator = capability.supported_format.frame_rate;
-      capability.frame_rate_denominator = 1;
-
-      capabilities_.Add(capability);
-    }
-  }
-
-  return !capabilities_.empty();
-}
-
-// Set the power line frequency removal in |capture_filter_| if available.
-void VideoCaptureDeviceWin::SetAntiFlickerInCaptureFilter() {
-  const int power_line_frequency = GetPowerLineFrequencyForLocation();
-  if (power_line_frequency != kPowerLine50Hz &&
-      power_line_frequency != kPowerLine60Hz) {
-    return;
-  }
-  ScopedComPtr<IKsPropertySet> ks_propset;
-  DWORD type_support = 0;
-  HRESULT hr;
-  if (SUCCEEDED(hr = ks_propset.QueryFrom(capture_filter_)) &&
-      SUCCEEDED(hr = ks_propset->QuerySupported(PROPSETID_VIDCAP_VIDEOPROCAMP,
-          KSPROPERTY_VIDEOPROCAMP_POWERLINE_FREQUENCY, &type_support)) &&
-      (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));
-    DVLOG_IF(ERROR, FAILED(hr)) << "Anti-flicker setting failed.";
-    DVLOG_IF(2, SUCCEEDED(hr)) << "Anti-flicker set correctly.";
+void VideoCaptureDeviceFactoryWin::GetDeviceNames(
+    VideoCaptureDevice::Names* device_names) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
+  // Use Media Foundation for Metro processes (after and including Win8) and
+  // DirectShow for any other versions, unless forced via flag. Media Foundation
+  // can also be forced if appropriate flag is set and we are in Windows 7 or
+  // 8 in non-Metro mode.
+  if ((base::win::IsMetroProcess() &&
+       !cmd_line->HasSwitch(switches::kForceDirectShowVideoCapture)) ||
+      (base::win::GetVersion() >= base::win::VERSION_WIN7 &&
+       cmd_line->HasSwitch(switches::kForceMediaFoundationVideoCapture))) {
+    GetDeviceNamesMediaFoundation(device_names);
   } else {
-    DVLOG(2) << "Anti-flicker setting not supported.";
+    GetDeviceNamesDirectShow(device_names);
   }
 }
 
-void VideoCaptureDeviceWin::SetErrorState(const std::string& reason) {
-  DCHECK(CalledOnValidThread());
-  DVLOG(1) << reason;
-  state_ = kError;
-  client_->OnError(reason);
+void VideoCaptureDeviceFactoryWin::GetDeviceSupportedFormats(
+    const VideoCaptureDevice::Name& device,
+    VideoCaptureFormats* formats) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
+  // Use Media Foundation for Metro processes (after and including Win8) and
+  // DirectShow for any other versions, unless forced via flag. Media Foundation
+  // can also be forced if appropriate flag is set and we are in Windows 7 or
+  // 8 in non-Metro mode.
+  if ((base::win::IsMetroProcess() &&
+       !cmd_line->HasSwitch(switches::kForceDirectShowVideoCapture)) ||
+      (base::win::GetVersion() >= base::win::VERSION_WIN7 &&
+       cmd_line->HasSwitch(switches::kForceMediaFoundationVideoCapture))) {
+    GetDeviceSupportedFormatsMediaFoundation(device, formats);
+  } else {
+    GetDeviceSupportedFormatsDirectShow(device, formats);
+  }
 }
+
 }  // namespace media