Fix the frame freezing issue observed during a config change in the H.264 decoder 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 574 matching lines @@
       codec_(media::kUnknownVideoCodec),
       decoder_thread_("DXVAVideoDecoderThread"),
       pending_flush_(false),
       share_nv12_textures_(gpu_preferences.enable_zero_copy_dxgi_video),
       use_dx11_(false),
       use_keyed_mutex_(false),
       dx11_video_format_converter_media_type_needs_init_(true),
       using_angle_device_(false),
       enable_accelerated_vpx_decode_(
           gpu_preferences.enable_accelerated_vpx_decode),
+      processing_config_changed_(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 315 matching lines @@
                                  PLATFORM_FAILURE, );
 
     bool inserted =
         output_picture_buffers_
             .insert(std::make_pair(buffers[buffer_index].id(), picture_buffer))
             .second;
     DCHECK(inserted);
   }
 
   ProcessPendingSamples();
-  if (pending_flush_) {
+  if (pending_flush_ || processing_config_changed_) {
     decoder_thread_task_runner_->PostTask(
         FROM_HERE, base::Bind(&DXVAVideoDecodeAccelerator::FlushInternal,
                               base::Unretained(this)));
   }
 }
 
 void DXVAVideoDecodeAccelerator::ReusePictureBuffer(int32_t picture_buffer_id) {
   TRACE_EVENT0("media", "DXVAVideoDecodeAccelerator::ReusePictureBuffer");
   DCHECK(main_thread_task_runner_->BelongsToCurrentThread());
 
@@ skipping 72 matching lines @@
                               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_) {
+  if (pending_flush_ || processing_config_changed_) {
     decoder_thread_task_runner_->PostTask(
         FROM_HERE, base::Bind(&DXVAVideoDecodeAccelerator::FlushInternal,
                               base::Unretained(this)));
   }
 }
 
 void DXVAVideoDecodeAccelerator::Flush() {
   DCHECK(main_thread_task_runner_->BelongsToCurrentThread());
 
   DVLOG(1) << "DXVAVideoDecodeAccelerator::Flush";
 
   State state = GetState();
   RETURN_AND_NOTIFY_ON_FAILURE((state == kNormal || state == kStopped),
                                "Unexpected decoder state: " << state,
                                ILLEGAL_STATE, );
 
   SetState(kFlushing);
 
   pending_flush_ = true;
 
+  // If we receive a flush while processing a video stream config change,  then
+  // we treat this as a regular flush, i.e we process queued decode packets,
+  // etc.
+  // We are resetting the processing_config_changed_ flag here which means that
+  // we won't be tearing down the decoder instance and recreating it to handle
+  // the changed configuration. The expectation here is that after the decoder
+  // is drained it should be able to handle a changed configuration.
+  // TODO(ananta)
+  // If a flush is sufficient to get the decoder to process video stream config
+  // changes correctly, then we don't need to tear down the decoder instance
+  // and recreate it. Check if this is indeed the case.
+  processing_config_changed_ = false;
+
   decoder_thread_task_runner_->PostTask(
       FROM_HERE, base::Bind(&DXVAVideoDecodeAccelerator::FlushInternal,
                             base::Unretained(this)));
 }
 
 void DXVAVideoDecodeAccelerator::Reset() {
   DCHECK(main_thread_task_runner_->BelongsToCurrentThread());
 
   DVLOG(1) << "DXVAVideoDecodeAccelerator::Reset";
 
@@ skipping 787 matching lines @@
       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();
     }
   }
-
+  sent_drain_message_ = false;
   SetState(kUninitialized);
 }
 
 void DXVAVideoDecodeAccelerator::NotifyInputBufferRead(int input_buffer_id) {
   DCHECK(main_thread_task_runner_->BelongsToCurrentThread());
   if (client_)
     client_->NotifyEndOfBitstreamBuffer(input_buffer_id);
 }
 
 void DXVAVideoDecodeAccelerator::NotifyFlushDone() {
@@ skipping 56 matching lines @@
                          "Failed to get buffer id associated with sample", );
     client_->NotifyEndOfBitstreamBuffer(input_buffer_id);
   }
   pending_input_buffers_.clear();
 }
 
 void DXVAVideoDecodeAccelerator::DecodePendingInputBuffers() {
   TRACE_EVENT0("media",
                "DXVAVideoDecodeAccelerator::DecodePendingInputBuffers");
   DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
+  DCHECK(!processing_config_changed_);
+
   State state = GetState();
   RETURN_AND_NOTIFY_ON_FAILURE((state != kUninitialized),
                                "Invalid state: " << state, ILLEGAL_STATE, );
 
   if (pending_input_buffers_.empty() || OutputSamplesPresent())
     return;
 
   PendingInputs pending_input_buffers_copy;
   std::swap(pending_input_buffers_, pending_input_buffers_copy);
 
   for (PendingInputs::iterator it = pending_input_buffers_copy.begin();
        it != pending_input_buffers_copy.end(); ++it) {
     DecodeInternal(*it);
   }
 }
 
 void DXVAVideoDecodeAccelerator::FlushInternal() {
   TRACE_EVENT0("media", "DXVAVideoDecodeAccelerator::FlushInternal");
   DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
 
   // We allow only one output frame to be present at any given time. If we have
   // an output frame, then we cannot complete the flush at this time.
   if (OutputSamplesPresent())
     return;
 
   // First drain the pending input because once the drain message is sent below,
   // the decoder will ignore further input until it's drained.
-  if (!pending_input_buffers_.empty()) {
+  // If we are processing a video configuration change, then we should just
+  // the drain the decoder.
+  if (!processing_config_changed_ && !pending_input_buffers_.empty()) {
     decoder_thread_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&DXVAVideoDecodeAccelerator::DecodePendingInputBuffers,
                    base::Unretained(this)));
     decoder_thread_task_runner_->PostTask(
         FROM_HERE, base::Bind(&DXVAVideoDecodeAccelerator::FlushInternal,
                               base::Unretained(this)));
     return;
   }
 
   {
     base::AutoLock lock(decoder_lock_);
     if (!sent_drain_message_) {
       RETURN_AND_NOTIFY_ON_FAILURE(SendMFTMessage(MFT_MESSAGE_COMMAND_DRAIN, 0),
                                    "Failed to send drain message",
                                    PLATFORM_FAILURE, );
       sent_drain_message_ = true;
     }
   }
 
   // Attempt to retrieve an output frame from the decoder. If we have one,
   // return and proceed when the output frame is processed. If we don't have a
   // frame then we are done.
   DoDecode();
   if (OutputSamplesPresent())
     return;
 
