Detect HDR capability

gpu/ipc/service/child_window_surface_win.cc

 // Copyright 2015 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 "gpu/ipc/service/child_window_surface_win.h"
 
+#include <d3d11_1.h>
 #include <memory>
 
 #include "base/compiler_specific.h"
 #include "base/memory/ptr_util.h"
+#include "base/metrics/histogram_macros.h"
+#include "base/win/scoped_comptr.h"
 #include "gpu/ipc/common/gpu_messages.h"
 #include "gpu/ipc/service/gpu_channel_manager.h"
 #include "gpu/ipc/service/gpu_channel_manager_delegate.h"
 #include "ui/display/display_switches.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gl/egl_util.h"
+#include "ui/gl/gl_angle_util_win.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_surface_egl.h"
 #include "ui/gl/scoped_make_current.h"
 
+#if defined(NTDDI_WIN10_RS2)
+#define ENABLE_HDR_DETECTION
+#include <dxgi1_6.h>
+#endif
+
 namespace gpu {
 
 ChildWindowSurfaceWin::ChildWindowSurfaceWin(
     std::unique_ptr<gfx::VSyncProvider> vsync_provider,
     base::WeakPtr<ImageTransportSurfaceDelegate> delegate,
     HWND parent_window)
     : gl::NativeViewGLSurfaceEGL(0, std::move(vsync_provider)),
       child_window_(delegate, parent_window),
       alpha_(true),
       first_swap_(true) {
   // Don't use EGL_ANGLE_window_fixed_size so that we can avoid recreating the
   // window surface, which can cause flicker on DirectComposition.
   enable_fixed_size_angle_ = false;
 }
 
+bool ChildWindowSurfaceWin::IsHDRSupported() {
+#if defined(ENABLE_HDR_DETECTION)
+  base::win::ScopedComPtr<ID3D11Device> d3d11_device =
+      gl::QueryD3D11DeviceObjectFromANGLE();
+  if (!d3d11_device) {
+    DLOG(ERROR) << "Failing to detect HDR, couldn't retrieve D3D11 "
+                << "device from ANGLE.";
+    return false;
+  }
+  base::win::ScopedComPtr<IDXGIDevice> dxgi_device;
+  d3d11_device.CopyTo(dxgi_device.GetAddressOf());
+  base::win::ScopedComPtr<IDXGIAdapter> dxgi_adapter;
+  dxgi_device->GetAdapter(dxgi_adapter.GetAddressOf());
+
+  unsigned int i = 0;
+  while (true) {
+    base::win::ScopedComPtr<IDXGIOutput> output;
+    if (FAILED(dxgi_adapter->EnumOutputs(i++, output.GetAddressOf())))
+      break;
+    base::win::ScopedComPtr<IDXGIOutput6> output6;
+    if (FAILED(output.CopyTo(output6.GetAddressOf())))
+      continue;
+
+    DXGI_OUTPUT_DESC1 desc;
+    if (FAILED(output6->GetDesc1(&desc)))
+      continue;
+
+    UMA_HISTOGRAM_SPARSE_SLOWLY("GPU.Output.ColorSpace", desc.ColorSpace);
+    UMA_HISTOGRAM_SPARSE_SLOWLY("GPU.Output.MaxLuminance", desc.MaxLuminance);
+
+    if (desc.ColorSpace == DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020) {
+      UMA_HISTOGRAM_BOOLEAN("GPU.Output.HDR", true);
+      return true;
+    }
+  }
+  UMA_HISTOGRAM_BOOLEAN("GPU.Output.HDR", false);
+#endif
+  return false;
+}
+
 EGLConfig ChildWindowSurfaceWin::GetConfig() {
   if (!config_) {
     int alpha_size = alpha_ ? 8 : EGL_DONT_CARE;
     int bits_per_channel =
         base::CommandLine::ForCurrentProcess()->HasSwitch(switches::kEnableHDR)
             ? 16
             : 8;
 
     EGLint config_attribs[] = {EGL_ALPHA_SIZE,
                                alpha_size,
@@ skipping 121 matching lines @@
 
 void ChildWindowSurfaceWin::WaitForSnapshotRendering() {
   DCHECK(gl::GLContext::GetCurrent()->IsCurrent(this));
   glFinish();
 }
 
 ChildWindowSurfaceWin::~ChildWindowSurfaceWin() {
 }
 
 }  // namespace gpu