Remove reference counting from media::VideoDecoder and friends.

webkit/media/webmediaplayer_impl.cc

 // Copyright (c) 2012 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/media/webmediaplayer_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
+#include "base/command_line.h"
 #include "base/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/synchronization/waitable_event.h"
 #include "cc/layers/video_layer.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "media/audio/null_audio_sink.h"
 #include "media/base/bind_to_loop.h"
 #include "media/base/filter_collection.h"
 #include "media/base/limits.h"
 #include "media/base/media_log.h"
+#include "media/base/media_switches.h"
 #include "media/base/pipeline.h"
 #include "media/base/video_frame.h"
 #include "media/filters/audio_renderer_impl.h"
 #include "media/filters/chunk_demuxer.h"
+#include "media/filters/ffmpeg_audio_decoder.h"
+#include "media/filters/ffmpeg_demuxer.h"
+#include "media/filters/ffmpeg_video_decoder.h"
+#include "media/filters/opus_audio_decoder.h"
 #include "media/filters/video_renderer_base.h"
+#include "media/filters/vpx_video_decoder.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebRect.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebSize.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebString.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebURL.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebMediaSource.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebRuntimeFeatures.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 #include "v8/include/v8.h"
 #include "webkit/compositor_bindings/web_layer_impl.h"
 #include "webkit/media/buffered_data_source.h"
-#include "webkit/media/filter_helpers.h"
 #include "webkit/media/webaudiosourceprovider_impl.h"
 #include "webkit/media/webmediaplayer_delegate.h"
 #include "webkit/media/webmediaplayer_params.h"
 #include "webkit/media/webmediaplayer_util.h"
 #include "webkit/media/webmediasourceclient_impl.h"
 #include "webkit/plugins/ppapi/ppapi_webplugin_impl.h"
 
 using WebKit::WebCanvas;
 using WebKit::WebMediaPlayer;
 using WebKit::WebRect;
@@ skipping 73 matching lines @@
 
 WebMediaPlayerImpl::WebMediaPlayerImpl(
     WebKit::WebFrame* frame,
     WebKit::WebMediaPlayerClient* client,
     base::WeakPtr<WebMediaPlayerDelegate> delegate,
     const WebMediaPlayerParams& params)
     : frame_(frame),
       network_state_(WebMediaPlayer::NetworkStateEmpty),
       ready_state_(WebMediaPlayer::ReadyStateHaveNothing),
       main_loop_(base::MessageLoopProxy::current()),
-      filter_collection_(new media::FilterCollection()),
       media_thread_("MediaPipeline"),
       paused_(true),
       seeking_(false),
       playback_rate_(0.0f),
       pending_seek_(false),
       pending_seek_seconds_(0.0f),
       client_(client),
       delegate_(delegate),
       media_log_(params.media_log()),
       accelerated_compositing_reported_(false),
       incremented_externally_allocated_memory_(false),
+      gpu_factories_(params.gpu_factories()),
       is_local_source_(false),
       supports_save_(true),
       starting_(false),
       pending_repaint_(false),
       video_frame_provider_client_(NULL) {
   media_log_->AddEvent(
       media_log_->CreateEvent(media::MediaLogEvent::WEBMEDIAPLAYER_CREATED));
 
   CHECK(media_thread_.Start());
   pipeline_ = new media::Pipeline(
       media_thread_.message_loop_proxy(), media_log_);
 
   // Let V8 know we started new thread if we did not do it yet.
   // Made separate task to avoid deletion of player currently being created.
   // Also, delaying GC until after player starts gets rid of starting lag --
   // collection happens in parallel with playing.
   //
   // TODO(enal): remove when we get rid of per-audio-stream thread.
   main_loop_->PostTask(
       FROM_HERE,
       base::Bind(&WebMediaPlayerImpl::IncrementExternallyAllocatedMemory,
                  AsWeakPtr()));
 
   // Also we want to be notified of |main_loop_| destruction.
   MessageLoop::current()->AddDestructionObserver(this);
 
-  media::SetDecryptorReadyCB set_decryptor_ready_cb;
   if (WebKit::WebRuntimeFeatures::isEncryptedMediaEnabled()) {
     decryptor_.reset(new ProxyDecryptor(
         client,
         frame,
         BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnKeyAdded),
         BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnKeyError),
         BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnKeyMessage),
         BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnNeedKey)));
-    set_decryptor_ready_cb = base::Bind(&ProxyDecryptor::SetDecryptorReadyCB,
-                                        base::Unretained(decryptor_.get()));
   }
 
