Added support for Decode() calls during Reset().

content/common/gpu/media/omx_video_decode_accelerator.cc

 // Copyright (c) 2011 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/omx_video_decode_accelerator.h"
 
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "content/common/gpu/gpu_channel.h"
 #include "content/common/gpu/media/gles2_texture_to_egl_image_translator.h"
@@ skipping 262 matching lines @@
   }
 
   return true;
 }
 
 void OmxVideoDecodeAccelerator::Decode(
     const media::BitstreamBuffer& bitstream_buffer) {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   DCHECK(!free_input_buffers_.empty());
 
+  if (current_state_change_ == RESETTING ||
+      !queued_bitstream_buffers_.empty()) {
+    queued_bitstream_buffers_.push_back(bitstream_buffer);
+    return;
+  }
+
   RETURN_ON_FAILURE(current_state_change_ == NO_TRANSITION &&
                     (client_state_ == OMX_StateIdle ||
                      client_state_ == OMX_StateExecuting),
                     "Call to Decode() during invalid state or transition: "
                     << current_state_change_ << ", " << client_state_,
                     ILLEGAL_STATE,);
 
   OMX_BUFFERHEADERTYPE* omx_buffer = free_input_buffers_.front();
   free_input_buffers_.pop();
 
@@ skipping 15 matching lines @@
   omx_buffer->nFlags &= ~OMX_BUFFERFLAG_EOS;
   // Abuse the header's nTimeStamp field to propagate the bitstream buffer ID to
   // the output buffer's nTimeStamp field, so we can report it back to the
   // client in PictureReady().
   omx_buffer->nTimeStamp = bitstream_buffer.id();
 
   // Give this buffer to OMX.
   OMX_ERRORTYPE result = OMX_EmptyThisBuffer(component_handle_, omx_buffer);
   RETURN_ON_OMX_FAILURE(result, "OMX_EmptyThisBuffer() failed",
                         PLATFORM_FAILURE,);
-
   input_buffers_at_component_++;
 }
 
 void OmxVideoDecodeAccelerator::AssignPictureBuffers(
     const std::vector<media::PictureBuffer>& buffers) {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   RETURN_ON_FAILURE(CanFillBuffer(), "Can't fill buffer", ILLEGAL_STATE,);
 
   CHECK_EQ(output_buffers_at_component_, 0);
   CHECK_EQ(fake_output_buffers_.size(), 0U);
@@ skipping 169 matching lines @@
 void OmxVideoDecodeAccelerator::OnReachedPauseInResetting() {
   DCHECK_EQ(client_state_, OMX_StateExecuting);
   client_state_ = OMX_StatePause;
   FlushIOPorts();
 }
 
 void OmxVideoDecodeAccelerator::OnReachedExecutingInResetting() {
   DCHECK_EQ(client_state_, OMX_StatePause);
   client_state_ = OMX_StateExecuting;
   current_state_change_ = NO_TRANSITION;
-  if (client_)
-    client_->NotifyResetDone();
+  if (!client_)
+    return;
+
+  // Drain queued bitstream & picture buffers that were held away from the
+  // decoder during the reset.
+  BitstreamBufferList buffers;
+  buffers.swap(queued_bitstream_buffers_);
+  for (size_t i = 0; i < buffers.size(); ++i)
+    Decode(buffers[i]);
+  // Ensure the Decode() calls above didn't end up re-enqueuing.
+  DCHECK(queued_bitstream_buffers_.empty());
+  for (size_t i = 0; i < queued_picture_buffer_ids_.size(); ++i)
+    ReusePictureBuffer(queued_picture_buffer_ids_[i]);
+  queued_picture_buffer_ids_.clear();
+
+  client_->NotifyResetDone();
 }
 
 // Alert: HORROR ahead!  OMX shutdown is an asynchronous dance but our clients
 // enjoy the fire-and-forget nature of a synchronous Destroy() call that
 // ensures no further callbacks are made.  Since the interface between OMX
 // callbacks and this class is a MessageLoop, we need to ensure the loop
 // outlives the shutdown dance, even during process shutdown.  We do this by
 // repeatedly enqueuing a no-op task until shutdown is complete, since
 // MessageLoop's shutdown drains pending tasks.
 void OmxVideoDecodeAccelerator::BusyLoopInDestroying() {
@@ skipping 205 matching lines @@
     return;
   }
   CHECK(!fake_output_buffers_.size());
 
   if (current_state_change_ == FLUSHING &&
       buffer->nFlags & OMX_BUFFERFLAG_EOS) {
     DCHECK(!saw_eos_during_flush_);
     saw_eos_during_flush_ = true;
   }
 
+  DCHECK(buffer->pAppPrivate);
+  media::Picture* picture =
+      reinterpret_cast<media::Picture*>(buffer->pAppPrivate);
+  int picture_buffer_id = picture->picture_buffer_id();
+
   // During the transition from Executing to Idle, and during port-flushing, all
   // pictures are sent back through here.  Avoid giving them to the client.
   // Also avoid sending the (fake) EOS buffer to the client.
   if ((current_state_change_ != NO_TRANSITION &&
        current_state_change_ != FLUSHING) ||
       saw_eos_during_flush_) {
+    if (current_state_change_ == RESETTING)
+      queued_picture_buffer_ids_.push_back(picture_buffer_id);
     return;
   }
 
-  CHECK(buffer->pAppPrivate);
-  media::Picture* picture =
-      reinterpret_cast<media::Picture*>(buffer->pAppPrivate);
   // See Decode() for an explanation of this abuse of nTimeStamp.
   picture->set_bitstream_buffer_id(buffer->nTimeStamp);
   if (client_)
     client_->PictureReady(*picture);
 }
 
 void OmxVideoDecodeAccelerator::EmptyBufferDoneTask(
     OMX_BUFFERHEADERTYPE* buffer) {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   DCHECK_GT(input_buffers_at_component_, 0);
@@ skipping 213 matching lines @@
 
 bool OmxVideoDecodeAccelerator::SendCommandToPort(
     OMX_COMMANDTYPE cmd, int port_index) {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   OMX_ERRORTYPE result = OMX_SendCommand(component_handle_,
                                          cmd, port_index, 0);
   RETURN_ON_OMX_FAILURE(result, "SendCommand() failed" << cmd,
                         PLATFORM_FAILURE, false);
   return true;
 }