Video capture: Refactor GetBestMatchedFormat from Win to OS independent

media/video/capture/win/video_capture_device_mf_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_mf_win.h"
 
 #include <mfapi.h>
 #include <mferror.h>
 
 #include "base/memory/ref_counted.h"
@@ skipping 16 matching lines @@
 const size_t kVidPidSize = 4;
 
 static bool GetFrameSize(IMFMediaType* type, gfx::Size* frame_size) {
   UINT32 width32, height32;
   if (FAILED(MFGetAttributeSize(type, MF_MT_FRAME_SIZE, &width32, &height32)))
     return false;
   frame_size->SetSize(width32, height32);
   return true;
 }
 
-static bool GetFrameRate(IMFMediaType* type,
-                         int* frame_rate_numerator,
-                         int* frame_rate_denominator) {
+static bool GetFrameRate(IMFMediaType* type, float* frame_rate) {
   UINT32 numerator, denominator;
   if (FAILED(MFGetAttributeRatio(type, MF_MT_FRAME_RATE, &numerator,
                                  &denominator))||
       !denominator) {
     return false;
   }
-  *frame_rate_numerator = numerator;
-  *frame_rate_denominator = denominator;
+  *frame_rate = static_cast<float>(numerator) / denominator;
   return true;
 }
 
-static bool FillCapabilitiesFromType(IMFMediaType* type,
-                                     VideoCaptureCapabilityWin* capability) {
+static bool FillFormat(IMFMediaType* type, VideoCaptureFormat* format) {
   GUID type_guid;
   if (FAILED(type->GetGUID(MF_MT_SUBTYPE, &type_guid)) ||
-      !GetFrameSize(type, &capability->supported_format.frame_size) ||
-      !GetFrameRate(type,
-                    &capability->frame_rate_numerator,
-                    &capability->frame_rate_denominator) ||
+      !GetFrameSize(type, &format->frame_size) ||
+      !GetFrameRate(type, &format->frame_rate) ||
       !VideoCaptureDeviceMFWin::FormatFromGuid(type_guid,
-          &capability->supported_format.pixel_format)) {
+                                               &format->pixel_format)) {
     return false;
   }
-  capability->supported_format.frame_rate =
-      capability->frame_rate_numerator / capability->frame_rate_denominator;
 
   return true;
 }
 
 HRESULT FillCapabilities(IMFSourceReader* source,
                          CapabilityList* capabilities) {
   DWORD stream_index = 0;
   ScopedComPtr<IMFMediaType> type;
   HRESULT hr;
-  for (hr = source->GetNativeMediaType(kFirstVideoStream, stream_index,
-                                       type.Receive());
-       SUCCEEDED(hr);
-       hr = source->GetNativeMediaType(kFirstVideoStream, stream_index,
-                                       type.Receive())) {
-    VideoCaptureCapabilityWin capability(stream_index++);
-    if (FillCapabilitiesFromType(type, &capability))
-      capabilities->Add(capability);
+  while (SUCCEEDED(hr = source->GetNativeMediaType(
+                       kFirstVideoStream, stream_index, type.Receive()))) {

[perkj_chrome, 2014/10/10 09:17:13]

indentation

[magjed_chromium, 2014/10/10 11:21:26]

This is correct according to clang-format already.

+    VideoCaptureFormat format;
+    if (FillFormat(type, &format))
+      capabilities->push_back(VideoCaptureCapabilityWin(stream_index, format));
     type.Release();
+    ++stream_index;
   }
 
   if (capabilities->empty() && (SUCCEEDED(hr) || hr == MF_E_NO_MORE_TYPES))
     hr = HRESULT_FROM_WIN32(ERROR_EMPTY);
 
   return (hr == MF_E_NO_MORE_TYPES) ? S_OK : hr;
 }
 
 
 class MFReaderCallback final
@@ skipping 151 matching lines @@
   base::AutoLock lock(lock_);
 
   client_ = client.Pass();
   DCHECK_EQ(capture_, false);
 
   CapabilityList capabilities;
   HRESULT hr = S_OK;
   if (reader_) {
     hr = FillCapabilities(reader_, &capabilities);
     if (SUCCEEDED(hr)) {
-      VideoCaptureCapabilityWin found_capability =
-          capabilities.GetBestMatchedFormat(
-              params.requested_format.frame_size.width(),
-              params.requested_format.frame_size.height(),
-              params.requested_format.frame_rate);
-
+      const VideoCaptureCapabilityWin& found_capability =
+          *GetBestMatchedCapability(params.requested_format, capabilities);
       ScopedComPtr<IMFMediaType> type;
       hr = reader_->GetNativeMediaType(
           kFirstVideoStream, found_capability.stream_index, type.Receive());
       if (SUCCEEDED(hr)) {
         hr = reader_->SetCurrentMediaType(kFirstVideoStream, NULL, type);
         if (SUCCEEDED(hr)) {
           hr = reader_->ReadSample(kFirstVideoStream, 0, NULL, NULL, NULL,
                                    NULL);
           if (SUCCEEDED(hr)) {
             capture_format_ = found_capability.supported_format;
@@ skipping 63 matching lines @@
 
 void VideoCaptureDeviceMFWin::OnError(HRESULT hr) {
   if (client_.get()) {
     client_->OnError(
         base::StringPrintf("VideoCaptureDeviceMFWin: %s",
                            logging::SystemErrorCodeToString(hr).c_str()));
   }
 }
 
 }  // namespace media