Implement proper synchronization between HW video decode IPC and CommandBuffer.

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-inl.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 317 matching lines @@
     }
     buffer->pAppPrivate = NULL;
     buffer->nTimeStamp = 0;
     buffer->nOutputPortIndex = output_port_;
     CHECK(fake_output_buffers_.insert(buffer).second);
   }
 
   return true;
 }
 
-bool OmxVideoDecodeAccelerator::Decode(
+void OmxVideoDecodeAccelerator::Decode(
     const media::BitstreamBuffer& bitstream_buffer) {
   DCHECK(!free_input_buffers_.empty());
 
   if (!CanAcceptInput())
-    return false;
+    return;
 
   OMX_BUFFERHEADERTYPE* omx_buffer = free_input_buffers_.front();
   free_input_buffers_.pop();
 
   // Setup |omx_buffer|.
   scoped_ptr<base::SharedMemory> shm(
       new base::SharedMemory(bitstream_buffer.handle(), true));
   if (!shm->Map(bitstream_buffer.size())) {
     LOG(ERROR) << "Failed to SharedMemory::Map().";
-    return false;
+    return;
   }
   SharedMemoryAndId* input_buffer_details = new SharedMemoryAndId();
   input_buffer_details->first.reset(shm.release());
   input_buffer_details->second = bitstream_buffer.id();
   DCHECK(!omx_buffer->pAppPrivate);
   omx_buffer->pAppPrivate = input_buffer_details;
   omx_buffer->pBuffer =
       static_cast<OMX_U8*>(input_buffer_details->first->memory());
   omx_buffer->nFilledLen = bitstream_buffer.size();
   omx_buffer->nAllocLen = omx_buffer->nFilledLen;
   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_ErrorNone;
   result = OMX_EmptyThisBuffer(component_handle_, omx_buffer);
   if (result != OMX_ErrorNone) {
     LOG(ERROR) << "OMX_EmptyThisBuffer() failed with result " << result;
     StopOnError();
-    return false;
+    return;
   }
   input_buffers_at_component_++;
-  return true;
 }
 
 void OmxVideoDecodeAccelerator::AssignGLESBuffers(
     const std::vector<media::GLESBuffer>& buffers) {
   if (!CanFillBuffer()) {
     StopOnError();
     return;
   }
   CHECK_EQ(output_buffers_at_component_, 0);
   CHECK_EQ(fake_output_buffers_.size(), 0U);
@@ skipping 43 matching lines @@
   ++output_buffers_at_component_;
   OMX_ERRORTYPE result =
       OMX_FillThisBuffer(component_handle_, output_picture.omx_buffer_header);
   if (result != OMX_ErrorNone) {
     LOG(ERROR) << "OMX_FillThisBuffer() failed with result " << result;
     StopOnError();
     return;
   }
 }
 
-bool OmxVideoDecodeAccelerator::Flush() {
+void OmxVideoDecodeAccelerator::Flush() {
   OMX_STATETYPE il_state;
   OMX_GetState(component_handle_, &il_state);
   DCHECK_EQ(il_state, OMX_StateExecuting);
   // Decode the pending data first. Then flush I/O ports.
   if (il_state != OMX_StateExecuting) {
     client_->NotifyFlushDone();
-    return false;
+    return;
   }
   on_buffer_flag_event_func_ = &OmxVideoDecodeAccelerator::FlushBegin;
 
   OMX_BUFFERHEADERTYPE* omx_buffer = free_input_buffers_.front();
   free_input_buffers_.pop();
 
   omx_buffer->nFilledLen = 0;
   omx_buffer->nAllocLen = omx_buffer->nFilledLen;
   omx_buffer->nFlags |= OMX_BUFFERFLAG_EOS;
   omx_buffer->nTimeStamp = 0;
   // Give this buffer to OMX.
   OMX_ERRORTYPE result = OMX_ErrorNone;
   result = OMX_EmptyThisBuffer(component_handle_, omx_buffer);
   if (result != OMX_ErrorNone) {
     LOG(ERROR) << "OMX_EmptyThisBuffer() failed with result " << result;
     StopOnError();
-    return false;
+    return;
   }
   input_buffers_at_component_++;
-  return true;
 }
 
 void OmxVideoDecodeAccelerator::FlushBegin() {
   VLOG(1) << "Starting actual flush for EOS";
   DCHECK(!on_state_event_func_);
   on_state_event_func_ = &OmxVideoDecodeAccelerator::PauseFromExecuting;
   TransitionToState(OMX_StatePause);
 }
 
 void OmxVideoDecodeAccelerator::PauseFromExecuting(OMX_STATETYPE ignored) {
@@ skipping 37 matching lines @@
 
 void OmxVideoDecodeAccelerator::OutputPortFlushDone(int port) {
   DCHECK_EQ(port, output_port_);
 
   VLOG(1) << "Output Port has been flushed";
   DCHECK_EQ(output_buffers_at_component_, 0);
   client_state_ = OMX_StatePause;
   client_->NotifyFlushDone();
 }
 
-bool OmxVideoDecodeAccelerator::Abort() {
+void OmxVideoDecodeAccelerator::Abort() {
   CHECK_EQ(message_loop_, MessageLoop::current());
   // Abort() implies immediacy but Flush() actually decodes pending data first.
   // TODO(vhiremath@nvidia.com) Fix the Abort to handle this immediacy.
   ShutDownOMXFromExecuting();
-  return true;
+  return;
 }
 
 // Event callback during initialization to handle DoneStateSet to idle
 void OmxVideoDecodeAccelerator::OnStateChangeLoadedToIdle(OMX_STATETYPE state) {
   DCHECK(!on_state_event_func_);
   DCHECK_EQ(client_state_, OMX_StateLoaded);
   DCHECK_EQ(OMX_StateIdle, state);
 
   VLOG(1) << "OMX video decode engine is in Idle";
 
@@ skipping 478 matching lines @@
   OMX_ERRORTYPE result = OMX_SendCommand(component_handle_,
                                          cmd, port_index, 0);
   if (result != OMX_ErrorNone) {
     LOG(ERROR) << "SendCommand() failed" << cmd << ":" << result;
     StopOnError();
     return;
   }
 }
 
 DISABLE_RUNNABLE_METHOD_REFCOUNT(OmxVideoDecodeAccelerator);