Correctly handle reusing reset picture buffers.

media/gpu/dxva_picture_buffer_win.cc

 // Copyright 2016 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 "media/gpu/dxva_picture_buffer_win.h"
 
 #include "media/gpu/dxva_video_decode_accelerator_win.h"
 #include "third_party/angle/include/EGL/egl.h"
 #include "third_party/angle/include/EGL/eglext.h"
 #include "ui/gl/gl_bindings.h"
@@ skipping 516 matching lines @@
     ID3D11Texture2D* dx11_texture,
     int input_buffer_id) {
   DCHECK(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
   // DXVAPictureBuffer instance is destroyed.
   dx11_decoding_texture_ = dx11_texture;
   decoder->CopyTexture(dx11_texture, decoder_copy_texture_.get(),
                        dx11_keyed_mutex_, keyed_mutex_value_, id(),
                        input_buffer_id);
+  // The texture copy will acquire the current keyed mutex value and release
+  // with the value + 1.
+  keyed_mutex_value_++;
   return true;
 }
 
 bool EGLStreamCopyPictureBuffer::CopySurfaceComplete(
     IDirect3DSurface9* src_surface,
     IDirect3DSurface9* dest_surface) {
   DCHECK(!available());
   DCHECK(!src_surface);
   DCHECK(!dest_surface);
 
   dx11_decoding_texture_.Release();
 
-  keyed_mutex_value_++;
   HRESULT hr =
       egl_keyed_mutex_->AcquireSync(keyed_mutex_value_, kAcquireSyncWaitMs);
   RETURN_ON_FAILURE(hr == S_OK, "Could not acquire sync mutex", false);
 
   EGLAttrib frame_attributes[] = {
       EGL_D3D_TEXTURE_SUBRESOURCE_ID_ANGLE, 0, EGL_NONE,
   };
 
   EGLDisplay egl_display = gl::GLSurfaceEGL::GetHardwareDisplay();
 
   EGLBoolean result = eglStreamPostD3DTextureNV12ANGLE(
       egl_display, stream_, static_cast<void*>(angle_copy_texture_.get()),
       frame_attributes);
   RETURN_ON_FAILURE(result, "Could not post stream", false);
   result = eglStreamConsumerAcquireKHR(egl_display, stream_);
   RETURN_ON_FAILURE(result, "Could not post acquire stream", false);
+  frame_in_consumer_ = true;
 
   return true;
 }
 
 bool EGLStreamCopyPictureBuffer::ReusePictureBuffer() {
   EGLDisplay egl_display = gl::GLSurfaceEGL::GetHardwareDisplay();
 
-  HRESULT hr = egl_keyed_mutex_->ReleaseSync(++keyed_mutex_value_);
-  RETURN_ON_FAILURE(hr == S_OK, "Could not release sync mutex", false);
+  if (frame_in_consumer_) {
+    HRESULT hr = egl_keyed_mutex_->ReleaseSync(++keyed_mutex_value_);
+    RETURN_ON_FAILURE(hr == S_OK, "Could not release sync mutex", false);
+  }
+  frame_in_consumer_ = false;
 
   if (stream_) {
     EGLBoolean result = eglStreamConsumerReleaseKHR(egl_display, stream_);
     RETURN_ON_FAILURE(result, "Could not release stream", false);
   }
   set_available(true);
   return true;
 }
 
 }  // namespace media