Don't wait endlessly for flushing the batched queries sent to the GPU driver during H/W decode

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 54 matching lines @@
       StopOnError(error_code);                                      \
       return ret;                                                   \
     }                                                               \
   } while (0)
 
 #define RETURN_AND_NOTIFY_ON_HR_FAILURE(result, log, error_code, ret)  \
   RETURN_AND_NOTIFY_ON_FAILURE(SUCCEEDED(result),                      \
                                log << ", HRESULT: 0x" << std::hex << result, \
                                error_code, ret);
 
+// Maximum number of iterations we allow before aborting the attempt to flush
+// the batched queries to the driver and allow torn/corrupt frames to be
+// rendered.
+enum { kMaxIterationsForD3DFlush = 10 };
+
 static IMFSample* CreateEmptySample() {
   base::win::ScopedComPtr<IMFSample> sample;
   HRESULT hr = MFCreateSample(sample.Receive());
   RETURN_ON_HR_FAILURE(hr, "MFCreateSample failed", NULL);
   return sample.Detach();
 }
 
 // Creates a Media Foundation sample with one buffer of length |buffer_length|
 // on a |align|-byte boundary. Alignment must be a perfect power of 2 or 0.
 static IMFSample* CreateEmptySampleWithBuffer(int buffer_length, int align) {
@@ skipping 144 matching lines @@
 
   HRESULT hr = DXVAVideoDecodeAccelerator::device_->CreateTexture(
       buffer.size().width(),
       buffer.size().height(),
       1,
       D3DUSAGE_RENDERTARGET,
       D3DFMT_X8R8G8B8,
       D3DPOOL_DEFAULT,
       picture_buffer->decoding_texture_.Receive(),
       &share_handle);
+
   RETURN_ON_HR_FAILURE(hr, "Failed to create texture",
                        linked_ptr<DXVAPictureBuffer>(NULL));
   return picture_buffer;
 }
 
 DXVAVideoDecodeAccelerator::DXVAPictureBuffer::DXVAPictureBuffer(
     const media::PictureBuffer& buffer)
     : available_(true),
       picture_buffer_(buffer),
       decoding_surface_(NULL) {
@@ skipping 68 matching lines @@
                             d3d_surface,
                             NULL,
                             D3DTEXF_NONE);
   RETURN_ON_HR_FAILURE(hr, "Colorspace conversion via StretchRect failed",
                         false);
 
   // Ideally, this should be done immediately before the draw call that uses
   // the texture. Flush it once here though.
   hr = query_->Issue(D3DISSUE_END);
   RETURN_ON_HR_FAILURE(hr, "Failed to issue END", false);
-  do {
-    hr = query_->GetData(NULL, 0, D3DGETDATA_FLUSH);
-    if (hr == S_FALSE)
-      Sleep(1);  // Poor-man's Yield().
-  } while (hr == S_FALSE);
+
+  // The DXVA decoder has its own device which it uses for decoding. ANGLE
+  // has its own device which we don't have access to.
+  // The above code attempts to copy the decoded picture into a surface
+  // which is owned by ANGLE. As there are multiple devices involved in
+  // this, the StretchRect call above is not synchronous.
+  // We attempt to flush the batched operations to ensure that the picture is
+  // copied to the surface owned by ANGLE.
+  // 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 10 on the number of iterations to
+  // wait for the Flush to finish.
+  int iterations = 0;
+  while ((query_->GetData(NULL, 0, D3DGETDATA_FLUSH) == S_FALSE) &&
+          ++iterations < kMaxIterationsForD3DFlush) {
+    Sleep(1);  // Poor-man's Yield().
+  }
   eglBindTexImage(
       static_cast<EGLDisplay*>(eglGetDisplay(EGL_DEFAULT_DISPLAY)),
       decoding_surface_,
       EGL_BACK_BUFFER);
-
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
   glBindTexture(GL_TEXTURE_2D, current_texture);
   return true;
 }
 
 DXVAVideoDecodeAccelerator::PendingSampleInfo::PendingSampleInfo(
     int32 buffer_id, IMFSample* sample)
     : input_buffer_id(buffer_id) {
   output_sample.Attach(sample);
 }
@@ skipping 61 matching lines @@
 
   hr = device_manager_->ResetDevice(device_, dev_manager_reset_token_);
   RETURN_ON_HR_FAILURE(hr, "Failed to reset device", false);
 
   hr = device_->CreateQuery(D3DQUERYTYPE_EVENT, &query_);
   RETURN_ON_HR_FAILURE(hr, "Failed to create D3D device query", false);
   // Ensure query_ API works (to avoid an infinite loop later in
   // CopyOutputSampleDataToPictureBuffer).
   hr = query_->Issue(D3DISSUE_END);
   RETURN_ON_HR_FAILURE(hr, "Failed to issue END test query", false);
-
   return true;
 }
 
 DXVAVideoDecodeAccelerator::DXVAVideoDecodeAccelerator(
     media::VideoDecodeAccelerator::Client* client,
     const base::Callback<bool(void)>& make_context_current)
     : client_(client),
       egl_config_(NULL),
       state_(kUninitialized),
       pictures_requested_(false),
@@ skipping 627 matching lines @@
       return;
   }
 
   MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
       &DXVAVideoDecodeAccelerator::NotifyFlushDone, base::AsWeakPtr(this)));
 
   state_ = kNormal;
 }
 
 }  // namespace content