Fix black frames on segment boundaries in H/W decoded h.264 video on windows.

media/gpu/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 "media/gpu/dxva_video_decode_accelerator_win.h"
 
 #include <memory>
 
 #if !defined(OS_WIN)
 #error This file should only be built on Windows.
@@ skipping 692 matching lines @@
   config_change_detector_.reset(new H264ConfigChangeDetector);
 
   SetState(kNormal);
 
   StartDecoderThread();
   return true;
 }
 
 bool DXVAVideoDecodeAccelerator::CreateD3DDevManager() {
   TRACE_EVENT0("gpu", "DXVAVideoDecodeAccelerator_CreateD3DDevManager");
+  // The device may exist if the last state was a config change.
+  if (d3d9_.get())
+    return true;
 
   HRESULT hr = E_FAIL;
 
   hr = Direct3DCreate9Ex(D3D_SDK_VERSION, d3d9_.Receive());
   RETURN_ON_HR_FAILURE(hr, "Direct3DCreate9Ex failed", false);
 
   hr = d3d9_->CheckDeviceFormatConversion(
       D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL,
       static_cast<D3DFORMAT>(MAKEFOURCC('N', 'V', '1', '2')), D3DFMT_X8R8G8B8);
   RETURN_ON_HR_FAILURE(hr, "D3D9 driver does not support H/W format conversion",
@@ skipping 41 matching lines @@
   hr = d3d9_device_ex_->CreateQuery(D3DQUERYTYPE_EVENT, query_.Receive());
   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;
 }
 
 bool DXVAVideoDecodeAccelerator::CreateDX11DevManager() {
+  // The device may exist if the last state was a config change.
+  if (d3d11_device_.get())
+    return true;
   HRESULT hr = create_dxgi_device_manager_(&dx11_dev_manager_reset_token_,
                                            d3d11_device_manager_.Receive());
   RETURN_ON_HR_FAILURE(hr, "MFCreateDXGIDeviceManager failed", false);
   if (share_nv12_textures_) {
     base::win::ScopedComPtr<ID3D11Device> angle_device =
         QueryDeviceObjectFromANGLE<ID3D11Device>(EGL_D3D11_DEVICE_ANGLE);
     RETURN_ON_FAILURE(angle_device.get(), "Failed to get d3d11 device", false);
 
     using_angle_device_ = true;
     d3d11_device_ = angle_device;
@@ skipping 1014 matching lines @@
 
 void DXVAVideoDecodeAccelerator::Invalidate() {
   if (GetState() == kUninitialized)
     return;
 
   // Best effort to make the GL context current.
   make_context_current_cb_.Run();
 
   decoder_thread_.Stop();
   weak_this_factory_.InvalidateWeakPtrs();
-  output_picture_buffers_.clear();
-  stale_output_picture_buffers_.clear();
   pending_output_samples_.clear();
-  // We want to continue processing pending input after detecting a config
-  // change.
-  if (GetState() != kConfigChange)
-    pending_input_buffers_.clear();
   decoder_.Release();
-  pictures_requested_ = false;
-
   config_change_detector_.reset();
 
-  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();
+  // If we are processing a config change, then leave the d3d9/d3d11 objects
+  // along with the output picture buffers intact as they can be reused. The
+  // output picture buffers may need to be recreated in case the video
+  // resolution changes. We already handle that in the
+  // HandleResolutionChanged() function.
+  if (GetState() != kConfigChange) {
+    output_picture_buffers_.clear();
+    stale_output_picture_buffers_.clear();
+    // We want to continue processing pending input after detecting a config
+    // change.
+    pending_input_buffers_.clear();
+    pictures_requested_ = false;
+    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();
+      multi_threaded_.Release();
+      dx11_video_format_converter_media_type_needs_init_ = true;
+    } else {
+      d3d9_.Release();
+      d3d9_device_ex_.Release();
+      device_manager_.Release();
+      query_.Release();
     }
-    d3d11_device_context_.Release();
-    d3d11_device_.Release();
-    d3d11_device_manager_.Release();
-    d3d11_query_.Release();
-    dx11_video_format_converter_media_type_needs_init_ = true;
-    multi_threaded_.Release();
-  } else {
-    d3d9_.Release();
-    d3d9_device_ex_.Release();
-    device_manager_.Release();
-    query_.Release();
   }
 
   SetState(kUninitialized);
 }
 
 void DXVAVideoDecodeAccelerator::NotifyInputBufferRead(int input_buffer_id) {
   DCHECK(main_thread_task_runner_->BelongsToCurrentThread());
   if (client_)
     client_->NotifyEndOfBitstreamBuffer(input_buffer_id);
 }
@@ skipping 788 matching lines @@
                          E_FAIL);
   }
   *config_changed = config_change_detector_->config_changed();
   return S_OK;
 }
 
 void DXVAVideoDecodeAccelerator::ConfigChanged(const Config& config) {
   DCHECK(main_thread_task_runner_->BelongsToCurrentThread());
 
   SetState(kConfigChange);
-  DismissStaleBuffers(true);
   Invalidate();
   Initialize(config_, client_);
   decoder_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&DXVAVideoDecodeAccelerator::DecodePendingInputBuffers,
                  base::Unretained(this)));
 }
 
 }  // namespace media