Adding callback support to media filter Initialize() and Seek().

media/filters/ffmpeg_demuxer.cc

 // Copyright (c) 2009 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 "base/scoped_ptr.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "media/base/filter_host.h"
 #include "media/filters/ffmpeg_common.h"
@@ skipping 243 matching lines @@
   message_loop()->PostTask(FROM_HERE,
       NewRunnableMethod(this, &FFmpegDemuxer::DemuxTask));
 }
 
 void FFmpegDemuxer::Stop() {
   // Post a task to notify the streams to stop as well.
   message_loop()->PostTask(FROM_HERE,
       NewRunnableMethod(this, &FFmpegDemuxer::StopTask));
 }
 
-void FFmpegDemuxer::Seek(base::TimeDelta time) {
+void FFmpegDemuxer::Seek(base::TimeDelta time, FilterCallback* callback) {
   // TODO(hclam): by returning from this method, it is assumed that the seek
   // operation is completed and filters behind the demuxer is good to issue
   // more reads, but we are posting a task here, which makes the seek operation
   // asynchronous, should change how seek works to make it fully asynchronous.
   message_loop()->PostTask(FROM_HERE,
-      NewRunnableMethod(this, &FFmpegDemuxer::SeekTask, time));
+      NewRunnableMethod(this, &FFmpegDemuxer::SeekTask, time, callback));
 }
 
-bool FFmpegDemuxer::Initialize(DataSource* data_source) {
+void FFmpegDemuxer::Initialize(DataSource* data_source,
+                               FilterCallback* callback) {
   message_loop()->PostTask(FROM_HERE,
-      NewRunnableMethod(this, &FFmpegDemuxer::InititalizeTask, data_source));
-  return true;
+      NewRunnableMethod(this, &FFmpegDemuxer::InititalizeTask, data_source,
+                        callback));
 }
 
 size_t FFmpegDemuxer::GetNumberOfStreams() {
   return streams_.size();
 }
 
 scoped_refptr<DemuxerStream> FFmpegDemuxer::GetStream(int stream) {
   DCHECK(stream >= 0);
   DCHECK(stream < static_cast<int>(streams_.size()));
   return streams_[stream].get();
 }
 
-void FFmpegDemuxer::InititalizeTask(DataSource* data_source) {
+void FFmpegDemuxer::InititalizeTask(DataSource* data_source,
+                                    FilterCallback* callback) {
   DCHECK_EQ(MessageLoop::current(), message_loop());
+  scoped_ptr<FilterCallback> c(callback);
 
   // In order to get FFmpeg to use |data_source| for file IO we must transfer
   // ownership via FFmpegGlue.  We'll add |data_source| to FFmpegGlue and pass
   // the resulting key to FFmpeg.  FFmpeg will pass the key to FFmpegGlue which
   // will take care of attaching |data_source| to an FFmpeg context.  After
   // we finish initializing the FFmpeg context we can remove |data_source| from
   // FFmpegGlue.
   //
   // Refer to media/filters/ffmpeg_glue.h for details.
 
   // Add our data source and get our unique key.
   std::string key = FFmpegGlue::get()->AddDataSource(data_source);
 
   // Open FFmpeg AVFormatContext.
   DCHECK(!format_context_);
   AVFormatContext* context = NULL;
   int result = av_open_input_file(&context, key.c_str(), NULL, 0, NULL);
 
   // Remove our data source.
   FFmpegGlue::get()->RemoveDataSource(data_source);
 
   if (result < 0) {
     host()->Error(DEMUXER_ERROR_COULD_NOT_OPEN);
+    callback->Run();
     return;
   }
 
   DCHECK(context);
   format_context_ = context;
 
   // Serialize calls to av_find_stream_info().
   {
     AutoLock auto_lock(FFmpegLock::get()->lock());
 
     // Fully initialize AVFormatContext by parsing the stream a little.
     result = av_find_stream_info(format_context_);
     if (result < 0) {
       host()->Error(DEMUXER_ERROR_COULD_NOT_PARSE);
+      callback->Run();
       return;
     }
   }
 
   // Create demuxer streams for all supported streams.
   base::TimeDelta max_duration;
   for (size_t i = 0; i < format_context_->nb_streams; ++i) {
     CodecType codec_type = format_context_->streams[i]->codec->codec_type;
     if (codec_type == CODEC_TYPE_AUDIO || codec_type == CODEC_TYPE_VIDEO) {
       AVStream* stream = format_context_->streams[i];
       FFmpegDemuxerStream* demuxer_stream
           = new FFmpegDemuxerStream(this, stream);
       DCHECK(demuxer_stream);
       streams_.push_back(demuxer_stream);
       packet_streams_.push_back(demuxer_stream);
       max_duration = std::max(max_duration, demuxer_stream->duration());
     } else {
       packet_streams_.push_back(NULL);
     }
   }
   if (streams_.empty()) {
     host()->Error(DEMUXER_ERROR_NO_SUPPORTED_STREAMS);
+    callback->Run();
     return;
   }
 
   // Good to go: set the duration and notify we're done initializing.
   host()->SetDuration(max_duration);
-  host()->InitializationComplete();
+  callback->Run();
 }
 
-void FFmpegDemuxer::SeekTask(base::TimeDelta time) {
+void FFmpegDemuxer::SeekTask(base::TimeDelta time, FilterCallback* callback) {
   DCHECK_EQ(MessageLoop::current(), message_loop());
+  scoped_ptr<FilterCallback> c(callback);
 
   // Tell streams to flush buffers due to seeking.
   StreamVector::iterator iter;
   for (iter = streams_.begin(); iter != streams_.end(); ++iter) {
     (*iter)->FlushBuffers();
   }
 
   // Seek backwards if requested timestamp is behind FFmpeg's current time.
   int flags = 0;
   if (time <= current_timestamp_) {
     flags |= AVSEEK_FLAG_BACKWARD;
   }
 
   if (av_seek_frame(format_context_, -1, time.InMicroseconds(),
                     flags) < 0) {
     // TODO(scherkus): signal error.
     NOTIMPLEMENTED();
   }
+
+  // Notify we're finished seeking.
+  callback->Run();
 }
 
 void FFmpegDemuxer::DemuxTask() {
   DCHECK_EQ(MessageLoop::current(), message_loop());
 
   // Make sure we have work to do before demuxing.
   if (!StreamsHavePendingReads()) {
     return;
   }
 
@@ skipping 69 matching lines @@
   DCHECK_EQ(MessageLoop::current(), message_loop());
   StreamVector::iterator iter;
   for (iter = streams_.begin(); iter != streams_.end(); ++iter) {
     AVPacket* packet = new AVPacket();
     memset(packet, 0, sizeof(*packet));
     (*iter)->EnqueuePacket(packet);
   }
 }
 
 }  // namespace media