Wait on fence before reusing DXVA picture buffer

content/common/gpu/media/dxva_video_decode_accelerator_win.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_win.h"
 
 #if !defined(OS_WIN)
 #error This file should only be built on Windows.
 #endif   // !defined(OS_WIN)
 
@@ skipping 23 matching lines @@
 #include "base/trace_event/trace_event.h"
 #include "base/win/windows_version.h"
 #include "build/build_config.h"
 #include "content/public/common/content_switches.h"
 #include "media/base/win/mf_initializer.h"
 #include "media/video/video_decode_accelerator.h"
 #include "third_party/angle/include/EGL/egl.h"
 #include "third_party/angle/include/EGL/eglext.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_context.h"
+#include "ui/gl/gl_fence.h"
 #include "ui/gl/gl_surface_egl.h"
 #include "ui/gl/gl_switches.h"
 
 namespace {
 
 // Path is appended on to the PROGRAM_FILES base path.
 const wchar_t kVPXDecoderDLLPath[] = L"Intel\\Media SDK\\";
 
 const wchar_t kVP8DecoderDLLName[] =
 #if defined(ARCH_CPU_X86)
@@ skipping 101 matching lines @@
                                log << ", HRESULT: 0x" << std::hex << result, \
                                error_code, ret);
 
 enum {
   // 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.
   kFlushDecoderSurfaceTimeoutMs = 1,
   // Maximum iterations where we try to flush the d3d device.
   kMaxIterationsForD3DFlush = 4,
+  // Maximum iterations where we try to flush the ANGLE device before reusing
+  // the texture.
+  kMaxIterationsForANGLEReuseFlush = 16,
   // We only request 5 picture buffers from the client which are used to hold
   // the decoded samples. These buffers are then reused when the client tells
   // us that it is done with the buffer.
   kNumPictureBuffers = 5,
   // The keyed mutex should always be released before the other thread
   // attempts to acquire it, so AcquireSync should always return immediately.
   kAcquireSyncWaitMs = 0,
 };
 
 static IMFSample* CreateEmptySample() {
@@ skipping 178 matching lines @@
   static linked_ptr<DXVAPictureBuffer> Create(
       const DXVAVideoDecodeAccelerator& decoder,
       const media::PictureBuffer& buffer,
       EGLConfig egl_config);
   ~DXVAPictureBuffer();
 
   bool InitializeTexture(const DXVAVideoDecodeAccelerator& decoder,
                          bool use_rgb);
 
   bool ReusePictureBuffer();
+  void ResetReuseFence();
   // Copies the output sample data to the picture buffer provided by the
   // client.
   // The dest_surface parameter contains the decoded bits.
   bool CopyOutputSampleDataToPictureBuffer(
       DXVAVideoDecodeAccelerator* decoder,
       IDirect3DSurface9* dest_surface,
       ID3D11Texture2D* dx11_texture,
       int input_buffer_id);
 
   bool available() const {
     return available_;
   }
 
   void set_available(bool available) {
     available_ = available;
   }
 
   int id() const {
     return picture_buffer_.id();
   }
 
   gfx::Size size() const {
     return picture_buffer_.size();
   }
 
+  bool waiting_to_reuse() const { return waiting_to_reuse_; }
+
+  gfx::GLFence* reuse_fence() { return reuse_fence_.get(); }
+
   // Called when the source surface |src_surface| is copied to the destination
   // |dest_surface|
   bool CopySurfaceComplete(IDirect3DSurface9* src_surface,
                            IDirect3DSurface9* dest_surface);
 
  private:
   explicit DXVAPictureBuffer(const media::PictureBuffer& buffer);
 
   bool available_;
+
+  // This is true if the decoder is currently waiting on the fence before
+  // reusing the buffer.
+  bool waiting_to_reuse_;
   media::PictureBuffer picture_buffer_;
   EGLSurface decoding_surface_;
+  scoped_ptr<gfx::GLFence> reuse_fence_;
 
   HANDLE texture_share_handle_;
   base::win::ScopedComPtr<IDirect3DTexture9> decoding_texture_;
   base::win::ScopedComPtr<ID3D11Texture2D> dx11_decoding_texture_;
 
   base::win::ScopedComPtr<IDXGIKeyedMutex> egl_keyed_mutex_;
   base::win::ScopedComPtr<IDXGIKeyedMutex> dx11_keyed_mutex_;
 
   // This is the last value that was used to release the keyed mutex.
   uint64_t keyed_mutex_value_;
@@ skipping 107 matching lines @@
     RETURN_ON_HR_FAILURE(hr, "Failed to create texture", false);
     RETURN_ON_FAILURE(texture_share_handle_, "Failed to query shared handle",
                       false);
   }
   return true;
 }
 
 DXVAVideoDecodeAccelerator::DXVAPictureBuffer::DXVAPictureBuffer(
     const media::PictureBuffer& buffer)
     : available_(true),
