OmxVideoDecodeAcceleratorTest is born!

content/common/gpu/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/omx_video_decode_accelerator.h"
 
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "content/common/gpu/gles2_texture_to_egl_image_translator.h"
 #include "content/common/gpu/gpu_channel.h"
@@ skipping 37 matching lines @@
       height_(-1),
       input_buffer_count_(0),
       input_buffer_size_(0),
       input_port_(0),
       input_buffers_at_component_(0),
       output_buffer_count_(0),
       output_buffer_size_(0),
       output_port_(0),
       output_buffers_at_component_(0),
       uses_egl_image_(false),
-      client_(client) {
+      client_(client),
+      on_port_disable_event_func_(NULL),
+      on_port_enable_event_func_(NULL),
+      on_state_event_func_(NULL),
+      on_flush_event_func_(NULL),
+      on_buffer_flag_event_func_(NULL) {
   if (!AreOMXFunctionPointersInitialized()) {
     LOG(ERROR) << "Failed to load openmax library";
     return;
   }
   OMX_ERRORTYPE result = omx_init();
   if (result != OMX_ErrorNone)
     LOG(ERROR) << "Failed to init OpenMAX core";
 }
 
 OmxVideoDecodeAccelerator::~OmxVideoDecodeAccelerator() {
   DCHECK(free_input_buffers_.empty());
   DCHECK_EQ(0, input_buffers_at_component_);
   DCHECK_EQ(0, output_buffers_at_component_);
   DCHECK(output_pictures_.empty());
 }
 
+void OmxVideoDecodeAccelerator::SetEglState(
+    EGLDisplay egl_display, EGLContext egl_context) {
+  egl_display_ = egl_display;
+  egl_context_ = egl_context;
+}
+
 void OmxVideoDecodeAccelerator::GetConfigs(
     const std::vector<uint32>& requested_configs,
     std::vector<uint32>* matched_configs) {
   // TODO(vhiremath@nvidia.com) use this properly
   NOTIMPLEMENTED();
 }
 
 // This is to initialize the OMX data structures to default values.
 template <typename T>
 static void InitParam(const OmxVideoDecodeAccelerator& dec, T* param) {
   memset(param, 0, sizeof(T));
   param->nVersion.nVersion = 0x00000101;
   param->nSize = sizeof(T);
 }
 
 bool OmxVideoDecodeAccelerator::Initialize(const std::vector<uint32>& config) {
   // TODO(vhiremath@nvidia.com) get these actual values from config
   // Assume qvga for now
   width_ = 320;
   height_ = 240;
 
   client_state_ = OMX_StateLoaded;
   if (!CreateComponent()) {
     StopOnError();
     return false;
   }
+
   // Transition component to Idle state
+  DCHECK(!on_state_event_func_);
   on_state_event_func_ =
       &OmxVideoDecodeAccelerator::OnStateChangeLoadedToIdle;
-  if (!TransitionToState(OMX_StateIdle))
+  if (!TransitionToState(OMX_StateIdle)) {
+    LOG(ERROR) << "TransitionToState(OMX_StateIdle) error";
+    StopOnError();
     return false;
+  }
 
   if (!AllocateInputBuffers()) {
     LOG(ERROR) << "OMX_AllocateBuffer() Input buffer error";
     StopOnError();
     return false;
   }
 
   // After AllocateInputBuffers ideally this should be AllocateOutputBuffers.
   // Since in this case app provides the output buffers,
   // we query this through ProvidePictureBuffers.
   // This is call to ppapi to provide the output buffers initially.
   // ProvidePictureBuffers will provide
   // - SharedMemHandle in case of decoding to system memory.
   // - Textures in case of decoding to egl-images.
 
   // Output buffers will be eventually handed to us via
   // Assign{GLES,Sysmem}Buffers().
   output_buffer_count_ = kNumPictureBuffers;
-  client_->ProvidePictureBuffers(
-      output_buffer_count_, gfx::Size(width_, height_),
-      PICTUREBUFFER_MEMORYTYPE_GL_TEXTURE);
+  message_loop_->PostTask(
+      FROM_HERE,
+      base::Bind(&Client::ProvidePictureBuffers, base::Unretained(client_),
+                 output_buffer_count_, gfx::Size(width_, height_),
+                 PICTUREBUFFER_MEMORYTYPE_GL_TEXTURE));
   // TODO(fischman): we always ask for GLES buffers above.  So why maintain the
   // !uses_egl_image_ path in this class at all?  Theoretically it could be
   // useful for testing, but today there's no such testing.  Consider ripping it
   // out of this class and replacing AssignSysmemBuffers() with
   // NOTIMPLEMENTED().
+
   return true;
 }
 
 bool OmxVideoDecodeAccelerator::CreateComponent() {
   OMX_CALLBACKTYPE omx_accelerator_callbacks = {
     &OmxVideoDecodeAccelerator::EventHandler,
     &OmxVideoDecodeAccelerator::EmptyBufferCallback,
     &OmxVideoDecodeAccelerator::FillBufferCallback
   };
   OMX_ERRORTYPE result = OMX_ErrorNone;
 
   // 1. Set the role and get all components of this role.
   // TODO(vhiremath@nvidia.com) Get this role_name from the configs
   // For now hard coding to avc.
   const char* role_name = "video_decoder.avc";
   OMX_U32 num_roles = 0;
   // Get all the components with this role.
   result = (*omx_get_components_of_role)(
       const_cast<OMX_STRING>(role_name), &num_roles, 0);
   if (result != OMX_ErrorNone || num_roles == 0) {
-    LOG(ERROR) << "Unsupported Role: " << role_name;
+    LOG(ERROR) << "Unsupported Role: " << role_name << ", " << result;
     StopOnError();
     return false;
   }
 
   // We haven't seen HW that needs more yet,
   // but there is no reason not to raise.
   const OMX_U32 kMaxRolePerComponent = 3;
   CHECK_LT(num_roles, kMaxRolePerComponent);
 
   scoped_array<scoped_array<OMX_U8> > component_names(
@@ skipping 27 matching lines @@
     return false;
   }
 
   // 4. Get the port information. This will obtain information about the
   //    number of ports and index of the first port.
   OMX_PORT_PARAM_TYPE port_param;
   InitParam(*this, &port_param);
   result = OMX_GetParameter(component_handle_, OMX_IndexParamVideoInit,
                             &port_param);
   if ((result != OMX_ErrorNone) || (port_param.nPorts != 2)) {
-    LOG(ERROR) << "Failed to get Port Param";
+    LOG(ERROR) << "Failed to get Port Param: "
+               << result << ", " << port_param.nPorts;
     StopOnError();
     return false;
   }
   input_port_ = port_param.nStartPortNumber;
   output_port_ = input_port_ + 1;
   // 5. Set role for the component because components can have multiple roles.
   OMX_PARAM_COMPONENTROLETYPE role_type;
   InitParam(*this, &role_type);
   base::strlcpy(reinterpret_cast<char*>(role_type.cRole),
                 role_name,
@@ skipping 75 matching lines @@
   // not make any assumptions about its completion.
   omx_buff_ids_.insert(std::make_pair(
       omx_buffer, std::make_pair(shm.release(), bitstream_buffer.id())));
   return true;
 }
 
 // NOTE: this is only partially-implemented as never unsets uses_egl_image_ once
 // set.
 void OmxVideoDecodeAccelerator::AssignGLESBuffers(
     const std::vector<media::GLESBuffer>& buffers) {
+  CHECK_EQ(message_loop_, MessageLoop::current());
   uses_egl_image_ = true;
   std::vector<media::BaseBuffer*> base_buffers(buffers.size());
   for (size_t i = 0; i < buffers.size(); ++i)
     base_buffers[i] = new media::GLESBuffer(buffers[i]);
   AssignBuffersHelper(base_buffers);
 }
 
 void OmxVideoDecodeAccelerator::AssignSysmemBuffers(
     const std::vector<media::SysmemBuffer>& buffers) {
+  CHECK_EQ(message_loop_, MessageLoop::current());
   DCHECK(!uses_egl_image_);
   std::vector<media::BaseBuffer*> base_buffers(buffers.size());
   for (size_t i = 0; i < buffers.size(); ++i)
     base_buffers[i] = new media::SysmemBuffer(buffers[i]);
   AssignBuffersHelper(base_buffers);
 }
 
 void OmxVideoDecodeAccelerator::AssignBuffersHelper(
     const std::vector<media::BaseBuffer*>& buffers) {
   assigned_picture_buffers_.insert(
@@ skipping 34 matching lines @@
       return;
     }
   } else {
     output_buffer_count_ = port_format.nBufferCountActual;
   }
   output_buffer_size_ = port_format.nBufferSize;
 
   if (!AllocateOutputBuffers()) {
     LOG(ERROR) << "OMX_AllocateBuffer() Output buffer error";
     StopOnError();
+    return;
   }
 }
 
 void OmxVideoDecodeAccelerator::ReusePictureBuffer(int32 picture_buffer_id) {
   // TODO(vhiremath@nvidia.com) Avoid leaking of the picture buffer.
   if (!CanFillBuffer())
     return;
 
   for (int i = 0; i < output_buffer_count_; ++i) {
     if (picture_buffer_id != assigned_picture_buffers_[i]->id())
@@ skipping 35 matching lines @@
   OMX_GetState(component_handle_, &il_state);
   DCHECK_EQ(il_state, OMX_StateExecuting);
   if (il_state != OMX_StateExecuting) {
     client_->NotifyFlushDone();
     return false;
   }
   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();
@@ skipping 31 matching lines @@
   }
 }
 
 void OmxVideoDecodeAccelerator::PortFlushDone(int port) {
   DCHECK_NE(port, static_cast<int>(OMX_ALL));
 
   if (port == input_port_) {
     VLOG(1) << "Input Port had been flushed";
     DCHECK_EQ(input_buffers_at_component_, 0);
     // Flush output port next.
+    on_flush_event_func_ = &OmxVideoDecodeAccelerator::PortFlushDone;
     OMX_ERRORTYPE result;
     result = OMX_SendCommand(component_handle_,
                              OMX_CommandFlush,
                              output_port_, 0);
     if (result != OMX_ErrorNone) {
       LOG(ERROR) << "OMX_SendCommand(OMX_CommandFlush) failed";
       StopOnError();
       return;
     }
     return;
   }
 
   if (port == output_port_) {
     VLOG(1) << "Output Port had been flushed";
     DCHECK_EQ(output_buffers_at_component_, 0);
   }
 
   client_state_ = OMX_StatePause;
   // So Finally call OnPortCommandFlush which should
   // internally call DismissPictureBuffer();
   OnPortCommandFlush(OMX_StateExecuting);
 }
 
 bool OmxVideoDecodeAccelerator::Abort() {
+  CHECK_EQ(message_loop_, MessageLoop::current());
   // TODO(vhiremath@nvidia.com)
   // Need more thinking on this to handle w.r.t OMX.
   // There is no explicit UnInitialize call for this.
   // Also review again for trick modes.
   client_->NotifyAbortDone();
   return true;
 }
 
 // Event callback during initialization to handle DoneStateSet to idle
 void OmxVideoDecodeAccelerator::OnStateChangeLoadedToIdle(OMX_STATETYPE state) {
+  CHECK_EQ(message_loop_, MessageLoop::current());
+  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";
 
+  client_->NotifyInitializeDone();

[vhiremath, 2011/06/03 11:01:20]

Ami,
What is plugin's reaction to this notification ?
Does it start sending Decode() calls to OVDA ?

In that case, this notification should not be here.
The omx initialization is complete only when it has allocated input and output
buffers and omx component is in executing state and initial FillBuffers has been
sent to decoder (ensures decoder has output buffers ready to decode).
But this place does not ensure that.

It is better to move this notification to
OmxVideoDecodeAccelerator::OnStateChangeIdleToExecuting() function.


If this notification is left here itself, then this might cause hang, in case
omx component take some time to enter into execution state and plugin calls
Decode (based on NotifyInitializeDone) before the execution state change.
==========

Also, on side note: (sorry if i missed previous CLs)
there was another notification: NotifyResourcesAcquired.
why was that removed ? 

[Ami GONE FROM CHROMIUM, 2011/06/03 17:43:59]

Great catch!  Fixed.  
I was in fact seeing deadlock on startup of the test intermittently, and that's
gone now.  Excellent.
NotifyResourcesAcquired was replaced with NotifyInitializationDone because it
makes more sense to be symmetric with Initialize.
(the actual evolution was more contorted than that, with each step being a
positive increment over the last, but the overall effect is as above).

+
   on_state_event_func_ =
       &OmxVideoDecodeAccelerator::OnStateChangeIdleToExecuting;
   if (!TransitionToState(OMX_StateExecuting))
     return;
 }
 
 // Event callback during initialization to handle DoneStateSet to executing
 void OmxVideoDecodeAccelerator::OnStateChangeIdleToExecuting(
     OMX_STATETYPE state) {
+  DCHECK(!on_state_event_func_);
   DCHECK_EQ(OMX_StateExecuting, state);
+  DCHECK(!on_state_event_func_);
   VLOG(1) << "OMX video decode engine is in Executing";
 
   client_state_ = OMX_StateExecuting;
-  on_state_event_func_ = NULL;
   // This will kickoff the actual decoding
   InitialFillBuffer();
 }
 
 // Send state transition command to component.
 bool OmxVideoDecodeAccelerator::TransitionToState(OMX_STATETYPE new_state) {
-    OMX_ERRORTYPE result = OMX_SendCommand(component_handle_,
-                                           OMX_CommandStateSet,
-                                           new_state, 0);
+  DCHECK(on_state_event_func_);
+  OMX_ERRORTYPE result = OMX_SendCommand(
+      component_handle_, OMX_CommandStateSet, new_state, 0);
   if (result != OMX_ErrorNone) {
     LOG(ERROR) << "SendCommand(OMX_CommandStateSet) failed";
     StopOnError();
     return false;
   }
   return true;
 }
 
 void OmxVideoDecodeAccelerator::OnPortCommandFlush(OMX_STATETYPE state) {
   DCHECK_EQ(state, OMX_StateExecuting);
+  CHECK_EQ(message_loop_, MessageLoop::current());
 
   VLOG(1) << "Deinit from Executing";
+  DCHECK(!on_state_event_func_);
   on_state_event_func_ =
       &OmxVideoDecodeAccelerator::OnStateChangeExecutingToIdle;
   TransitionToState(OMX_StateIdle);
   for (int i = 0; i < output_buffer_count_; ++i) {
     OutputPicture output_picture = output_pictures_[i];
     client_->DismissPictureBuffer(output_picture.first);
   }
   STLDeleteElements(&assigned_picture_buffers_);
 }
 
 void OmxVideoDecodeAccelerator::OnStateChangeExecutingToIdle(
     OMX_STATETYPE state) {
   DCHECK_EQ(state, OMX_StateIdle);
+  DCHECK(!on_state_event_func_);
 
   VLOG(1) << "Deinit from Idle";
   on_state_event_func_ =
       &OmxVideoDecodeAccelerator::OnStateChangeIdleToLoaded;
   TransitionToState(OMX_StateLoaded);
 
   if (!input_buffers_at_component_)
     FreeInputBuffers();
 
   if (!output_buffers_at_component_)
     FreeOutputBuffers();
 }
 
 void OmxVideoDecodeAccelerator::OnStateChangeIdleToLoaded(OMX_STATETYPE state) {
   DCHECK_EQ(state, OMX_StateLoaded);
+  CHECK_EQ(message_loop_, MessageLoop::current());
+  DCHECK(!on_state_event_func_);
 
   VLOG(1) << "Idle to Loaded";
 
   if (component_handle_) {
     OMX_ERRORTYPE result = (*omx_free_handle)(component_handle_);
     if (result != OMX_ErrorNone)
         LOG(ERROR) << "OMX_FreeHandle() error. Error code: " << result;
     component_handle_ = NULL;
   }
   client_state_ = OMX_StateLoaded;
@@ skipping 16 matching lines @@
     case OMX_StateLoaded:
       OnStateChangeIdleToLoaded(OMX_StateLoaded);
       return;
     default:
       // LOG unexpected state or just ignore?
       return;
   }
 }
 
 bool OmxVideoDecodeAccelerator::AllocateInputBuffers() {
-  scoped_array<uint8> data(new uint8[input_buffer_size_]);
-
   for (int i = 0; i < input_buffer_count_; ++i) {
     OMX_BUFFERHEADERTYPE* buffer;
     OMX_ERRORTYPE result =
-        OMX_UseBuffer(component_handle_, &buffer, input_port_,
-                      this, input_buffer_size_, data.get());
+        OMX_AllocateBuffer(component_handle_, &buffer, input_port_,
+                           this, input_buffer_size_);
     if (result != OMX_ErrorNone)
       return false;
     buffer->nInputPortIndex = input_port_;
     buffer->nOffset = 0;
     buffer->nFlags = 0;
     free_input_buffers_.push(buffer);
   }
   return true;
 }
 
 bool OmxVideoDecodeAccelerator::AllocateOutputBuffers() {
-  static Gles2TextureToEglImageTranslator* texture2eglImage_translator(
-      new Gles2TextureToEglImageTranslator(NULL, 0));
+  CHECK_EQ(message_loop_, MessageLoop::current());
+  static Gles2TextureToEglImageTranslator texture2eglImage_translator;
 
   gfx::Size decoded_pixel_size(width_, height_);
   gfx::Size visible_pixel_size(width_, height_);
   // TODO(fischman): remove garbage bitstream buffer id's below (42 and 24) when
   // the bitstream_buffer_id field is removed from Picture.
   if (uses_egl_image_) {
     for (uint32 i = 0; i < assigned_picture_buffers_.size(); i++) {
       media::GLESBuffer* gles_buffer =
           reinterpret_cast<media::GLESBuffer*>(assigned_picture_buffers_[i]);
       OMX_BUFFERHEADERTYPE* omx_buffer;
-      void* egl = texture2eglImage_translator->TranslateToEglImage(
-          gles_buffer->texture_id());
+      void* egl = texture2eglImage_translator.TranslateToEglImage(
+          egl_display_, egl_context_, gles_buffer->texture_id());
       OMX_ERRORTYPE result = OMX_UseEGLImage(
           component_handle_, &omx_buffer, output_port_, gles_buffer, egl);
       if (result != OMX_ErrorNone) {
-        LOG(ERROR) << "OMX_UseEGLImage failed";
+        LOG(ERROR) << "OMX_UseEGLImage failed with: " << result;
         return false;
       }
       omx_buffer->pAppPrivate =
           new media::Picture(gles_buffer->id(),
                              42 /* garbage bitstreambuffer id */,
                              decoded_pixel_size, visible_pixel_size);
       output_pictures_.push_back(
           std::make_pair(assigned_picture_buffers_[i]->id(), omx_buffer));
     }
   } else {
@@ skipping 19 matching lines @@
 
 void OmxVideoDecodeAccelerator::FreeInputBuffers() {
   // Calls to OMX to free buffers.
   OMX_ERRORTYPE result;
   OMX_BUFFERHEADERTYPE* omx_buffer;
   while (!free_input_buffers_.empty()) {
     omx_buffer = free_input_buffers_.front();
     free_input_buffers_.pop();
     result = OMX_FreeBuffer(component_handle_, input_port_, omx_buffer);
     if (result != OMX_ErrorNone) {
-      LOG(ERROR) << "SendCommand(OMX_CommandPortDisable) failed";
+      LOG(ERROR) << "OMX_CommandPortDisable failed with: " << result;
       StopOnError();
       return;
     }
   }
 }
 
 void OmxVideoDecodeAccelerator::FreeOutputBuffers() {
   // Calls to OMX to free buffers.
   OMX_ERRORTYPE result;
   for (size_t i = 0; i < output_pictures_.size(); ++i) {
     OMX_BUFFERHEADERTYPE* omx_buffer = output_pictures_[i].second;
     CHECK(omx_buffer);
     delete reinterpret_cast<media::Picture*>(omx_buffer->pAppPrivate);
     result = OMX_FreeBuffer(component_handle_, output_port_, omx_buffer);
     if (result != OMX_ErrorNone) {
-      LOG(ERROR) << "SendCommand(OMX_CommandPortDisable) failed";
+      LOG(ERROR) << "OMX_FreeBuffer failed with: " << result;
       StopOnError();
       return;
     }
   }
   output_pictures_.clear();
 }
 
 void OmxVideoDecodeAccelerator::OnPortSettingsChangedRun(
         int port, OMX_INDEXTYPE index) {
   // TODO(vhiremath@nvidia.com) visit again later
   // Port settings changes can be called during run time
   // changes in the resolution of video playback.
   // In this case, the component detects PortSettingsChanged
   // and sends the particular event to the IL-client.
   // This needs to be handled in this method.
   return;
 }
 
 void OmxVideoDecodeAccelerator::FillBufferDoneTask(
     OMX_BUFFERHEADERTYPE* buffer) {
+  CHECK_EQ(message_loop_, MessageLoop::current());
   DCHECK_GT(output_buffers_at_component_, 0);
   output_buffers_at_component_--;
   client_->PictureReady(*reinterpret_cast<media::Picture*>(
       buffer->pAppPrivate));
 }
 
 void OmxVideoDecodeAccelerator::EmptyBufferDoneTask(
     OMX_BUFFERHEADERTYPE* buffer) {
   DCHECK_GT(input_buffers_at_component_, 0);
+  CHECK_EQ(message_loop_, MessageLoop::current());
   free_input_buffers_.push(buffer);
   input_buffers_at_component_--;
   if (buffer->nFlags & OMX_BUFFERFLAG_EOS)
     return;
+
   // Retrieve the corresponding BitstreamBuffer's id and notify the client of
   // its completion.
   OMXBufferIdMap::iterator it = omx_buff_ids_.find(buffer);
   if (it == omx_buff_ids_.end()) {
     LOG(ERROR) << "Unexpectedly failed to find a buffer id.";
     StopOnError();
     return;
   }
   delete it->second.first;
   client_->NotifyEndOfBitstreamBuffer(it->second.second);
   omx_buff_ids_.erase(it);
 }
 
 void OmxVideoDecodeAccelerator::EventHandlerCompleteTask(OMX_EVENTTYPE event,
                                                          OMX_U32 data1,
                                                          OMX_U32 data2) {
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
   switch (event) {
     case OMX_EventCmdComplete: {
       // If the last command was successful, we have completed
       // a state transition. So notify that we have done it
       // accordingly.
       OMX_COMMANDTYPE cmd = static_cast<OMX_COMMANDTYPE>(data1);
       switch (cmd) {
-        case OMX_CommandPortDisable: {
-          if (on_port_disable_event_func_)
-            (this->*on_port_disable_event_func_)(static_cast<int>(data2));
+        case OMX_CommandPortDisable:
+          if (on_port_disable_event_func_) {
+            void (OmxVideoDecodeAccelerator::*func)(int) = NULL;
+            std::swap(func, on_port_disable_event_func_);
+            (this->*func)(static_cast<int>(data2));
           }
           break;
-        case OMX_CommandPortEnable: {
-          if (on_port_enable_event_func_)
-            (this->*on_port_enable_event_func_)(static_cast<int>(data2));
+        case OMX_CommandPortEnable:
+          if (on_port_enable_event_func_) {
+            void (OmxVideoDecodeAccelerator::*func)(int) = NULL;
+            std::swap(func, on_port_enable_event_func_);
+            (this->*func)(static_cast<int>(data2));
           }
           break;
         case OMX_CommandStateSet:
-          (this->*on_state_event_func_)(static_cast<OMX_STATETYPE>(data2));
+          {
+            void (OmxVideoDecodeAccelerator::*func)(OMX_STATETYPE state) = NULL;
+            std::swap(func, on_state_event_func_);
+            (this->*func)(static_cast<OMX_STATETYPE>(data2));
+          }
           break;
         case OMX_CommandFlush:
-          (this->*on_flush_event_func_)(data2);
+          {
+            void (OmxVideoDecodeAccelerator::*func)(int) = NULL;
+            std::swap(func, on_flush_event_func_);
+            (this->*func)(data2);
+          }
           break;
         default:
           LOG(ERROR) << "Unknown command completed\n" << data1;
           break;
-        }
+      }
       break;
     }
     case OMX_EventError:
       if (static_cast<OMX_ERRORTYPE>(data1) == OMX_ErrorInvalidState)
         StopOnError();
       break;
     case OMX_EventPortSettingsChanged:
       // TODO(vhiremath@nvidia.com) remove this hack
       // when all vendors observe same spec.
       if (data1 < OMX_IndexComponentStartUnused) {
         OnPortSettingsChangedRun(static_cast<int>(data1),
                                  static_cast<OMX_INDEXTYPE>(data2));
       } else {
         OnPortSettingsChangedRun(static_cast<int>(data2),
                                  static_cast<OMX_INDEXTYPE>(data1));
       }
       break;
     case OMX_EventBufferFlag:
       if (data1 == static_cast<OMX_U32>(output_port_)) {
-        (this->*on_buffer_flag_event_func_)();
+        void (OmxVideoDecodeAccelerator::*func)() = NULL;
+        std::swap(func, on_buffer_flag_event_func_);
+        (this->*func)();
       }
       break;
     default:
       LOG(ERROR) << "Warning - Unknown event received\n";
       break;
   }
 }
 
 // static
 OMX_ERRORTYPE OmxVideoDecodeAccelerator::EventHandler(OMX_HANDLETYPE component,
@@ skipping 69 matching lines @@
     StopOnError();
     return false;
   }
   return (il_state == OMX_StateExecuting);
 }
 
 // Send command to disable/enable port.
 void OmxVideoDecodeAccelerator::ChangePort(
     OMX_COMMANDTYPE cmd, int port_index) {
   OMX_ERRORTYPE result = OMX_SendCommand(component_handle_,
-                                             cmd, port_index, 0);
+                                         cmd, port_index, 0);
   if (result != OMX_ErrorNone) {
     LOG(ERROR) << "SendCommand(OMX_CommandPortDisable) failed";
     StopOnError();
     return;
   }
 }
 
 DISABLE_RUNNABLE_METHOD_REFCOUNT(OmxVideoDecodeAccelerator);