Update OVDA to handle error condition.

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 128 matching lines @@
   memset(param, 0, sizeof(T));
   param->nVersion.nVersion = 0x00000101;
   param->nSize = sizeof(T);
 }
 
 bool OmxVideoDecodeAccelerator::Initialize(const std::vector<uint32>& config) {
   // Extract the required info from the configs.
   // For now consider only what we care about.
   std::vector<uint32> matched_configs;
   GetConfigs(config, &matched_configs);
-  if (config != matched_configs)
+  if (config != matched_configs) {
+    StopOnError(VIDEODECODERERROR_INVALIDINPUT);
     return false;
+  }
   client_state_ = OMX_StateLoaded;
   if (!CreateComponent()) {
-    StopOnError();
+    StopOnError(VIDEODECODERERROR_UNINITIALIZED);
     return false;
   }
 
   // Transition component to Idle state
   DCHECK(!on_state_event_func_);
   on_state_event_func_ =
       &OmxVideoDecodeAccelerator::OnStateChangeLoadedToIdle;
   if (!TransitionToState(OMX_StateIdle)) {
     LOG(ERROR) << "TransitionToState(OMX_StateIdle) error";
-    StopOnError();
+    StopOnError(VIDEODECODERERROR_UNINITIALIZED);
     return false;
   }
 
   if (!AllocateInputBuffers()) {
     LOG(ERROR) << "OMX_AllocateBuffer() Input buffer error";
-    StopOnError();
+    StopOnError(VIDEODECODERERROR_MEMFAILURE);
     return false;
   }
 
   return true;
 }
 
 bool OmxVideoDecodeAccelerator::CreateComponent() {
   OMX_CALLBACKTYPE omx_accelerator_callbacks = {
     &OmxVideoDecodeAccelerator::EventHandler,
     &OmxVideoDecodeAccelerator::EmptyBufferCallback,
     &OmxVideoDecodeAccelerator::FillBufferCallback
   };
   OMX_ERRORTYPE result = OMX_ErrorNone;
 
   // 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 << ", " << result;
-    StopOnError();
+    StopOnError(VIDEODECODERERROR_UNSUPPORTED);
     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(
       new scoped_array<OMX_U8>[num_roles]);
   for (size_t i = 0; i < num_roles; ++i)
     component_names[i].reset(new OMX_U8[OMX_MAX_STRINGNAME_SIZE]);
   result = (*omx_get_components_of_role)(
       const_cast<OMX_STRING>(role_name),
       &num_roles, reinterpret_cast<OMX_U8**>(component_names.get()));
 
   // Use first component only. Copy the name of the first component so that we
   // could free the memory.
   std::string component_name;
   if (result == OMX_ErrorNone)
     component_name = reinterpret_cast<char*>(component_names[0].get());
 
   if (result != OMX_ErrorNone || num_roles == 0) {
     LOG(ERROR) << "Unsupported Role: " << component_name.c_str();
-    StopOnError();
+    StopOnError(VIDEODECODERERROR_UNSUPPORTED);
     return false;
   }
 
   // Get the handle to the component.  After OMX_GetHandle(), the component is
   // in loaded state.
   OMX_STRING component = const_cast<OMX_STRING>(component_name.c_str());
   result = omx_gethandle(&component_handle_, component, this,
                          &omx_accelerator_callbacks);
   if (result != OMX_ErrorNone) {
     LOG(ERROR) << "Failed to Load the component: " << component;
-    StopOnError();
+    StopOnError(VIDEODECODERERROR_INSUFFICIENT_RESOURCES);
     return false;
   }
 
   // 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: "
                << result << ", " << port_param.nPorts;
-    StopOnError();
+    StopOnError(VIDEODECODERERROR_INSUFFICIENT_RESOURCES);
     return false;
   }
   input_port_ = port_param.nStartPortNumber;
   output_port_ = input_port_ + 1;
 
   // 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,
                 OMX_MAX_STRINGNAME_SIZE);
 
   result = OMX_SetParameter(component_handle_,
                             OMX_IndexParamStandardComponentRole,
                             &role_type);
   if (result != OMX_ErrorNone) {
     LOG(ERROR) << "Failed to Set Role";
-    StopOnError();
+    StopOnError(VIDEODECODERERROR_INVALIDINPUT);
     return false;
   }
 
   // Populate input-buffer-related members based on input port data.
   OMX_PARAM_PORTDEFINITIONTYPE port_format;
   InitParam(*this, &port_format);
   port_format.nPortIndex = input_port_;
   result = OMX_GetParameter(component_handle_,
                             OMX_IndexParamPortDefinition,
                             &port_format);
   if (result != OMX_ErrorNone) {
     LOG(ERROR) << "GetParameter(OMX_IndexParamPortDefinition) failed";
-    StopOnError();
+    StopOnError(VIDEODECODERERROR_INVALIDINPUT);
     return false;
   }
   if (OMX_DirInput != port_format.eDir) {
     LOG(ERROR) << "Expected input port";
-    StopOnError();
+    StopOnError(VIDEODECODERERROR_INVALIDINPUT);
     return false;
   }
   input_buffer_count_ = port_format.nBufferCountActual;
   input_buffer_size_ = port_format.nBufferSize;
 
   // Verify output port conforms to our expectations.
   InitParam(*this, &port_format);
   port_format.nPortIndex = output_port_;
   result = OMX_GetParameter(component_handle_,
                             OMX_IndexParamPortDefinition,
                             &port_format);
   if (result != OMX_ErrorNone) {
     LOG(ERROR) << "GetParameter(OMX_IndexParamPortDefinition) failed";
-    StopOnError();
+    StopOnError(VIDEODECODERERROR_INVALIDINPUT);
     return false;
   }
   if (OMX_DirOutput != port_format.eDir) {
     LOG(ERROR) << "Expect Output Port";
-    StopOnError();
+    StopOnError(VIDEODECODERERROR_INVALIDINPUT);
     return false;
   }
 
   // Set output port parameters.
   port_format.nBufferCountActual = kNumPictureBuffers;
   port_format.nBufferCountMin = kNumPictureBuffers;
   // Force an OMX_EventPortSettingsChanged event to be sent once we know the
   // stream's real dimensions (which can only happen once some Decode() work has
   // been done).
   port_format.format.video.nFrameWidth = -1;
   port_format.format.video.nFrameHeight = -1;
   result = OMX_SetParameter(component_handle_,
                             OMX_IndexParamPortDefinition,
                             &port_format);
   if (result != OMX_ErrorNone) {
     LOG(ERROR) << "SetParameter(OMX_IndexParamPortDefinition) failed";
-    StopOnError();
+    StopOnError(VIDEODECODERERROR_INVALIDINPUT);
     return false;
   }
 
   // Fill the component with fake output buffers.  This seems to be required for
   // the component to move from Loaded to Idle.  How bogus.
   for (int i = 0; i < kNumPictureBuffers; ++i) {
     OMX_BUFFERHEADERTYPE* buffer;
     result = OMX_UseBuffer(component_handle_, &buffer, output_port_,
                            NULL, 0, reinterpret_cast<OMX_U8*>(0x1));
     if (result != OMX_ErrorNone) {
@@ skipping 39 matching lines @@
   // 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();
+    StopOnError(VIDEODECODERERROR_INVALIDINPUT);
     return;
   }
   input_buffers_at_component_++;
 }
 
 void OmxVideoDecodeAccelerator::AssignGLESBuffers(
     const std::vector<media::GLESBuffer>& buffers) {
   if (!CanFillBuffer()) {
-    StopOnError();
+    StopOnError(VIDEODECODERERROR_UNINITIALIZED);
     return;
   }
   CHECK_EQ(output_buffers_at_component_, 0);
   CHECK_EQ(fake_output_buffers_.size(), 0U);
   CHECK_EQ(pictures_.size(), 0U);
 
   CHECK_EQ(message_loop_, MessageLoop::current());
   for (size_t i = 0; i < buffers.size(); ++i) {
     CHECK(pictures_.insert(std::make_pair(
         buffers[i].id(), OutputPicture(buffers[i], NULL))).second);
   }
 
   if (pictures_.size() < kNumPictureBuffers)
     return;  // get all the buffers first.
   DCHECK_EQ(pictures_.size(), kNumPictureBuffers);
 
   if (!AllocateOutputBuffers()) {
     LOG(ERROR) << "OMX_AllocateBuffer() Output buffer error";
-    StopOnError();
+    StopOnError(VIDEODECODERERROR_MEMFAILURE);
     return;
   }
 
   DCHECK(!on_port_enable_event_func_);
   on_port_enable_event_func_ =
       &OmxVideoDecodeAccelerator::PortEnabledAfterSettingsChange;
   ChangePort(OMX_CommandPortEnable, output_port_);
 }
 
 void OmxVideoDecodeAccelerator::AssignSysmemBuffers(
@@ skipping 13 matching lines @@
     LOG(DFATAL) << "Missing picture buffer id: " << picture_buffer_id;
     return;
   }
   OutputPicture& output_picture = it->second;
 
   ++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();
