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) {

[mcasas, 2014/09/10 16:52:28]

const IMFMediaType* type ?

[tommi (sloooow) - chröme, 2014/09/10 17:41:09]

COM doesn't have a concept of 'const' for objects and methods.  Hence if this
was made const, the implementation would not be able to hold on to a reference
to it (since it can't call AddRef/Release).

So, when passing around naked pointers to COM objects, don't use const.  What
you could do instead would be to pass |const ScopedComPtr<IMFMediaType>& type|. 
This would be in line with how we typically pass reference counted objects.

   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,

[mcasas, 2014/09/10 16:52:28]

s/FillCapabilities/FillFormat/

const IMFMediaType* type

-                                     VideoCaptureCapabilityWin* capability) {
+                                     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()))) {
+    VideoCaptureFormat format;
+    if (FillCapabilitiesFromType(type, &format))
+      capabilities->push_back(VideoCaptureCapabilityWin(stream_index, format));
     type.Release();
+    stream_index++;

[tommi (sloooow) - chröme, 2014/09/09 20:11:11]

++stream_index;

[magjed_chromium, 2014/09/10 18:34:21]

Done.

   }
 
   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 =
+          *GetBestMatchedFormat(params.requested_format, capabilities);
       ScopedComPtr<IMFMediaType> type;
       hr = reader_->GetNativeMediaType(
-          kFirstVideoStream, found_capability.stream_index, type.Receive());
+          kFirstVideoStream, found_capability.first, 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;
+            capture_format_ = found_capability.second;
             capture_ = true;
             return;
           }
         }
       }
     }
   }
 
   OnError(hr);
 }
@@ skipping 53 matching lines @@
 
 void VideoCaptureDeviceMFWin::OnError(HRESULT hr) {
   if (client_.get()) {
     client_->OnError(
         base::StringPrintf("VideoCaptureDeviceMFWin: %s",
                            logging::SystemErrorCodeToString(hr).c_str()));
   }
 }
 
 }  // namespace media