Ensure that the code in the DXVA DX11 decoder which can potentially access the DX11 device context …

content/common/gpu/media/dxva_video_decode_accelerator.cc

 // Copyright (c) 2012 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 "content/common/gpu/media/dxva_video_decode_accelerator.h"
 
 #if !defined(OS_WIN)
 #error This file should only be built on Windows.
 #endif   // !defined(OS_WIN)
 
@@ skipping 91 matching lines @@
 #endif
 
 // MF_XVP_PLAYBACK_MODE
 // Data type: UINT32 (treat as BOOL)
 // If this attribute is TRUE, the video processor will run in playback mode
 // where it allows callers to allocate output samples and allows last frame
 // regeneration (repaint).
 DEFINE_GUID(MF_XVP_PLAYBACK_MODE, 0x3c5d293f, 0xad67, 0x4e29, 0xaf, 0x12,
             0xcf, 0x3e, 0x23, 0x8a, 0xcc, 0xe9);
 
+// Helper class to automatically lock unlock the DX11 device in a scope.
+class AutoDX11DeviceLock {
+ public:
+  explicit AutoDX11DeviceLock(ID3D10Multithread* multi_threaded)
+      : multi_threaded_(multi_threaded) {
+    multi_threaded_->Enter();
+  }
+
+  ~AutoDX11DeviceLock() {
+    multi_threaded_->Leave();
+  }
+
+ private:
+  base::win::ScopedComPtr<ID3D10Multithread> multi_threaded_;
+
+  DISALLOW_COPY_AND_ASSIGN(AutoDX11DeviceLock);
+};
+
 }  // namespace
 
 namespace content {
 
 static const media::VideoCodecProfile kSupportedProfiles[] = {
   media::H264PROFILE_BASELINE,
   media::H264PROFILE_MAIN,
   media::H264PROFILE_HIGH,
   media::VP8PROFILE_ANY,
   media::VP9PROFILE_ANY
@@ skipping 660 matching lines @@
 
   base::win::ScopedComPtr<ID3D11Device> angle_device =
       QueryDeviceObjectFromANGLE<ID3D11Device>(EGL_D3D11_DEVICE_ANGLE);
   RETURN_ON_FAILURE(
       angle_device.get(),
       "Failed to query DX11 device object from ANGLE",
       false);
 
   using_angle_device_ = true;
   d3d11_device_ = angle_device;
-  d3d11_device_->GetImmediateContext(d3d11_device_context_.Receive());
-  RETURN_ON_FAILURE(
-      d3d11_device_context_.get(),
-      "Failed to query DX11 device context from ANGLE device",
-      false);
 
   // Enable multithreaded mode on the device. This ensures that accesses to
   // context are synchronized across threads. We have multiple threads
   // accessing the context, the media foundation decoder threads and the
   // decoder thread via the video format conversion transform.
   hr = multi_threaded_.QueryFrom(angle_device.get());
   RETURN_ON_HR_FAILURE(hr, "Failed to query ID3D10Multithread", false);
   multi_threaded_->SetMultithreadProtected(TRUE);
 
   hr = d3d11_device_manager_->ResetDevice(d3d11_device_.get(),
                                           dx11_dev_manager_reset_token_);
   RETURN_ON_HR_FAILURE(hr, "Failed to reset device", false);
 
-  D3D11_QUERY_DESC query_desc;
-  query_desc.Query = D3D11_QUERY_EVENT;
-  query_desc.MiscFlags = 0;
-  hr = d3d11_device_->CreateQuery(
-      &query_desc,
-      d3d11_query_.Receive());
-  RETURN_ON_HR_FAILURE(hr, "Failed to create DX11 device query", false);
-
   HMODULE video_processor_dll = ::GetModuleHandle(L"msvproc.dll");
   RETURN_ON_FAILURE(video_processor_dll, "Failed to load video processor",
                     false);
 
   hr = CreateCOMObjectFromDll(
       video_processor_dll,
       CLSID_VideoProcessorMFT,
       __uuidof(IMFTransform),
       video_format_converter_mft_.ReceiveVoid());
   if (FAILED(hr)) {
@@ skipping 687 matching lines @@
   pending_output_samples_.clear();
   pending_input_buffers_.clear();
   decoder_.Release();
 
   if (use_dx11_) {
     if (video_format_converter_mft_.get()) {
       video_format_converter_mft_->ProcessMessage(
           MFT_MESSAGE_NOTIFY_END_STREAMING, 0);
       video_format_converter_mft_.Release();
     }
-    d3d11_device_context_.Release();
     d3d11_device_.Release();
     d3d11_device_manager_.Release();
-    d3d11_query_.Release();
     dx11_video_format_converter_media_type_needs_init_ = true;
   } else {
     d3d9_.Release();
     d3d9_device_ex_.Release();
     device_manager_.Release();
     query_.Release();
   }
 
   SetState(kUninitialized);
 }
@@ skipping 452 matching lines @@
     return;
   }
 
   DCHECK(video_frame);
 
   base::win::ScopedComPtr<IMFSample> input_sample;
   input_sample.Attach(video_frame);
 
   DCHECK(video_format_converter_mft_.get());
 
-  // d3d11_device_context_->Begin(d3d11_query_.get());
-
-  hr = video_format_converter_mft_->ProcessInput(0, video_frame, 0);
-  if (FAILED(hr)) {
-    DCHECK(false);
-    RETURN_AND_NOTIFY_ON_HR_FAILURE(hr,
-        "Failed to convert output sample format.", PLATFORM_FAILURE,);
-  }
-
   // The video processor MFT requires output samples to be allocated by the
   // caller. We create a sample with a buffer backed with the ID3D11Texture2D
   // interface exposed by ANGLE. This works nicely as this ensures that the
   // video processor coverts the color space of the output frame and copies
   // the result into the ANGLE texture.
   base::win::ScopedComPtr<IMFSample> output_sample;
   hr = MFCreateSample(output_sample.Receive());
   if (FAILED(hr)) {
     RETURN_AND_NOTIFY_ON_HR_FAILURE(hr,
         "Failed to create output sample.", PLATFORM_FAILURE,);
   }
 
   base::win::ScopedComPtr<IMFMediaBuffer> output_buffer;
   hr = MFCreateDXGISurfaceBuffer(
       __uuidof(ID3D11Texture2D), dest_texture, 0, FALSE,
       output_buffer.Receive());
   if (FAILED(hr)) {
     base::debug::Alias(&hr);
     // TODO(ananta)
     // Remove this CHECK when the change to use DX11 for H/W decoding
     // stablizes.
     CHECK(false);
     RETURN_AND_NOTIFY_ON_HR_FAILURE(hr,
         "Failed to create output sample.", PLATFORM_FAILURE,);
   }
 
   output_sample->AddBuffer(output_buffer.get());
 
-  // Lock the device here as we are accessing the destination texture created
-  // on the main thread.
-  multi_threaded_->Enter();
+  // Lock the device here as we are accessing the DX11 video context and the
+  // texture which need to be synchronized with the main thread.
+  AutoDX11DeviceLock device_lock(multi_threaded_.get());
+
+  hr = video_format_converter_mft_->ProcessInput(0, video_frame, 0);
+  if (FAILED(hr)) {
+    DCHECK(false);
+    RETURN_AND_NOTIFY_ON_HR_FAILURE(hr,
+        "Failed to convert output sample format.", PLATFORM_FAILURE,);
+  }
 
   DWORD status = 0;
   MFT_OUTPUT_DATA_BUFFER format_converter_output = {};
   format_converter_output.pSample = output_sample.get();
   hr = video_format_converter_mft_->ProcessOutput(
         0,  // No flags
         1,  // # of out streams to pull from
         &format_converter_output,
         &status);
 
-  d3d11_device_context_->Flush();
-  d3d11_device_context_->End(d3d11_query_.get());
-
-  multi_threaded_->Leave();
-
   if (FAILED(hr)) {
     base::debug::Alias(&hr);
     // TODO(ananta)
     // Remove this CHECK when the change to use DX11 for H/W decoding
     // stablizes.
     CHECK(false);
     RETURN_AND_NOTIFY_ON_HR_FAILURE(hr,
         "Failed to convert output sample format.", PLATFORM_FAILURE,);
   }
 
@@ skipping 161 matching lines @@
       if (FAILED(hr)) {
         base::debug::Alias(&hr);
         // TODO(ananta)
         // Remove this CHECK when the change to use DX11 for H/W decoding
         // stablizes.
         CHECK(false);
       }
       RETURN_AND_NOTIFY_ON_HR_FAILURE(hr,
           "Failed to set converter output type", PLATFORM_FAILURE, false);
 
-      hr = video_format_converter_mft_->ProcessMessage(
-          MFT_MESSAGE_NOTIFY_BEGIN_STREAMING, 0);
-      if (FAILED(hr)) {
-        // TODO(ananta)
-        // Remove this CHECK when the change to use DX11 for H/W decoding
-        // stablizes.
-        RETURN_AND_NOTIFY_ON_FAILURE(
-            false, "Failed to initialize video converter.", PLATFORM_FAILURE,
-            false);
-      }
       dx11_video_format_converter_media_type_needs_init_ = false;
       return true;
     }
     out_media_type.Release();
   }
   return false;
 }
 
 bool DXVAVideoDecodeAccelerator::GetVideoFrameDimensions(
     IMFSample* sample,
@@ skipping 27 matching lines @@
     D3DSURFACE_DESC surface_desc;
     hr = surface->GetDesc(&surface_desc);
     RETURN_ON_HR_FAILURE(hr, "Failed to get surface description", false);
     *width = surface_desc.Width;
     *height = surface_desc.Height;
   }
   return true;
 }
 
 }  // namespace content