+    StopOnError(VIDEODECODERERROR_INVALIDINPUT);
     return;
   }
 }
 
 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;
   }
   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();
+    StopOnError(VIDEODECODERERROR_INVALIDINPUT);
     return;
   }
   input_buffers_at_component_++;
 }
 
 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) {
   on_state_event_func_ = NULL;
   FlushIOPorts();
 }
 
 void OmxVideoDecodeAccelerator::FlushIOPorts() {
   // TODO(vhiremath@nvidia.com) review again for trick modes.
   VLOG(1) << "FlushIOPorts";
 
   // Flush input port first.
   DCHECK(!on_flush_event_func_);
   on_flush_event_func_ = &OmxVideoDecodeAccelerator::InputPortFlushDone;
   OMX_ERRORTYPE result = OMX_SendCommand(component_handle_,
                                          OMX_CommandFlush,
                                          input_port_, 0);
   if (result != OMX_ErrorNone) {
     LOG(ERROR) << "OMX_SendCommand(OMX_CommandFlush) failed";
-    StopOnError();
+    StopOnError(VIDEODECODERERROR_INVALIDINPUT);
     return;
   }
 }
 
 void OmxVideoDecodeAccelerator::InputPortFlushDone(int port) {
   DCHECK_EQ(port, input_port_);
   VLOG(1) << "Input Port has been flushed";
   DCHECK_EQ(input_buffers_at_component_, 0);
   // Flush output port next.
   DCHECK(!on_flush_event_func_);
   on_flush_event_func_ = &OmxVideoDecodeAccelerator::OutputPortFlushDone;
   if (OMX_ErrorNone !=
       OMX_SendCommand(component_handle_,
                       OMX_CommandFlush,
                       output_port_, 0)) {
     LOG(ERROR) << "OMX_SendCommand(OMX_CommandFlush) failed";
-    StopOnError();
+    StopOnError(VIDEODECODERERROR_INVALIDINPUT);
     return;
   }
 }
 
 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;
