Updated OMX decoder for recent PPAPI changes, and added to the build.

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/gpu/omx_video_decode_accelerator.h"
+#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"
-#include "content/common/gpu_messages.h"
-#include "content/gpu/gles2_texture_to_egl_image_translator.h"
 #include "media/base/bitstream_buffer.h"
-#include "media/base/data_buffer.h"
 #include "media/video/picture.h"
 
 static Gles2TextureToEglImageTranslator* texture2eglImage_translator(
     new Gles2TextureToEglImageTranslator(NULL, 0));
 enum { kNumPictureBuffers = 4 };
 
 // Open the libnvomx here for now.
 void* omx_handle = dlopen("libnvomx.so", RTLD_NOW);
 
 typedef OMX_ERRORTYPE (*OMXInit)();
 typedef OMX_ERRORTYPE (*OMXGetHandle)(
     OMX_HANDLETYPE*, OMX_STRING, OMX_PTR, OMX_CALLBACKTYPE*);
 typedef OMX_ERRORTYPE (*OMXGetComponentsOfRole)(OMX_STRING, OMX_U32*, OMX_U8**);
 typedef OMX_ERRORTYPE (*OMXFreeHandle)(OMX_HANDLETYPE);
 typedef OMX_ERRORTYPE (*OMXDeinit)();
 
 OMXInit omx_init = reinterpret_cast<OMXInit>(dlsym(omx_handle, "OMX_Init"));
-
 OMXGetHandle omx_gethandle =
     reinterpret_cast<OMXGetHandle>(dlsym(omx_handle, "OMX_GetHandle"));
 OMXGetComponentsOfRole omx_get_components_of_role =
     reinterpret_cast<OMXGetComponentsOfRole>(
         dlsym(omx_handle, "OMX_GetComponentsOfRole"));
 OMXFreeHandle omx_free_handle =
     reinterpret_cast<OMXFreeHandle>(dlsym(omx_handle, "OMX_FreeHandle"));
 OMXDeinit omx_deinit =
     reinterpret_cast<OMXDeinit>(dlsym(omx_handle, "OMX_Deinit"));
 
@@ skipping 11 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),
-      egl_image_(NULL) {
+      client_(client) {
   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());
 }
 
-const std::vector<uint32>& OmxVideoDecodeAccelerator::GetConfig(
-    const std::vector<uint32>& prototype_config) {
+void OmxVideoDecodeAccelerator::GetConfigs(
+    const std::vector<uint32>& requested_configs,
+    std::vector<uint32>* matched_configs) {
   // TODO(vhiremath@nvidia.com) use this properly
   NOTIMPLEMENTED();
-  return component_config_;
 }
 
 // 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 acutal values from 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
   on_state_event_func_ =
       &OmxVideoDecodeAccelerator::OnStateChangeLoadedToIdle;
   if (!TransitionToState(OMX_StateIdle))
     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 allocated in AssignPictureBuffer().
-
-  // TODO(vhiremath@nvidia.com) fill buffer_properties
-  std::vector<uint32> buffer_properties;
+  // Output buffers will be eventually handed to us via
+  // Assign{GLES,Sysmem}Buffers().
   output_buffer_count_ = kNumPictureBuffers;
-  client_->ProvidePictureBuffers(output_buffer_count_, buffer_properties);
+  client_->ProvidePictureBuffers(
+      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;
@@ skipping 100 matching lines @@
   // OMX_IndexParamPortDefinition on output port to be done in
   // AllocateOutputBuffers.
   // Since at this point we dont know if we will be using system memory
   // or egl-image for decoding.
   // We get this info in AssignPictureBuffers() from plugin.
 
   return true;
 }
 
 bool OmxVideoDecodeAccelerator::Decode(
-    const media::BitstreamBuffer& bitstream_buffer,
-    const media::VideoDecodeAcceleratorCallback& callback) {
+    const media::BitstreamBuffer& bitstream_buffer) {
   DCHECK(!free_input_buffers_.empty());
-  DCHECK(bitstream_buffer);
 
   if (!CanAcceptInput()) {
     return false;
   }
 
   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;
   }
   omx_buffer->pBuffer = static_cast<OMX_U8*>(shm->memory());
-  omx_buffer->nFilledLen = bitstream_buffer->size();
+  omx_buffer->nFilledLen = bitstream_buffer.size();
   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;
   }
   input_buffers_at_component_++;
   // OMX_EmptyThisBuffer is a non blocking call and should
   // not make any assumptions about its completion.
