media/renderers/renderer_impl.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "media/renderers/renderer_impl.h"
   6
   7 #include "base/bind.h"
   8 #include "base/callback.h"
   9 #include "base/callback_helpers.h"
  10 #include "base/command_line.h"
  11 #include "base/compiler_specific.h"
  12 #include "base/location.h"
  13 #include "base/single_thread_task_runner.h"
  14 #include "base/strings/string_number_conversions.h"
  15 #include "media/base/audio_renderer.h"
  16 #include "media/base/bind_to_current_loop.h"
  17 #include "media/base/demuxer_stream_provider.h"
  18 #include "media/base/media_switches.h"
  19 #include "media/base/time_source.h"
  20 #include "media/base/video_renderer.h"
  21 #include "media/base/wall_clock_time_source.h"
  22
  23 namespace media {
  24
  25 // See |video_underflow_threshold_|.
  26 static const int kDefaultVideoUnderflowThresholdMs = 3000;
  27
  28 RendererImpl::RendererImpl(
  29     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
  30     scoped_ptr<AudioRenderer> audio_renderer,
  31     scoped_ptr<VideoRenderer> video_renderer)
  32     : state_(STATE_UNINITIALIZED),
  33       task_runner_(task_runner),
  34       audio_renderer_(audio_renderer.Pass()),
  35       video_renderer_(video_renderer.Pass()),
  36       time_source_(NULL),
  37       time_ticking_(false),
  38       playback_rate_(0.0),
  39       audio_buffering_state_(BUFFERING_HAVE_NOTHING),
  40       video_buffering_state_(BUFFERING_HAVE_NOTHING),
  41       audio_ended_(false),
  42       video_ended_(false),
  43       cdm_context_(nullptr),
  44       underflow_disabled_for_testing_(false),
  45       clockless_video_playback_enabled_for_testing_(false),
  46       video_underflow_threshold_(
  47           base::TimeDelta::FromMilliseconds(kDefaultVideoUnderflowThresholdMs)),
  48       weak_factory_(this) {
  49   weak_this_ = weak_factory_.GetWeakPtr();
  50   DVLOG(1) << __FUNCTION__;
  51
  52   // TODO(dalecurtis): Remove once experiments for http://crbug.com/470940 are
  53   // complete.
  54   int threshold_ms = 0;
  55   std::string threshold_ms_str(
  56       base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
  57           switches::kVideoUnderflowThresholdMs));
  58   if (base::StringToInt(threshold_ms_str, &threshold_ms) && threshold_ms > 0) {
  59     video_underflow_threshold_ =
  60         base::TimeDelta::FromMilliseconds(threshold_ms);
  61   }
  62 }
  63
  64 RendererImpl::~RendererImpl() {
  65   DVLOG(1) << __FUNCTION__;
  66   DCHECK(task_runner_->BelongsToCurrentThread());
  67
  68   // Tear down in opposite order of construction as |video_renderer_| can still
  69   // need |time_source_| (which can be |audio_renderer_|) to be alive.
  70   video_renderer_.reset();
  71   audio_renderer_.reset();
  72
  73   if (!init_cb_.is_null())
  74     base::ResetAndReturn(&init_cb_).Run(PIPELINE_ERROR_ABORT);
  75   else if (!flush_cb_.is_null())
  76     base::ResetAndReturn(&flush_cb_).Run();
  77 }
  78
  79 void RendererImpl::Initialize(
  80     DemuxerStreamProvider* demuxer_stream_provider,
  81     const PipelineStatusCB& init_cb,
  82     const StatisticsCB& statistics_cb,
  83     const BufferingStateCB& buffering_state_cb,
  84     const base::Closure& ended_cb,
  85     const PipelineStatusCB& error_cb,
  86     const base::Closure& waiting_for_decryption_key_cb) {
  87   DVLOG(1) << __FUNCTION__;
  88   DCHECK(task_runner_->BelongsToCurrentThread());
  89   DCHECK_EQ(state_, STATE_UNINITIALIZED);
  90   DCHECK(!init_cb.is_null());
  91   DCHECK(!statistics_cb.is_null());
  92   DCHECK(!buffering_state_cb.is_null());
  93   DCHECK(!ended_cb.is_null());
  94   DCHECK(!error_cb.is_null());
  95   DCHECK(demuxer_stream_provider->GetStream(DemuxerStream::AUDIO) ||
  96          demuxer_stream_provider->GetStream(DemuxerStream::VIDEO));
  97
  98   demuxer_stream_provider_ = demuxer_stream_provider;
  99   statistics_cb_ = statistics_cb;
 100   buffering_state_cb_ = buffering_state_cb;
 101   ended_cb_ = ended_cb;
 102   error_cb_ = error_cb;
 103   init_cb_ = init_cb;
 104   waiting_for_decryption_key_cb_ = waiting_for_decryption_key_cb;
 105
 106   state_ = STATE_INITIALIZING;
 107   InitializeAudioRenderer();
 108 }
 109
 110 void RendererImpl::SetCdm(CdmContext* cdm_context,
 111                           const CdmAttachedCB& cdm_attached_cb) {
 112   DVLOG(1) << __FUNCTION__;
 113   DCHECK(task_runner_->BelongsToCurrentThread());
 114   DCHECK(cdm_context);
 115
 116   if (cdm_context_) {
 117     DVLOG(1) << "Switching CDM not supported.";
 118     cdm_attached_cb.Run(false);
 119     return;
 120   }
 121
 122   cdm_context_ = cdm_context;
 123
 124   if (decryptor_ready_cb_.is_null()) {
 125     cdm_attached_cb.Run(true);
 126     return;
 127   }
 128
 129   base::ResetAndReturn(&decryptor_ready_cb_)
 130       .Run(cdm_context->GetDecryptor(), cdm_attached_cb);
 131 }
 132
 133 void RendererImpl::Flush(const base::Closure& flush_cb) {
 134   DVLOG(1) << __FUNCTION__;
 135   DCHECK(task_runner_->BelongsToCurrentThread());
 136   DCHECK(flush_cb_.is_null());
 137
 138   if (state_ != STATE_PLAYING) {
 139     DCHECK_EQ(state_, STATE_ERROR);
 140     return;
 141   }
 142
 143   flush_cb_ = flush_cb;
 144   state_ = STATE_FLUSHING;
 145
 146   if (time_ticking_)
 147     PausePlayback();
 148
 149   FlushAudioRenderer();
 150 }
 151
 152 void RendererImpl::StartPlayingFrom(base::TimeDelta time) {
 153   DVLOG(1) << __FUNCTION__;
 154   DCHECK(task_runner_->BelongsToCurrentThread());
 155
 156   if (state_ != STATE_PLAYING) {
 157     DCHECK_EQ(state_, STATE_ERROR);
 158     return;
 159   }
 160
 161   time_source_->SetMediaTime(time);
 162
 163   if (audio_renderer_)
 164     audio_renderer_->StartPlaying();
 165   if (video_renderer_)
 166     video_renderer_->StartPlayingFrom(time);
 167 }
 168
 169 void RendererImpl::SetPlaybackRate(double playback_rate) {
 170   DVLOG(1) << __FUNCTION__ << "(" << playback_rate << ")";
 171   DCHECK(task_runner_->BelongsToCurrentThread());
 172
 173   // Playback rate changes are only carried out while playing.
 174   if (state_ != STATE_PLAYING)
 175     return;
 176
 177   time_source_->SetPlaybackRate(playback_rate);
 178
 179   const double old_rate = playback_rate_;
 180   playback_rate_ = playback_rate;
 181   if (!time_ticking_ || !video_renderer_)
 182     return;
 183
 184   if (old_rate == 0 && playback_rate > 0)
 185     video_renderer_->OnTimeStateChanged(true);
 186   else if (old_rate > 0 && playback_rate == 0)
 187     video_renderer_->OnTimeStateChanged(false);
 188 }
 189
 190 void RendererImpl::SetVolume(float volume) {
 191   DVLOG(1) << __FUNCTION__;
 192   DCHECK(task_runner_->BelongsToCurrentThread());
 193
 194   if (audio_renderer_)
 195     audio_renderer_->SetVolume(volume);
 196 }
 197
 198 base::TimeDelta RendererImpl::GetMediaTime() {
 199   // No BelongsToCurrentThread() checking because this can be called from other
 200   // threads.
 201   return time_source_->CurrentMediaTime();
 202 }
 203
 204 bool RendererImpl::HasAudio() {
 205   DCHECK(task_runner_->BelongsToCurrentThread());
 206   return audio_renderer_ != NULL;
 207 }
 208
 209 bool RendererImpl::HasVideo() {
 210   DCHECK(task_runner_->BelongsToCurrentThread());
 211   return video_renderer_ != NULL;
 212 }
 213
 214 void RendererImpl::DisableUnderflowForTesting() {
 215   DVLOG(1) << __FUNCTION__;
 216   DCHECK(task_runner_->BelongsToCurrentThread());
 217   DCHECK_EQ(state_, STATE_UNINITIALIZED);
 218
 219   underflow_disabled_for_testing_ = true;
 220 }
 221
 222 void RendererImpl::EnableClocklessVideoPlaybackForTesting() {
 223   DVLOG(1) << __FUNCTION__;
 224   DCHECK(task_runner_->BelongsToCurrentThread());
 225   DCHECK_EQ(state_, STATE_UNINITIALIZED);
 226   DCHECK(underflow_disabled_for_testing_)
 227       << "Underflow must be disabled for clockless video playback";
 228
 229   clockless_video_playback_enabled_for_testing_ = true;
 230 }
 231
 232 bool RendererImpl::GetWallClockTimes(
 233     const std::vector<base::TimeDelta>& media_timestamps,
 234     std::vector<base::TimeTicks>* wall_clock_times) {
 235   // No BelongsToCurrentThread() checking because this can be called from other
 236   // threads.
 237   //
 238   // TODO(scherkus): Currently called from VideoRendererImpl's internal thread,
 239   // which should go away at some point http://crbug.com/110814
 240   if (clockless_video_playback_enabled_for_testing_) {
 241     *wall_clock_times = std::vector<base::TimeTicks>(media_timestamps.size(),
 242                                                      base::TimeTicks::Now());
 243     return true;
 244   }
 245
 246   return time_source_->GetWallClockTimes(media_timestamps, wall_clock_times);
 247 }
 248
 249 void RendererImpl::SetDecryptorReadyCallback(
 250     const DecryptorReadyCB& decryptor_ready_cb) {
 251   // Cancels the previous decryptor request.
 252   if (decryptor_ready_cb.is_null()) {
 253     if (!decryptor_ready_cb_.is_null()) {
 254       base::ResetAndReturn(&decryptor_ready_cb_)
 255           .Run(nullptr, base::Bind(IgnoreCdmAttached));
 256     }
 257     return;
 258   }
 259
 260   // We initialize audio and video decoders in sequence.
 261   DCHECK(decryptor_ready_cb_.is_null());
 262
 263   if (cdm_context_) {
 264     decryptor_ready_cb.Run(cdm_context_->GetDecryptor(),
 265                            base::Bind(IgnoreCdmAttached));
 266     return;
 267   }
 268
 269   decryptor_ready_cb_ = decryptor_ready_cb;
 270 }
 271
 272 void RendererImpl::InitializeAudioRenderer() {
 273   DVLOG(1) << __FUNCTION__;
 274   DCHECK(task_runner_->BelongsToCurrentThread());
 275   DCHECK_EQ(state_, STATE_INITIALIZING);
 276   DCHECK(!init_cb_.is_null());
 277
 278   PipelineStatusCB done_cb =
 279       base::Bind(&RendererImpl::OnAudioRendererInitializeDone, weak_this_);
 280
 281   if (!demuxer_stream_provider_->GetStream(DemuxerStream::AUDIO)) {
 282     audio_renderer_.reset();
 283     task_runner_->PostTask(FROM_HERE, base::Bind(done_cb, PIPELINE_OK));
 284     return;
 285   }
 286
 287   // Note: After the initialization of a renderer, error events from it may
 288   // happen at any time and all future calls must guard against STATE_ERROR.
 289   audio_renderer_->Initialize(
 290       demuxer_stream_provider_->GetStream(DemuxerStream::AUDIO), done_cb,
 291       base::Bind(&RendererImpl::SetDecryptorReadyCallback, weak_this_),
 292       base::Bind(&RendererImpl::OnUpdateStatistics, weak_this_),
 293       base::Bind(&RendererImpl::OnBufferingStateChanged, weak_this_,
 294                  &audio_buffering_state_),
 295       base::Bind(&RendererImpl::OnAudioRendererEnded, weak_this_),
 296       base::Bind(&RendererImpl::OnError, weak_this_),
 297       waiting_for_decryption_key_cb_);
 298 }
 299
 300 void RendererImpl::OnAudioRendererInitializeDone(PipelineStatus status) {
 301   DVLOG(1) << __FUNCTION__ << ": " << status;
 302   DCHECK(task_runner_->BelongsToCurrentThread());
 303
 304   // OnError() may be fired at any time by the renderers, even if they thought
 305   // they initialized successfully (due to delayed output device setup).
 306   if (state_ != STATE_INITIALIZING) {
 307     DCHECK(init_cb_.is_null());
 308     audio_renderer_.reset();
 309     return;
 310   }
 311
 312   if (status != PIPELINE_OK) {
 313     base::ResetAndReturn(&init_cb_).Run(status);
 314     return;
 315   }
 316
 317   DCHECK(!init_cb_.is_null());
 318   InitializeVideoRenderer();
 319 }
 320
 321 void RendererImpl::InitializeVideoRenderer() {
 322   DVLOG(1) << __FUNCTION__;
 323   DCHECK(task_runner_->BelongsToCurrentThread());
 324   DCHECK_EQ(state_, STATE_INITIALIZING);
 325   DCHECK(!init_cb_.is_null());
 326
 327   PipelineStatusCB done_cb =
 328       base::Bind(&RendererImpl::OnVideoRendererInitializeDone, weak_this_);
 329
 330   if (!demuxer_stream_provider_->GetStream(DemuxerStream::VIDEO)) {
 331     video_renderer_.reset();
 332     task_runner_->PostTask(FROM_HERE, base::Bind(done_cb, PIPELINE_OK));
 333     return;
 334   }
 335
 336   video_renderer_->Initialize(
 337       demuxer_stream_provider_->GetStream(DemuxerStream::VIDEO), done_cb,
 338       base::Bind(&RendererImpl::SetDecryptorReadyCallback, weak_this_),
 339       base::Bind(&RendererImpl::OnUpdateStatistics, weak_this_),
 340       base::Bind(&RendererImpl::OnBufferingStateChanged, weak_this_,
 341                  &video_buffering_state_),
 342       base::Bind(&RendererImpl::OnVideoRendererEnded, weak_this_),
 343       base::Bind(&RendererImpl::OnError, weak_this_),
 344       base::Bind(&RendererImpl::GetWallClockTimes, base::Unretained(this)),
 345       waiting_for_decryption_key_cb_);
 346 }
 347
 348 void RendererImpl::OnVideoRendererInitializeDone(PipelineStatus status) {
 349   DVLOG(1) << __FUNCTION__ << ": " << status;
 350   DCHECK(task_runner_->BelongsToCurrentThread());
 351
 352   // OnError() may be fired at any time by the renderers, even if they thought
 353   // they initialized successfully (due to delayed output device setup).
 354   if (state_ != STATE_INITIALIZING) {
 355     DCHECK(init_cb_.is_null());
 356     audio_renderer_.reset();
 357     video_renderer_.reset();
 358     return;
 359   }
 360
 361   DCHECK(!init_cb_.is_null());
 362
 363   if (status != PIPELINE_OK) {
 364     base::ResetAndReturn(&init_cb_).Run(status);
 365     return;
 366   }
 367
 368   if (audio_renderer_) {
 369     time_source_ = audio_renderer_->GetTimeSource();
 370   } else if (!time_source_) {
 371     wall_clock_time_source_.reset(new WallClockTimeSource());
 372     time_source_ = wall_clock_time_source_.get();
 373   }
 374
 375   state_ = STATE_PLAYING;
 376   DCHECK(time_source_);
 377   DCHECK(audio_renderer_ || video_renderer_);
 378   base::ResetAndReturn(&init_cb_).Run(PIPELINE_OK);
 379 }
 380
 381 void RendererImpl::FlushAudioRenderer() {
 382   DVLOG(1) << __FUNCTION__;
 383   DCHECK(task_runner_->BelongsToCurrentThread());
 384   DCHECK_EQ(state_, STATE_FLUSHING);
 385   DCHECK(!flush_cb_.is_null());
 386
 387   if (!audio_renderer_) {
 388     OnAudioRendererFlushDone();
 389     return;
 390   }
 391
 392   audio_renderer_->Flush(
 393       base::Bind(&RendererImpl::OnAudioRendererFlushDone, weak_this_));
 394 }
 395
 396 void RendererImpl::OnAudioRendererFlushDone() {
 397   DVLOG(1) << __FUNCTION__;
 398   DCHECK(task_runner_->BelongsToCurrentThread());
 399
 400   if (state_ == STATE_ERROR) {
 401     DCHECK(flush_cb_.is_null());
 402     return;
 403   }
 404
 405   DCHECK_EQ(state_, STATE_FLUSHING);
 406   DCHECK(!flush_cb_.is_null());
 407
 408   // If we had a deferred video renderer underflow prior to the flush, it should
 409   // have been cleared by the audio renderer changing to BUFFERING_HAVE_NOTHING.
 410   DCHECK(deferred_underflow_cb_.IsCancelled());
 411
 412   DCHECK_EQ(audio_buffering_state_, BUFFERING_HAVE_NOTHING);
 413   audio_ended_ = false;
 414   FlushVideoRenderer();
 415 }
 416
 417 void RendererImpl::FlushVideoRenderer() {
 418   DVLOG(1) << __FUNCTION__;
 419   DCHECK(task_runner_->BelongsToCurrentThread());
 420   DCHECK_EQ(state_, STATE_FLUSHING);
 421   DCHECK(!flush_cb_.is_null());
 422
 423   if (!video_renderer_) {
 424     OnVideoRendererFlushDone();
 425     return;
 426   }
 427
 428   video_renderer_->Flush(
 429       base::Bind(&RendererImpl::OnVideoRendererFlushDone, weak_this_));
 430 }
 431
 432 void RendererImpl::OnVideoRendererFlushDone() {
 433   DVLOG(1) << __FUNCTION__;
 434   DCHECK(task_runner_->BelongsToCurrentThread());
 435
 436   if (state_ == STATE_ERROR) {
 437     DCHECK(flush_cb_.is_null());
 438     return;
 439   }
 440
 441   DCHECK_EQ(state_, STATE_FLUSHING);
 442   DCHECK(!flush_cb_.is_null());
 443
 444   DCHECK_EQ(video_buffering_state_, BUFFERING_HAVE_NOTHING);
 445   video_ended_ = false;
 446   state_ = STATE_PLAYING;
 447   base::ResetAndReturn(&flush_cb_).Run();
 448 }
 449
 450 void RendererImpl::OnUpdateStatistics(const PipelineStatistics& stats) {
 451   DCHECK(task_runner_->BelongsToCurrentThread());
 452   statistics_cb_.Run(stats);
 453 }
 454
 455 void RendererImpl::OnBufferingStateChanged(BufferingState* buffering_state,
 456                                            BufferingState new_buffering_state) {
 457   const bool is_audio = buffering_state == &audio_buffering_state_;
 458   DVLOG(1) << __FUNCTION__ << "(" << *buffering_state << ", "
 459            << new_buffering_state << ") " << (is_audio ? "audio" : "video");
 460   DCHECK(task_runner_->BelongsToCurrentThread());
 461
 462   bool was_waiting_for_enough_data = WaitingForEnoughData();
 463
 464   // When audio is present and has enough data, defer video underflow callbacks
 465   // for some time to avoid unnecessary glitches in audio; see
 466   // http://crbug.com/144683#c53.
 467   if (audio_renderer_ && !is_audio && state_ == STATE_PLAYING) {
 468     if (video_buffering_state_ == BUFFERING_HAVE_ENOUGH &&
 469         audio_buffering_state_ == BUFFERING_HAVE_ENOUGH &&
 470         new_buffering_state == BUFFERING_HAVE_NOTHING &&
 471         deferred_underflow_cb_.IsCancelled()) {
 472       deferred_underflow_cb_.Reset(base::Bind(
 473           &RendererImpl::OnBufferingStateChanged, weak_factory_.GetWeakPtr(),
 474           buffering_state, new_buffering_state));
 475       task_runner_->PostDelayedTask(FROM_HERE,
 476                                     deferred_underflow_cb_.callback(),
 477                                     video_underflow_threshold_);
 478       return;
 479     }
 480
 481     deferred_underflow_cb_.Cancel();
 482   } else if (!deferred_underflow_cb_.IsCancelled() && is_audio &&
 483              new_buffering_state == BUFFERING_HAVE_NOTHING) {
 484     // If audio underflows while we have a deferred video underflow in progress
 485     // we want to mark video as underflowed immediately and cancel the deferral.
 486     deferred_underflow_cb_.Cancel();
 487     video_buffering_state_ = BUFFERING_HAVE_NOTHING;
 488   }
 489
 490   *buffering_state = new_buffering_state;
 491
 492   // Disable underflow by ignoring updates that renderers have ran out of data.
 493   if (state_ == STATE_PLAYING && underflow_disabled_for_testing_ &&
 494       time_ticking_) {
 495     DVLOG(1) << "Update ignored because underflow is disabled for testing.";
 496     return;
 497   }
 498
 499   // Renderer underflowed.
 500   if (!was_waiting_for_enough_data && WaitingForEnoughData()) {
 501     PausePlayback();
 502
 503     // TODO(scherkus): Fire BUFFERING_HAVE_NOTHING callback to alert clients of
 504     // underflow state http://crbug.com/144683
 505     return;
 506   }
 507
 508   // Renderer prerolled.
 509   if (was_waiting_for_enough_data && !WaitingForEnoughData()) {
 510     StartPlayback();
 511     buffering_state_cb_.Run(BUFFERING_HAVE_ENOUGH);
 512     return;
 513   }
 514 }
 515
 516 bool RendererImpl::WaitingForEnoughData() const {
 517   DCHECK(task_runner_->BelongsToCurrentThread());
 518   if (state_ != STATE_PLAYING)
 519     return false;
 520   if (audio_renderer_ && audio_buffering_state_ != BUFFERING_HAVE_ENOUGH)
 521     return true;
 522   if (video_renderer_ && video_buffering_state_ != BUFFERING_HAVE_ENOUGH)
 523     return true;
 524   return false;
 525 }
 526
 527 void RendererImpl::PausePlayback() {
 528   DVLOG(1) << __FUNCTION__;
 529   DCHECK(task_runner_->BelongsToCurrentThread());
 530   DCHECK(time_ticking_);
 531   switch (state_) {
 532     case STATE_PLAYING:
 533       DCHECK(PlaybackHasEnded() || WaitingForEnoughData())
 534           << "Playback should only pause due to ending or underflowing";
 535       break;
 536
 537     case STATE_FLUSHING:
 538       // It's OK to pause playback when flushing.
 539       break;
 540
 541     case STATE_UNINITIALIZED:
 542     case STATE_INITIALIZING:
 543       NOTREACHED() << "Invalid state: " << state_;
 544       break;
 545
 546     case STATE_ERROR:
 547       // An error state may occur at any time.
 548       break;
 549   }
 550
 551   time_ticking_ = false;
 552   time_source_->StopTicking();
 553   if (playback_rate_ > 0 && video_renderer_)
 554     video_renderer_->OnTimeStateChanged(false);
 555 }
 556
 557 void RendererImpl::StartPlayback() {
 558   DVLOG(1) << __FUNCTION__;
 559   DCHECK(task_runner_->BelongsToCurrentThread());
 560   DCHECK_EQ(state_, STATE_PLAYING);
 561   DCHECK(!time_ticking_);
 562   DCHECK(!WaitingForEnoughData());
 563
 564   time_ticking_ = true;
 565   time_source_->StartTicking();
 566   if (playback_rate_ > 0 && video_renderer_)
 567     video_renderer_->OnTimeStateChanged(true);
 568 }
 569
 570 void RendererImpl::OnAudioRendererEnded() {
 571   DVLOG(1) << __FUNCTION__;
 572   DCHECK(task_runner_->BelongsToCurrentThread());
 573
 574   if (state_ != STATE_PLAYING)
 575     return;
 576
 577   DCHECK(!audio_ended_);
 578   audio_ended_ = true;
 579
 580   RunEndedCallbackIfNeeded();
 581 }
 582
 583 void RendererImpl::OnVideoRendererEnded() {
 584   DVLOG(1) << __FUNCTION__;
 585   DCHECK(task_runner_->BelongsToCurrentThread());
 586
 587   if (state_ != STATE_PLAYING)
 588     return;
 589
 590   DCHECK(!video_ended_);
 591   video_ended_ = true;
 592
 593   RunEndedCallbackIfNeeded();
 594 }
 595
 596 bool RendererImpl::PlaybackHasEnded() const {
 597   DVLOG(1) << __FUNCTION__;
 598   DCHECK(task_runner_->BelongsToCurrentThread());
 599
 600   if (audio_renderer_ && !audio_ended_)
 601     return false;
 602
 603   if (video_renderer_ && !video_ended_)
 604     return false;
 605
 606   return true;
 607 }
 608
 609 void RendererImpl::RunEndedCallbackIfNeeded() {
 610   DVLOG(1) << __FUNCTION__;
 611   DCHECK(task_runner_->BelongsToCurrentThread());
 612
 613   if (!PlaybackHasEnded())
 614     return;
 615
 616   if (time_ticking_)
 617     PausePlayback();
 618
 619   ended_cb_.Run();
 620 }
 621
 622 void RendererImpl::OnError(PipelineStatus error) {
 623   DVLOG(1) << __FUNCTION__ << "(" << error << ")";
 624   DCHECK(task_runner_->BelongsToCurrentThread());
 625   DCHECK_NE(PIPELINE_OK, error) << "PIPELINE_OK isn't an error!";
 626
 627   // An error has already been delivered.
 628   if (state_ == STATE_ERROR)
 629     return;
 630
 631   const State old_state = state_;
 632   state_ = STATE_ERROR;
 633
 634   if (old_state == STATE_INITIALIZING) {
 635     base::ResetAndReturn(&init_cb_).Run(error);
 636     return;
 637   }
 638
 639   // After OnError() returns, the pipeline may destroy |this|.
 640   base::ResetAndReturn(&error_cb_).Run(error);
 641
 642   if (!flush_cb_.is_null())
 643     base::ResetAndReturn(&flush_cb_).Run();
 644 }
 645
 646 }  // namespace media