Video capture: Refactor GetBestMatchedFormat from Win to OS independent

media/video/capture/win/capability_list_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/capability_list_win.h"
 
 #include <algorithm>
+#include <functional>
 
 #include "base/logging.h"
 
 namespace media {
-namespace {
 
-// Help structure used for comparing video capture capabilities.
-struct ResolutionDiff {
-  const VideoCaptureCapabilityWin* capability;
-  int diff_height;
-  int diff_width;
-  int diff_frame_rate;
-};
+static bool CompareCapability(const VideoCaptureFormat& requested,
+                              const CapabilityWin& capability_lhs,
+                              const CapabilityWin& capability_rhs) {
+  const VideoCaptureFormat& lhs = capability_lhs.supported_format;
+  const VideoCaptureFormat& rhs = capability_rhs.supported_format;
 
-bool CompareHeight(const ResolutionDiff& item1, const ResolutionDiff& item2) {
-  return abs(item1.diff_height) < abs(item2.diff_height);
+  const int diff_height_lhs =
+      std::abs(lhs.frame_size.height() - requested.frame_size.height());
+  const int diff_height_rhs =
+      std::abs(rhs.frame_size.height() - requested.frame_size.height());
+  if (diff_height_lhs != diff_height_rhs)
+    return diff_height_lhs < diff_height_rhs;
+
+  const int diff_width_lhs =
+      std::abs(lhs.frame_size.width() - requested.frame_size.width());
+  const int diff_width_rhs =
+      std::abs(rhs.frame_size.width() - requested.frame_size.width());
+  if (diff_width_lhs != diff_width_rhs)
+    return diff_width_lhs < diff_width_rhs;
+
+  const float diff_fps_lhs = std::fabs(lhs.frame_rate - requested.frame_rate);
+  const float diff_fps_rhs = std::fabs(rhs.frame_rate - requested.frame_rate);
+  if (diff_fps_lhs != diff_fps_rhs)
+    return diff_fps_lhs < diff_fps_rhs;
+
+  return lhs.pixel_format < rhs.pixel_format;
 }
 
-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.capability->supported_format.pixel_format <
-         item2.capability->supported_format.pixel_format;
-}
-
-}  // namespace.
-
-CapabilityList::CapabilityList() {
-  DetachFromThread();
-}
-
-CapabilityList::~CapabilityList() {}
-
-// Appends an entry to the list.
-void CapabilityList::Add(const VideoCaptureCapabilityWin& capability) {
-  DCHECK(CalledOnValidThread());
-  capabilities_.push_back(capability);
-}
-
-const VideoCaptureCapabilityWin& CapabilityList::GetBestMatchedFormat(
-    int requested_width,
-    int requested_height,
-    float requested_frame_rate) const {
-  DCHECK(CalledOnValidThread());
-  DCHECK(!capabilities_.empty());
-
-  std::list<ResolutionDiff> diff_list;
-
-  // Loop through the candidates to create a list of differentials between the
-  // requested resolution and the camera capability.
-  for (Capabilities::const_iterator it = capabilities_.begin();
-       it != capabilities_.end(); ++it) {
-    ResolutionDiff diff;
-    diff.capability = &(*it);
-    diff.diff_width = it->supported_format.frame_size.width() - requested_width;
-    diff.diff_height =
-        it->supported_format.frame_size.height() - requested_height;
-    // The 1000 allows using integer arithmetic for f.i. 29.971 fps.
-    diff.diff_frame_rate =
-        1000 * ((static_cast<float>(it->frame_rate_numerator) /
-                 it->frame_rate_denominator) -
-                requested_frame_rate);
-    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;
+CapabilityWin GetBestMatchedCapability(const VideoCaptureFormat& requested,
+                                       const CapabilityList& capabilities) {
+  DCHECK(!capabilities.empty());
+  CapabilityWin best_match = capabilities.front();

[mcasas, 2014/10/14 15:17:35]

const CapabilityWin&

[mcasas, 2014/10/14 15:17:35]

What if the first capability is bad and none improves its CompareCapability()?
Shouldn't we return an empty Capability in that case...? Bah probably this is
all paranoia, seems like before (l.117 on the original file) we could end up
with an empty |diff_list| and still do a .front.capability() on it :?

[magjed_chromium, 2014/10/14 15:27:47]

Not possible because I can't reassign a reference.

[magjed_chromium, 2014/10/14 15:27:48]

I know the list is non-empty, because I do DCHECK(!capabilities.empty()); This
is exactly as the previous behaviour.

+  for (const CapabilityWin& capability : capabilities) {
+    if (CompareCapability(requested, capability, best_match)) {

[mcasas, 2014/10/14 15:17:35]

No need for {} in the if.

[magjed_chromium, 2014/10/14 15:27:48]

Done.

+      best_match = capability;
     }
   }
-
-  // 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;
+  return best_match;
 }
 
 }  // namespace media