@@ skipping 34 matching lines @@
   // Request filling of our fake buffers to trigger decode processing.  In
   // reality as soon as any data is decoded these will get dismissed due to
   // dimension mismatch.
   for (std::set<OMX_BUFFERHEADERTYPE*>::iterator it =
            fake_output_buffers_.begin();
        it != fake_output_buffers_.end(); ++it) {
     OMX_BUFFERHEADERTYPE* buffer = *it;
     OMX_ERRORTYPE result = OMX_FillThisBuffer(component_handle_, buffer);
     if (result != OMX_ErrorNone) {
       LOG(ERROR) << "OMX_FillThisBuffer() failed with: " << result;
-      StopOnError();
+      StopOnError(VIDEODECODERERROR_INVALIDINPUT);
       return;
     }
     ++output_buffers_at_component_;
   }
 
   message_loop_->PostTask(
       FROM_HERE,
       base::Bind(&Client::NotifyInitializeDone, base::Unretained(client_)));
 }
 
 // Send state transition command to component.
 bool OmxVideoDecodeAccelerator::TransitionToState(OMX_STATETYPE new_state) {
   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();
+    StopOnError(VIDEODECODERERROR_INVALIDINPUT);
     return false;
   }
+  client_state_ = new_state;
   return true;
 }
 
 void OmxVideoDecodeAccelerator::ShutDownOMXFromExecuting() {
   VLOG(1) << "Deinit from Executing";
   DCHECK(!on_state_event_func_);
   on_state_event_func_ =
       &OmxVideoDecodeAccelerator::OnStateChangeExecutingToIdle;
   TransitionToState(OMX_StateIdle);
 }
