Lock the decoder device (Angle) device from the decoder thread before copying the decoded frame to …

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 603 matching lines @@
       pictures_requested_(false),
       inputs_before_decode_(0),
       sent_drain_message_(false),
       make_context_current_(make_context_current),
       codec_(media::kUnknownVideoCodec),
       decoder_thread_("DXVAVideoDecoderThread"),
       pending_flush_(false),
       use_dx11_(false),
       dx11_video_format_converter_media_type_needs_init_(true),
       gl_context_(gl_context),
+      dx11_device_locked_(false),
       weak_this_factory_(this) {
   weak_ptr_ = weak_this_factory_.GetWeakPtr();
   memset(&input_stream_info_, 0, sizeof(input_stream_info_));
   memset(&output_stream_info_, 0, sizeof(output_stream_info_));
 }
 
 DXVAVideoDecodeAccelerator::~DXVAVideoDecodeAccelerator() {
   client_ = NULL;
 }
 
@@ skipping 163 matching lines @@
   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 context. 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.
-  base::win::ScopedComPtr<ID3D10Multithread> multi_threaded;
-  hr = multi_threaded.QueryFrom(d3d11_device_context_.get());
+  hr = multi_threaded_.QueryFrom(d3d11_device_context_.get());
   RETURN_ON_HR_FAILURE(hr, "Failed to query ID3D10Multithread", false);
-  multi_threaded->SetMultithreadProtected(TRUE);
+  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,
@@ skipping 140 matching lines @@
 
 void DXVAVideoDecodeAccelerator::Reset() {
   DCHECK(main_thread_task_runner_->BelongsToCurrentThread());
 
   DVLOG(1) << "DXVAVideoDecodeAccelerator::Reset";
 
   State state = GetState();
   RETURN_AND_NOTIFY_ON_FAILURE((state == kNormal || state == kStopped),
       "Reset: invalid state: " << state, ILLEGAL_STATE,);
 
-  decoder_thread_.Stop();
+  StopDecoderThread();
 
   SetState(kResetting);
 
   // If we have pending output frames waiting for display then we drop those
   // frames and set the corresponding picture buffer as available.
   PendingOutputSamples::iterator index;
   for (index = pending_output_samples_.begin();
        index != pending_output_samples_.end();
        ++index) {
     if (index->picture_buffer_id != -1) {
@@ skipping 509 matching lines @@
   client_ = NULL;
 
   if (GetState() != kUninitialized) {
     Invalidate();
   }
 }
 
 void DXVAVideoDecodeAccelerator::Invalidate() {
   if (GetState() == kUninitialized)
     return;
-  decoder_thread_.Stop();
+  StopDecoderThread();
   weak_this_factory_.InvalidateWeakPtrs();
   output_picture_buffers_.clear();
   stale_output_picture_buffers_.clear();
   pending_output_samples_.clear();
   pending_input_buffers_.clear();
   decoder_.Release();
 
   if (use_dx11_) {
     if (video_format_converter_mft_.get()) {
       video_format_converter_mft_->ProcessMessage(
@@ skipping 492 matching lines @@
     // 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.
+  CHECK(!dx11_device_locked_);
+  dx11_device_locked_ = true;
+  multi_threaded_->Enter();
+
   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());
 
   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,);
   }
 
   decoder_thread_task_runner_->PostDelayedTask(

[jbauman, 2015/11/02 20:50:42]

I think you should do the Leave here - it should be fine for other code to use
the D3D11 context while we're waiting for results.

[ananta, 2015/11/02 22:17:56]

We don't need to wait anymore for the flush based on our discussion about
sharing the angle device.

       FROM_HERE,
       base::Bind(&DXVAVideoDecodeAccelerator::FlushDecoder,
                  base::Unretained(this), 0,
                  reinterpret_cast<IDirect3DSurface9*>(NULL),
                  reinterpret_cast<IDirect3DSurface9*>(NULL),
                  picture_buffer_id, input_buffer_id),
                  base::TimeDelta::FromMilliseconds(
                     kFlushDecoderSurfaceTimeoutMs));
 }
 
@@ skipping 15 matching lines @@
   // We need to do this in a loop and call flush multiple times.
   // We have seen the GetData call for flushing the command buffer fail to
   // return success occassionally on multi core machines, leading to an
   // infinite loop.
   // Workaround is to have an upper limit of 4 on the number of iterations to
   // wait for the Flush to finish.
   HRESULT hr = E_FAIL;
 
   if (use_dx11_) {
     BOOL query_data = 0;
     hr = d3d11_device_context_->GetData(d3d11_query_.get(), &query_data,

[jbauman, 2015/11/02 20:50:42]

You could maybe do an Enter() and Leave() just around this call.

[ananta, 2015/11/02 22:17:56]

Ditto

                                         sizeof(BOOL), 0);
     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);
     }
   } else {
     hr = query_->GetData(NULL, 0, D3DGETDATA_FLUSH);
   }
   if ((hr == S_FALSE) && (++iterations < kMaxIterationsForD3DFlush)) {
     decoder_thread_task_runner_->PostDelayedTask(
         FROM_HERE,
         base::Bind(&DXVAVideoDecodeAccelerator::FlushDecoder,
                    base::Unretained(this), iterations, src_surface,
                    dest_surface, picture_buffer_id, input_buffer_id),
         base::TimeDelta::FromMilliseconds(kFlushDecoderSurfaceTimeoutMs));
     return;
   }
 
+  dx11_device_locked_ = false;
+  multi_threaded_->Leave();
+
   main_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&DXVAVideoDecodeAccelerator::CopySurfaceComplete,
                  weak_this_factory_.GetWeakPtr(),
                  src_surface,
                  dest_surface,
                  picture_buffer_id,
                  input_buffer_id));
 }
 
@@ skipping 160 matching lines @@
                          false);
     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;
 }
 
+void DXVAVideoDecodeAccelerator::StopDecoderThread() {
+  if (main_thread_task_runner_->BelongsToCurrentThread()) {
+    if (decoder_thread_.IsRunning()) {
+      decoder_thread_task_runner_->PostTask(
+          FROM_HERE,
+          base::Bind(&DXVAVideoDecodeAccelerator::StopDecoderThread,
+                     base::Unretained(this)));
+    }
+    decoder_thread_.Stop();
+    return;
+  }
+
+  if (dx11_device_locked_) {
+    dx11_device_locked_ = false;
+    multi_threaded_->Leave();
+  }
+}
+
 }  // namespace content