Adding ChunkDemuxer implementation.

webkit/glue/webmediaplayer_impl.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 "webkit/glue/webmediaplayer_impl.h"
 
 #include <limits>
 #include <string>
 
 #include "base/callback.h"
@@ skipping 322 matching lines @@
       new media::CompositeDataSourceFactory());
 
   if (use_simple_data_source) {
     data_source_factory->AddFactory(simple_data_source_factory.release());
     data_source_factory->AddFactory(buffered_data_source_factory.release());
   } else {
     data_source_factory->AddFactory(buffered_data_source_factory.release());
     data_source_factory->AddFactory(simple_data_source_factory.release());
   }
 
+  if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kEnableAdaptive)) {
+    chunk_demuxer_factory_.reset(new media::ChunkDemuxerFactory(
+        data_source_factory->Clone()));
+  }
+
   scoped_ptr<media::DemuxerFactory> demuxer_factory(
       new media::FFmpegDemuxerFactory(data_source_factory.release(),
                                       pipeline_message_loop));
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kEnableAdaptive)) {
     demuxer_factory.reset(new media::AdaptiveDemuxerFactory(
         demuxer_factory.release()));
   }
   filter_collection_->SetDemuxerFactory(demuxer_factory.release());
 
   // Add in the default filter factories.
@@ skipping 24 matching lines @@
     // Remove the default decoder
     scoped_refptr<media::VideoDecoder> old_videodecoder;
     filter_collection_->SelectVideoDecoder(&old_videodecoder);
     media::RTCVideoDecoder* rtc_video_decoder =
         new media::RTCVideoDecoder(
              message_loop_factory_->GetMessageLoop("VideoDecoderThread"),
              url.spec());
     filter_collection_->AddVideoDecoder(rtc_video_decoder);
   }
 
+  if (chunk_demuxer_factory_.get() &&
+      chunk_demuxer_factory_->IsUrlSupported(url.spec())) {
+    media_data_sink_.reset(chunk_demuxer_factory_->CreateMediaDataSink());

[scherkus (not reviewing), 2011/06/22 17:31:09]

what if chunk_demuxer_factory_ passed a ref to a media data sink as opposed to
creating a ptr?

[acolwell GONE FROM CHROMIUM, 2011/06/23 16:51:29]

No can do. WebMediaPlayerImpl needs to be able to manage the lifetime of
MediaDataSink. The factory becomes owned by the FilterCollection and can be
destroyed at any point. I believe the collection gets destroyed after the
pipeline is initialized.

+    filter_collection_->SetDemuxerFactory(chunk_demuxer_factory_.release());
+  }
+
   // Handle any volume changes that occured before load().
   setVolume(GetClient()->volume());
   // Get the preload value.
   setPreload(GetClient()->preload());
 
   // Initialize the pipeline.
   SetNetworkState(WebKit::WebMediaPlayer::Loading);
   SetReadyState(WebKit::WebMediaPlayer::HaveNothing);
   pipeline_->Start(
       filter_collection_.release(),
@@ skipping 14 matching lines @@
 }
 
 void WebMediaPlayerImpl::pause() {
   DCHECK(MessageLoop::current() == main_loop_);
 
   paused_ = true;
   pipeline_->SetPlaybackRate(0.0f);
   paused_time_ = pipeline_->GetCurrentTime();
 }
 
+bool WebMediaPlayerImpl::addData(const unsigned char* data, unsigned length) {
+  DCHECK(MessageLoop::current() == main_loop_);
+
+  if (!media_data_sink_.get())
+    return false;
+
+  return media_data_sink_->AddData(data, length);
+}
+
 bool WebMediaPlayerImpl::supportsFullscreen() const {
   DCHECK(MessageLoop::current() == main_loop_);
   return true;
 }
 
 bool WebMediaPlayerImpl::supportsSave() const {
   DCHECK(MessageLoop::current() == main_loop_);
   return true;
 }
 
@@ skipping 14 matching lines @@
 
   base::TimeDelta seek_time = ConvertSecondsToTimestamp(seconds);
 
   // Update our paused time.
   if (paused_) {
     paused_time_ = seek_time;
   }
 
   seeking_ = true;
 
