Video capture implementation using the Media Foundation API.

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/string_util.h"
 #include "base/sys_string_conversions.h"
 #include "base/win/scoped_variant.h"
+#include "base/win/windows_version.h"
+#include "media/video/capture/win/video_capture_device_mf_win.h"
 
 using base::win::ScopedComPtr;
 using base::win::ScopedVariant;
 
 namespace {
 
 // Finds and creates a DirectShow Video Capture filter matching the device_name.
 HRESULT GetDeviceFilter(const media::VideoCaptureDevice::Name& device_name,
                         IBaseFilter** filter) {
   DCHECK(filter);
@@ skipping 112 matching lines @@
 
 // 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);
   }
 }
 
-// Help structure used for comparing video capture capabilities.
-struct ResolutionDiff {
-  int capability_index;
-  int diff_height;
-  int diff_width;
-  int diff_frame_rate;
-  media::VideoCaptureCapability::Format color;
-};
-
-bool CompareHeight(const ResolutionDiff& item1, const ResolutionDiff& item2) {
-  return abs(item1.diff_height) < abs(item2.diff_height);
-}
-
-bool CompareWidth(const ResolutionDiff& item1, const ResolutionDiff& item2) {
-  return abs(item1.diff_width) < abs(item2.diff_width);
-}
-
-bool CompareFrameRate(const ResolutionDiff& item1,
-                      const ResolutionDiff& item2) {
-  return abs(item1.diff_frame_rate) < abs(item2.diff_frame_rate);
-}
-
-bool CompareColor(const ResolutionDiff& item1, const ResolutionDiff& item2) {
-  return (item1.color < item2.color);
-}
-
 }  // namespace
 
 namespace media {
 
-// Name of a fake DirectShow filter that exist on computers with
-// GTalk installed.
-static const char kGoogleCameraAdapter[] = "google camera adapter";
+// static
+void VideoCaptureDevice::GetDeviceNames(Names* device_names) {
+  if (base::win::GetVersion() >= base::win::VERSION_VISTA) {
+    VideoCaptureDeviceMFWin::GetDeviceNames(device_names);
+  } else {
+    VideoCaptureDeviceWin::GetDeviceNames(device_names);
+  }
+}
 
-// Gets the names of all video capture devices connected to this computer.
-void VideoCaptureDevice::GetDeviceNames(Names* device_names) {
+// static
+VideoCaptureDevice* VideoCaptureDevice::Create(const Name& device_name) {

[darin (slow to review), 2012/12/03 18:15:43]

nit: might be nice to return scoped_ptr<VideoCaptureDevice> here, but not
necessary for this CL.

+  VideoCaptureDevice* ret = NULL;
+  if (base::win::GetVersion() >= base::win::VERSION_VISTA) {
+    scoped_ptr<VideoCaptureDeviceMFWin> device(
+        new VideoCaptureDeviceMFWin(device_name));
+    if (device->Init())
+      ret = device.release();
+  } else {
+    scoped_ptr<VideoCaptureDeviceWin> device(
+        new VideoCaptureDeviceWin(device_name));
+    if (device->Init())
+      ret = device.release();
+  }
+
+  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)
     return;
 
   device_names->clear();
 
+  // Name of a fake DirectShow filter that exist on computers with
+  // GTalk installed.
+  static const char kGoogleCameraAdapter[] = "google camera adapter";
+
   // Enumerate all video capture devices.
   ScopedComPtr<IMoniker> moniker;
   int index = 0;
   while (enum_moniker->Next(1, moniker.Receive(), NULL) == S_OK) {
     Name device;
     ScopedComPtr<IPropertyBag> prop_bag;
     hr = moniker->BindToStorage(0, 0, IID_IPropertyBag, prop_bag.ReceiveVoid());
     if (FAILED(hr)) {
       moniker.Release();
       continue;
@@ skipping 25 matching lines @@
           device.unique_id = base::SysWideToUTF8(V_BSTR(&name));
         }
 
         device_names->push_back(device);
       }
     }
     moniker.Release();
   }
 }
 
