media: Introduce Renderer interface and RendererImpl.

content/renderer/media/webmediaplayer_impl.cc

 // Copyright 2013 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 "content/renderer/media/webmediaplayer_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 #include <vector>
@@ skipping 40 matching lines @@
 #include "media/base/text_renderer.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/gpu_video_accelerator_factories.h"
 #include "media/filters/gpu_video_decoder.h"
 #include "media/filters/opus_audio_decoder.h"
+#include "media/filters/renderer_impl.h"
 #include "media/filters/video_renderer_impl.h"
 #include "media/filters/vpx_video_decoder.h"
 #include "third_party/WebKit/public/platform/WebContentDecryptionModule.h"
 #include "third_party/WebKit/public/platform/WebContentDecryptionModuleResult.h"
 #include "third_party/WebKit/public/platform/WebMediaSource.h"
 #include "third_party/WebKit/public/platform/WebRect.h"
 #include "third_party/WebKit/public/platform/WebSize.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
@@ skipping 1090 matching lines @@
   if (!is_downloading && network_state_ == WebMediaPlayer::NetworkStateLoading)
     SetNetworkState(WebMediaPlayer::NetworkStateIdle);
   else if (is_downloading && network_state_ == WebMediaPlayer::NetworkStateIdle)
     SetNetworkState(WebMediaPlayer::NetworkStateLoading);
   media_log_->AddEvent(
       media_log_->CreateBooleanEvent(
           media::MediaLogEvent::NETWORK_ACTIVITY_SET,
           "is_downloading_data", is_downloading));
 }
 
+// TODO(xhwang): Move this to a factory class so that we can create different

[gunsch, 2014/08/22 22:55:26]

qq: what's the plan for this? Is this expected to be swappable at runtime by the
content embedder implementation? Or are you looking to get further towards the
IPC-based pipeline path before providing that sort of possibility?

[gunsch, 2014/08/22 22:56:35]

Ah, I just saw your reply to Damien earlier this CL about plans going forward
from here. Feel free to ignore this :)

[xhwang, 2014/08/22 23:00:55]

The current plan is that we'll create different Renderer implementation for
different platform and pass it to the WebMediaPlayerImpl. I don't think we can
swap Renderers at run-time after the initialization though. 

+// renderers.
+scoped_ptr<media::Renderer> WebMediaPlayerImpl::CreateRenderer() {
+  media::SetDecryptorReadyCB set_decryptor_ready_cb =
+      BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::SetDecryptorReadyCB);
+
+  // Create our audio decoders and renderer.
+  ScopedVector<media::AudioDecoder> audio_decoders;
+
+  media::LogCB log_cb = base::Bind(&LogMediaSourceError, media_log_);
+  audio_decoders.push_back(new media::FFmpegAudioDecoder(media_loop_, log_cb));
+  audio_decoders.push_back(new media::OpusAudioDecoder(media_loop_));
+
+  scoped_ptr<media::AudioRenderer> audio_renderer(new media::AudioRendererImpl(
+      media_loop_,
+      audio_source_provider_.get(),
+      audio_decoders.Pass(),
+      set_decryptor_ready_cb,
+      RenderThreadImpl::current()->GetAudioHardwareConfig()));
+
+  // Create our video decoders and renderer.
+  ScopedVector<media::VideoDecoder> video_decoders;
+
+  if (gpu_factories_.get()) {
+    video_decoders.push_back(
+        new media::GpuVideoDecoder(gpu_factories_, media_log_));
+  }
+
+#if !defined(MEDIA_DISABLE_LIBVPX)
+  video_decoders.push_back(new media::VpxVideoDecoder(media_loop_));
+#endif  // !defined(MEDIA_DISABLE_LIBVPX)
+
+  video_decoders.push_back(new media::FFmpegVideoDecoder(media_loop_));
+
+  scoped_ptr<media::VideoRenderer> video_renderer(
+      new media::VideoRendererImpl(
+          media_loop_,
+          video_decoders.Pass(),
+          set_decryptor_ready_cb,
+          base::Bind(&WebMediaPlayerImpl::FrameReady, base::Unretained(this)),
+          true));
+
+  // Create renderer.
+  return scoped_ptr<media::Renderer>(new media::RendererImpl(
+      media_loop_,
+      demuxer_.get(),
+      audio_renderer.Pass(),
+      video_renderer.Pass()));
+}
+
 void WebMediaPlayerImpl::StartPipeline() {
   DCHECK(main_loop_->BelongsToCurrentThread());
   const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
 
   // Keep track if this is a MSE or non-MSE playback.
   UMA_HISTOGRAM_BOOLEAN("Media.MSE.Playback",
                         (load_type_ == LoadTypeMediaSource));
 
   media::LogCB mse_log_cb;
 
@@ skipping 16 matching lines @@
         BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnDemuxerOpened),
         BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnNeedKey),
         mse_log_cb,
         true);
     demuxer_.reset(chunk_demuxer_);
   }
 
   scoped_ptr<media::FilterCollection> filter_collection(
       new media::FilterCollection());
   filter_collection->SetDemuxer(demuxer_.get());
-
-  media::SetDecryptorReadyCB set_decryptor_ready_cb =
-      BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::SetDecryptorReadyCB);
-
-  // Create our audio decoders and renderer.
-  ScopedVector<media::AudioDecoder> audio_decoders;
-  audio_decoders.push_back(new media::FFmpegAudioDecoder(media_loop_,
-                                                         mse_log_cb));
-  audio_decoders.push_back(new media::OpusAudioDecoder(media_loop_));
-
-  scoped_ptr<media::AudioRenderer> audio_renderer(new media::AudioRendererImpl(
-      media_loop_,
-      audio_source_provider_.get(),
-      audio_decoders.Pass(),
-      set_decryptor_ready_cb,
-      RenderThreadImpl::current()->GetAudioHardwareConfig()));
-  filter_collection->SetAudioRenderer(audio_renderer.Pass());
-
-  // Create our video decoders and renderer.
-  ScopedVector<media::VideoDecoder> video_decoders;
-
-  if (gpu_factories_.get()) {
-    video_decoders.push_back(
-        new media::GpuVideoDecoder(gpu_factories_, media_log_));
-  }
-
-#if !defined(MEDIA_DISABLE_LIBVPX)
-  video_decoders.push_back(new media::VpxVideoDecoder(media_loop_));
-#endif  // !defined(MEDIA_DISABLE_LIBVPX)
-
-  video_decoders.push_back(new media::FFmpegVideoDecoder(media_loop_));
-
-  scoped_ptr<media::VideoRenderer> video_renderer(
-      new media::VideoRendererImpl(
-          media_loop_,
-          video_decoders.Pass(),
-          set_decryptor_ready_cb,
-          base::Bind(&WebMediaPlayerImpl::FrameReady, base::Unretained(this)),
-          true));
-  filter_collection->SetVideoRenderer(video_renderer.Pass());
+  filter_collection->SetRenderer(CreateRenderer());
 
   if (cmd_line->HasSwitch(switches::kEnableInbandTextTracks)) {
     scoped_ptr<media::TextRenderer> text_renderer(
         new media::TextRenderer(
             media_loop_,
             BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnAddTextTrack)));
 
     filter_collection->SetTextRenderer(text_renderer.Pass());
   }
 
@@ skipping 149 matching lines @@
   compositor_task_runner_->PostTask(FROM_HERE,
                                     base::Bind(&GetCurrentFrameAndSignal,
                                                base::Unretained(compositor_),
                                                &video_frame,
                                                &event));
   event.Wait();
   return video_frame;
 }
 
 }  // namespace content