chromecast/media/cma/pipeline/media_pipeline_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 "chromecast/media/cma/pipeline/media_pipeline_impl.h"
   6
   7 #include "base/bind.h"
   8 #include "base/callback.h"
   9 #include "base/callback_helpers.h"
  10 #include "base/location.h"
  11 #include "base/logging.h"
  12 #include "base/message_loop/message_loop_proxy.h"
  13 #include "base/time/time.h"
  14 #include "chromecast/media/cdm/browser_cdm_cast.h"
  15 #include "chromecast/media/cma/backend/media_clock_device.h"
  16 #include "chromecast/media/cma/backend/media_pipeline_device.h"
  17 #include "chromecast/media/cma/base/buffering_controller.h"
  18 #include "chromecast/media/cma/base/buffering_state.h"
  19 #include "chromecast/media/cma/base/cma_logging.h"
  20 #include "chromecast/media/cma/base/coded_frame_provider.h"
  21 #include "chromecast/media/cma/pipeline/audio_pipeline_impl.h"
  22 #include "chromecast/media/cma/pipeline/video_pipeline_impl.h"
  23 #include "media/base/buffers.h"
  24
  25 namespace chromecast {
  26 namespace media {
  27
  28 namespace {
  29
  30 // Buffering parameters when load_type is kLoadTypeUrl.
  31 const base::TimeDelta kLowBufferThresholdURL(
  32     base::TimeDelta::FromMilliseconds(2000));
  33 const base::TimeDelta kHighBufferThresholdURL(
  34     base::TimeDelta::FromMilliseconds(6000));
  35
  36 // Buffering parameters when load_type is kLoadTypeMediaSource.
  37 const base::TimeDelta kLowBufferThresholdMediaSource(
  38     base::TimeDelta::FromMilliseconds(0));
  39 const base::TimeDelta kHighBufferThresholdMediaSource(
  40     base::TimeDelta::FromMilliseconds(300));
  41
  42 // Interval between two updates of the media time.
  43 const base::TimeDelta kTimeUpdateInterval(
  44     base::TimeDelta::FromMilliseconds(250));
  45
  46 // Interval between two updates of the statistics is equal to:
  47 // kTimeUpdateInterval * kStatisticsUpdatePeriod.
  48 const int kStatisticsUpdatePeriod = 4;
  49
  50 }  // namespace
  51
  52 MediaPipelineImpl::MediaPipelineImpl()
  53     : has_audio_(false),
  54       has_video_(false),
  55       target_playback_rate_(0.0),
  56       enable_time_update_(false),
  57       pending_time_update_task_(false),
  58       statistics_rolling_counter_(0),
  59       weak_factory_(this) {
  60   CMALOG(kLogControl) << __FUNCTION__;
  61   weak_this_ = weak_factory_.GetWeakPtr();
  62   thread_checker_.DetachFromThread();
  63 }
  64
  65 MediaPipelineImpl::~MediaPipelineImpl() {
  66   CMALOG(kLogControl) << __FUNCTION__;
  67   DCHECK(thread_checker_.CalledOnValidThread());
  68 }
  69
  70 void MediaPipelineImpl::Initialize(
  71     LoadType load_type,
  72     scoped_ptr<MediaPipelineDevice> media_pipeline_device) {
  73   CMALOG(kLogControl) << __FUNCTION__;
  74   DCHECK(thread_checker_.CalledOnValidThread());
  75   media_pipeline_device_.reset(media_pipeline_device.release());
  76   clock_device_ = media_pipeline_device_->GetMediaClockDevice();
  77
  78   if (load_type == kLoadTypeURL || load_type == kLoadTypeMediaSource) {
  79     base::TimeDelta low_threshold(kLowBufferThresholdURL);
  80     base::TimeDelta high_threshold(kHighBufferThresholdURL);
  81     if (load_type == kLoadTypeMediaSource) {
  82       low_threshold = kLowBufferThresholdMediaSource;
  83       high_threshold = kHighBufferThresholdMediaSource;
  84     }
  85     scoped_refptr<BufferingConfig> buffering_config(
  86         new BufferingConfig(low_threshold, high_threshold));
  87     buffering_controller_.reset(new BufferingController(
  88         buffering_config,
  89         base::Bind(&MediaPipelineImpl::OnBufferingNotification, weak_this_)));
  90   }
  91
  92   audio_pipeline_.reset(new AudioPipelineImpl(
  93       media_pipeline_device_->GetAudioPipelineDevice()));
  94
  95   video_pipeline_.reset(new VideoPipelineImpl(
  96       media_pipeline_device_->GetVideoPipelineDevice()));
  97 }
  98
  99 void MediaPipelineImpl::SetClient(const MediaPipelineClient& client) {
 100   DCHECK(thread_checker_.CalledOnValidThread());
 101   DCHECK(!client.error_cb.is_null());
 102   DCHECK(!client.time_update_cb.is_null());
 103   DCHECK(!client.buffering_state_cb.is_null());
 104   client_ = client;
 105 }
 106
 107 void MediaPipelineImpl::SetCdm(int cdm_id) {
 108   CMALOG(kLogControl) << __FUNCTION__ << " cdm_id=" << cdm_id;
 109   DCHECK(thread_checker_.CalledOnValidThread());
 110   NOTIMPLEMENTED();
 111   // TODO(gunsch): SetCdm(int) is not implemented.
 112   // One possibility would be a GetCdmByIdCB that's passed in.
 113 }
 114
 115 void MediaPipelineImpl::SetCdm(::media::BrowserCdm* media_keys) {
 116   CMALOG(kLogControl) << __FUNCTION__;
 117   DCHECK(thread_checker_.CalledOnValidThread());
 118   audio_pipeline_->SetCdm(static_cast<BrowserCdmCast*>(media_keys));
 119   video_pipeline_->SetCdm(static_cast<BrowserCdmCast*>(media_keys));
 120 }
 121
 122 AudioPipeline* MediaPipelineImpl::GetAudioPipeline() const {
 123   return audio_pipeline_.get();
 124 }
 125
 126 VideoPipeline* MediaPipelineImpl::GetVideoPipeline() const {
 127   return video_pipeline_.get();
 128 }
 129
 130 void MediaPipelineImpl::InitializeAudio(
 131     const ::media::AudioDecoderConfig& config,
 132     scoped_ptr<CodedFrameProvider> frame_provider,
 133     const ::media::PipelineStatusCB& status_cb) {
 134   DCHECK(thread_checker_.CalledOnValidThread());
 135   DCHECK(!has_audio_);
 136   if (clock_device_->GetState() == MediaClockDevice::kStateUninitialized &&
 137       !clock_device_->SetState(MediaClockDevice::kStateIdle)) {
 138     status_cb.Run(::media::PIPELINE_ERROR_INITIALIZATION_FAILED);
 139     return;
 140   }
 141   has_audio_ = true;
 142   audio_pipeline_->Initialize(config, frame_provider.Pass(), status_cb);
 143 }
 144
 145 void MediaPipelineImpl::InitializeVideo(
 146     const ::media::VideoDecoderConfig& config,
 147     scoped_ptr<CodedFrameProvider> frame_provider,
 148     const ::media::PipelineStatusCB& status_cb) {
 149   DCHECK(thread_checker_.CalledOnValidThread());
 150   DCHECK(!has_video_);
 151   if (clock_device_->GetState() == MediaClockDevice::kStateUninitialized &&
 152       !clock_device_->SetState(MediaClockDevice::kStateIdle)) {
 153     status_cb.Run(::media::PIPELINE_ERROR_INITIALIZATION_FAILED);
 154     return;
 155   }
 156   has_video_ = true;
 157   video_pipeline_->Initialize(config, frame_provider.Pass(), status_cb);
 158 }
 159
 160 void MediaPipelineImpl::StartPlayingFrom(base::TimeDelta time) {
 161   CMALOG(kLogControl) << __FUNCTION__ << " t0=" << time.InMilliseconds();
 162   DCHECK(thread_checker_.CalledOnValidThread());
 163   DCHECK(has_audio_ || has_video_);
 164   DCHECK(!pending_callbacks_);
 165
 166   // Reset the start of the timeline.
 167   DCHECK_EQ(clock_device_->GetState(), MediaClockDevice::kStateIdle);
 168   clock_device_->ResetTimeline(time);
 169
 170   // Start the clock. If the playback rate is 0, then the clock is started
 171   // but does not increase.
 172   if (!clock_device_->SetState(MediaClockDevice::kStateRunning)) {
 173     OnError(::media::PIPELINE_ERROR_ABORT);
 174     return;
 175   }
 176
 177   // Enable time updates.
 178   enable_time_update_ = true;
 179   statistics_rolling_counter_ = 0;
 180   if (!pending_time_update_task_) {
 181     pending_time_update_task_ = true;
 182     base::MessageLoopProxy::current()->PostTask(
 183         FROM_HERE,
 184         base::Bind(&MediaPipelineImpl::UpdateMediaTime, weak_this_));
 185   }
 186
 187   // Setup the audio and video pipeline for the new timeline.
 188   if (has_audio_) {
 189     scoped_refptr<BufferingState> buffering_state;
 190     if (buffering_controller_)
 191       buffering_state = buffering_controller_->AddStream("audio");
 192     if (!audio_pipeline_->StartPlayingFrom(time, buffering_state)) {
 193       OnError(::media::PIPELINE_ERROR_ABORT);
 194       return;
 195     }
 196   }
 197   if (has_video_) {
 198     scoped_refptr<BufferingState> buffering_state;
 199     if (buffering_controller_)
 200       buffering_state = buffering_controller_->AddStream("video");
 201     if (!video_pipeline_->StartPlayingFrom(time, buffering_state)) {
 202       OnError(::media::PIPELINE_ERROR_ABORT);
 203       return;
 204     }
 205   }
 206 }
 207
 208 void MediaPipelineImpl::Flush(const ::media::PipelineStatusCB& status_cb) {
 209   CMALOG(kLogControl) << __FUNCTION__;
 210   DCHECK(thread_checker_.CalledOnValidThread());
 211   DCHECK(has_audio_ || has_video_);
 212   DCHECK(!pending_callbacks_);
 213
 214   // No need to update media time anymore.
 215   enable_time_update_ = false;
 216
 217   buffering_controller_->Reset();
 218
 219   // The clock should return to idle.
 220   if (!clock_device_->SetState(MediaClockDevice::kStateIdle)) {
 221     status_cb.Run(::media::PIPELINE_ERROR_ABORT);
 222     return;
 223   }
 224
 225   // Flush both the audio and video pipeline.
 226   ::media::SerialRunner::Queue bound_fns;
 227   if (has_audio_) {
 228     bound_fns.Push(base::Bind(
 229         &AudioPipelineImpl::Flush,
 230         base::Unretained(audio_pipeline_.get())));
 231   }
 232   if (has_video_) {
 233     bound_fns.Push(base::Bind(
 234         &VideoPipelineImpl::Flush,
 235         base::Unretained(video_pipeline_.get())));
 236   }
 237   ::media::PipelineStatusCB transition_cb =
 238       base::Bind(&MediaPipelineImpl::StateTransition, weak_this_, status_cb);
 239   pending_callbacks_ =
 240       ::media::SerialRunner::Run(bound_fns, transition_cb);
 241 }
 242
 243 void MediaPipelineImpl::Stop() {
 244   CMALOG(kLogControl) << __FUNCTION__;
 245   DCHECK(thread_checker_.CalledOnValidThread());
 246   DCHECK(has_audio_ || has_video_);
 247   DCHECK(!pending_callbacks_);
 248
 249   // No need to update media time anymore.
 250   enable_time_update_ = false;
 251
 252   // Release hardware resources on Stop.
 253   // Note: Stop can be called from any state.
 254   if (clock_device_->GetState() == MediaClockDevice::kStateRunning)
 255     clock_device_->SetState(MediaClockDevice::kStateIdle);
 256   if (clock_device_->GetState() == MediaClockDevice::kStateIdle)
 257     clock_device_->SetState(MediaClockDevice::kStateUninitialized);
 258
 259   // Stop both the audio and video pipeline.
 260   if (has_audio_)
 261     audio_pipeline_->Stop();
 262   if (has_video_)
 263     video_pipeline_->Stop();
 264 }
 265
 266 void MediaPipelineImpl::SetPlaybackRate(float rate) {
 267   CMALOG(kLogControl) << __FUNCTION__ << " rate=" << rate;
 268   DCHECK(thread_checker_.CalledOnValidThread());
 269   target_playback_rate_ = rate;
 270   if (!buffering_controller_ || !buffering_controller_->IsBuffering())
 271     media_pipeline_device_->GetMediaClockDevice()->SetRate(rate);
 272 }
 273
 274 AudioPipelineImpl* MediaPipelineImpl::GetAudioPipelineImpl() const {
 275   return audio_pipeline_.get();
 276 }
 277
 278 VideoPipelineImpl* MediaPipelineImpl::GetVideoPipelineImpl() const {
 279   return video_pipeline_.get();
 280 }
 281
 282 void MediaPipelineImpl::StateTransition(
 283     const ::media::PipelineStatusCB& status_cb,
 284     ::media::PipelineStatus status) {
 285   pending_callbacks_.reset();
 286   status_cb.Run(status);
 287 }
 288
 289 void MediaPipelineImpl::OnBufferingNotification(bool is_buffering) {
 290   CMALOG(kLogControl) << __FUNCTION__ << " is_buffering=" << is_buffering;
 291   DCHECK(thread_checker_.CalledOnValidThread());
 292   DCHECK(buffering_controller_);
 293
 294   if (!client_.buffering_state_cb.is_null()) {
 295     ::media::BufferingState buffering_state = is_buffering ?
 296         ::media::BUFFERING_HAVE_NOTHING : ::media::BUFFERING_HAVE_ENOUGH;
 297     client_.buffering_state_cb.Run(buffering_state);
 298   }
 299
 300   if (media_pipeline_device_->GetMediaClockDevice()->GetState() ==
 301       MediaClockDevice::kStateUninitialized) {
 302     return;
 303   }
 304
 305   if (is_buffering) {
 306     // Do not consume data in a rebuffering phase.
 307     media_pipeline_device_->GetMediaClockDevice()->SetRate(0.0);
 308   } else {
 309     media_pipeline_device_->GetMediaClockDevice()->SetRate(
 310         target_playback_rate_);
 311   }
 312 }
 313
 314 void MediaPipelineImpl::UpdateMediaTime() {
 315   pending_time_update_task_ = false;
 316   if (!enable_time_update_)
 317     return;
 318
 319   if (statistics_rolling_counter_ == 0) {
 320     audio_pipeline_->UpdateStatistics();
 321     video_pipeline_->UpdateStatistics();
 322   }
 323   statistics_rolling_counter_ =
 324       (statistics_rolling_counter_ + 1) % kStatisticsUpdatePeriod;
 325
 326   base::TimeDelta media_time(clock_device_->GetTime());
 327   if (media_time == ::media::kNoTimestamp()) {
 328     pending_time_update_task_ = true;
 329     base::MessageLoopProxy::current()->PostDelayedTask(
 330         FROM_HERE,
 331         base::Bind(&MediaPipelineImpl::UpdateMediaTime, weak_this_),
 332         kTimeUpdateInterval);
 333     return;
 334   }
 335   base::TimeTicks stc = base::TimeTicks::Now();
 336
 337   base::TimeDelta max_rendering_time = media_time;
 338   if (buffering_controller_) {
 339     buffering_controller_->SetMediaTime(media_time);
 340
 341     // Receiving the same time twice in a row means playback isn't moving,
 342     // so don't interpolate ahead.
 343     if (media_time != last_media_time_) {
 344       max_rendering_time = buffering_controller_->GetMaxRenderingTime();
 345       if (max_rendering_time == ::media::kNoTimestamp())
 346         max_rendering_time = media_time;
 347
 348       // Cap interpolation time to avoid interpolating too far ahead.
 349       max_rendering_time =
 350           std::min(max_rendering_time, media_time + 2 * kTimeUpdateInterval);
 351     }
 352   }
 353
 354   last_media_time_ = media_time;
 355   if (!client_.time_update_cb.is_null())
 356     client_.time_update_cb.Run(media_time, max_rendering_time, stc);
 357
 358   pending_time_update_task_ = true;
 359   base::MessageLoopProxy::current()->PostDelayedTask(
 360       FROM_HERE,
 361       base::Bind(&MediaPipelineImpl::UpdateMediaTime, weak_this_),
 362       kTimeUpdateInterval);
 363 }
 364
 365 void MediaPipelineImpl::OnError(::media::PipelineStatus error) {
 366   DCHECK(thread_checker_.CalledOnValidThread());
 367   DCHECK_NE(error, ::media::PIPELINE_OK) << "PIPELINE_OK is not an error!";
 368   if (!client_.error_cb.is_null())
 369     client_.error_cb.Run(error);
 370 }
 371
 372 }  // namespace media
 373 }  // namespace chromecast