Allow media track switching.

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"
@@ skipping 62 matching lines @@
 };
 
 RendererImpl::RendererImpl(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     std::unique_ptr<AudioRenderer> audio_renderer,
     std::unique_ptr<VideoRenderer> video_renderer)
     : state_(STATE_UNINITIALIZED),
       task_runner_(task_runner),
       audio_renderer_(std::move(audio_renderer)),
       video_renderer_(std::move(video_renderer)),
+      current_audio_stream_(nullptr),
+      current_video_stream_(nullptr),
       time_source_(NULL),
       time_ticking_(false),
       playback_rate_(0.0),
       audio_buffering_state_(BUFFERING_HAVE_NOTHING),
       video_buffering_state_(BUFFERING_HAVE_NOTHING),
       audio_ended_(false),
       video_ended_(false),
       cdm_context_(nullptr),
       underflow_disabled_for_testing_(false),
       clockless_video_playback_enabled_for_testing_(false),
@@ skipping 136 matching lines @@
     DVLOG(3) << __func__ << ": postponed stream " << stream
              << " status change handling.";
     pending_stream_status_notifications_.push_back(
         base::Bind(&RendererImpl::OnStreamStatusChanged, weak_this_, stream,
                    enabled, time));
     return;
   }
   if (stream->type() == DemuxerStream::VIDEO) {
     DCHECK(video_renderer_);
     restarting_video_ = true;
-    video_renderer_->Flush(
-        base::Bind(&RendererImpl::RestartVideoRenderer, weak_this_, time));
+    video_renderer_->Flush(base::Bind(&RendererImpl::RestartVideoRenderer,
+                                      weak_this_, stream, time));
   } else if (stream->type() == DemuxerStream::AUDIO) {
     DCHECK(audio_renderer_);
     DCHECK(time_source_);
     restarting_audio_ = true;
     // Stop ticking (transition into paused state) in audio renderer before
     // calling Flush, since after Flush we are going to restart playback by
     // calling audio renderer StartPlaying which would fail in playing state.
     if (time_ticking_) {
       time_ticking_ = false;
       time_source_->StopTicking();
     }
-    audio_renderer_->Flush(
-        base::Bind(&RendererImpl::RestartAudioRenderer, weak_this_, time));
+    audio_renderer_->Flush(base::Bind(&RendererImpl::RestartAudioRenderer,
+                                      weak_this_, stream, time));
   }
 }
 
