Switch DirectComposition layers to BGRA if overlay allocation fails.

gpu/ipc/service/direct_composition_surface_win.cc

 // Copyright 2017 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/direct_composition_surface_win.h"
 
 #include <d3d11_1.h>
 #include <dcomptypes.h>
 
+#include <deque>
+
 #include "base/feature_list.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/optional.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/trace_event/trace_event.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/windows_version.h"
 #include "gpu/ipc/service/gpu_channel_manager.h"
 #include "gpu/ipc/service/gpu_channel_manager_delegate.h"
@@ skipping 44 matching lines @@
   }
 
  private:
   base::Optional<ui::ScopedMakeCurrent> make_current_;
 };
 
 bool SizeContains(const gfx::Size& a, const gfx::Size& b) {
   return gfx::Rect(a).Contains(gfx::Rect(b));
 }
 
+// This keeps track of whether the previous 30 frames used Overlays or GPU
+// composition to present.
+class PresentationHistory {
+ public:
+  static const int kPresentsToStore = 30;
+
+  PresentationHistory() {}
+
+  void AddSample(DXGI_FRAME_PRESENTATION_MODE mode) {
+    if (mode == DXGI_FRAME_PRESENTATION_MODE_COMPOSED)
+      composed_count_++;
+
+    presents_.push_back(mode);
+    if (presents_.size() > kPresentsToStore) {
+      DXGI_FRAME_PRESENTATION_MODE first_mode = presents_.front();
+      if (first_mode == DXGI_FRAME_PRESENTATION_MODE_COMPOSED)
+        composed_count_--;
+      presents_.pop_front();
+    }
+  }
+
+  bool valid() const { return presents_.size() >= kPresentsToStore; }
+  int composed_count() const { return composed_count_; }
+
+ private:
+  std::deque<DXGI_FRAME_PRESENTATION_MODE> presents_;
+  int composed_count_ = 0;
+
+  DISALLOW_COPY_AND_ASSIGN(PresentationHistory);
+};
+
 // Only one DirectComposition surface can be rendered into at a time. Track
 // here which IDCompositionSurface is being rendered into. If another context
 // is made current, then this surface will be suspended.
 IDCompositionSurface* g_current_surface;
 
 }  // namespace
 
 class DCLayerTree {
  public:
   DCLayerTree(DirectCompositionSurfaceWin* surface,
@@ skipping 87 matching lines @@
     return swap_chain_;
   }
 
  private:
   using PFN_DCOMPOSITION_CREATE_SURFACE_HANDLE =
       HRESULT(WINAPI*)(DWORD, SECURITY_ATTRIBUTES*, HANDLE*);
 
   // Returns true if the video processor changed.
   bool InitializeVideoProcessor(const gfx::Size& in_size,
                                 const gfx::Size& out_size);
-  void ReallocateSwapChain();
+  void ReallocateSwapChain(bool yuy2);
+  bool ShouldBeYUY2();
 
   DCLayerTree* surface_;
   PFN_DCOMPOSITION_CREATE_SURFACE_HANDLE create_surface_handle_function_;
 
   gfx::Size swap_chain_size_;
   gfx::Size processor_input_size_;
   gfx::Size processor_output_size_;
   bool is_yuy2_swapchain_ = false;
 
   // This is the scale from the swapchain size to the size of the contents
   // onscreen.
   float swap_chain_scale_x_ = 0.0f;
   float swap_chain_scale_y_ = 0.0f;
 
+  PresentationHistory presentation_history_;
+  bool failed_to_create_yuy2_swapchain_ = false;
+  int frames_since_color_space_change_ = 0;
+
   // This is the GLImage that was presented in the last frame.
   scoped_refptr<gl::GLImageDXGI> last_gl_image_;
 
   base::win::ScopedComPtr<ID3D11Device> d3d11_device_;
   base::win::ScopedComPtr<IDXGISwapChain1> swap_chain_;
   base::win::ScopedComPtr<ID3D11VideoProcessorOutputView> out_view_;
   base::win::ScopedComPtr<ID3D11VideoProcessor> video_processor_;
   base::win::ScopedComPtr<ID3D11VideoProcessorEnumerator>
       video_processor_enumerator_;
   base::win::ScopedComPtr<ID3D11VideoDevice> video_device_;
@@ skipping 74 matching lines @@
   HMODULE dcomp = ::GetModuleHandleA("dcomp.dll");
   CHECK(dcomp);
   create_surface_handle_function_ =
       reinterpret_cast<PFN_DCOMPOSITION_CREATE_SURFACE_HANDLE>(
           GetProcAddress(dcomp, "DCompositionCreateSurfaceHandle"));
   CHECK(create_surface_handle_function_);
 }
 
 DCLayerTree::SwapChainPresenter::~SwapChainPresenter() {}
 