-VideoCaptureDevice* VideoCaptureDevice::Create(const Name& device_name) {
-  VideoCaptureDeviceWin* self = new VideoCaptureDeviceWin(device_name);
-  if (self  && self->Init())
-    return self;
-
-  delete self;
-  return NULL;
-}
-
 VideoCaptureDeviceWin::VideoCaptureDeviceWin(const Name& device_name)
     : device_name_(device_name),
       state_(kIdle),
       observer_(NULL) {
   DetachFromThread();
 }
 
 VideoCaptureDeviceWin::~VideoCaptureDeviceWin() {
   DCHECK(CalledOnValidThread());
   if (media_control_)
@@ skipping 68 matching lines @@
 void VideoCaptureDeviceWin::Allocate(
     int width,
     int height,
     int frame_rate,
     VideoCaptureDevice::EventHandler* observer) {
   DCHECK(CalledOnValidThread());
   if (state_ != kIdle)
     return;
 
   observer_ = observer;
+
   // Get the camera capability that best match the requested resolution.
-  const int capability_index = GetBestMatchedCapability(width, height,
-                                                        frame_rate);
-  VideoCaptureCapability capability = capabilities_[capability_index];
+  const VideoCaptureCapabilityWin& found_capability =
+      capabilities_.GetBestMatchedCapability(width, height, frame_rate);
+  VideoCaptureCapability capability = found_capability;
 
   // Reduce the frame rate if the requested frame rate is lower
   // than the capability.
   if (capability.frame_rate > frame_rate)
     capability.frame_rate = frame_rate;
 
   AM_MEDIA_TYPE* pmt = NULL;
   VIDEO_STREAM_CONFIG_CAPS caps;
 
   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;
   }
 
   // Get the windows capability from the capture device.
-  hr = stream_config->GetStreamCaps(capability_index, &pmt,
+  hr = stream_config->GetStreamCaps(found_capability.stream_index, &pmt,
                                     reinterpret_cast<BYTE*>(&caps));
   if (SUCCEEDED(hr)) {
     if (pmt->formattype == FORMAT_VideoInfo) {
       VIDEOINFOHEADER* h = reinterpret_cast<VIDEOINFOHEADER*>(pmt->pbFormat);
       if (capability.frame_rate > 0)
         h->AvgTimePerFrame = kSecondsToReferenceTime / capability.frame_rate;
     }
     // Set the sink filter to request this capability.
     sink_filter_->SetRequestedMediaCapability(capability);
     // Order the capture device to use this capability.
@@ skipping 146 matching lines @@
   for (int i = 0; i < count; ++i) {
     hr = stream_config->GetStreamCaps(i, &media_type,
                                       reinterpret_cast<BYTE*>(&caps));
     if (FAILED(hr)) {
       DVLOG(2) << "Failed to GetStreamCaps";
       return false;
     }
 
     if (media_type->majortype == MEDIATYPE_Video &&
         media_type->formattype == FORMAT_VideoInfo) {
-      VideoCaptureCapability capability;
+      VideoCaptureCapabilityWin capability(i);
       REFERENCE_TIME time_per_frame = 0;
 
       VIDEOINFOHEADER* h =
           reinterpret_cast<VIDEOINFOHEADER*>(media_type->pbFormat);
       capability.width = h->bmiHeader.biWidth;
       capability.height = h->bmiHeader.biHeight;
       time_per_frame = h->AvgTimePerFrame;
 
       // Try to get the max frame rate from IAMVideoControl.
       if (video_control.get()) {
@@ skipping 39 matching lines @@
       } else if (media_type->subtype == MEDIASUBTYPE_YUY2) {
         capability.color = VideoCaptureCapability::kYUY2;
       } else if (media_type->subtype == MEDIASUBTYPE_MJPG) {
         capability.color = VideoCaptureCapability::kMJPEG;
       } 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_[i] = capability;
+      capabilities_.Add(capability);
     }
     DeleteMediaType(media_type);
     media_type = NULL;
   }
 
-  return capabilities_.size() > 0;
-}
-
-// Loops through the list of capabilities and returns an index of the best
-// matching capability.
-// The algorithm prioritize height, width, frame rate and color format in that
-// order.
-int VideoCaptureDeviceWin::GetBestMatchedCapability(int requested_width,
-                                                    int requested_height,
-                                                    int requested_frame_rate) {
-  DCHECK(CalledOnValidThread());
-  std::list<ResolutionDiff> diff_list;
-
-  // Loop through the candidates to create a list of differentials between the
-  // requested resolution and the camera capability.
-  for (CapabilityMap::iterator iterator = capabilities_.begin();
-       iterator != capabilities_.end();
-       ++iterator) {
-    VideoCaptureCapability capability = iterator->second;
-
-    ResolutionDiff diff;
-    diff.capability_index = iterator->first;
-    diff.diff_width = capability.width - requested_width;
-    diff.diff_height = capability.height - requested_height;
-    diff.diff_frame_rate = capability.frame_rate - requested_frame_rate;
-    diff.color = capability.color;
-    diff_list.push_back(diff);
-  }
-
-  // Sort the best height candidates.
-  diff_list.sort(&CompareHeight);
-  int best_diff = diff_list.front().diff_height;
-  for (std::list<ResolutionDiff>::iterator it = diff_list.begin();
-       it != diff_list.end(); ++it) {
-    if (it->diff_height != best_diff) {
-      // Remove all candidates but the best.
-      diff_list.erase(it, diff_list.end());
-      break;
-    }
-  }
-
-  // Sort the best width candidates.
-  diff_list.sort(&CompareWidth);
-  best_diff = diff_list.front().diff_width;
-  for (std::list<ResolutionDiff>::iterator it = diff_list.begin();
-       it != diff_list.end(); ++it) {
-    if (it->diff_width != best_diff) {
-      // Remove all candidates but the best.
-      diff_list.erase(it, diff_list.end());
-      break;
-    }
-  }
-
-  // Sort the best frame rate candidates.
-  diff_list.sort(&CompareFrameRate);
-  best_diff = diff_list.front().diff_frame_rate;
-  for (std::list<ResolutionDiff>::iterator it = diff_list.begin();
-       it != diff_list.end(); ++it) {
-    if (it->diff_frame_rate != best_diff) {
-      diff_list.erase(it, diff_list.end());
-      break;
-    }
-  }
-
-  // Decide the best color format.
-  diff_list.sort(&CompareColor);
-  return diff_list.front().capability_index;
+  return !capabilities_.empty();
 }
 
 void VideoCaptureDeviceWin::SetErrorState(const char* reason) {
   DCHECK(CalledOnValidThread());
   DVLOG(1) << reason;
   state_ = kError;
   observer_->OnError();
 }
 
 }  // namespace media