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());
+    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 95 matching lines @@
   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 WebMediaPlayerImpl::currentTime() const {
   DCHECK(MessageLoop::current() == main_loop_);
-
   if (paused_) {
     return static_cast<float>(paused_time_.InSecondsF());
   }
   return static_cast<float>(pipeline_->GetCurrentTime().InSecondsF());
 }
 
 int WebMediaPlayerImpl::dataRate() const {
   DCHECK(MessageLoop::current() == main_loop_);
 
   // TODO(hclam): Add this method call if pipeline has it in the interface.
@@ skipping 320 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