remove omx_sink and buffer merge

media/omx/omx_codec.cc

 // Copyright (c) 2010 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 <algorithm>
 #include <string>
 
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "media/omx/omx_codec.h"
 #include "media/base/buffers.h"
-#include "media/omx/omx_output_sink.h"
 
 namespace media {
 
 #if !defined(COMPILER_MSVC)
 int const OmxCodec::kEosBuffer;
 #endif
 
 template <typename T>
 static void ResetPortHeader(const OmxCodec& dec, T* param) {
   memset(param, 0, sizeof(T));
@@ skipping 14 matching lines @@
       next_state_(kEmpty),
       component_handle_(NULL),
       message_loop_(message_loop) {
 }
 
 OmxCodec::~OmxCodec() {
   DCHECK(state_ == kError || state_ == kEmpty);
   DCHECK_EQ(0u, input_buffers_.size());
   DCHECK_EQ(0u, output_buffers_.size());
   DCHECK(available_input_buffers_.empty());
-  DCHECK(output_buffers_in_use_.empty());
   DCHECK(pending_input_queue_.empty());
   DCHECK(output_queue_.empty());
   DCHECK(processing_input_queue_.empty());
 }
 
-void OmxCodec::Setup(OmxConfigurator* configurator,
-                     OmxOutputSink* output_sink) {
+void OmxCodec::Setup(OmxConfigurator* configurator) {
   DCHECK_EQ(kEmpty, state_);
-
   CHECK(configurator);
-  CHECK(output_sink);
-
   configurator_ = configurator;
-  output_sink_ = output_sink;
 }
 
 void OmxCodec::SetErrorCallback(Callback* callback) {
   DCHECK_EQ(kEmpty, state_);
   error_callback_.reset(callback);
 }
 
 void OmxCodec::SetFormatCallback(FormatCallback* callback) {
   DCHECK_EQ(kEmpty, state_);
   format_callback_.reset(callback);
 }
 
 void OmxCodec::Start() {
   CHECK(configurator_);
-  CHECK(output_sink_);
 
   message_loop_->PostTask(
       FROM_HERE,
       NewRunnableMethod(this, &OmxCodec::StartTask));
 }
 
 void OmxCodec::Stop(Callback* callback) {
   message_loop_->PostTask(
       FROM_HERE,
       NewRunnableMethod(this, &OmxCodec::StopTask, callback));
@@ skipping 69 matching lines @@
     StateTransitionTask(kLoaded);
   else if (GetState() == kLoaded)
     StateTransitionTask(kEmpty);
 }
 
 void OmxCodec::ReadTask(ReadCallback* callback) {
   DCHECK_EQ(message_loop_, MessageLoop::current());
 
   // Don't accept read request on error state.
   if (!CanAcceptOutput()) {
-    callback->Run(
-        kEosBuffer,
-        static_cast<OmxOutputSink::BufferUsedCallback*>(NULL));
+    callback->Run(static_cast<OMX_BUFFERHEADERTYPE*>(NULL));
     delete callback;
     return;
   }
 
   // If output has been reached then enqueue an end-of-stream buffer.
   if (output_eos_)
     output_buffers_ready_.push(kEosBuffer);
 
   // Queue this request.
   output_queue_.push(callback);
@@ skipping 43 matching lines @@
 }
 
 // This method assumes OMX_AllocateBuffer() will allocate buffer
 // header internally. In additional to that memory that holds the
 // header, the same method call will allocate memory for holding
 // output data. If we use EGL images for holding output data,
 // the memory allocation will be done externally.
 bool OmxCodec::AllocateOutputBuffers() {
   DCHECK_EQ(message_loop_, MessageLoop::current());
 
-  if (output_sink_->ProvidesEGLImages()) {
-    // TODO(hclam): Do the following things here:
-    // 1. Call output_sink_->AllocateEGLImages() to allocate some
-    //    EGL images from the sink component.
-    // 2. Call OMX_UseEGLImage() to assign the images to the output
-    //    port.
-    NOTIMPLEMENTED();
-  } else {
-    for (int i = 0; i < output_buffer_count_; ++i) {
-      OMX_BUFFERHEADERTYPE* buffer;
-      OMX_ERRORTYPE error =
-          OMX_AllocateBuffer(component_handle_, &buffer, output_port_,
-                             NULL, output_buffer_size_);
-      if (error != OMX_ErrorNone)
-        return false;
-      output_buffers_.push_back(buffer);
-    }
-  }
-
-  // Tell the sink component to use the buffers for output.
-  for (size_t i = 0; i < output_buffers_.size(); ++i) {
-    output_sink_->UseThisBuffer(static_cast<int>(i),
-                                output_buffers_[i]);
+  for (int i = 0; i < output_buffer_count_; ++i) {
+    OMX_BUFFERHEADERTYPE* buffer;
+    OMX_ERRORTYPE error =
+        OMX_AllocateBuffer(component_handle_, &buffer, output_port_,
+                           NULL, output_buffer_size_);
+    if (error != OMX_ErrorNone)
+      return false;
+    output_buffers_.push_back(buffer);
   }
 
   return true;
 }
 
 void OmxCodec::FreeInputBuffers() {
   DCHECK_EQ(message_loop_, MessageLoop::current());
 
   // Calls to OMX to free buffers.
   for (size_t i = 0; i < input_buffers_.size(); ++i)
     OMX_FreeBuffer(component_handle_, input_port_, input_buffers_[i]);
   input_buffers_.clear();
 
   // Empty available buffer queue.
   while (!available_input_buffers_.empty()) {
     available_input_buffers_.pop();
   }
 }
 
 void OmxCodec::FreeOutputBuffers() {
   DCHECK_EQ(message_loop_, MessageLoop::current());
 
-  // First we need to make sure output sink is not using the buffer so
-  // tell it to stop using our buffer headers.
-  // TODO(hclam): We should make this an asynchronous call so that
-  // we'll wait until all buffers are not used.
-  for (size_t i = 0; i < output_buffers_.size(); ++i)
-    output_sink_->StopUsingThisBuffer(static_cast<int>(i));
-
   // Calls to OMX to free buffers.
   for (size_t i = 0; i < output_buffers_.size(); ++i)
     OMX_FreeBuffer(component_handle_, output_port_, output_buffers_[i]);
   output_buffers_.clear();
-
-  // If we have asked the sink component to provide us EGL images for
-  // output we need to tell it we are done with those images.
-  // TODO(hclam): Implement this correctly.
-  if (output_sink_->ProvidesEGLImages()) {
-    std::vector<EGLImageKHR> images;
-    output_sink_->ReleaseEGLImages(images);
-  }
 }
 
 void OmxCodec::FreeInputQueue() {
   DCHECK_EQ(message_loop_, MessageLoop::current());
 
   while (!pending_input_queue_.empty()) {
     scoped_refptr<Buffer> buffer = pending_input_queue_.front().first;
     FeedCallback* callback = pending_input_queue_.front().second;
     callback->Run(buffer);
     delete callback;
@@ skipping 803 matching lines @@
 
   if (!output_queue_.empty() && !output_buffers_ready_.empty()) {
     int buffer_id = output_buffers_ready_.front();
     output_buffers_ready_.pop();
     ReadCallback* callback = output_queue_.front();
     output_queue_.pop();
 
     // If the buffer is real then save it to the in-use list.
     // Otherwise if it is an end-of-stream buffer then just drop it.
     if (buffer_id != kEosBuffer) {
-      output_buffers_in_use_.push_back(buffer_id);
-      callback->Run(buffer_id,
-                    NewCallback(this, &OmxCodec::BufferUsedCallback));
+      callback->Run(output_buffers_[buffer_id]);
+      BufferUsedCallback(buffer_id); //hack, we will change this really soon.
     } else {
-      callback->Run(kEosBuffer,
-                    static_cast<OmxOutputSink::BufferUsedCallback*>(NULL));
+      callback->Run(static_cast<OMX_BUFFERHEADERTYPE*>(NULL));
     }
     delete callback;
   }
 }
 
 void OmxCodec::BufferUsedCallback(int buffer_id) {
   // If this method is called on the message loop where OmxCodec belongs, we
   // execute the task directly to save posting another task.
   if (message_loop_ == MessageLoop::current()) {
     BufferUsedTask(buffer_id);
@@ skipping 13 matching lines @@
 // receive end-of-stream buffers from OpenMAX.
 // It is possible to not submit FillThisBuffer() after the first
 // end-of-stream buffer is received from OpenMAX, but that will complicate
 // the logic and so we rely on OpenMAX to do the right thing.
 void OmxCodec::BufferUsedTask(int buffer_id) {
   DCHECK_EQ(message_loop_, MessageLoop::current());
 
   // Make sure an end-of-stream buffer id is not received here.
   CHECK(buffer_id != kEosBuffer);
 
-  // The use of |output_buffers_in_use_| is just a precaution. So we can
-  // actually move it to a debugging section.
-  OutputBuffersInUseSet::iterator iter =
-      std::find(output_buffers_in_use_.begin(),
-                output_buffers_in_use_.end(),
-                buffer_id);
-
-  if (iter == output_buffers_in_use_.end()) {
-    LOG(ERROR) << "Received an unknown buffer id: " << buffer_id;
-    StateTransitionTask(kError);
-  }
-  output_buffers_in_use_.erase(iter);
-
   // We'll try to issue more FillThisBuffer() to the decoder.
   // If we can't do it now then just return.
   if (!CanFillBuffer())
     return;
 
   CHECK(buffer_id >= 0 &&
         buffer_id < static_cast<int>(output_buffers_.size()));
   OMX_BUFFERHEADERTYPE* omx_buffer =  output_buffers_[buffer_id];
 
   omx_buffer->nOutputPortIndex = output_port_;
@@ skipping 121 matching lines @@
 OMX_ERRORTYPE OmxCodec::FillBufferCallback(
     OMX_HANDLETYPE component,
     OMX_PTR priv_data,
     OMX_BUFFERHEADERTYPE* buffer) {
   OmxCodec* decoder = static_cast<OmxCodec*>(priv_data);
   decoder->FillBufferCallbackInternal(component, buffer);
   return OMX_ErrorNone;
 }
 
 }  // namespace media