-void RendererImpl::RestartVideoRenderer(base::TimeDelta time) {
-  DVLOG(3) << __func__;
+void RendererImpl::RestartVideoRenderer(DemuxerStream* stream,
+                                        base::TimeDelta time) {

[xhwang, 2017/03/27 19:13:53]

I see what you are doing, but feel it's a bit hard to read that
RestartVideoRenderer() schedules OnVideoRendererReinitCompleted(), and
OnVideoRendererReinitCompleted() in turn calls RestartVideoRenderer() again.

So, in OnStreamStatusChanged(), if stream->type() == DemuxerStream::VIDEO, we
know we will reinitialize the VideoRenderer. Is that correct? In that case,
instead of calling RestartVideoRenderer(), which actually reinitializes the
VideoRenderer and returns, can we call ReinitializeVideoRenderer(), which is
basically the block of line 266-273?

[servolk, 2017/03/27 22:34:13]

Ok, sure, I've refactored it a bit to hopefully make it more readable. 

+  DVLOG(3) << __func__ << " stream=" << stream << " time=" << time.InSecondsF();
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(video_renderer_);
   DCHECK_EQ(state_, STATE_PLAYING);
+  if (stream != current_video_stream_) {
+    DVLOG(3) << __func__ << ": detected stream change, reinitializing decoder";
+    current_video_stream_ = stream;
+    video_renderer_->OnTimeStopped();
+    video_renderer_->Initialize(
+        stream, cdm_context_, video_renderer_client_.get(),
+        base::Bind(&RendererImpl::GetWallClockTimes, base::Unretained(this)),
+        base::Bind(&RendererImpl::OnVideoRendererReinitCompleted, weak_this_,
+                   stream, time));
+    return;
+  }

[xhwang, 2017/03/27 19:13:53]

nit: empty line here

[servolk, 2017/03/27 22:34:13]

Done.

   video_ended_ = false;
   video_renderer_->StartPlayingFrom(time);
 }
 
-void RendererImpl::RestartAudioRenderer(base::TimeDelta time) {
-  DVLOG(3) << __func__;
+void RendererImpl::OnVideoRendererReinitCompleted(DemuxerStream* stream,
+                                                  base::TimeDelta time,
+                                                  PipelineStatus status) {
+  DVLOG(3) << __func__ << ": status=" << status;
+  if (status != PIPELINE_OK) {
+    OnError(status);
+    return;
+  }
+  DCHECK_EQ(stream, current_video_stream_);
+  RestartVideoRenderer(stream, time);
+}
+
+void RendererImpl::RestartAudioRenderer(DemuxerStream* stream,
+                                        base::TimeDelta time) {
+  DVLOG(3) << __func__ << " stream=" << stream << " time=" << time.InSecondsF();
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, STATE_PLAYING);
   DCHECK(time_source_);
   DCHECK(audio_renderer_);
+  if (stream != current_audio_stream_) {
+    DVLOG(3) << __func__ << ": detected stream change, reinitializing decoder";
+    current_audio_stream_ = stream;
+    audio_renderer_->Initialize(
+        stream, cdm_context_, audio_renderer_client_.get(),
+        base::Bind(&RendererImpl::OnAudioRendererReinitCompleted, weak_this_,
+                   stream, time));
+    return;
+  }
   audio_ended_ = false;
   audio_renderer_->StartPlaying();
 }
 
+void RendererImpl::OnAudioRendererReinitCompleted(DemuxerStream* stream,
+                                                  base::TimeDelta time,
+                                                  PipelineStatus status) {
+  DVLOG(3) << __func__ << ": status=" << status;
+  if (status != PIPELINE_OK) {
+    OnError(status);
+    return;
+  }
+  DCHECK_EQ(stream, current_audio_stream_);
+  RestartAudioRenderer(stream, time);
+}
+
 void RendererImpl::SetPlaybackRate(double playback_rate) {
   DVLOG(1) << __func__ << "(" << playback_rate << ")";
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   // Playback rate changes are only carried out while playing.
   if (state_ != STATE_PLAYING)
     return;
 
   time_source_->SetPlaybackRate(playback_rate);
 
@@ skipping 101 matching lines @@
   // TODO(servolk): Implement proper support for multiple streams. But for now
   // pick the first enabled stream to preserve the existing behavior.
   DemuxerStream* audio_stream =
       media_resource_->GetFirstStream(DemuxerStream::AUDIO);
   if (!audio_stream) {
     audio_renderer_.reset();
     task_runner_->PostTask(FROM_HERE, base::Bind(done_cb, PIPELINE_OK));
     return;
   }
 
+  current_audio_stream_ = 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 28 matching lines @@
   // TODO(servolk): Implement proper support for multiple streams. But for now
   // pick the first enabled stream to preserve the existing behavior.
   DemuxerStream* video_stream =
       media_resource_->GetFirstStream(DemuxerStream::VIDEO);
   if (!video_stream) {
     video_renderer_.reset();
     task_runner_->PostTask(FROM_HERE, base::Bind(done_cb, PIPELINE_OK));
     return;
   }
 
+  current_video_stream_ = 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;
@@ skipping 394 matching lines @@
   DCHECK(task_runner_->BelongsToCurrentThread());
   client_->OnVideoNaturalSizeChange(size);
 }
 
 void RendererImpl::OnVideoOpacityChange(bool opaque) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   client_->OnVideoOpacityChange(opaque);
 }
 
 }  // namespace media