DemuxerFactory is born!

media/filters/ffmpeg_demuxer.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 "base/callback.h"
 #include "base/command_line.h"
 #include "base/message_loop.h"
 #include "base/scoped_ptr.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
@@ skipping 234 matching lines @@
 
 //
 // FFmpegDemuxer
 //
 FFmpegDemuxer::FFmpegDemuxer(MessageLoop* message_loop)
     : message_loop_(message_loop),
       format_context_(NULL),
       read_event_(false, false),
       read_has_failed_(false),
       last_read_bytes_(0),
-      read_position_(0) {
+      read_position_(0),
+      max_duration_(base::TimeDelta::FromMicroseconds(-1)),
+      deferred_status_(PIPELINE_OK) {
   DCHECK(message_loop_);
 }
 
 FFmpegDemuxer::~FFmpegDemuxer() {
   // In this destructor, we clean up resources held by FFmpeg. It is ugly to
   // close the codec contexts here because the corresponding codecs are opened
   // in the decoder filters. By reaching this point, all filters should have
   // stopped, so this is the only safe place to do the global clean up.
   // TODO(hclam): close the codecs in the corresponding decoders.
   if (!format_context_)
@@ skipping 42 matching lines @@
   // asynchronous, should change how seek works to make it fully asynchronous.
   message_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &FFmpegDemuxer::SeekTask, time, callback));
 }
 
 void FFmpegDemuxer::OnAudioRendererDisabled() {
   message_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &FFmpegDemuxer::DisableAudioStreamTask));
 }
 
+void FFmpegDemuxer::set_host(FilterHost* filter_host) {
+  Demuxer::set_host(filter_host);
+  if (data_source_)
+    data_source_->set_host(filter_host);
+  if (max_duration_.InMicroseconds() >= 0)
+    host()->SetDuration(max_duration_);
+  if (read_position_ > 0)
+    host()->SetCurrentReadPosition(read_position_);
+  if (deferred_status_ != PIPELINE_OK)
+    host()->SetError(deferred_status_);
+}
+
 void FFmpegDemuxer::Initialize(DataSource* data_source,
-                               FilterCallback* callback) {
+                               PipelineStatusCallback* callback) {
   message_loop_->PostTask(
       FROM_HERE,
       NewRunnableMethod(this,
                         &FFmpegDemuxer::InitializeTask,
                         make_scoped_refptr(data_source),
                         callback));
 }
 
 size_t FFmpegDemuxer::GetNumberOfStreams() {
   return streams_.size();
@@ skipping 21 matching lines @@
 
   // Asynchronous read from data source.
   data_source_->Read(read_position_, size, data,
                      NewCallback(this, &FFmpegDemuxer::OnReadCompleted));
 
   // TODO(hclam): The method is called on the demuxer thread and this method
   // call will block the thread. We need to implemented an additional thread to
   // let FFmpeg demuxer methods to run on.
   size_t last_read_bytes = WaitForRead();
   if (last_read_bytes == DataSource::kReadError) {
-    host()->SetError(PIPELINE_ERROR_READ);
+    if (host())
+      host()->SetError(PIPELINE_ERROR_READ);
+    else
+      deferred_status_ = PIPELINE_ERROR_READ;
 
     // Returns with a negative number to signal an error to FFmpeg.
     read_has_failed_ = true;
     return AVERROR_IO;
   }
   read_position_ += last_read_bytes;
 
-  host()->SetCurrentReadPosition(read_position_);
+  if (host())
+    host()->SetCurrentReadPosition(read_position_);
 
   return last_read_bytes;
 }
 
 bool FFmpegDemuxer::GetPosition(int64* position_out) {
   *position_out = read_position_;
   return true;
 }
 
 bool FFmpegDemuxer::SetPosition(int64 position) {
@@ skipping 18 matching lines @@
   DCHECK(data_source_);
 
   return data_source_->IsStreaming();
 }
 
 MessageLoop* FFmpegDemuxer::message_loop() {
   return message_loop_;
 }
 
 void FFmpegDemuxer::InitializeTask(DataSource* data_source,
-                                   FilterCallback* callback) {
+                                   PipelineStatusCallback* callback) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
-  scoped_ptr<FilterCallback> c(callback);
+  scoped_ptr<PipelineStatusCallback> callback_deleter(callback);
 
   data_source_ = data_source;