-  omx_buff_cb_.insert(std::make_pair(
-      omx_buffer, make_pair(shm.release(), callback)));
+  omx_buff_ids_.insert(std::make_pair(
+      omx_buffer, std::make_pair(shm.release(), bitstream_buffer.id())));
   return true;
 }
 
-void OmxVideoDecodeAccelerator::AssignPictureBuffer(
-    std::vector<PictureBuffer*> picture_buffers) {
-  // NOTE: this is only partially-implemented as it only inspects the first
-  // picture buffer passed in each AssignPictureBuffer call, and never unsets
-  // uses_egl_image_ once set.
-  if (PictureBuffer::PICTUREBUFFER_MEMORYTYPE_GL_TEXTURE ==
-      picture_buffers[0]->GetMemoryType()) {
-      uses_egl_image_ = true;
-  }
+// NOTE: this is only partially-implemented as never unsets uses_egl_image_ once
+// set.
+void OmxVideoDecodeAccelerator::AssignGLESBuffers(
+    const std::vector<media::GLESBuffer>& buffers) {
+  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) {
+  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(
-      assigned_picture_buffers_.end(),
-      picture_buffers.begin(),
-      picture_buffers.end());
+      assigned_picture_buffers_.end(), buffers.begin(), buffers.end());
 
   if (assigned_picture_buffers_.size() < kNumPictureBuffers)
     return;  // get all the buffers first.
 
   // Obtain the information about the output port.
   OMX_PARAM_PORTDEFINITIONTYPE port_format;
   InitParam(*this, &port_format);
   port_format.nPortIndex = output_port_;
   OMX_ERRORTYPE result = OMX_GetParameter(component_handle_,
                                           OMX_IndexParamPortDefinition,
@@ skipping 32 matching lines @@
     StopOnError();
   }
 }
 
 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]->GetId())
+    if (picture_buffer_id != assigned_picture_buffers_[i]->id())
       continue;
     output_buffers_at_component_++;
     OMX_ERRORTYPE result =
         OMX_FillThisBuffer(component_handle_, output_pictures_[i].second);
     if (result != OMX_ErrorNone) {
       LOG(ERROR) << "OMX_FillThisBuffer() failed with result " << result;
       StopOnError();
     }
     // Sent one buffer to omx.
     return;
@@ skipping 13 matching lines @@
     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();
       return;
     }
   }
 }
 
-bool OmxVideoDecodeAccelerator::Flush(
-    const media::VideoDecodeAcceleratorCallback& callback) {
+bool OmxVideoDecodeAccelerator::Flush() {
   OMX_STATETYPE il_state;
   OMX_GetState(component_handle_, &il_state);
   DCHECK_EQ(il_state, OMX_StateExecuting);
   if (il_state != OMX_StateExecuting) {
-    callback.Run();
+    client_->NotifyFlushDone();
     return false;
   }
   on_buffer_flag_event_func_ = &OmxVideoDecodeAccelerator::FlushBegin;
-  flush_done_callback_ = callback;
 
   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);
@@ skipping 57 matching lines @@
     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(
-    const media::VideoDecodeAcceleratorCallback& callback) {
+bool OmxVideoDecodeAccelerator::Abort() {
   // 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.
-  callback.Run();
+  client_->NotifyAbortDone();
   return true;
 }
 
 // Event callback during initialization to handle DoneStateSet to idle
 void OmxVideoDecodeAccelerator::OnStateChangeLoadedToIdle(OMX_STATETYPE state) {
   DCHECK_EQ(client_state_, OMX_StateLoaded);
   DCHECK_EQ(OMX_StateIdle, state);
   VLOG(1) << "OMX video decode engine is in Idle";
 
   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_EQ(OMX_StateExecuting, state);
   VLOG(1) << "OMX video decode engine is in Executing";
 
   client_state_ = OMX_StateExecuting;
   on_state_event_func_ = NULL;
   // This will kickoff the actual decoding
-  client_->NotifyResourcesAcquired();
   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);
   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);
 
   VLOG(1) << "Deinit from Executing";
   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);
 
   VLOG(1) << "Deinit from Idle";
   on_state_event_func_ =
       &OmxVideoDecodeAccelerator::OnStateChangeIdleToLoaded;
   TransitionToState(OMX_StateLoaded);
