Support queuing input buffers when OMX's buffer list is exhausted.

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 260 matching lines @@
     buffer->nOutputPortIndex = output_port_;
     CHECK(fake_output_buffers_.insert(buffer).second);
   }
 
   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_.empty() ||
+      free_input_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,);
@@ skipping 208 matching lines @@
   if (client_)
     client_->NotifyFlushDone();
 }
 
 void OmxVideoDecodeAccelerator::OnReachedPauseInResetting() {
   DCHECK_EQ(client_state_, OMX_StateExecuting);
   client_state_ = OMX_StatePause;
   FlushIOPorts();
 }
 
+void OmxVideoDecodeAccelerator::DecodeQueuedBitstreamBuffers() {
+  BitstreamBufferList buffers;
+  buffers.swap(queued_bitstream_buffers_);
+  for (size_t i = 0; i < buffers.size(); ++i)
+    Decode(buffers[i]);
+}
+
 void OmxVideoDecodeAccelerator::OnReachedExecutingInResetting() {
   DCHECK_EQ(client_state_, OMX_StatePause);
   client_state_ = OMX_StateExecuting;
   current_state_change_ = NO_TRANSITION;
   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());
+  // Drain queues of input & output buffers held during the reset.
+  DecodeQueuedBitstreamBuffers();
   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
@@ skipping 250 matching lines @@
 
   // Retrieve the corresponding BitstreamBuffer's id and notify the client of
   // its completion.
   SharedMemoryAndId* input_buffer_details =
       reinterpret_cast<SharedMemoryAndId*>(buffer->pAppPrivate);
   DCHECK(input_buffer_details);
   buffer->pAppPrivate = NULL;
   if (client_)
     client_->NotifyEndOfBitstreamBuffer(input_buffer_details->second);
   delete input_buffer_details;
+
+  DecodeQueuedBitstreamBuffers();
 }
 
 void OmxVideoDecodeAccelerator::DispatchStateReached(OMX_STATETYPE reached) {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   switch (current_state_change_) {
     case INITIALIZING:
       switch (reached) {
         case OMX_StateIdle:
           OnReachedIdleInInitializing();
           return;
@@ skipping 203 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;
 }