+  if (host())
+    data_source_->set_host(host());
 
   // Add ourself to Protocol list and get our unique key.
   std::string key = FFmpegGlue::GetInstance()->AddProtocol(this);
 
   // Open FFmpeg AVFormatContext.
   DCHECK(!format_context_);
   AVFormatContext* context = NULL;
   int result = av_open_input_file(&context, key.c_str(), NULL, 0, NULL);
 
   // Remove ourself from protocol list.
   FFmpegGlue::GetInstance()->RemoveProtocol(this);
 
   if (result < 0) {
-    host()->SetError(DEMUXER_ERROR_COULD_NOT_OPEN);
-    callback->Run();
+    callback->Run(DEMUXER_ERROR_COULD_NOT_OPEN);
     return;
   }
 
   DCHECK(context);
   format_context_ = context;
 
   // Fully initialize AVFormatContext by parsing the stream a little.
   result = av_find_stream_info(format_context_);
   if (result < 0) {
-    host()->SetError(DEMUXER_ERROR_COULD_NOT_PARSE);
-    callback->Run();
+    callback->Run(DEMUXER_ERROR_COULD_NOT_PARSE);
     return;
   }
 
   // Create demuxer streams for all supported streams.
   base::TimeDelta max_duration;
   const bool kDemuxerIsWebm = !strcmp("webm", format_context_->iformat->name);
   for (size_t i = 0; i < format_context_->nb_streams; ++i) {
     AVCodecContext* codec_context = format_context_->streams[i]->codec;
     CodecType codec_type = codec_context->codec_type;
     if (codec_type == CODEC_TYPE_AUDIO || codec_type == CODEC_TYPE_VIDEO) {
@@ skipping 10 matching lines @@
 
       DCHECK(demuxer_stream);
       streams_.push_back(make_scoped_refptr(demuxer_stream));
       packet_streams_.push_back(make_scoped_refptr(demuxer_stream));
       max_duration = std::max(max_duration, demuxer_stream->duration());
     } else {
       packet_streams_.push_back(NULL);
     }
   }
   if (streams_.empty()) {
-    host()->SetError(DEMUXER_ERROR_NO_SUPPORTED_STREAMS);
-    callback->Run();
+    callback->Run(DEMUXER_ERROR_NO_SUPPORTED_STREAMS);
     return;
   }
   if (format_context_->duration != static_cast<int64_t>(AV_NOPTS_VALUE)) {
     // If there is a duration value in the container use that to find the
     // maximum between it and the duration from A/V streams.
     const AVRational av_time_base = {1, AV_TIME_BASE};
     max_duration =
         std::max(max_duration,
                  ConvertTimestamp(av_time_base, format_context_->duration));
   } else {
     // If the duration is not a valid value. Assume that this is a live stream
     // and we set duration to the maximum int64 number to represent infinity.
     max_duration = base::TimeDelta::FromMicroseconds(
         Limits::kMaxTimeInMicroseconds);
   }
 
   // Good to go: set the duration and notify we're done initializing.
-  host()->SetDuration(max_duration);
-  callback->Run();
+  if (host())
+    host()->SetDuration(max_duration);
+  max_duration_ = max_duration;
+  callback->Run(PIPELINE_OK);
 }
 
 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();
@@ skipping 67 matching lines @@
     PostDemuxTask();
   }
 }
 
 void FFmpegDemuxer::StopTask(FilterCallback* callback) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   StreamVector::iterator iter;
   for (iter = streams_.begin(); iter != streams_.end(); ++iter) {
     (*iter)->Stop();
   }
-  if (callback) {
+  if (data_source_) {
+    data_source_->Stop(callback);
+  } else {
     callback->Run();
     delete callback;
   }
 }
 
 void FFmpegDemuxer::DisableAudioStreamTask() {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
 
   StreamVector::iterator iter;
   for (size_t i = 0; i < packet_streams_.size(); ++i) {
@@ skipping 39 matching lines @@
   read_event_.Wait();
   return last_read_bytes_;
 }
 
 void FFmpegDemuxer::SignalReadCompleted(size_t size) {
   last_read_bytes_ = size;
   read_event_.Signal();
 }
 
 }  // namespace media