MediaResource refactoring to support multiple streams

media/renderers/renderer_impl.cc

 // Copyright 2014 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 "media/renderers/renderer_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/audio_renderer.h"
 #include "media/base/bind_to_current_loop.h"
-#include "media/base/demuxer_stream_provider.h"
 #include "media/base/media_log.h"
+#include "media/base/media_resource.h"
 #include "media/base/media_switches.h"
 #include "media/base/renderer_client.h"
 #include "media/base/time_source.h"
 #include "media/base/video_decoder_config.h"
 #include "media/base/video_renderer.h"
 #include "media/base/wall_clock_time_source.h"
 
 namespace media {
 
 // See |video_underflow_threshold_|.
@@ skipping 90 matching lines @@
   video_renderer_.reset();
   audio_renderer_.reset();
 
   if (!init_cb_.is_null()) {
     FinishInitialization(PIPELINE_ERROR_ABORT);
   } else if (!flush_cb_.is_null()) {
     base::ResetAndReturn(&flush_cb_).Run();
   }
 }
 
-void RendererImpl::Initialize(DemuxerStreamProvider* demuxer_stream_provider,
+void RendererImpl::Initialize(MediaResource* media_resource,
                               RendererClient* client,
                               const PipelineStatusCB& init_cb) {
   DVLOG(1) << __func__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, STATE_UNINITIALIZED);
   DCHECK(!init_cb.is_null());
   DCHECK(client);
 
   client_ = client;
-  demuxer_stream_provider_ = demuxer_stream_provider;
+  media_resource_ = media_resource;
   init_cb_ = init_cb;
 
   if (HasEncryptedStream() && !cdm_context_) {
     state_ = STATE_INIT_PENDING_CDM;
     return;
   }
 
   state_ = STATE_INITIALIZING;
   InitializeAudioRenderer();
 }
@@ skipping 190 matching lines @@
         wall_clock_times->push_back(base::TimeTicks() + media_time);
       }
     }
     return true;
   }
 
   return time_source_->GetWallClockTimes(media_timestamps, wall_clock_times);
 }
 
 bool RendererImpl::HasEncryptedStream() {
-  DemuxerStream* audio_stream =
-      demuxer_stream_provider_->GetStream(DemuxerStream::AUDIO);
-  if (audio_stream && audio_stream->audio_decoder_config().is_encrypted())
-    return true;
+  std::vector<DemuxerStream*> demuxer_streams = media_resource_->GetStreams();
 
-  DemuxerStream* video_stream =
-      demuxer_stream_provider_->GetStream(DemuxerStream::VIDEO);
-  if (video_stream && video_stream->video_decoder_config().is_encrypted())
-    return true;
+  for (const auto& s : demuxer_streams) {
+    if (s->type() == DemuxerStream::AUDIO &&
+        s->audio_decoder_config().is_encrypted())
+      return true;
+    if (s->type() == DemuxerStream::VIDEO &&
+        s->video_decoder_config().is_encrypted())
+      return true;
+  }

[xhwang, 2017/02/01 18:26:04]

Do we care about disabled streams? This is another example exposing disabled
streams would make a lot of downstream code harder.

[servolk, 2017/02/01 22:29:21]

Actually I think this, and the unit tests make a good case for reconsidering
whether we want to include disabled streams into GetStreams result or not.
IIUC if at least one of the streams is encrypted, then we want to set up and
initialize the CDM, so that later, if the encrypted stream is enabled we can
start playing it back without tearing down and reinitializing the whole
rendering pipeline. Or can we set up a renderer without CDM and initialize the
CDM later if the encrypted stream gets enabled? This is tricky. Let's move this
discussion to the CL that moves SetStreamStatusChangeCB to the MediaResource.

 
   return false;
 }
 
 void RendererImpl::FinishInitialization(PipelineStatus status) {
   DCHECK(!init_cb_.is_null());
 
   if (!pending_cdm_attached_cb_.is_null())
     base::ResetAndReturn(&pending_cdm_attached_cb_).Run(status == PIPELINE_OK);
 
   base::ResetAndReturn(&init_cb_).Run(status);
 }
 
 void RendererImpl::InitializeAudioRenderer() {
   DVLOG(1) << __func__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, STATE_INITIALIZING);
   DCHECK(!init_cb_.is_null());
 
   PipelineStatusCB done_cb =
       base::Bind(&RendererImpl::OnAudioRendererInitializeDone, weak_this_);
 