+  if (media_data_sink_.get())
+    media_data_sink_->Flush();
+
   // Kick off the asynchronous seek!
   pipeline_->Seek(
       seek_time,
       NewCallback(proxy_.get(),
                   &WebMediaPlayerImpl::Proxy::PipelineSeekCallback));
 }
 
 void WebMediaPlayerImpl::setEndTime(float seconds) {
   DCHECK(MessageLoop::current() == main_loop_);
 
@@ skipping 90 matching lines @@
 
   return seeking_;
 }
 
 float WebMediaPlayerImpl::duration() const {
   DCHECK(MessageLoop::current() == main_loop_);
 
   base::TimeDelta duration = pipeline_->GetMediaDuration();
   if (duration.InMicroseconds() == media::Limits::kMaxTimeInMicroseconds)
     return std::numeric_limits<float>::infinity();
-  return static_cast<float>(duration.InSecondsF());
+  float ret = static_cast<float>(duration.InSecondsF());
+
+  //LOG(ERROR) << "duration() : " << ret;

[scherkus (not reviewing), 2011/06/22 17:31:09]

?

[acolwell GONE FROM CHROMIUM, 2011/06/23 16:51:29]

reverted

+
+  return ret;
 }
 
 float WebMediaPlayerImpl::currentTime() const {
   DCHECK(MessageLoop::current() == main_loop_);
-
+  float ret = -1;
   if (paused_) {
-    return static_cast<float>(paused_time_.InSecondsF());
+    ret = static_cast<float>(paused_time_.InSecondsF());

[scherkus (not reviewing), 2011/06/22 17:31:09]

revert the changes here?

[acolwell GONE FROM CHROMIUM, 2011/06/23 16:51:29]

Done.

+  } else {
+    ret = static_cast<float>(pipeline_->GetCurrentTime().InSecondsF());
   }
-  return static_cast<float>(pipeline_->GetCurrentTime().InSecondsF());
+  //LOG(ERROR) << "currentTime() : " << ret;

[scherkus (not reviewing), 2011/06/22 17:31:09]

?

[acolwell GONE FROM CHROMIUM, 2011/06/23 16:51:29]

reverted

+  return ret;
 }
 
 int WebMediaPlayerImpl::dataRate() const {
   DCHECK(MessageLoop::current() == main_loop_);
 
   // TODO(hclam): Add this method call if pipeline has it in the interface.
   return 0;
 }
 
 WebKit::WebMediaPlayer::NetworkState WebMediaPlayerImpl::networkState() const {
   return network_state_;
 }
 
 WebKit::WebMediaPlayer::ReadyState WebMediaPlayerImpl::readyState() const {
   return ready_state_;
 }
 
 const WebKit::WebTimeRanges& WebMediaPlayerImpl::buffered() {
   DCHECK(MessageLoop::current() == main_loop_);
 
   // Update buffered_ with the most recent buffered time.
   if (buffered_.size() > 0) {
     float buffered_time = static_cast<float>(
         pipeline_->GetBufferedTime().InSecondsF());
     if (buffered_time >= buffered_[0].start)
       buffered_[0].end = buffered_time;
+
+    //LOG(ERROR) << "buffered() : " << buffered_[0].start
+    //           << " - " << buffered_[0].end;

[scherkus (not reviewing), 2011/06/22 17:31:09]

?

[acolwell GONE FROM CHROMIUM, 2011/06/23 16:51:29]

reverted

   }
 
   return buffered_;
 }
 
 float WebMediaPlayerImpl::maxTimeSeekable() const {
   DCHECK(MessageLoop::current() == main_loop_);
 
   // If we are performing streaming, we report that we cannot seek at all.
   // We are using this flag to indicate if the data source supports seeking
   // or not. We should be able to seek even if we are performing streaming.
   // TODO(hclam): We need to update this when we have better caching.
   if (pipeline_->IsStreaming())
     return 0.0f;
-  return static_cast<float>(pipeline_->GetMediaDuration().InSecondsF());
+  float ret = static_cast<float>(pipeline_->GetMediaDuration().InSecondsF());
+
+  LOG(ERROR) << "maxTimeSeekable() : " << ret;

[acolwell GONE FROM CHROMIUM, 2011/06/23 16:51:29]

reverted

+  return ret;
 }
 
 unsigned long long WebMediaPlayerImpl::bytesLoaded() const {
   DCHECK(MessageLoop::current() == main_loop_);
 
   return pipeline_->GetBufferedBytes();
 }
 
 unsigned long long WebMediaPlayerImpl::totalBytes() const {
   DCHECK(MessageLoop::current() == main_loop_);
@@ skipping 275 matching lines @@
 }
 
 void WebMediaPlayerImpl::Destroy() {
   DCHECK(MessageLoop::current() == main_loop_);
 
   // Tell the data source to abort any pending reads so that the pipeline is
   // not blocked when issuing stop commands to the other filters.
   if (proxy_)
     proxy_->AbortDataSources();
 
+  if (media_data_sink_.get())
+    media_data_sink_->Shutdown();
+
   // Make sure to kill the pipeline so there's no more media threads running.
   // Note: stopping the pipeline might block for a long time.
   if (pipeline_) {
     media::PipelineStatusNotification note;
     pipeline_->Stop(note.Callback());
     note.Wait();
   }
 
   message_loop_factory_.reset();
 
   // And then detach the proxy, it may live on the render thread for a little
   // longer until all the tasks are finished.
   if (proxy_) {
     proxy_->Detach();
     proxy_ = NULL;
   }
 }
 
 WebKit::WebMediaPlayerClient* WebMediaPlayerImpl::GetClient() {
   DCHECK(MessageLoop::current() == main_loop_);
   DCHECK(client_);
   return client_;
 }
 
 }  // namespace webkit_glue