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) {
+  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;
+  }
   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_);

[DaleCurtis, 2017/03/24 19:35:22]

Seems like this could change if called in fast succession? I don't see a
callback indicating the stream switch has completed before allowing further
calls.

[servolk, 2017/03/24 21:15:32]

No, it should be fine. Here is how it works: when the status of any track/stream
changes, we set a flag (either restarting_audio_ or restarting_video_ in
RendererImpl::OnStreamStatusChanged, see
https://cs.chromium.org/chromium/src/media/renderers/renderer_impl.cc?rcl=68e...).
As long as one of those flags is set we are going to postpone handling of other
track status changes, including status changes of the same track, see
https://cs.chromium.org/chromium/src/media/renderers/renderer_impl.cc?rcl=68e....
The flags are reset in RendererImpl::OnStreamRestartCompleted, which only gets
invoked after we have finished processing the current status change. This
mechanism ensures that chains of async calls involved in handling track status
changes (OnStreamStatusChanged -> RestartAudio/VideoRenderer -> (optionally, in
case of track switch) OnAudio/VideoRendererReinitCompleted ->
OnBufferingStateChange -> OnStreamRestartCompleted) are serialized and never
overlap.

+  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