-  DemuxerStream* audio_stream =
-      demuxer_stream_provider_->GetStream(DemuxerStream::AUDIO);
+  std::vector<DemuxerStream*> streams = media_resource_->GetStreams();

[xhwang, 2017/02/01 18:26:04]

ditto about comment and TODO

+  DemuxerStream* audio_stream = nullptr;
+  for (const auto& s : streams) {
+    if (s->type() == DemuxerStream::AUDIO && s->enabled()) {
+      audio_stream = s;
+      break;
+    }
+  }
   if (!audio_stream) {
     audio_renderer_.reset();
     task_runner_->PostTask(FROM_HERE, base::Bind(done_cb, PIPELINE_OK));
     return;
   }
 
-  audio_stream->SetStreamStatusChangeCB(base::Bind(
-      &RendererImpl::OnStreamStatusChanged, weak_this_, audio_stream));
-
   audio_renderer_client_.reset(
       new RendererClientInternal(DemuxerStream::AUDIO, this));
   // Note: After the initialization of a renderer, error events from it may
   // happen at any time and all future calls must guard against STATE_ERROR.
   audio_renderer_->Initialize(audio_stream, cdm_context_,
                               audio_renderer_client_.get(), done_cb);
 }
 
 void RendererImpl::OnAudioRendererInitializeDone(PipelineStatus status) {
   DVLOG(1) << __func__ << ": " << status;
@@ skipping 18 matching lines @@
 
 void RendererImpl::InitializeVideoRenderer() {
   DVLOG(1) << __func__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, STATE_INITIALIZING);
   DCHECK(!init_cb_.is_null());
 
   PipelineStatusCB done_cb =
       base::Bind(&RendererImpl::OnVideoRendererInitializeDone, weak_this_);
 
-  DemuxerStream* video_stream =
-      demuxer_stream_provider_->GetStream(DemuxerStream::VIDEO);
+  std::vector<DemuxerStream*> streams = media_resource_->GetStreams();
+  DemuxerStream* video_stream = nullptr;
+  for (const auto& s : streams) {
+    if (s->type() == DemuxerStream::VIDEO && s->enabled()) {
+      video_stream = s;
+      break;
+    }
+  }
+
   if (!video_stream) {
     video_renderer_.reset();
     task_runner_->PostTask(FROM_HERE, base::Bind(done_cb, PIPELINE_OK));
     return;
   }
 
-  video_stream->SetStreamStatusChangeCB(base::Bind(
-      &RendererImpl::OnStreamStatusChanged, weak_this_, video_stream));
-
   video_renderer_client_.reset(
       new RendererClientInternal(DemuxerStream::VIDEO, this));
   video_renderer_->Initialize(
       video_stream, cdm_context_, video_renderer_client_.get(),
       base::Bind(&RendererImpl::GetWallClockTimes, base::Unretained(this)),
       done_cb);
 }
 
 void RendererImpl::OnVideoRendererInitializeDone(PipelineStatus status) {
   DVLOG(1) << __func__ << ": " << status;
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   // OnError() may be fired at any time by the renderers, even if they thought
   // they initialized successfully (due to delayed output device setup).
   if (state_ != STATE_INITIALIZING) {
     DCHECK(init_cb_.is_null());
     audio_renderer_.reset();
     video_renderer_.reset();
     return;
   }
 
   DCHECK(!init_cb_.is_null());
 
   if (status != PIPELINE_OK) {
     FinishInitialization(status);
     return;
   }
 
+  media_resource_->SetStreamStatusChangeCB(
+      base::Bind(&RendererImpl::OnStreamStatusChanged, weak_this_));
+
   if (audio_renderer_) {
     time_source_ = audio_renderer_->GetTimeSource();
   } else if (!time_source_) {
     wall_clock_time_source_.reset(new WallClockTimeSource());
     time_source_ = wall_clock_time_source_.get();
   }
 
   state_ = STATE_PLAYING;
   DCHECK(time_source_);
   DCHECK(audio_renderer_ || video_renderer_);
@@ skipping 363 matching lines @@
   DCHECK(task_runner_->BelongsToCurrentThread());
   client_->OnVideoNaturalSizeChange(size);
 }
 
 void RendererImpl::OnVideoOpacityChange(bool opaque) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   client_->OnVideoOpacityChange(opaque);
 }
 
 }  // namespace media