Chromecast: use multiple video configs in CMA

- The CL also remove space in front of ::media namespace.

BUG= internal b/18865809

Review URL: https://codereview.chromium.org/1148253006

Cr-Commit-Position: refs/heads/master@{#333225}

chromecast/browser/media/cma_message_filter_host.cc

@@ -536,7 +536,8 @@ void CmaMessageFilterHost::AudioInitialize(
 }
 
 void CmaMessageFilterHost::VideoInitialize(
-    int media_id, TrackId track_id, const ::media::VideoDecoderConfig& config) {
+    int media_id, TrackId track_id,
+    const std::vector<::media::VideoDecoderConfig>& configs) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   MediaPipelineHost* media_pipeline = LookupById(media_id);
   if (!media_pipeline) {
@@ -566,7 +567,7 @@ void CmaMessageFilterHost::VideoInitialize(
       FROM_HERE,
       base::Bind(&MediaPipelineHost::VideoInitialize,
                  base::Unretained(media_pipeline),
-                 track_id, client, config, pipeline_status_cb));
+                 track_id, client, configs, pipeline_status_cb));
 }
 
 void CmaMessageFilterHost::StartPlayingFrom(

chromecast/browser/media/cma_message_filter_host.h

@@ -74,9 +74,10 @@ class CmaMessageFilterHost
   void AudioInitialize(int media_id,
                        TrackId track_id,
                        const ::media::AudioDecoderConfig& config);
-  void VideoInitialize(int media_id,
-                       TrackId track_id,
-                       const ::media::VideoDecoderConfig& config);
+  void VideoInitialize(
+      int media_id,
+      TrackId track_id,
+      const std::vector<::media::VideoDecoderConfig>& configs);
   void StartPlayingFrom(int media_id, base::TimeDelta time);
   void Flush(int media_id);
   void Stop(int media_id);

chromecast/browser/media/media_pipeline_host.cc

@@ -118,13 +118,13 @@ void MediaPipelineHost::AudioInitialize(
 void MediaPipelineHost::VideoInitialize(
     TrackId track_id,
     const VideoPipelineClient& client,
-    const ::media::VideoDecoderConfig& config,
+    const std::vector<::media::VideoDecoderConfig>& configs,
     const ::media::PipelineStatusCB& status_cb) {
   DCHECK(thread_checker_.CalledOnValidThread());
   CHECK(track_id == kVideoTrackId);
   media_pipeline_->GetVideoPipeline()->SetClient(client);
   media_pipeline_->InitializeVideo(
-      config, scoped_ptr<CodedFrameProvider>(), status_cb);
+      configs, scoped_ptr<CodedFrameProvider>(), status_cb);
 }
 
 void MediaPipelineHost::StartPlayingFrom(base::TimeDelta time) {

chromecast/browser/media/media_pipeline_host.h

@@ -56,7 +56,7 @@ class MediaPipelineHost {
                        const ::media::PipelineStatusCB& status_cb);
   void VideoInitialize(TrackId track_id,
                        const VideoPipelineClient& client,
-                       const ::media::VideoDecoderConfig& config,
+                       const std::vector<::media::VideoDecoderConfig>& configs,
                        const ::media::PipelineStatusCB& status_cb);
   void StartPlayingFrom(base::TimeDelta time);
   void Flush(const ::media::PipelineStatusCB& status_cb);

chromecast/common/media/cma_messages.h

@@ -50,11 +50,12 @@ IPC_MESSAGE_CONTROL3(CmaHostMsg_CreateAvPipe,
 IPC_MESSAGE_CONTROL3(CmaHostMsg_AudioInitialize,
                      int /* Media pipeline ID */,
                      chromecast::media::TrackId /* Track ID */,
-                     media::AudioDecoderConfig /* Audio config */)
+                     ::media::AudioDecoderConfig /* Audio config */)
 IPC_MESSAGE_CONTROL3(CmaHostMsg_VideoInitialize,
                      int /* Media pipeline ID */,
                      chromecast::media::TrackId /* Track ID */,
-                     media::VideoDecoderConfig /* Video config */)
+                     /* Video Config */
+                     std::vector<::media::VideoDecoderConfig>)
 IPC_MESSAGE_CONTROL3(CmaHostMsg_SetVolume,
                      int /* Media pipeline ID */,
                      chromecast::media::TrackId /* Track ID */,
@@ -112,4 +113,4 @@ IPC_MESSAGE_CONTROL3(CmaMsg_PlaybackStatistics,
 IPC_MESSAGE_CONTROL3(CmaMsg_NaturalSizeChanged,
                      int /* Media pipeline ID */,
                      chromecast::media::TrackId /* Track ID */,
-                     gfx::Size /* Size */)
+                     gfx::Size /* Size */)

chromecast/media/cma/base/buffering_frame_provider.cc

@@ -114,7 +114,7 @@ void BufferingFrameProvider::RequestBufferIfNeeded() {
     return;
 
   is_pending_request_ = true;
-  coded_frame_provider_->Read(BindToCurrentLoop(
+  coded_frame_provider_->Read(::media::BindToCurrentLoop(
       base::Bind(&BufferingFrameProvider::OnNewBuffer, weak_this_)));
 }
 

chromecast/media/cma/filters/cma_renderer.cc

@@ -323,8 +323,10 @@ void CmaRenderer::InitializeVideoPipeline() {
   initial_natural_size_ = config.natural_size();
 
   has_video_ = true;
+  std::vector<::media::VideoDecoderConfig> configs;
+  configs.push_back(config);
   media_pipeline_->InitializeVideo(
-      config,
+      configs,
       frame_provider.Pass(),
       video_initialization_done_cb);
 }

chromecast/media/cma/filters/demuxer_stream_adapter.cc

@@ -114,7 +114,7 @@ void DemuxerStreamAdapter::RequestBuffer(const ReadCB& read_cb) {
 void DemuxerStreamAdapter::OnNewBuffer(
     const ReadCB& read_cb,
     ::media::DemuxerStream::Status status,
-    const scoped_refptr< ::media::DecoderBuffer>& input) {
+    const scoped_refptr<::media::DecoderBuffer>& input) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   is_pending_demuxer_read_ = false;

chromecast/media/cma/filters/demuxer_stream_adapter_unittest.cc

@@ -93,7 +93,7 @@ void DummyDemuxerStream::Read(const ReadCB& read_cb) {
     config_idx_.pop_front();
     has_pending_read_ = false;
     read_cb.Run(kConfigChanged,
-                scoped_refptr< ::media::DecoderBuffer>());
+                scoped_refptr<::media::DecoderBuffer>());
     return;
   }
 
@@ -141,7 +141,7 @@ bool DummyDemuxerStream::SupportsConfigChanges() {
 
 void DummyDemuxerStream::DoRead(const ReadCB& read_cb) {
   has_pending_read_ = false;
-  scoped_refptr< ::media::DecoderBuffer> buffer(
+  scoped_refptr<::media::DecoderBuffer> buffer(
       new ::media::DecoderBuffer(16));
   buffer->set_timestamp(frame_count_ * base::TimeDelta::FromMilliseconds(40));
   frame_count_++;

chromecast/media/cma/pipeline/audio_pipeline_impl.cc

@@ -109,6 +109,7 @@ void AudioPipelineImpl::Initialize(
   if (frame_provider)
     SetCodedFrameProvider(frame_provider.Pass());
 
+  DCHECK(audio_config.IsValidConfig());
   if (!audio_device_->SetConfig(
          DecoderConfigAdapter::ToCastAudioConfig(kPrimary, audio_config)) ||
       !av_pipeline_impl_->Initialize()) {

chromecast/media/cma/pipeline/audio_video_pipeline_impl_unittest.cc

@@ -91,14 +91,15 @@ void AudioVideoPipelineImplTest::Initialize(
       ::media::CHANNEL_LAYOUT_STEREO,
       44100,
       NULL, 0, false);
-  ::media::VideoDecoderConfig video_config(
+  std::vector<::media::VideoDecoderConfig> video_configs;
+  video_configs.push_back(::media::VideoDecoderConfig(
       ::media::kCodecH264,
       ::media::H264PROFILE_MAIN,
       ::media::VideoFrame::I420,
       gfx::Size(640, 480),
       gfx::Rect(0, 0, 640, 480),
       gfx::Size(640, 480),
-      NULL, 0, false);
+      NULL, 0, false));
 
   // Frame generation on the producer side.
   std::vector<FrameGeneratorForTest::FrameSpec> frame_specs;
@@ -135,7 +136,7 @@ void AudioVideoPipelineImplTest::Initialize(
                  next_task) :
       base::Bind(&MediaPipeline::InitializeVideo,
                  base::Unretained(media_pipeline_.get()),
-                 video_config,
+                 video_configs,
                  base::Passed(&frame_provider_base),
                  next_task);
 

chromecast/media/cma/pipeline/media_pipeline.h

@@ -47,7 +47,7 @@ class MediaPipeline {
       scoped_ptr<CodedFrameProvider> frame_provider,
       const ::media::PipelineStatusCB& status_cb) = 0;
   virtual void InitializeVideo(
-      const ::media::VideoDecoderConfig& config,
+      const std::vector<::media::VideoDecoderConfig>& configs,
       scoped_ptr<CodedFrameProvider> frame_provider,
       const ::media::PipelineStatusCB& status_cb) = 0;
 

chromecast/media/cma/pipeline/media_pipeline_impl.cc

@@ -144,7 +144,7 @@ void MediaPipelineImpl::InitializeAudio(
 }
 
 void MediaPipelineImpl::InitializeVideo(
-    const ::media::VideoDecoderConfig& config,
+    const std::vector<::media::VideoDecoderConfig>& configs,
     scoped_ptr<CodedFrameProvider> frame_provider,
     const ::media::PipelineStatusCB& status_cb) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ -155,7 +155,7 @@ void MediaPipelineImpl::InitializeVideo(
     return;
   }
   has_video_ = true;
-  video_pipeline_->Initialize(config, frame_provider.Pass(), status_cb);
+  video_pipeline_->Initialize(configs, frame_provider.Pass(), status_cb);
 }
 
 void MediaPipelineImpl::StartPlayingFrom(base::TimeDelta time) {

chromecast/media/cma/pipeline/media_pipeline_impl.h

@@ -45,7 +45,7 @@ class MediaPipelineImpl : public MediaPipeline {
       scoped_ptr<CodedFrameProvider> frame_provider,
       const ::media::PipelineStatusCB& status_cb) override;
   void InitializeVideo(
-      const ::media::VideoDecoderConfig& config,
+      const std::vector<::media::VideoDecoderConfig>& configs,
       scoped_ptr<CodedFrameProvider> frame_provider,
       const ::media::PipelineStatusCB& status_cb) override;
   void StartPlayingFrom(base::TimeDelta time) override;
@@ -83,7 +83,7 @@ class MediaPipelineImpl : public MediaPipeline {
   bool has_video_;
   scoped_ptr<AudioPipelineImpl> audio_pipeline_;
   scoped_ptr<VideoPipelineImpl> video_pipeline_;
-  scoped_ptr< ::media::SerialRunner> pending_callbacks_;
+  scoped_ptr<::media::SerialRunner> pending_callbacks_;
 
   // Playback rate set by the upper layer.
   float target_playback_rate_;

chromecast/media/cma/pipeline/video_pipeline_impl.cc

@@ -101,11 +101,10 @@ void VideoPipelineImpl::SetClient(const VideoPipelineClient& client) {
 }
 
 void VideoPipelineImpl::Initialize(
-    const ::media::VideoDecoderConfig& video_config,
+    const std::vector<::media::VideoDecoderConfig>& configs,
     scoped_ptr<CodedFrameProvider> frame_provider,
     const ::media::PipelineStatusCB& status_cb) {
-  CMALOG(kLogControl) << "VideoPipelineImpl::Initialize "
-                      << video_config.AsHumanReadableString();
+  CMALOG(kLogControl) << __FUNCTION__ << " config (" << configs.size() << ")";
   VideoPipelineDevice::VideoClient client;
   client.natural_size_changed_cb =
       base::Bind(&VideoPipelineImpl::OnNaturalSizeChanged, weak_this_);
@@ -113,8 +112,23 @@ void VideoPipelineImpl::Initialize(
   if (frame_provider)
     SetCodedFrameProvider(frame_provider.Pass());
 
-  if (!video_device_->SetConfig(
-          DecoderConfigAdapter::ToCastVideoConfig(kPrimary, video_config)) ||
+  if (configs.empty()) {
+     status_cb.Run(::media::PIPELINE_ERROR_INITIALIZATION_FAILED);
+     return;
+  }
+  DCHECK(configs.size() <= 2);
+  DCHECK(configs[0].IsValidConfig());
+  VideoConfig video_config =
+      DecoderConfigAdapter::ToCastVideoConfig(kPrimary, configs[0]);
+  VideoConfig secondary_config;
+  if (configs.size() == 2) {
+    DCHECK(configs[1].IsValidConfig());
+    secondary_config = DecoderConfigAdapter::ToCastVideoConfig(kSecondary,
+                                                               configs[1]);
+    video_config.additional_config = &secondary_config;
+  }
+
+  if (!video_device_->SetConfig(video_config) ||
       !av_pipeline_impl_->Initialize()) {
     status_cb.Run(::media::PIPELINE_ERROR_INITIALIZATION_FAILED);
     return;

chromecast/media/cma/pipeline/video_pipeline_impl.h

@@ -44,7 +44,7 @@ class VideoPipelineImpl : public VideoPipeline {
 
   // Functions to control the state of the audio pipeline.
   void Initialize(
-      const ::media::VideoDecoderConfig& config,
+      const std::vector<::media::VideoDecoderConfig>& configs,
       scoped_ptr<CodedFrameProvider> frame_provider,
       const ::media::PipelineStatusCB& status_cb);
   bool StartPlayingFrom(base::TimeDelta time,

chromecast/renderer/media/media_pipeline_proxy.cc

@@ -214,12 +214,12 @@ void MediaPipelineProxy::InitializeAudio(
 }
 
 void MediaPipelineProxy::InitializeVideo(
-    const ::media::VideoDecoderConfig& config,
+    const std::vector<::media::VideoDecoderConfig>& configs,
     scoped_ptr<CodedFrameProvider> frame_provider,
     const ::media::PipelineStatusCB& status_cb) {
   DCHECK(thread_checker_.CalledOnValidThread());
   has_video_ = true;
-  video_pipeline_->Initialize(config, frame_provider.Pass(), status_cb);
+  video_pipeline_->Initialize(configs, frame_provider.Pass(), status_cb);
 }
 
 void MediaPipelineProxy::StartPlayingFrom(base::TimeDelta time) {

chromecast/renderer/media/media_pipeline_proxy.h

@@ -43,7 +43,7 @@ class MediaPipelineProxy : public MediaPipeline {
       scoped_ptr<CodedFrameProvider> frame_provider,
       const ::media::PipelineStatusCB& status_cb) override;
   void InitializeVideo(
-      const ::media::VideoDecoderConfig& config,
+      const std::vector<::media::VideoDecoderConfig>& configs,
       scoped_ptr<CodedFrameProvider> frame_provider,
       const ::media::PipelineStatusCB& status_cb) override;
   void StartPlayingFrom(base::TimeDelta time) override;
@@ -70,7 +70,7 @@ class MediaPipelineProxy : public MediaPipeline {
   bool has_video_;
   scoped_ptr<AudioPipelineProxy> audio_pipeline_;
   scoped_ptr<VideoPipelineProxy> video_pipeline_;
-  scoped_ptr< ::media::SerialRunner> pending_callbacks_;
+  scoped_ptr<::media::SerialRunner> pending_callbacks_;
 
   base::WeakPtr<MediaPipelineProxy> weak_this_;
   base::WeakPtrFactory<MediaPipelineProxy> weak_factory_;

chromecast/renderer/media/video_pipeline_proxy.cc

@@ -56,7 +56,7 @@ class VideoPipelineProxyInternal {
   void SetClient(const base::Closure& pipe_read_cb,
                  const VideoPipelineClient& client);
   void CreateAvPipe(const SharedMemCB& shared_mem_cb);
-  void Initialize(const ::media::VideoDecoderConfig& config,
+  void Initialize(const std::vector<::media::VideoDecoderConfig>& configs,
                   const ::media::PipelineStatusCB& status_cb);
 
  private:
@@ -166,12 +166,12 @@ void VideoPipelineProxyInternal::OnAvPipeCreated(
 }
 
 void VideoPipelineProxyInternal::Initialize(
-    const ::media::VideoDecoderConfig& arg1,
+    const std::vector<::media::VideoDecoderConfig>& configs,
     const ::media::PipelineStatusCB& status_cb) {
   DCHECK(thread_checker_.CalledOnValidThread());
   bool success = media_channel_proxy_->Send(scoped_ptr<IPC::Message>(
       new CmaHostMsg_VideoInitialize(media_channel_proxy_->GetId(),
-                                     kVideoTrackId, arg1)));
+                                     kVideoTrackId, configs)));
   if (!success) {
     status_cb.Run( ::media::PIPELINE_ERROR_INITIALIZATION_FAILED);
     return;
@@ -223,7 +223,7 @@ void VideoPipelineProxy::SetClient(
 }
 
 void VideoPipelineProxy::Initialize(
-    const ::media::VideoDecoderConfig& config,
+    const std::vector<::media::VideoDecoderConfig>& configs,
     scoped_ptr<CodedFrameProvider> frame_provider,
     const ::media::PipelineStatusCB& status_cb) {
   CMALOG(kLogControl) << "VideoPipelineProxy::Initialize";
@@ -233,12 +233,12 @@ void VideoPipelineProxy::Initialize(
   VideoPipelineProxyInternal::SharedMemCB shared_mem_cb =
       ::media::BindToCurrentLoop(base::Bind(
           &VideoPipelineProxy::OnAvPipeCreated, weak_this_,
-          config, status_cb));
+          configs, status_cb));
   FORWARD_ON_IO_THREAD(CreateAvPipe, shared_mem_cb);
 }
 
 void VideoPipelineProxy::OnAvPipeCreated(
-    const ::media::VideoDecoderConfig& config,
+    const std::vector<::media::VideoDecoderConfig>& configs,
     const ::media::PipelineStatusCB& status_cb,
     scoped_ptr<base::SharedMemory> shared_memory) {
   CMALOG(kLogControl) << "VideoPipelineProxy::OnAvPipeCreated";
@@ -260,7 +260,7 @@ void VideoPipelineProxy::OnAvPipeCreated(
   video_streamer_->SetMediaMessageFifo(video_pipe.Pass());
 
   // Now proceed to the decoder/renderer initialization.
-  FORWARD_ON_IO_THREAD(Initialize, config, status_cb);
+  FORWARD_ON_IO_THREAD(Initialize, configs, status_cb);
 }
 
 void VideoPipelineProxy::StartFeeding() {

chromecast/renderer/media/video_pipeline_proxy.h

@@ -36,7 +36,7 @@ class VideoPipelineProxy : public VideoPipeline {
                      scoped_refptr<MediaChannelProxy> media_channel_proxy);
   ~VideoPipelineProxy() override;
 
-  void Initialize(const ::media::VideoDecoderConfig& config,
+  void Initialize(const std::vector<::media::VideoDecoderConfig>& configs,
                   scoped_ptr<CodedFrameProvider> frame_provider,
                   const ::media::PipelineStatusCB& status_cb);
   void StartFeeding();
@@ -50,7 +50,7 @@ class VideoPipelineProxy : public VideoPipeline {
   base::ThreadChecker thread_checker_;
 
   void OnAvPipeCreated(
-      const ::media::VideoDecoderConfig& config,
+      const std::vector<::media::VideoDecoderConfig>& configs,
       const ::media::PipelineStatusCB& status_cb,
       scoped_ptr<base::SharedMemory> shared_memory);
   void OnPipeWrite();