+      waiting_to_reuse_(false),
       picture_buffer_(buffer),
       decoding_surface_(NULL),
       texture_share_handle_(nullptr),
       keyed_mutex_value_(0),
       use_rgb_(true) {}
 
 DXVAVideoDecodeAccelerator::DXVAPictureBuffer::~DXVAPictureBuffer() {
   if (decoding_surface_) {
     EGLDisplay egl_display = gfx::GLSurfaceEGL::GetHardwareDisplay();
 
@@ skipping 12 matching lines @@
 bool DXVAVideoDecodeAccelerator::DXVAPictureBuffer::ReusePictureBuffer() {
   DCHECK(decoding_surface_);
   EGLDisplay egl_display = gfx::GLSurfaceEGL::GetHardwareDisplay();
   eglReleaseTexImage(
     egl_display,
     decoding_surface_,
     EGL_BACK_BUFFER);
   decoder_surface_.Release();
   target_surface_.Release();
   decoder_dx11_texture_.Release();
+  waiting_to_reuse_ = false;
   set_available(true);
   if (egl_keyed_mutex_) {
     HRESULT hr = egl_keyed_mutex_->ReleaseSync(++keyed_mutex_value_);
     RETURN_ON_FAILURE(hr == S_OK, "Could not release sync mutex", false);
   }
   return true;
 }
 
+void DXVAVideoDecodeAccelerator::DXVAPictureBuffer::ResetReuseFence() {
+  if (!reuse_fence_ || !reuse_fence_->ResetSupported())
+    reuse_fence_.reset(gfx::GLFence::Create());
+  else
+    reuse_fence_->ResetState();
+  waiting_to_reuse_ = true;
+}
+
 bool DXVAVideoDecodeAccelerator::DXVAPictureBuffer::
     CopyOutputSampleDataToPictureBuffer(
         DXVAVideoDecodeAccelerator* decoder,
         IDirect3DSurface9* dest_surface,
         ID3D11Texture2D* dx11_texture,
         int input_buffer_id) {
   DCHECK(dest_surface || dx11_texture);
   if (dx11_texture) {
     // Grab a reference on the decoder texture. This reference will be released
     // when we receive a notification that the copy was completed or when the
@@ skipping 171 matching lines @@
     create_dxgi_device_manager_ = reinterpret_cast<CreateDXGIDeviceManager>(
             ::GetProcAddress(dxgi_manager_dll, "MFCreateDXGIDeviceManager"));
   }
 
   RETURN_AND_NOTIFY_ON_FAILURE(
       gfx::g_driver_egl.ext.b_EGL_ANGLE_surface_d3d_texture_2d_share_handle,
       "EGL_ANGLE_surface_d3d_texture_2d_share_handle unavailable",
       PLATFORM_FAILURE,
       false);
 
+  RETURN_AND_NOTIFY_ON_FAILURE(gfx::GLFence::IsSupported(),
+                               "GL fences are unsupported", PLATFORM_FAILURE,
+                               false);
+
   State state = GetState();
   RETURN_AND_NOTIFY_ON_FAILURE((state == kUninitialized),
       "Initialize: invalid state: " << state, ILLEGAL_STATE, false);
 
   media::InitializeMediaFoundation();
 
   RETURN_AND_NOTIFY_ON_FAILURE(InitDecoder(config.profile),
       "Failed to initialize decoder", PLATFORM_FAILURE, false);
 
   RETURN_AND_NOTIFY_ON_FAILURE(GetStreamsInfoAndBufferReqs(),
@@ skipping 251 matching lines @@
     it = stale_output_picture_buffers_.find(picture_buffer_id);
     RETURN_AND_NOTIFY_ON_FAILURE(it != stale_output_picture_buffers_.end(),
         "Invalid picture id: " << picture_buffer_id, INVALID_ARGUMENT,);
     main_thread_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&DXVAVideoDecodeAccelerator::DeferredDismissStaleBuffer,
                    weak_this_factory_.GetWeakPtr(), picture_buffer_id));
     return;
   }
 
-  RETURN_AND_NOTIFY_ON_FAILURE(it->second->ReusePictureBuffer(),
+  if (it->second->available() || it->second->waiting_to_reuse())
+    return;
+
+  if (use_keyed_mutex_ || using_angle_device_) {
+    RETURN_AND_NOTIFY_ON_FAILURE(it->second->ReusePictureBuffer(),
+                                 "Failed to reuse picture buffer",
+                                 PLATFORM_FAILURE, );
+
+    ProcessPendingSamples();
+    if (pending_flush_) {
+      decoder_thread_task_runner_->PostTask(
+          FROM_HERE, base::Bind(&DXVAVideoDecodeAccelerator::FlushInternal,
+                                base::Unretained(this)));
+    }
+  } else {
+    RETURN_AND_NOTIFY_ON_FAILURE(make_context_current_.Run(),
+                                 "Failed to make context current",
+                                 PLATFORM_FAILURE, );
+    it->second->ResetReuseFence();
+
+    WaitForOutputBuffer(picture_buffer_id, 0);
+  }
+}
+
+void DXVAVideoDecodeAccelerator::WaitForOutputBuffer(int32_t picture_buffer_id,
+                                                     int count) {
+  DCHECK(main_thread_task_runner_->BelongsToCurrentThread());
+  OutputBuffers::iterator it = output_picture_buffers_.find(picture_buffer_id);
+  if (it == output_picture_buffers_.end())
+    return;
+
+  DXVAPictureBuffer* picture_buffer = it->second.get();
+
+  DCHECK(!picture_buffer->available());
+  DCHECK(picture_buffer->waiting_to_reuse());
+
+  gfx::GLFence* fence = picture_buffer->reuse_fence();
+  RETURN_AND_NOTIFY_ON_FAILURE(make_context_current_.Run(),
+                               "Failed to make context current",
+                               PLATFORM_FAILURE, );
+  if (count <= kMaxIterationsForANGLEReuseFlush && !fence->HasCompleted()) {
+    main_thread_task_runner_->PostDelayedTask(
+        FROM_HERE, base::Bind(&DXVAVideoDecodeAccelerator::WaitForOutputBuffer,
+                              weak_this_factory_.GetWeakPtr(),
+                              picture_buffer_id, count + 1),
+        base::TimeDelta::FromMilliseconds(kFlushDecoderSurfaceTimeoutMs));
+    return;
+  }
+  RETURN_AND_NOTIFY_ON_FAILURE(picture_buffer->ReusePictureBuffer(),
                                "Failed to reuse picture buffer",
                                PLATFORM_FAILURE, );
 
   ProcessPendingSamples();
   if (pending_flush_) {
     decoder_thread_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&DXVAVideoDecodeAccelerator::FlushInternal,
                    base::Unretained(this)));
   }
@@ skipping 1342 matching lines @@
       }
       RETURN_ON_HR_FAILURE(hr, "Failed to set output type", false);
       return true;
     }
     media_type.Release();
   }
   return false;
 }
 
 }  // namespace content