-  // Create the GPU video decoder if factories were provided.
-  if (params.gpu_factories()) {
-    filter_collection_->GetVideoDecoders()->push_back(
-        new media::GpuVideoDecoder(
-            media_thread_.message_loop_proxy(),
-            params.gpu_factories()));
-    gpu_factories_ = params.gpu_factories();
-  }
-
-  // Create default video renderer.
-  scoped_ptr<media::VideoRenderer> video_renderer(
-      new media::VideoRendererBase(
-          media_thread_.message_loop_proxy(),
-          set_decryptor_ready_cb,
-          base::Bind(&WebMediaPlayerImpl::FrameReady, base::Unretained(this)),
-          BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::SetOpaque),
-          true));
-  filter_collection_->SetVideoRenderer(video_renderer.Pass());
-
-  // Create default audio renderer using the null sink if no sink was provided.
+  // Use the null sink if no sink was provided.
   audio_source_provider_ = new WebAudioSourceProviderImpl(
       params.audio_renderer_sink() ? params.audio_renderer_sink() :
       new media::NullAudioSink(media_thread_.message_loop_proxy()));
-
-  ScopedVector<media::AudioDecoder> audio_decoders;
-  AddDefaultAudioDecoders(media_thread_.message_loop_proxy(), &audio_decoders);
-
-  scoped_ptr<media::AudioRenderer> audio_renderer(
-      new media::AudioRendererImpl(
-        media_thread_.message_loop_proxy(),
-        audio_source_provider_,
-        audio_decoders.Pass(),
-        set_decryptor_ready_cb));
-  filter_collection_->SetAudioRenderer(audio_renderer.Pass());
 }
 
 WebMediaPlayerImpl::~WebMediaPlayerImpl() {
   SetVideoFrameProviderClient(NULL);
   GetClient()->setWebLayer(NULL);
 
   DCHECK(main_loop_->BelongsToCurrentThread());
   Destroy();
   media_log_->AddEvent(
       media_log_->CreateEvent(media::MediaLogEvent::WEBMEDIAPLAYER_DESTROYED));
@@ skipping 51 matching lines @@
   data_source_ = new BufferedDataSource(
       main_loop_, frame_, media_log_, base::Bind(
           &WebMediaPlayerImpl::NotifyDownloading, AsWeakPtr()));
   data_source_->Initialize(
       url, static_cast<BufferedResourceLoader::CORSMode>(cors_mode),
       base::Bind(
           &WebMediaPlayerImpl::DataSourceInitialized,
           AsWeakPtr(), gurl));
 
   is_local_source_ = !gurl.SchemeIs("http") && !gurl.SchemeIs("https");
-
-  BuildDefaultCollection(
-      data_source_,
-      media_thread_.message_loop_proxy(),
-      filter_collection_.get(),
-      BIND_TO_RENDER_LOOP_2(&WebMediaPlayerImpl::OnNeedKey, "", ""));
 }
 
 void WebMediaPlayerImpl::load(const WebKit::WebURL& url,
                               WebKit::WebMediaSource* media_source,
                               CORSMode cors_mode) {
   scoped_ptr<WebKit::WebMediaSource> ms(media_source);
   LoadSetup(url);
 
   // Media source pipelines can start immediately.
   chunk_demuxer_ = new media::ChunkDemuxer(
       BIND_TO_RENDER_LOOP_1(&WebMediaPlayerImpl::OnDemuxerOpened,
                             base::Passed(&ms)),
       BIND_TO_RENDER_LOOP_2(&WebMediaPlayerImpl::OnNeedKey, "", ""),
       base::Bind(&LogMediaSourceError, media_log_));
 
-  BuildMediaSourceCollection(chunk_demuxer_,
-                             media_thread_.message_loop_proxy(),
-                             filter_collection_.get());
   supports_save_ = false;
   StartPipeline();
 }
 
 void WebMediaPlayerImpl::LoadSetup(const WebKit::WebURL& url) {
   GURL gurl(url);
   UMA_HISTOGRAM_ENUMERATION("Media.URLScheme", URLScheme(gurl), kMaxURLScheme);
 
   // Handle any volume/preload changes that occurred before load().
   setVolume(GetClient()->volume());
@@ skipping 798 matching lines @@
     SetNetworkState(WebMediaPlayer::NetworkStateLoading);
   media_log_->AddEvent(
       media_log_->CreateBooleanEvent(
           media::MediaLogEvent::NETWORK_ACTIVITY_SET,
           "is_downloading_data", is_downloading));
 }
 
 void WebMediaPlayerImpl::StartPipeline() {
   starting_ = true;
   pipeline_->Start(
-      filter_collection_.Pass(),
+      BuildFilterCollection(),
       BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnPipelineEnded),
       BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnPipelineError),
       BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnPipelineSeek),
       BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnPipelineBufferingState),
       BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnDurationChange));
 }
 
 void WebMediaPlayerImpl::SetNetworkState(WebMediaPlayer::NetworkState state) {
   DCHECK(main_loop_->BelongsToCurrentThread());
   DVLOG(1) << "SetNetworkState: " << state;
@@ skipping 90 matching lines @@
   current_frame_ = frame;
 
   if (pending_repaint_)
     return;
 
   pending_repaint_ = true;
   main_loop_->PostTask(FROM_HERE, base::Bind(
       &WebMediaPlayerImpl::Repaint, AsWeakPtr()));
 }
 
