src/media/filters/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/filters/renderer_impl.h"
   6
   7 #include "base/bind.h"
   8 #include "base/callback.h"
   9 #include "base/callback_helpers.h"
  10 #include "base/compiler_specific.h"
  11 #include "base/location.h"
  12 #include "base/single_thread_task_runner.h"
  13 #include "media/base/audio_renderer.h"
  14 #include "media/base/demuxer_stream_provider.h"
  15 #include "media/base/time_source.h"
  16 #include "media/base/video_renderer.h"
  17 #include "media/base/wall_clock_time_source.h"
  18
  19 namespace media {
  20
  21 RendererImpl::RendererImpl(
  22     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
  23     DemuxerStreamProvider* demuxer_stream_provider,
  24     scoped_ptr<AudioRenderer> audio_renderer,
  25     scoped_ptr<VideoRenderer> video_renderer)
  26     : state_(STATE_UNINITIALIZED),
  27       task_runner_(task_runner),
  28       demuxer_stream_provider_(demuxer_stream_provider),
  29       audio_renderer_(audio_renderer.Pass()),
  30       video_renderer_(video_renderer.Pass()),
  31       time_source_(NULL),
  32       time_ticking_(false),
  33       audio_buffering_state_(BUFFERING_HAVE_NOTHING),
  34       video_buffering_state_(BUFFERING_HAVE_NOTHING),
  35       audio_ended_(false),
  36       video_ended_(false),
  37       underflow_disabled_for_testing_(false),
  38       clockless_video_playback_enabled_for_testing_(false),
  39       weak_factory_(this),
  40       weak_this_(weak_factory_.GetWeakPtr()) {
  41   DVLOG(1) << __FUNCTION__;
  42 }
  43
  44 RendererImpl::~RendererImpl() {
  45   DVLOG(1) << __FUNCTION__;
  46   DCHECK(task_runner_->BelongsToCurrentThread());
  47
  48   // Tear down in opposite order of construction as |video_renderer_| can still
  49   // need |time_source_| (which can be |audio_renderer_|) to be alive.
  50   video_renderer_.reset();
  51   audio_renderer_.reset();
  52
  53   FireAllPendingCallbacks();
  54 }
  55
  56 void RendererImpl::Initialize(const base::Closure& init_cb,
  57                               const StatisticsCB& statistics_cb,
  58                               const base::Closure& ended_cb,
  59                               const PipelineStatusCB& error_cb,
  60                               const BufferingStateCB& buffering_state_cb) {
  61   DVLOG(1) << __FUNCTION__;
  62   DCHECK(task_runner_->BelongsToCurrentThread());
  63   DCHECK_EQ(state_, STATE_UNINITIALIZED) << state_;
  64   DCHECK(!init_cb.is_null());
  65   DCHECK(!statistics_cb.is_null());
  66   DCHECK(!ended_cb.is_null());
  67   DCHECK(!error_cb.is_null());
  68   DCHECK(!buffering_state_cb.is_null());
  69   DCHECK(demuxer_stream_provider_->GetStream(DemuxerStream::AUDIO) ||
  70          demuxer_stream_provider_->GetStream(DemuxerStream::VIDEO));
  71
  72   statistics_cb_ = statistics_cb;
  73   ended_cb_ = ended_cb;
  74   error_cb_ = error_cb;
  75   buffering_state_cb_ = buffering_state_cb;
  76
  77   init_cb_ = init_cb;
  78   state_ = STATE_INITIALIZING;
  79   InitializeAudioRenderer();
  80 }
  81
  82 void RendererImpl::Flush(const base::Closure& flush_cb) {
  83   DVLOG(1) << __FUNCTION__;
  84   DCHECK(task_runner_->BelongsToCurrentThread());
  85   DCHECK_EQ(state_, STATE_PLAYING) << state_;
  86   DCHECK(flush_cb_.is_null());
  87
  88   flush_cb_ = flush_cb;
  89   state_ = STATE_FLUSHING;
  90
  91   if (time_ticking_)
  92     PausePlayback();
  93
  94   FlushAudioRenderer();
  95 }
  96
  97 void RendererImpl::StartPlayingFrom(base::TimeDelta time) {
  98   DVLOG(1) << __FUNCTION__;
  99   DCHECK(task_runner_->BelongsToCurrentThread());
 100   DCHECK_EQ(state_, STATE_PLAYING) << state_;
 101
 102   time_source_->SetMediaTime(time);
 103
 104   if (audio_renderer_)
 105     audio_renderer_->StartPlaying();
 106   if (video_renderer_)
 107     video_renderer_->StartPlayingFrom(time);
 108 }
 109
 110 void RendererImpl::SetPlaybackRate(float playback_rate) {
 111   DVLOG(1) << __FUNCTION__ << "(" << playback_rate << ")";
 112   DCHECK(task_runner_->BelongsToCurrentThread());
 113
 114   // Playback rate changes are only carried out while playing.
 115   if (state_ != STATE_PLAYING)
 116     return;
 117
 118   time_source_->SetPlaybackRate(playback_rate);
 119 }
 120
 121 void RendererImpl::SetVolume(float volume) {
 122   DVLOG(1) << __FUNCTION__;
 123   DCHECK(task_runner_->BelongsToCurrentThread());
 124
 125   if (audio_renderer_)
 126     audio_renderer_->SetVolume(volume);
 127 }
 128
 129 base::TimeDelta RendererImpl::GetMediaTime() {
 130   // No BelongsToCurrentThread() checking because this can be called from other
 131   // threads.
 132   return time_source_->CurrentMediaTime();
 133 }
 134
 135 bool RendererImpl::HasAudio() {
 136   DCHECK(task_runner_->BelongsToCurrentThread());
 137   return audio_renderer_ != NULL;
 138 }
 139
 140 bool RendererImpl::HasVideo() {
 141   DCHECK(task_runner_->BelongsToCurrentThread());
 142   return video_renderer_ != NULL;
 143 }
 144
 145 void RendererImpl::SetCdm(MediaKeys* cdm) {
 146   DVLOG(1) << __FUNCTION__;
 147   DCHECK(task_runner_->BelongsToCurrentThread());
 148   // TODO(xhwang): Explore to possibility to move CDM setting from
 149   // WebMediaPlayerImpl to this class. See http://crbug.com/401264
 150   NOTREACHED();
 151 }
 152
 153 void RendererImpl::DisableUnderflowForTesting() {
 154   DVLOG(1) << __FUNCTION__;
 155   DCHECK(task_runner_->BelongsToCurrentThread());
 156   DCHECK_EQ(state_, STATE_UNINITIALIZED);
 157
 158   underflow_disabled_for_testing_ = true;
 159 }
 160
 161 void RendererImpl::EnableClocklessVideoPlaybackForTesting() {
 162   DVLOG(1) << __FUNCTION__;
 163   DCHECK(task_runner_->BelongsToCurrentThread());
 164   DCHECK_EQ(state_, STATE_UNINITIALIZED);
 165   DCHECK(underflow_disabled_for_testing_)
 166       << "Underflow must be disabled for clockless video playback";
 167
 168   clockless_video_playback_enabled_for_testing_ = true;
 169 }
 170
 171 base::TimeDelta RendererImpl::GetMediaTimeForSyncingVideo() {
 172   // No BelongsToCurrentThread() checking because this can be called from other
 173   // threads.
 174   //
 175   // TODO(scherkus): Currently called from VideoRendererImpl's internal thread,
 176   // which should go away at some point http://crbug.com/110814
 177   if (clockless_video_playback_enabled_for_testing_)
 178     return base::TimeDelta::Max();
 179
 180   return time_source_->CurrentMediaTimeForSyncingVideo();
 181 }
 182
 183 void RendererImpl::InitializeAudioRenderer() {
 184   DVLOG(1) << __FUNCTION__;
 185   DCHECK(task_runner_->BelongsToCurrentThread());
 186   DCHECK_EQ(state_, STATE_INITIALIZING) << state_;
 187   DCHECK(!init_cb_.is_null());
 188
 189   PipelineStatusCB done_cb =
 190       base::Bind(&RendererImpl::OnAudioRendererInitializeDone, weak_this_);
 191
 192   if (!demuxer_stream_provider_->GetStream(DemuxerStream::AUDIO)) {
 193     audio_renderer_.reset();
 194     task_runner_->PostTask(FROM_HERE, base::Bind(done_cb, PIPELINE_OK));
 195     return;
 196   }
 197
 198   audio_renderer_->Initialize(
 199       demuxer_stream_provider_->GetStream(DemuxerStream::AUDIO),
 200       done_cb,
 201       base::Bind(&RendererImpl::OnUpdateStatistics, weak_this_),
 202       base::Bind(&RendererImpl::OnBufferingStateChanged, weak_this_,
 203                  &audio_buffering_state_),
 204       base::Bind(&RendererImpl::OnAudioRendererEnded, weak_this_),
 205       base::Bind(&RendererImpl::OnError, weak_this_));
 206 }
 207
 208 void RendererImpl::OnAudioRendererInitializeDone(PipelineStatus status) {
 209   DVLOG(1) << __FUNCTION__ << ": " << status;
 210   DCHECK(task_runner_->BelongsToCurrentThread());
 211   DCHECK_EQ(state_, STATE_INITIALIZING) << state_;
 212   DCHECK(!init_cb_.is_null());
 213
 214   if (status != PIPELINE_OK) {
 215     audio_renderer_.reset();
 216     OnError(status);
 217     return;
 218   }
 219
 220   InitializeVideoRenderer();
 221 }
 222
 223 void RendererImpl::InitializeVideoRenderer() {
 224   DVLOG(1) << __FUNCTION__;
 225   DCHECK(task_runner_->BelongsToCurrentThread());
 226   DCHECK_EQ(state_, STATE_INITIALIZING) << state_;
 227   DCHECK(!init_cb_.is_null());
 228
 229   PipelineStatusCB done_cb =
 230       base::Bind(&RendererImpl::OnVideoRendererInitializeDone, weak_this_);
 231
 232   if (!demuxer_stream_provider_->GetStream(DemuxerStream::VIDEO)) {
 233     video_renderer_.reset();
 234     task_runner_->PostTask(FROM_HERE, base::Bind(done_cb, PIPELINE_OK));
 235     return;
 236   }
 237
 238   video_renderer_->Initialize(
 239       demuxer_stream_provider_->GetStream(DemuxerStream::VIDEO),
 240       demuxer_stream_provider_->GetLiveness() ==
 241           DemuxerStreamProvider::LIVENESS_LIVE,
 242       done_cb,
 243       base::Bind(&RendererImpl::OnUpdateStatistics, weak_this_),
 244       base::Bind(&RendererImpl::OnBufferingStateChanged,
 245                  weak_this_,
 246                  &video_buffering_state_),
 247       base::Bind(&RendererImpl::OnVideoRendererEnded, weak_this_),
 248       base::Bind(&RendererImpl::OnError, weak_this_),
 249       base::Bind(&RendererImpl::GetMediaTimeForSyncingVideo,
 250                  base::Unretained(this)));
 251 }
 252
 253 void RendererImpl::OnVideoRendererInitializeDone(PipelineStatus status) {
 254   DVLOG(1) << __FUNCTION__ << ": " << status;
 255   DCHECK(task_runner_->BelongsToCurrentThread());
 256   DCHECK_EQ(state_, STATE_INITIALIZING) << state_;
 257   DCHECK(!init_cb_.is_null());
 258
 259   if (status != PIPELINE_OK) {
 260     audio_renderer_.reset();
 261     video_renderer_.reset();
 262     OnError(status);
 263     return;
 264   }
 265
 266   if (audio_renderer_) {
 267     time_source_ = audio_renderer_->GetTimeSource();
 268   } else {
 269     wall_clock_time_source_.reset(new WallClockTimeSource());
 270     time_source_ = wall_clock_time_source_.get();
 271   }
 272
 273   state_ = STATE_PLAYING;
 274   DCHECK(time_source_);
 275   DCHECK(audio_renderer_ || video_renderer_);
 276   base::ResetAndReturn(&init_cb_).Run();
 277 }
 278
 279 void RendererImpl::FlushAudioRenderer() {
 280   DVLOG(1) << __FUNCTION__;
 281   DCHECK(task_runner_->BelongsToCurrentThread());
 282   DCHECK_EQ(state_, STATE_FLUSHING) << state_;
 283   DCHECK(!flush_cb_.is_null());
 284
 285   if (!audio_renderer_) {
 286     OnAudioRendererFlushDone();
 287     return;
 288   }
 289
 290   audio_renderer_->Flush(
 291       base::Bind(&RendererImpl::OnAudioRendererFlushDone, weak_this_));
 292 }
 293
 294 void RendererImpl::OnAudioRendererFlushDone() {
 295   DVLOG(1) << __FUNCTION__;
 296   DCHECK(task_runner_->BelongsToCurrentThread());
 297
 298   if (state_ == STATE_ERROR) {
 299     DCHECK(flush_cb_.is_null());
 300     return;
 301   }
 302
 303   DCHECK_EQ(state_, STATE_FLUSHING) << state_;
 304   DCHECK(!flush_cb_.is_null());
 305
 306   DCHECK_EQ(audio_buffering_state_, BUFFERING_HAVE_NOTHING);
 307   audio_ended_ = false;
 308   FlushVideoRenderer();
 309 }
 310
 311 void RendererImpl::FlushVideoRenderer() {
 312   DVLOG(1) << __FUNCTION__;
 313   DCHECK(task_runner_->BelongsToCurrentThread());
 314   DCHECK_EQ(state_, STATE_FLUSHING) << state_;
 315   DCHECK(!flush_cb_.is_null());
 316
 317   if (!video_renderer_) {
 318     OnVideoRendererFlushDone();
 319     return;
 320   }
 321
 322   video_renderer_->Flush(
 323       base::Bind(&RendererImpl::OnVideoRendererFlushDone, weak_this_));
 324 }
 325
 326 void RendererImpl::OnVideoRendererFlushDone() {
 327   DVLOG(1) << __FUNCTION__;
 328   DCHECK(task_runner_->BelongsToCurrentThread());
 329
 330   if (state_ == STATE_ERROR) {
 331     DCHECK(flush_cb_.is_null());
 332     return;
 333   }
 334
 335   DCHECK_EQ(state_, STATE_FLUSHING) << state_;
 336   DCHECK(!flush_cb_.is_null());
 337
 338   DCHECK_EQ(video_buffering_state_, BUFFERING_HAVE_NOTHING);
 339   video_ended_ = false;
 340   state_ = STATE_PLAYING;
 341   base::ResetAndReturn(&flush_cb_).Run();
 342 }
 343
 344 void RendererImpl::OnUpdateStatistics(const PipelineStatistics& stats) {
 345   DCHECK(task_runner_->BelongsToCurrentThread());
 346   statistics_cb_.Run(stats);
 347 }
 348
 349 void RendererImpl::OnBufferingStateChanged(BufferingState* buffering_state,
 350                                            BufferingState new_buffering_state) {
 351   DVLOG(1) << __FUNCTION__ << "(" << *buffering_state << ", "
 352            << new_buffering_state << ") "
 353            << (buffering_state == &audio_buffering_state_ ? "audio" : "video");
 354   DCHECK(task_runner_->BelongsToCurrentThread());
 355   bool was_waiting_for_enough_data = WaitingForEnoughData();
 356
 357   *buffering_state = new_buffering_state;
 358
 359   // Disable underflow by ignoring updates that renderers have ran out of data.
 360   if (state_ == STATE_PLAYING && underflow_disabled_for_testing_ &&
 361       time_ticking_) {
 362     DVLOG(1) << "Update ignored because underflow is disabled for testing.";
 363     return;
 364   }
 365
 366   // Renderer underflowed.
 367   if (!was_waiting_for_enough_data && WaitingForEnoughData()) {
 368     PausePlayback();
 369
 370     // TODO(scherkus): Fire BUFFERING_HAVE_NOTHING callback to alert clients of
 371     // underflow state http://crbug.com/144683
 372     return;
 373   }
 374
 375   // Renderer prerolled.
 376   if (was_waiting_for_enough_data && !WaitingForEnoughData()) {
 377     StartPlayback();
 378     buffering_state_cb_.Run(BUFFERING_HAVE_ENOUGH);
 379     return;
 380   }
 381 }
 382
 383 bool RendererImpl::WaitingForEnoughData() const {
 384   DCHECK(task_runner_->BelongsToCurrentThread());
 385   if (state_ != STATE_PLAYING)
 386     return false;
 387   if (audio_renderer_ && audio_buffering_state_ != BUFFERING_HAVE_ENOUGH)
 388     return true;
 389   if (video_renderer_ && video_buffering_state_ != BUFFERING_HAVE_ENOUGH)
 390     return true;
 391   return false;
 392 }
 393
 394 void RendererImpl::PausePlayback() {
 395   DVLOG(1) << __FUNCTION__;
 396   DCHECK(task_runner_->BelongsToCurrentThread());
 397   DCHECK(time_ticking_);
 398   switch (state_) {
 399     case STATE_PLAYING:
 400       DCHECK(PlaybackHasEnded() || WaitingForEnoughData())
 401           << "Playback should only pause due to ending or underflowing";
 402       break;
 403
 404     case STATE_FLUSHING:
 405       // It's OK to pause playback when flushing.
 406       break;
 407
 408     case STATE_UNINITIALIZED:
 409     case STATE_INITIALIZING:
 410     case STATE_ERROR:
 411       NOTREACHED() << "Invalid state: " << state_;
 412       break;
 413   }
 414
 415   time_ticking_ = false;
 416   time_source_->StopTicking();
 417 }
 418
 419 void RendererImpl::StartPlayback() {
 420   DVLOG(1) << __FUNCTION__;
 421   DCHECK(task_runner_->BelongsToCurrentThread());
 422   DCHECK_EQ(state_, STATE_PLAYING);
 423   DCHECK(!time_ticking_);
 424   DCHECK(!WaitingForEnoughData());
 425
 426   time_ticking_ = true;
 427   time_source_->StartTicking();
 428 }
 429
 430 void RendererImpl::OnAudioRendererEnded() {
 431   DVLOG(1) << __FUNCTION__;
 432   DCHECK(task_runner_->BelongsToCurrentThread());
 433
 434   if (state_ != STATE_PLAYING)
 435     return;
 436
 437   DCHECK(!audio_ended_);
 438   audio_ended_ = true;
 439
 440   RunEndedCallbackIfNeeded();
 441 }
 442
 443 void RendererImpl::OnVideoRendererEnded() {
 444   DVLOG(1) << __FUNCTION__;
 445   DCHECK(task_runner_->BelongsToCurrentThread());
 446
 447   if (state_ != STATE_PLAYING)
 448     return;
 449
 450   DCHECK(!video_ended_);
 451   video_ended_ = true;
 452
 453   RunEndedCallbackIfNeeded();
 454 }
 455
 456 bool RendererImpl::PlaybackHasEnded() const {
 457   DVLOG(1) << __FUNCTION__;
 458   DCHECK(task_runner_->BelongsToCurrentThread());
 459
 460   if (audio_renderer_ && !audio_ended_)
 461     return false;
 462
 463   if (video_renderer_ && !video_ended_)
 464     return false;
 465
 466   return true;
 467 }
 468
 469 void RendererImpl::RunEndedCallbackIfNeeded() {
 470   DVLOG(1) << __FUNCTION__;
 471   DCHECK(task_runner_->BelongsToCurrentThread());
 472
 473   if (!PlaybackHasEnded())
 474     return;
 475
 476   if (time_ticking_)
 477     PausePlayback();
 478
 479   ended_cb_.Run();
 480 }
 481
 482 void RendererImpl::OnError(PipelineStatus error) {
 483   DVLOG(1) << __FUNCTION__ << "(" << error << ")";
 484   DCHECK(task_runner_->BelongsToCurrentThread());
 485   DCHECK_NE(PIPELINE_OK, error) << "PIPELINE_OK isn't an error!";
 486
 487   state_ = STATE_ERROR;
 488
 489   // Pipeline will destroy |this| as the result of error.
 490   base::ResetAndReturn(&error_cb_).Run(error);
 491
 492   FireAllPendingCallbacks();
 493 }
 494
 495 void RendererImpl::FireAllPendingCallbacks() {
 496   DCHECK(task_runner_->BelongsToCurrentThread());
 497
 498   if (!init_cb_.is_null())
 499     base::ResetAndReturn(&init_cb_).Run();
 500
 501   if (!flush_cb_.is_null())
 502     base::ResetAndReturn(&flush_cb_).Run();
 503 }
 504
 505 }  // namespace media