@@ skipping 26 matching lines @@
     if (result != OMX_ErrorNone)
         LOG(ERROR) << "OMX_FreeHandle() error. Error code: " << result;
     component_handle_ = NULL;
   }
   client_state_ = OMX_StateLoaded;
   (*omx_deinit)();
   VLOG(1) << "OMX Deinit Clean exit done";
   client_->NotifyAbortDone();
 }
 
-void OmxVideoDecodeAccelerator::StopOnError() {
+void OmxVideoDecodeAccelerator::StopOnError(
+    media::VideoDecodeAccelerator::Error error) {
+  if (client_)
+      client_->NotifyError(error);
+  if (client_state_ == OMX_StateInvalid)
+      return;
+
+  client_state_ = OMX_StateInvalid;
+  if (!component_handle_)
+      return;
+
   OMX_STATETYPE il_state;
   OMX_GetState(component_handle_, &il_state);
-  client_state_ = OMX_StateInvalid;
   switch (il_state) {
     case OMX_StateExecuting:
       ShutDownOMXFromExecuting();
       return;
     case OMX_StateIdle:
       OnStateChangeExecutingToIdle(OMX_StateIdle);
       return;
     case OMX_StateLoaded:
       OnStateChangeIdleToLoaded(OMX_StateLoaded);
       return;
     default:
-      // LOG unexpected state or just ignore?
+      LOG(ERROR) << "Invalid state: "
+                 << il_state << " received in StopOnError()";
       return;
   }
 }
 
 bool OmxVideoDecodeAccelerator::AllocateInputBuffers() {
   for (int i = 0; i < input_buffer_count_; ++i) {
     OMX_BUFFERHEADERTYPE* buffer;
     // While registering the buffer header we use fake buffer information
     // (length 0, at memory address 0x1) to fake out the "safety" check in
     // OMX_UseBuffer.  When it comes time to actually use this header in Decode
@@ skipping 46 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) << "OMX_FreeBuffer failed with: " << result;
-      StopOnError();
+      StopOnError(VIDEODECODERERROR_INVALIDINPUT);
       return;
     }
   }
   VLOG(1) << "Input buffers freed.";
 }
 
 void OmxVideoDecodeAccelerator::FreeOutputBuffers() {
   // Calls to OMX to free buffers.
   OMX_ERRORTYPE result;
   for (OutputPictureById::iterator it = pictures_.begin();
        it != pictures_.end(); ++it) {
     OMX_BUFFERHEADERTYPE* omx_buffer = it->second.omx_buffer_header;
     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) << "OMX_FreeBuffer failed with: " << result;
-      StopOnError();
+      StopOnError(VIDEODECODERERROR_INVALIDINPUT);
       return;
     }
     client_->DismissPictureBuffer(it->first);
   }
   pictures_.clear();
 }
 
 void OmxVideoDecodeAccelerator::OnIndexParamPortDefinitionChanged(int port) {
   DCHECK_EQ(port, output_port_);
   DCHECK(!on_port_disable_event_func_);
@@ skipping 29 matching lines @@
                  static_cast<int32>(kNumPictureBuffers),
                  gfx::Size(vformat.nFrameWidth, vformat.nFrameHeight),
                  PICTUREBUFFER_MEMORYTYPE_GL_TEXTURE));
 }
 
 void OmxVideoDecodeAccelerator::PortEnabledAfterSettingsChange(int port) {
   DCHECK_EQ(port, output_port_);
 
   if (!CanFillBuffer()) {
     LOG(ERROR) << "Can't FillBuffer on port-enabled";
-    StopOnError();
+    StopOnError(VIDEODECODERERROR_INSUFFICIENT_RESOURCES);
     return;
   }
 
   // Ask the decoder to fill the output buffers.
   for (OutputPictureById::iterator it = pictures_.begin();
        it != pictures_.end(); ++it) {
     OMX_BUFFERHEADERTYPE* omx_buffer = it->second.omx_buffer_header;
     DCHECK(omx_buffer);
     // Clear EOS flag.
     omx_buffer->nFlags &= ~OMX_BUFFERFLAG_EOS;
     omx_buffer->nOutputPortIndex = output_port_;
     ++output_buffers_at_component_;
     OMX_ERRORTYPE result = OMX_FillThisBuffer(component_handle_, omx_buffer);
     if (result != OMX_ErrorNone) {
       LOG(ERROR) << "OMX_FillThisBuffer() failed with result " << result;
-      StopOnError();
+      StopOnError(VIDEODECODERERROR_INSUFFICIENT_BUFFERS);
       return;
     }
   }
 }
 
 void OmxVideoDecodeAccelerator::FillBufferDoneTask(
     OMX_BUFFERHEADERTYPE* buffer) {
   CHECK_EQ(message_loop_, MessageLoop::current());
   DCHECK_GT(output_buffers_at_component_, 0);
   --output_buffers_at_component_;
 
   if (fake_output_buffers_.size() && fake_output_buffers_.count(buffer)) {
     CHECK_EQ(fake_output_buffers_.erase(buffer), 1U);
     OMX_ERRORTYPE result =
         OMX_FreeBuffer(component_handle_, output_port_, buffer);
     if (result != OMX_ErrorNone) {
       LOG(ERROR) << "OMX_FreeBuffer failed with: " << result;
-      StopOnError();
+      StopOnError(VIDEODECODERERROR_INVALIDINPUT);
       return;
     }
     return;
   }
   CHECK(!fake_output_buffers_.size());
 
   // During the transition from Paused to Idle (e.g. during Flush()) all
   // pictures are sent back through here.  Avoid giving them to the client.
   // TODO(fischman): this is a hokey way to detect this condition.  The state
   // transitions in this class need to be rethought, and this implemented more
@@ skipping 72 matching lines @@
             (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();
+        StopOnError(VIDEODECODERERROR_HARDWARE);
       break;
     case OMX_EventPortSettingsChanged:
       if (data2 == OMX_IndexParamPortDefinition) {
           OnIndexParamPortDefinitionChanged(static_cast<int>(data1));
       } else if (data1 == static_cast<OMX_U32>(output_port_) &&
                  data2 == OMX_IndexConfigCommonOutputCrop) {
           // TODO(vjain): Handle video crop rect.
       } else {
           LOG(ERROR) << "Unexpected EventPortSettingsChanged [data1:"
                      << data1 << " data2:" << data2 << "]";
@@ skipping 76 matching lines @@
 bool OmxVideoDecodeAccelerator::CanFillBuffer() {
   // Make sure component is in the executing state and end-of-stream
   // has not been reached.
   OMX_ERRORTYPE result;
   OMX_STATETYPE il_state;
   if (client_state_ == OMX_StateLoaded)
     return false;
   result = OMX_GetState(component_handle_, &il_state);
   if (result != OMX_ErrorNone) {
     LOG(ERROR) << "OMX_GetState failed";
-    StopOnError();
+    StopOnError(VIDEODECODERERROR_INVALIDINPUT);
     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);
   if (result != OMX_ErrorNone) {
     LOG(ERROR) << "SendCommand() failed" << cmd << ":" << result;
-    StopOnError();
+    StopOnError(VIDEODECODERERROR_INVALIDINPUT);
     return;
   }
 }
 
 DISABLE_RUNNABLE_METHOD_REFCOUNT(OmxVideoDecodeAccelerator);