+scoped_ptr<media::FilterCollection>
+WebMediaPlayerImpl::BuildFilterCollection() {
+  const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
+
+  scoped_ptr<media::FilterCollection> filter_collection(
+      new media::FilterCollection());
+
+  // Figure out which demuxer to use.
+  if (data_source_) {
+    DCHECK(!chunk_demuxer_);
+    filter_collection->SetDemuxer(new media::FFmpegDemuxer(
+        media_thread_.message_loop_proxy(), data_source_,
+        BIND_TO_RENDER_LOOP_2(&WebMediaPlayerImpl::OnNeedKey, "", "")));
+  } else {
+    DCHECK(chunk_demuxer_);
+    filter_collection->SetDemuxer(chunk_demuxer_);
+
+    // Disable GpuVideoDecoder creation until it supports codec config changes.
+    // TODO(acolwell): Remove this once http://crbug.com/151045 is fixed.
+    gpu_factories_ = NULL;
+  }
+
+  // Figure out if EME is enabled.
+  media::SetDecryptorReadyCB set_decryptor_ready_cb;
+  if (decryptor_) {
+    set_decryptor_ready_cb = base::Bind(&ProxyDecryptor::SetDecryptorReadyCB,
+                                        base::Unretained(decryptor_.get()));
+  }
+
+  // Create our audio decoders and renderer.
+  ScopedVector<media::AudioDecoder> audio_decoders;
+  audio_decoders.push_back(new media::FFmpegAudioDecoder(
+      media_thread_.message_loop_proxy()));
+  if (cmd_line->HasSwitch(switches::kEnableOpusPlayback)) {
+    audio_decoders.push_back(new media::OpusAudioDecoder(
+        media_thread_.message_loop_proxy()));
+  }
+
+  scoped_ptr<media::AudioRenderer> audio_renderer(
+      new media::AudioRendererImpl(media_thread_.message_loop_proxy(),
+                                   audio_source_provider_,
+                                   audio_decoders.Pass(),
+                                   set_decryptor_ready_cb));
+  filter_collection->SetAudioRenderer(audio_renderer.Pass());
+
+  // Create our video decoders and renderer.
+  ScopedVector<media::VideoDecoder> video_decoders;
+
+  if (gpu_factories_) {
+    video_decoders.push_back(new media::GpuVideoDecoder(
+        media_thread_.message_loop_proxy(), gpu_factories_));
+  }
+
+  video_decoders.push_back(new media::FFmpegVideoDecoder(
+      media_thread_.message_loop_proxy()));
+
+  // TODO(phajdan.jr): Remove ifdefs when libvpx with vp9 support is released
+  // (http://crbug.com/174287) .
+#if !defined(MEDIA_DISABLE_LIBVPX)
+  if (cmd_line->HasSwitch(switches::kEnableVp9Playback)) {
+    video_decoders.push_back(new media::VpxVideoDecoder(
+        media_thread_.message_loop_proxy()));
+  }
+#endif  // !defined(MEDIA_DISABLE_LIBVPX)
+
+  scoped_ptr<media::VideoRenderer> video_renderer(
+      new media::VideoRendererBase(
+          media_thread_.message_loop_proxy(),
+          video_decoders.Pass(),
+          set_decryptor_ready_cb,
+          base::Bind(&WebMediaPlayerImpl::FrameReady, base::Unretained(this)),
+          BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::SetOpaque),
+          true));
+  filter_collection->SetVideoRenderer(video_renderer.Pass());
+
+  return filter_collection.Pass();
+}
+
 }  // namespace webkit_media