+bool DCLayerTree::SwapChainPresenter::ShouldBeYUY2() {
+  // Start out as YUY2.
+  if (!presentation_history_.valid())
+    return true;
+  int composition_count = presentation_history_.composed_count();
+
+  // It's more efficient to use a BGRA backbuffer instead of YUY2 if overlays
+  // aren't being used, as otherwise DWM will use the video processor a second
+  // time to convert it to BGRA before displaying it on screen.
+
+  if (is_yuy2_swapchain_) {
+    // Switch to BGRA once 3/4 of presents are composed.
+    return composition_count < (PresentationHistory::kPresentsToStore * 3 / 4);
+  } else {
+    // Switch to YUY2 once 3/4 are using overlays (or unknown).
+    return composition_count < (PresentationHistory::kPresentsToStore / 4);
+  }
+}
+
 void DCLayerTree::SwapChainPresenter::PresentToSwapChain(
     const ui::DCRendererLayerParams& params) {
   gl::GLImageDXGI* image_dxgi =
       gl::GLImageDXGI::FromGLImage(params.image.get());
   DCHECK(image_dxgi);
 
   // Swap chain size is the minimum of the on-screen size and the source
   // size so the video processor can do the minimal amount of work and
   // the overlay has to read the minimal amount of data.
   // DWM is also less likely to promote a surface to an overlay if it's
   // much larger than its area on-screen.
   gfx::Rect bounds_rect = params.rect;
   gfx::Size ceiled_input_size = gfx::ToCeiledSize(params.contents_rect.size());
   gfx::Size swap_chain_size = bounds_rect.size();
   swap_chain_size.SetToMin(ceiled_input_size);
 
   // YUY2 surfaces must have an even width.
   if (swap_chain_size.width() % 2 == 1)
     swap_chain_size.set_width(swap_chain_size.width() + 1);
 
   InitializeVideoProcessor(ceiled_input_size, swap_chain_size);
 
+  bool yuy2_swapchain = ShouldBeYUY2();
   bool first_present = false;
-  if (!swap_chain_ || swap_chain_size_ != swap_chain_size) {
+  if (!swap_chain_ || swap_chain_size_ != swap_chain_size ||
+      ((yuy2_swapchain != is_yuy2_swapchain_) &&
+       !failed_to_create_yuy2_swapchain_)) {
     first_present = true;
     swap_chain_size_ = swap_chain_size;
     swap_chain_.Reset();
-    ReallocateSwapChain();
+    ReallocateSwapChain(yuy2_swapchain);
   } else if (last_gl_image_ == image_dxgi) {
     // The swap chain is presenting the same image as last swap, which means
     // that the image was never returned to the video decoder and should have
     // the same contents as last time. It shouldn't need to be redrawn.
     return;
   }
 
   last_gl_image_ = image_dxgi;
 
   if (!out_view_) {
@@ skipping 80 matching lines @@
     hr = video_context_->VideoProcessorBlt(video_processor_.get(),
                                            out_view_.get(), 0, 1, &stream);
     CHECK(SUCCEEDED(hr));
   }
 
   swap_chain_scale_x_ = bounds_rect.width() * 1.0f / swap_chain_size.width();
   swap_chain_scale_y_ = bounds_rect.height() * 1.0f / swap_chain_size.height();
 
   swap_chain_->Present(first_present ? 0 : 1, 0);
 
+  frames_since_color_space_change_++;
+
   base::win::ScopedComPtr<IDXGISwapChainMedia> swap_chain_media;
   if (SUCCEEDED(swap_chain_.QueryInterface(swap_chain_media.Receive()))) {
     DXGI_FRAME_STATISTICS_MEDIA stats = {};
     if (SUCCEEDED(swap_chain_media->GetFrameStatisticsMedia(&stats))) {
       UMA_HISTOGRAM_SPARSE_SLOWLY("GPU.DirectComposition.CompositionMode",
                                   stats.CompositionMode);
+      presentation_history_.AddSample(stats.CompositionMode);
     }
   }
 }
 
 bool DCLayerTree::SwapChainPresenter::InitializeVideoProcessor(
     const gfx::Size& in_size,
     const gfx::Size& out_size) {
   if (video_processor_ && SizeContains(processor_input_size_, in_size) &&
       SizeContains(processor_output_size_, out_size))
     return false;
   processor_input_size_ = in_size;
   processor_output_size_ = out_size;
   surface_->InitializeVideoProcessor(in_size, out_size);
 
   video_processor_enumerator_ = surface_->video_processor_enumerator();
   video_processor_ = surface_->video_processor();
   // out_view_ depends on video_processor_enumerator_, so ensure it's
   // recreated if the enumerator is.
   out_view_.Reset();
   return true;
 }
 
-void DCLayerTree::SwapChainPresenter::ReallocateSwapChain() {
+void DCLayerTree::SwapChainPresenter::ReallocateSwapChain(bool yuy2) {
   TRACE_EVENT0("gpu", "DCLayerTree::SwapChainPresenter::ReallocateSwapChain");
   DCHECK(!swap_chain_);
 
   base::win::ScopedComPtr<IDXGIDevice> dxgi_device;
   d3d11_device_.QueryInterface(dxgi_device.Receive());
   base::win::ScopedComPtr<IDXGIAdapter> dxgi_adapter;
   dxgi_device->GetAdapter(dxgi_adapter.Receive());
   base::win::ScopedComPtr<IDXGIFactory2> dxgi_factory;
   dxgi_adapter->GetParent(IID_PPV_ARGS(dxgi_factory.Receive()));
 
@@ skipping 11 matching lines @@
   desc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;
   desc.AlphaMode = DXGI_ALPHA_MODE_IGNORE;
   desc.Flags =
       DXGI_SWAP_CHAIN_FLAG_YUV_VIDEO | DXGI_SWAP_CHAIN_FLAG_FULLSCREEN_VIDEO;
 
   HANDLE handle;
   create_surface_handle_function_(COMPOSITIONOBJECT_ALL_ACCESS, nullptr,
                                   &handle);
   swap_chain_handle_.Set(handle);
 
-  is_yuy2_swapchain_ = true;
+  if (is_yuy2_swapchain_ != yuy2) {
+    UMA_HISTOGRAM_COUNTS_1000(
+        "GPU.DirectComposition.FramesSinceColorSpaceChange",
+        frames_since_color_space_change_);
+  }
+
+  frames_since_color_space_change_ = 0;
+
+  is_yuy2_swapchain_ = false;
   // The composition surface handle isn't actually used, but
   // CreateSwapChainForComposition can't create YUY2 swapchains.
-  HRESULT hr = media_factory->CreateSwapChainForCompositionSurfaceHandle(
-      d3d11_device_.get(), swap_chain_handle_.Get(), &desc, nullptr,
-      swap_chain_.Receive());
+  HRESULT hr = E_FAIL;
+  if (yuy2) {
+    hr = media_factory->CreateSwapChainForCompositionSurfaceHandle(
+        d3d11_device_.get(), swap_chain_handle_.Get(), &desc, nullptr,
+        swap_chain_.Receive());
+    is_yuy2_swapchain_ = SUCCEEDED(hr);
+    failed_to_create_yuy2_swapchain_ = !is_yuy2_swapchain_;
+  }
 
-  if (FAILED(hr)) {
-    // This should not be hit in production but is a simple fallback for
-    // testing on systems without YUY2 swapchain support.
-    DLOG(ERROR) << "YUY2 creation failed with " << std::hex << hr
-                << ". Falling back to BGRA";
-    is_yuy2_swapchain_ = false;
+  if (!is_yuy2_swapchain_) {
+    if (yuy2) {
+      DLOG(ERROR) << "YUY2 creation failed with " << std::hex << hr
+                  << ". Falling back to BGRA";
+    }
     desc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
     desc.Flags = 0;
     hr = media_factory->CreateSwapChainForCompositionSurfaceHandle(
         d3d11_device_.get(), swap_chain_handle_.Get(), &desc, nullptr,
         swap_chain_.Receive());
     CHECK(SUCCEEDED(hr));
   }
   UMA_HISTOGRAM_BOOLEAN("GPU.DirectComposition.SwapchainFormat",
                         is_yuy2_swapchain_);
   out_view_.Reset();
@@ skipping 560 matching lines @@
 DirectCompositionSurfaceWin::GetWindowTaskRunnerForTesting() {
   return child_window_.GetTaskRunnerForTesting();
 }
 
 base::win::ScopedComPtr<IDXGISwapChain1>
 DirectCompositionSurfaceWin::GetLayerSwapChainForTesting(size_t index) const {
   return layer_tree_->GetLayerSwapChainForTesting(index);
 }
 
 }  // namespace gpu