-  SetState(kFlushing);
+  if (!processing_config_changed_) {
+    SetState(kFlushing);
 
-  main_thread_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&DXVAVideoDecodeAccelerator::NotifyFlushDone,
-                            weak_this_factory_.GetWeakPtr()));
+    main_thread_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&DXVAVideoDecodeAccelerator::NotifyFlushDone,
+                              weak_this_factory_.GetWeakPtr()));
+  } else {
+    processing_config_changed_ = false;
+    main_thread_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&DXVAVideoDecodeAccelerator::ConfigChanged,
+                              weak_this_factory_.GetWeakPtr(), config_));
+  }
 
   SetState(kNormal);
 }
 
 void DXVAVideoDecodeAccelerator::DecodeInternal(
     const base::win::ScopedComPtr<IMFSample>& sample) {
   TRACE_EVENT0("media", "DXVAVideoDecodeAccelerator::DecodeInternal");
   DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
 
   if (GetState() == kUninitialized)
     return;
 
   if (OutputSamplesPresent() || !pending_input_buffers_.empty()) {
     pending_input_buffers_.push_back(sample);
     return;
   }
 
   // Check if the resolution, bit rate, etc changed in the stream. If yes we
   // reinitialize the decoder to ensure that the stream decodes correctly.
   bool config_changed = false;
 
   HRESULT hr = CheckConfigChanged(sample.get(), &config_changed);
   RETURN_AND_NOTIFY_ON_HR_FAILURE(hr, "Failed to check video stream config",
                                   PLATFORM_FAILURE, );
 
+  processing_config_changed_ = config_changed;
+
   if (config_changed) {
     pending_input_buffers_.push_back(sample);
-    main_thread_task_runner_->PostTask(
-        FROM_HERE, base::Bind(&DXVAVideoDecodeAccelerator::ConfigChanged,
-                              weak_this_factory_.GetWeakPtr(), config_));
+    FlushInternal();
     return;
   }
 
   if (!inputs_before_decode_) {
     TRACE_EVENT_ASYNC_BEGIN0("gpu", "DXVAVideoDecodeAccelerator.Decoding",
                              this);
   }
   inputs_before_decode_++;
 
   hr = decoder_->ProcessInput(0, sample.get(), 0);
@@ skipping 221 matching lines @@
                                PLATFORM_FAILURE, );
 
   NotifyPictureReady(picture_buffer->id(), input_buffer_id);
 
   {
     base::AutoLock lock(decoder_lock_);
     if (!pending_output_samples_.empty())
       pending_output_samples_.pop_front();
   }
 
-  if (pending_flush_) {
+  if (pending_flush_ || processing_config_changed_) {
     decoder_thread_task_runner_->PostTask(
         FROM_HERE, base::Bind(&DXVAVideoDecodeAccelerator::FlushInternal,
                               base::Unretained(this)));
     return;
   }
   decoder_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&DXVAVideoDecodeAccelerator::DecodePendingInputBuffers,
                  base::Unretained(this)));
 }
@@ skipping 31 matching lines @@
                                PLATFORM_FAILURE, );
 
   NotifyPictureReady(picture_buffer->id(), input_buffer_id);
 
   {
     base::AutoLock lock(decoder_lock_);
     if (!pending_output_samples_.empty())
       pending_output_samples_.pop_front();
   }
 
-  if (pending_flush_) {
+  if (pending_flush_ || processing_config_changed_) {
     decoder_thread_task_runner_->PostTask(
         FROM_HERE, base::Bind(&DXVAVideoDecodeAccelerator::FlushInternal,
                               base::Unretained(this)));
     return;
   }
   decoder_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&DXVAVideoDecodeAccelerator::DecodePendingInputBuffers,
                  base::Unretained(this)));
 }
@@ skipping 336 matching lines @@
   SetState(kConfigChange);
   Invalidate();
   Initialize(config_, client_);
   decoder_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&DXVAVideoDecodeAccelerator::DecodePendingInputBuffers,
                  base::Unretained(this)));
 }
 
 }  // namespace media