remove omx_sink and buffer merge

media/tools/omx_test/omx_test.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.
 
 // A test program that drives an OpenMAX video decoder module. This program
 // will take video in elementary stream and read into the decoder.
 //
 // Run the following command to see usage:
 // ./omx_test
 
 #include "base/at_exit.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/message_loop.h"
 #include "base/scoped_ptr.h"
 #include "base/time.h"
 #include "media/base/media.h"
 #include "media/ffmpeg/ffmpeg_common.h"
 #include "media/ffmpeg/file_protocol.h"
 #include "media/filters/bitstream_converter.h"
 #include "media/omx/omx_codec.h"
 #include "media/base/data_buffer.h"
-#include "media/omx/omx_output_sink.h"
 #include "media/tools/omx_test/color_space_util.h"
 #include "media/tools/omx_test/file_reader_util.h"
 #include "media/tools/omx_test/file_sink.h"
 
 using media::BlockFileReader;
 using media::FFmpegFileReader;
 using media::FileReader;
 using media::FileSink;
 using media::H264FileReader;
 using media::OmxCodec;
 using media::OmxConfigurator;
 using media::OmxDecoderConfigurator;
 using media::OmxEncoderConfigurator;
-using media::OmxOutputSink;
 using media::YuvFileReader;
 using media::Buffer;
 using media::DataBuffer;
 
 // This is the driver object to feed the decoder with data from a file.
 // It also provides callbacks for the decoder to receive events from the
 // decoder.
 class TestApp {
  public:
   TestApp(OmxConfigurator* configurator, FileSink* file_sink,
@@ skipping 56 matching lines @@
     // We receive this callback when the decoder has consumed an input buffer.
     // In this case, delete the previous buffer and enqueue a new one.
     // There are some conditions we don't want to enqueue, for example when
     // the last buffer is an end-of-stream buffer, when we have stopped, and
     // when we have received an error.
     bool eos = buffer->IsEndOfStream();
     if (!eos && !stopped_ && !error_)
       FeedInputBuffer();
   }
 
-  void ReadCompleteCallback(int buffer,
-                            FileSink::BufferUsedCallback* callback) {
+  void ReadCompleteCallback(OMX_BUFFERHEADERTYPE* buffer) {
     // This callback is received when the decoder has completed a decoding
     // task and given us some output data. The buffer is owned by the decoder.
     if (stopped_ || error_)
       return;
 
     if (!frame_count_)
       first_sample_delivered_time_ = base::TimeTicks::HighResNow();
 
     // If we are readding to the end, then stop.
-    if (buffer == OmxCodec::kEosBuffer) {
+    if (buffer == NULL) {
       codec_->Stop(NewCallback(this, &TestApp::StopCallback));
       return;
     }
 
     // Read one more from the decoder.
     codec_->Read(NewCallback(this, &TestApp::ReadCompleteCallback));
 
     if (file_sink_.get())
-      file_sink_->BufferReady(buffer, callback);
+      file_sink_->BufferReady(buffer->nFilledLen, buffer->pBuffer);
 
     // could OMX IL return patial sample for decoder?
     frame_count_++;
   }
 
   void FeedInputBuffer() {
     uint8* data;
     int read;
     file_reader_->Read(&data, &read);
     codec_->Feed(new DataBuffer(data, read),
                  NewCallback(this, &TestApp::FeedCallback));
   }
 
   void Run() {
     StartProfiler();
 
     // Setup the |codec_| with the message loop of the current thread. Also
     // setup component name, codec format and callbacks.
     codec_ = new OmxCodec(&message_loop_);
-    codec_->Setup(configurator_.get(), file_sink_.get());
+    codec_->Setup(configurator_.get());
     codec_->SetErrorCallback(NewCallback(this, &TestApp::ErrorCallback));
     codec_->SetFormatCallback(NewCallback(this, &TestApp::FormatCallback));
 
     // Start the |codec_|.
     codec_->Start();
     for (int i = 0; i < 20; ++i)
       FeedInputBuffer();
     codec_->Read(NewCallback(this, &TestApp::ReadCompleteCallback));
 
     // Execute the message loop so that we can run tasks on it. This call
@@ skipping 210 matching lines @@
   if (!test.Initialize()) {
     LOG(ERROR) << "can't initialize this application";
     return -1;
   }
 
   // This will run the decoder until EOS is reached or an error
   // is encountered.
   test.Run();
   return 0;
 }