Allow presenting DXGI share handles as overlays.

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>
@@ skipping 456 matching lines @@
         uv_image_memory->memory() + y * uv_image_memory->stride();
     uint8_t* dest = uv_dest_plane_start + dest_stride * y;
     memcpy(dest, uv_source, texture_size.width());
   }
   context->Unmap(staging_texture_.Get(), 0);
   return true;
 }
 
 void DCLayerTree::SwapChainPresenter::PresentToSwapChain(
     const ui::DCRendererLayerParams& params) {
-  gl::GLImageDXGI* image_dxgi =
-      gl::GLImageDXGI::FromGLImage(params.image[0].get());
+  gl::GLImageDXGIBase* image_dxgi =
+      gl::GLImageDXGIBase::FromGLImage(params.image[0].get());
   gl::GLImageMemory* y_image_memory = nullptr;
   gl::GLImageMemory* uv_image_memory = nullptr;
   if (params.image.size() >= 2) {
     y_image_memory = gl::GLImageMemory::FromGLImage(params.image[0].get());
     uv_image_memory = gl::GLImageMemory::FromGLImage(params.image[1].get());
   }
 
   if (!image_dxgi && (!y_image_memory || !uv_image_memory)) {
     DLOG(ERROR) << "Video GLImages are missing";
     last_gl_images_.clear();
@@ skipping 61 matching lines @@
     // The swap chain is presenting the same images as last swap, which means
     // that the images were 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_images_ = params.image;
 
   base::win::ScopedComPtr<ID3D11Texture2D> input_texture;
   UINT input_level;
+  base::win::ScopedComPtr<IDXGIKeyedMutex> keyed_mutex;
   if (image_dxgi) {
     input_texture = image_dxgi->texture();
     input_level = (UINT)image_dxgi->level();
+    if (!input_texture)
+      return;
+    // Keyed mutex may not exist.
+    keyed_mutex = image_dxgi->keyed_mutex();
     staging_texture_.Reset();
   } else {
     DCHECK(y_image_memory);
     DCHECK(uv_image_memory);
     if (!UploadVideoImages(y_image_memory, uv_image_memory))
       return;
     DCHECK(staging_texture_);
     input_texture = staging_texture_;
     input_level = 0;
   }
@@ skipping 44 matching lines @@
                                                    color_space);
     } else {
       D3D11_VIDEO_PROCESSOR_COLOR_SPACE d3d11_color_space =
           gfx::ColorSpaceWin::GetD3D11ColorSpace(output_color_space);
       video_context_->VideoProcessorSetOutputColorSpace(video_processor_.Get(),
                                                         &d3d11_color_space);
     }
   }
 
   {
+    if (keyed_mutex) {
+      // The producer may still be using this texture for a short period of
+      // time, so wait long enough to hopefully avoid glitches. For example,
+      // all levels of the texture share the same keyed mutex, so if the
+      // hardware decoder acquired the mutex to decode into a different array
+      // level then it still may block here temporarily.
+      const int kMaxSyncTimeMs = 1000;
+      HRESULT hr = keyed_mutex->AcquireSync(0, kMaxSyncTimeMs);
+      if (FAILED(hr)) {
+        DLOG(ERROR) << "Error acquiring keyed mutex: " << std::hex << hr;
+        return;
+      }
+    }
     D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC in_desc = {};
     in_desc.ViewDimension = D3D11_VPIV_DIMENSION_TEXTURE2D;
     in_desc.Texture2D.ArraySlice = input_level;
     base::win::ScopedComPtr<ID3D11VideoProcessorInputView> in_view;
     HRESULT hr = video_device_->CreateVideoProcessorInputView(
         input_texture.Get(), video_processor_enumerator_.Get(), &in_desc,
         in_view.GetAddressOf());
     CHECK(SUCCEEDED(hr));
 
     D3D11_VIDEO_PROCESSOR_STREAM stream = {};
     stream.Enable = true;
     stream.OutputIndex = 0;
     stream.InputFrameOrField = 0;
     stream.PastFrames = 0;
     stream.FutureFrames = 0;
     stream.pInputSurface = in_view.Get();
     RECT dest_rect = gfx::Rect(swap_chain_size).ToRECT();
     video_context_->VideoProcessorSetOutputTargetRect(video_processor_.Get(),
                                                       TRUE, &dest_rect);
     video_context_->VideoProcessorSetStreamDestRect(video_processor_.Get(), 0,
                                                     TRUE, &dest_rect);
     RECT source_rect = gfx::Rect(ceiled_input_size).ToRECT();
     video_context_->VideoProcessorSetStreamSourceRect(video_processor_.Get(), 0,
                                                       TRUE, &source_rect);
 
     hr = video_context_->VideoProcessorBlt(video_processor_.Get(),
                                            out_view_.Get(), 0, 1, &stream);
     CHECK(SUCCEEDED(hr));
+    if (keyed_mutex) {
+      HRESULT hr = keyed_mutex->ReleaseSync(0);
+      DCHECK(SUCCEEDED(hr));
+    }
   }
 
   if (first_present) {
     swap_chain_->Present(0, 0);
 
     // DirectComposition can display black for a swapchain between the first
     // and second time it's presented to - maybe the first Present can get
     // lost somehow and it shows the wrong buffer. In that case copy the
     // buffers so both have the correct contents, which seems to help. The
     // first Present() after this needs to have SyncInterval > 0, or else the
@@ skipping 550 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