ui/gl/gl_visual_picker_glx.cc

// Copyright 2016 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 "ui/gl/gl_visual_picker_glx.h"

#include <algorithm>
#include <numeric>
#include <vector>

#include "base/memory/singleton.h"
#include "ui/gfx/x/x11_types.h"
#include "ui/gl/gl_bindings.h"
#include "ui/gl/gl_context.h"
#include "ui/gl/gl_surface_glx.h"

namespace gl {

namespace {

bool IsArgbVisual(const XVisualInfo& visual) {
  return visual.depth == 32 && visual.red_mask == 0xff0000 &&
         visual.green_mask == 0x00ff00 && visual.blue_mask == 0x0000ff;
}

}  // anonymous namespace

// static
GLVisualPickerGLX* GLVisualPickerGLX::GetInstance() {
  return base::Singleton<GLVisualPickerGLX>::get();
}

XVisualInfo GLVisualPickerGLX::PickBestGlVisual(
    const std::vector<XVisualInfo>& visuals,
    bool want_alpha) const {
  // Find the highest scoring visual and return it.
  Visual* default_visual = DefaultVisual(display_, DefaultScreen(display_));
  int highest_score = -1;
  XVisualInfo best_visual{0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
  for (const XVisualInfo& const_visual_info : visuals) {
    int supports_gl, double_buffer, stereo, alpha_size, depth_size,
        stencil_size, num_multisample, visual_caveat;
    // glXGetConfig unfortunately doesn't use const.
    XVisualInfo* visual_info = const_cast<XVisualInfo*>(&const_visual_info);
    if (glXGetConfig(display_, visual_info, GLX_USE_GL, &supports_gl) ||
        !supports_gl ||
        glXGetConfig(display_, visual_info, GLX_DOUBLEBUFFER, &double_buffer) ||
        !double_buffer ||
        glXGetConfig(display_, visual_info, GLX_STEREO, &stereo) || stereo) {
      continue;
    }
    if (has_glx_visual_rating_) {
      if (glXGetConfig(display_, visual_info, GLX_VISUAL_CAVEAT_EXT,
                       &visual_caveat) ||
          visual_caveat != GLX_NONE_EXT) {
        continue;
      }
    }

    // Give precedence to the root visual if it satisfies the basic requirements
    // above.  This can avoid an expensive copy-on-present.
    if (const_visual_info.visual == default_visual)
      return const_visual_info;

    int score = 0;
    if (!has_glx_multisample_ ||
        (!glXGetConfig(display_, visual_info, GLX_SAMPLE_BUFFERS_ARB,
                       &num_multisample) &&
         num_multisample == 0)) {
      score++;
      if (!glXGetConfig(display_, visual_info, GLX_DEPTH_SIZE, &depth_size) &&
          depth_size == 0 &&
          !glXGetConfig(display_, visual_info, GLX_STENCIL_SIZE,
                        &stencil_size) &&
          stencil_size == 0) {
        score++;
        if (!glXGetConfig(display_, visual_info, GLX_ALPHA_SIZE, &alpha_size) &&
            (alpha_size > 0) == want_alpha) {
          score++;
        }
      }
    }

    if (score > highest_score) {
      highest_score = score;
      best_visual = const_visual_info;
    }
  }
  return best_visual;
}

XVisualInfo GLVisualPickerGLX::PickBestSystemVisual(
    const std::vector<XVisualInfo>& visuals) const {
  Visual* default_visual = DefaultVisual(display_, DefaultScreen(display_));
  auto it = std::find_if(visuals.begin(), visuals.end(),
                         [default_visual](const XVisualInfo& visual_info) {
                           return visual_info.visual == default_visual;
                         });
  DCHECK(it != visuals.end());

  const XVisualInfo& default_visual_info = *it;
  std::vector<XVisualInfo> filtered_visuals;
  std::copy_if(
      visuals.begin(), visuals.end(), std::back_inserter(filtered_visuals),
      [&default_visual_info](const XVisualInfo& visual_info) {
        const XVisualInfo& v1 = visual_info;
        const XVisualInfo& v2 = default_visual_info;
        return v1.c_class == v2.c_class && v1.depth == v2.depth &&
               v1.red_mask == v2.red_mask && v1.green_mask == v2.green_mask &&
               v1.blue_mask == v2.blue_mask &&
               v1.colormap_size == v2.colormap_size &&
               v1.bits_per_rgb == v2.bits_per_rgb;
      });
  return PickBestGlVisual(filtered_visuals, IsArgbVisual(default_visual_info));
}

XVisualInfo GLVisualPickerGLX::PickBestRgbaVisual(
    const std::vector<XVisualInfo>& visuals) const {
  // Filter the visuals by the best class.
  auto score = [](int c_class) {
    // A higher score is more preferable.
    switch (c_class) {
      case TrueColor:
        return 1;
      case DirectColor:
        return 0;
      default:
        return -1;
    }
  };
  int best_class_score =
      std::accumulate(visuals.begin(), visuals.end(), -1,
                      [&score](int acc, const XVisualInfo& visual_info) {
                        return std::max(acc, score(visual_info.c_class));
                      });
  std::vector<XVisualInfo> filtered_visuals;
  std::copy_if(visuals.begin(), visuals.end(),
               std::back_inserter(filtered_visuals),
               [best_class_score, &score](const XVisualInfo& visual_info) {
                 if (!IsArgbVisual(visual_info))
                   return false;
                 return score(visual_info.c_class) == best_class_score;
               });
  return PickBestGlVisual(filtered_visuals, true);
}

GLVisualPickerGLX::GLVisualPickerGLX() : display_(gfx::GetXDisplay()) {
  has_glx_visual_rating_ =
      GLSurfaceGLX::HasGLXExtension("GLX_EXT_visual_rating");
  has_glx_multisample_ = GLSurfaceGLX::HasGLXExtension("GLX_EXT_multisample");

  XVisualInfo visual_template;
  visual_template.screen = DefaultScreen(display_);

  // Get all of the visuals for the default screen.
  int n_visuals;
  gfx::XScopedPtr<XVisualInfo[]> x_visuals(
      XGetVisualInfo(display_, VisualScreenMask, &visual_template, &n_visuals));
  std::vector<XVisualInfo> visuals;
  for (int i = 0; i < n_visuals; i++)
    visuals.push_back(x_visuals[i]);

  system_visual_ = PickBestSystemVisual(visuals);
  rgba_visual_ = PickBestRgbaVisual(visuals);
}

GLVisualPickerGLX::~GLVisualPickerGLX() {}

}  // namespace gl