resolution_selector.cc

// Copyright (c) 2010 The Chromium OS 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 "monitor_reconfig/resolution_selector.h"

#include "base/logging.h"

namespace monitor_reconfig {

using std::string;
using std::vector;


const int ResolutionSelector::kMaxProjectorPixels = 1280 * 720;


bool ResolutionSelector::FindBestResolutions(
    const vector<Mode>& lcd_modes,
    const vector<Mode>& external_modes,
    Mode* lcd_resolution,
    Mode* external_resolution,
    Mode* screen_resolution) {
  DCHECK(!lcd_modes.empty());

  // If there's no external display, just use the highest resolution
  // available from the LCD.
  if (external_modes.empty()) {
    *lcd_resolution = *screen_resolution = lcd_modes[0];
    external_resolution->name.clear();
    return true;
  }

  const int max_lcd_size = lcd_modes[0].width * lcd_modes[0].height;
  const int max_external_size =
      external_modes[0].width * external_modes[0].height;

  if (max_lcd_size >= max_external_size) {
    return FindNearestResolutions(
        lcd_modes, external_modes,
        lcd_resolution, external_resolution, screen_resolution);
  } else {
    // If the external output is large enough that we think it's a monitor
    // (as opposed to a projector), then we just use its max resolution and
    // forget about trying to choose a screen size that'll fit on the
    // built-in display.
    if (max_external_size > kMaxProjectorPixels) {
      *external_resolution = *screen_resolution = external_modes[0];
      lcd_resolution->name.clear();
      return true;
    }
    return FindNearestResolutions(
        external_modes, lcd_modes,
        external_resolution, lcd_resolution, screen_resolution);
  }
}

bool ResolutionSelector::FindNearestResolutions(
    const vector<Mode>& larger_device_modes,
    const vector<Mode>& smaller_device_modes,
    Mode* larger_resolution,
    Mode* smaller_resolution,
    Mode* screen_resolution) {
  DCHECK(!larger_device_modes.empty());
  DCHECK(!smaller_device_modes.empty());
  DCHECK(larger_resolution);
  DCHECK(smaller_resolution);
  DCHECK(screen_resolution);

  // Start with the best that the smaller device has to offer.
  *smaller_resolution = smaller_device_modes[0];
  *screen_resolution = *smaller_resolution;
  int smaller_width = smaller_device_modes[0].width;
  int smaller_height = smaller_device_modes[0].height;

  for (vector<Mode>::const_reverse_iterator it =
           larger_device_modes.rbegin();
       it != larger_device_modes.rend(); ++it) {
    if (it->width >= smaller_width && it->height >= smaller_height) {
      *larger_resolution = *it;
      return true;
    }
  }

  LOG(WARNING) << "Failed to find a resolution from larger device "
               << "exceeding chosen resolution from smaller device ("
               << smaller_resolution->name << ")";
  return false;
}

}  // namespace monitor_reconfig