@@ skipping 12 matching lines @@
 
   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;
   (*omx_deinit)();
   VLOG(1) << "OMX Deinit Clean exit done";
-  flush_done_callback_.Run();
+  client_->NotifyFlushDone();
 }
 
 void OmxVideoDecodeAccelerator::StopOnError() {
   OMX_STATETYPE il_state;
   OMX_GetState(component_handle_, &il_state);
   client_state_ = OMX_StateInvalid;
   switch (il_state) {
     case OMX_StateExecuting:
       OnPortCommandFlush(OMX_StateExecuting);
       return;
@@ skipping 21 matching lines @@
       return false;
     buffer->nInputPortIndex = input_port_;
     buffer->nOffset = 0;
     buffer->nFlags = 0;
     free_input_buffers_.push(buffer);
   }
   return true;
 }
 
 bool OmxVideoDecodeAccelerator::AllocateOutputBuffers() {
-  OMX_BUFFERHEADERTYPE* buffer;
-  Picture* picture;
-  OMX_ERRORTYPE result;
   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_) {
-    media::VideoDecodeAccelerator::PictureBuffer::DataPlaneHandle egl_ids;
-    std::vector<PictureBuffer::DataPlaneHandle> planes;
-    uint32 texture;
-
     for (uint32 i = 0; i < assigned_picture_buffers_.size(); i++) {
-      picture = new media::Picture(
-          reinterpret_cast<media::PictureBuffer*>(assigned_picture_buffers_[i]),
-          decoded_pixel_size, visible_pixel_size,
-          static_cast<void*>(component_handle_));
-
-      planes = assigned_picture_buffers_[i]->GetPlaneHandles();
-      egl_ids = planes[i];
-      texture = egl_ids.texture_id;
-      egl_image_ = texture2eglImage_translator->TranslateToEglImage(texture);
-      result = OMX_UseEGLImage(
-          component_handle_,
-          &buffer,
-          output_port_,
-          reinterpret_cast<media::PictureBuffer*>(assigned_picture_buffers_[i]),
-          egl_image_);
-
+      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());
+      OMX_ERRORTYPE result = OMX_UseEGLImage(
+          component_handle_, &omx_buffer, output_port_, gles_buffer, egl);
       if (result != OMX_ErrorNone) {
         LOG(ERROR) << "OMX_UseEGLImage failed";
         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(
-                reinterpret_cast<media::PictureBuffer*>(
-                    assigned_picture_buffers_[i]),
-                buffer));
-      buffer->pAppPrivate = picture;
+          std::make_pair(assigned_picture_buffers_[i]->id(), omx_buffer));
     }
   } else {
     for (uint32 i = 0; i < assigned_picture_buffers_.size(); i++) {
-      picture = new media::Picture(
-          reinterpret_cast<media::PictureBuffer*>(assigned_picture_buffers_[i]),
-          decoded_pixel_size, visible_pixel_size,
-          static_cast<void*>(component_handle_));
-
-      result = OMX_AllocateBuffer(component_handle_, &buffer, output_port_,
-                                  NULL, output_buffer_size_);
+      media::SysmemBuffer* sysmem_buffer =
+          reinterpret_cast<media::SysmemBuffer*>(assigned_picture_buffers_[i]);
+      OMX_BUFFERHEADERTYPE* omx_buffer;
+      OMX_ERRORTYPE result = OMX_AllocateBuffer(
+          component_handle_, &omx_buffer, output_port_, NULL,
+          output_buffer_size_);
       if (result != OMX_ErrorNone)
         return false;
+      omx_buffer->pAppPrivate = new media::Picture(
+          sysmem_buffer->id(),
+          24 /* garbage bitstreambuffer id */,
+          decoded_pixel_size, visible_pixel_size);
       output_pictures_.push_back(
-          std::make_pair(
-                reinterpret_cast<media::PictureBuffer*>(
-                    assigned_picture_buffers_[i]),
-                buffer));
-      buffer->pAppPrivate = picture;
+          std::make_pair(sysmem_buffer->id(), omx_buffer));
     }
   }
   return true;
 }
 
 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";
       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";
       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) {
   DCHECK_GT(output_buffers_at_component_, 0);
   output_buffers_at_component_--;
-  client_->PictureReady(reinterpret_cast<Picture*>(buffer->pAppPrivate));
+  client_->PictureReady(*reinterpret_cast<media::Picture*>(
+      buffer->pAppPrivate));
 }
 
 void OmxVideoDecodeAccelerator::EmptyBufferDoneTask(
     OMX_BUFFERHEADERTYPE* buffer) {
   DCHECK_GT(input_buffers_at_component_, 0);
   free_input_buffers_.push(buffer);
   input_buffers_at_component_--;
   if (buffer->nFlags & OMX_BUFFERFLAG_EOS)
     return;
-  // Retrieve the corresponding callback and run it.
-  OMXBufferCallbackMap::iterator it = omx_buff_cb_.find(buffer);
-  if (it == omx_buff_cb_.end()) {
-    LOG(ERROR) << "Unexpectedly failed to find a buffer callback.";
+  // 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;
-  it->second.second.Run();
-  omx_buff_cb_.erase(it);
+  client_->NotifyEndOfBitstreamBuffer(it->second.second);
+  omx_buff_ids_.erase(it);
 }
 
 void OmxVideoDecodeAccelerator::EventHandlerCompleteTask(OMX_EVENTTYPE event,
                                                          OMX_U32 data1,
                                                          OMX_U32 data2) {
   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.
@@ skipping 51 matching lines @@
 OMX_ERRORTYPE OmxVideoDecodeAccelerator::EventHandler(OMX_HANDLETYPE component,
                                                       OMX_PTR priv_data,
                                                       OMX_EVENTTYPE event,
                                                       OMX_U32 data1,
                                                       OMX_U32 data2,
                                                       OMX_PTR event_data) {
   OmxVideoDecodeAccelerator* decoder =
       static_cast<OmxVideoDecodeAccelerator*>(priv_data);
   DCHECK_EQ(component, decoder->component_handle_);
 
-  decoder->message_loop_->PostTask(FROM_HERE,
-  NewRunnableMethod(decoder,
-                    &OmxVideoDecodeAccelerator::EventHandlerCompleteTask,
-                    event, data1, data2));
+  decoder->message_loop_->PostTask(
+      FROM_HERE,
+      NewRunnableMethod(decoder,
+                        &OmxVideoDecodeAccelerator::EventHandlerCompleteTask,
+                        event, data1, data2));
 
   return OMX_ErrorNone;
 }
 
 // static
 OMX_ERRORTYPE OmxVideoDecodeAccelerator::EmptyBufferCallback(
     OMX_HANDLETYPE component,
     OMX_PTR priv_data,
     OMX_BUFFERHEADERTYPE* buffer) {
   OmxVideoDecodeAccelerator* decoder =
@@ skipping 10 matching lines @@
 
 // static
 OMX_ERRORTYPE OmxVideoDecodeAccelerator::FillBufferCallback(
     OMX_HANDLETYPE component,
     OMX_PTR priv_data,
     OMX_BUFFERHEADERTYPE* buffer) {
   OmxVideoDecodeAccelerator* decoder =
       static_cast<OmxVideoDecodeAccelerator*>(priv_data);
   DCHECK_EQ(component, decoder->component_handle_);
 
-  decoder->message_loop_->PostTask(FROM_HERE,
+  decoder->message_loop_->PostTask(
+      FROM_HERE,
       NewRunnableMethod(
           decoder,
           &OmxVideoDecodeAccelerator::FillBufferDoneTask, buffer));
   return OMX_ErrorNone;
 }
 
 bool OmxVideoDecodeAccelerator::CanAcceptInput() {
   // We can't take input buffer when in error state.
   return (client_state_ != OMX_StateInvalid &&
           client_state_ != OMX_StatePause &&
@@ skipping 22 matching lines @@
   OMX_ERRORTYPE result = OMX_SendCommand(component_handle_,
                                              cmd, port_index, 0);
   if (result != OMX_ErrorNone) {
     LOG(ERROR) << "SendCommand(OMX_CommandPortDisable) failed";
     StopOnError();
     return;
   }
 }
 
 DISABLE_RUNNABLE_METHOD_REFCOUNT(OmxVideoDecodeAccelerator);