Video capture: Refactor GetBestMatchedFormat from Win to OS independent

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 <ks.h>
 #include <ksmedia.h>
 
 #include <algorithm>
@@ skipping 269 matching lines @@
 
 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.
+  // Get the camera capability that best match the requested format.
   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;
+      *GetBestMatchedFormat(params.requested_format, capabilities_);
+  VideoCaptureFormat format = found_capability.second;
 
   // 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;
+  format.frame_rate =
+      std::min(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;
   }
 
   int count = 0, size = 0;
   hr = stream_config->GetNumberOfCapabilities(&count, &size);
   if (FAILED(hr)) {
     SetErrorState("Failed to GetNumberOfCapabilities");
     return;
   }
 
   scoped_ptr<BYTE[]> caps(new BYTE[size]);
   ScopedMediaType media_type;
 
   // Get the windows capability from the capture device.
   // GetStreamCaps can return S_FALSE which we consider an error. Therefore the
   // FAILED macro can't be used.
   hr = stream_config->GetStreamCaps(
-      found_capability.stream_index, media_type.Receive(), caps.get());
+      found_capability.first, media_type.Receive(), caps.get());
   if (hr != S_OK) {
     SetErrorState("Failed to get capture device capabilities");
     return;
   } else {
     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;
     }
@@ skipping 122 matching lines @@
 
   int count = 0, size = 0;
   hr = stream_config->GetNumberOfCapabilities(&count, &size);
   if (FAILED(hr)) {
     DLOG(ERROR) << "Failed to GetNumberOfCapabilities: "
                 << logging::SystemErrorCodeToString(hr);
     return false;
   }
 
   scoped_ptr<BYTE[]> caps(new BYTE[size]);
-  for (int i = 0; i < count; ++i) {
+  for (int stream_index = 0; stream_index < count; ++stream_index) {
     ScopedMediaType media_type;
-    hr = stream_config->GetStreamCaps(i, media_type.Receive(), caps.get());
+    hr = stream_config->GetStreamCaps(
+        stream_index, 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) {
       DLOG(ERROR) << "Failed to GetStreamCaps: "
                   << logging::SystemErrorCodeToString(hr);
       return false;
     }
 
     if (media_type->majortype == MEDIATYPE_Video &&
         media_type->formattype == FORMAT_VideoInfo) {
-      VideoCaptureCapabilityWin capability(i);
-      capability.supported_format.pixel_format =
+      VideoCaptureFormat format;
+      format.pixel_format =
           TranslateMediaSubtypeToPixelFormat(media_type->subtype);
-      if (capability.supported_format.pixel_format == PIXEL_FORMAT_UNKNOWN)
+      if (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);
+      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()};
-
+        const SIZE size = {format.frame_size.width(),
+                           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);
+        hr = video_control->GetFrameRateList(
+            output_capture_pin_, stream_index, 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 =
+      format.frame_rate =
           (time_per_frame > 0)
               ? (kSecondsToReferenceTime / static_cast<float>(time_per_frame))
               : 0.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);
+      capabilities_.push_back(VideoCaptureCapabilityWin(stream_index, format));
     }
   }
 
   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 &&
@@ skipping 23 matching lines @@
     DVLOG(2) << "Anti-flicker setting not supported.";
   }
 }
 
 void VideoCaptureDeviceWin::SetErrorState(const std::string& reason) {
   DCHECK(CalledOnValidThread());
   state_ = kError;
   client_->OnError(reason);
 }
 }  // namespace media