Home | History | Annotate | Download | only in base 
      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/base/buffering_controller.h"
      6 
      7 #include "base/bind.h"
      8 #include "base/location.h"
      9 #include "base/message_loop/message_loop_proxy.h"
     10 #include "chromecast/media/cma/base/buffering_state.h"
     11 #include "chromecast/media/cma/base/cma_logging.h"
     12 #include "media/base/buffers.h"
     13 
     14 namespace chromecast {
     15 namespace media {
     16 
     17 BufferingController::BufferingController(
     18     const scoped_refptr<BufferingConfig>& config,
     19     const BufferingNotificationCB& buffering_notification_cb)
     20     : config_(config),
     21       buffering_notification_cb_(buffering_notification_cb),
     22       is_buffering_(false),
     23       begin_buffering_time_(base::Time()),
     24       weak_factory_(this) {
     25   weak_this_ = weak_factory_.GetWeakPtr();
     26   thread_checker_.DetachFromThread();
     27 }
     28 
     29 BufferingController::~BufferingController() {
     30   // Some weak pointers might possibly be invalidated here.
     31   DCHECK(thread_checker_.CalledOnValidThread());
     32 }
     33 
     34 void BufferingController::UpdateHighLevelThreshold(
     35     base::TimeDelta high_level_threshold) {
     36   // Can only decrease the high level threshold.
     37   if (high_level_threshold > config_->high_level())
     38     return;
     39   CMALOG(kLogControl) << "High buffer threshold: "
     40                       << high_level_threshold.InMilliseconds();
     41   config_->set_high_level(high_level_threshold);
     42 
     43   // Make sure the low level threshold is somewhat consistent.
     44   // Currently, we set it to one third of the high level threshold:
     45   // this value could be adjusted in the future.
     46   base::TimeDelta low_level_threshold = high_level_threshold / 3;
     47   if (low_level_threshold <= config_->low_level()) {
     48     CMALOG(kLogControl) << "Low buffer threshold: "
     49                         << low_level_threshold.InMilliseconds();
     50     config_->set_low_level(low_level_threshold);
     51   }
     52 
     53   // Signal all the streams the config has changed.
     54   for (StreamList::iterator it = stream_list_.begin();
     55        it != stream_list_.end(); ++it) {
     56     (*it)->OnConfigChanged();
     57   }
     58 
     59   // Once all the streams have been notified, the buffering state must be
     60   // updated (no notification is received from the streams).
     61   OnBufferingStateChanged(false, false);
     62 }
     63 
     64 scoped_refptr<BufferingState> BufferingController::AddStream() {
     65   DCHECK(thread_checker_.CalledOnValidThread());
     66 
     67   // Add a new stream to the list of streams being monitored.
     68   scoped_refptr<BufferingState> buffering_state(new BufferingState(
     69       config_,
     70       base::Bind(&BufferingController::OnBufferingStateChanged, weak_this_,
     71                  false, false),
     72       base::Bind(&BufferingController::UpdateHighLevelThreshold, weak_this_)));
     73   stream_list_.push_back(buffering_state);
     74 
     75   // Update the state and force a notification to the streams.
     76   // TODO(damienv): Should this be a PostTask ?
     77   OnBufferingStateChanged(true, false);
     78 
     79   return buffering_state;
     80 }
     81 
     82 void BufferingController::SetMediaTime(base::TimeDelta time) {
     83   for (StreamList::iterator it = stream_list_.begin();
     84        it != stream_list_.end(); ++it) {
     85     (*it)->SetMediaTime(time);
     86   }
     87 }
     88 
     89 base::TimeDelta BufferingController::GetMaxRenderingTime() const {
     90   base::TimeDelta max_rendering_time(::media::kNoTimestamp());
     91   for (StreamList::const_iterator it = stream_list_.begin();
     92        it != stream_list_.end(); ++it) {
     93     base::TimeDelta max_stream_rendering_time =
     94         (*it)->GetMaxRenderingTime();
     95     if (max_stream_rendering_time == ::media::kNoTimestamp())
     96       return ::media::kNoTimestamp();
     97     if (max_rendering_time == ::media::kNoTimestamp() ||
     98         max_stream_rendering_time < max_rendering_time) {
     99       max_rendering_time = max_stream_rendering_time;
    100     }
    101   }
    102   return max_rendering_time;
    103 }
    104 
    105 void BufferingController::Reset() {
    106   DCHECK(thread_checker_.CalledOnValidThread());
    107 
    108   is_buffering_ = false;
    109   stream_list_.clear();
    110 }
    111 
    112 void BufferingController::OnBufferingStateChanged(
    113     bool force_notification, bool buffering_timeout) {
    114   DCHECK(thread_checker_.CalledOnValidThread());
    115 
    116   // Log the state of each stream.
    117   DumpState();
    118 
    119   bool is_low_buffering = IsLowBufferLevel();
    120   bool is_high_buffering = !is_low_buffering;
    121   if (!buffering_timeout) {
    122     // Hysteresis:
    123     // - to leave buffering, not only should we leave the low buffer level state
    124     //   but we should go to the high buffer level state (medium is not enough).
    125     is_high_buffering = IsHighBufferLevel();
    126   }
    127 
    128   bool is_buffering_prv = is_buffering_;
    129   if (is_buffering_) {
    130     if (is_high_buffering)
    131       is_buffering_ = false;
    132   } else {
    133     if (is_low_buffering)
    134       is_buffering_ = true;
    135   }
    136 
    137   // Start buffering.
    138   if (is_buffering_ && !is_buffering_prv) {
    139     begin_buffering_time_ = base::Time::Now();
    140   }
    141 
    142   // End buffering.
    143   if (is_buffering_prv && !is_buffering_) {
    144     // TODO(damienv): |buffering_user_time| could be a UMA histogram.
    145     base::Time current_time = base::Time::Now();
    146     base::TimeDelta buffering_user_time = current_time - begin_buffering_time_;
    147     CMALOG(kLogControl)
    148         << "Buffering took: "
    149         << buffering_user_time.InMilliseconds() << "ms";
    150   }
    151 
    152   if (is_buffering_prv != is_buffering_ || force_notification)
    153     buffering_notification_cb_.Run(is_buffering_);
    154 }
    155 
    156 bool BufferingController::IsHighBufferLevel() {
    157   if (stream_list_.empty())
    158     return true;
    159 
    160   bool is_high_buffering = true;
    161   for (StreamList::iterator it = stream_list_.begin();
    162        it != stream_list_.end(); ++it) {
    163     BufferingState::State stream_state = (*it)->GetState();
    164     is_high_buffering = is_high_buffering &&
    165         ((stream_state == BufferingState::kHighLevel) ||
    166          (stream_state == BufferingState::kEosReached));
    167   }
    168   return is_high_buffering;
    169 }
    170 
    171 bool BufferingController::IsLowBufferLevel() {
    172   if (stream_list_.empty())
    173     return false;
    174 
    175   for (StreamList::iterator it = stream_list_.begin();
    176        it != stream_list_.end(); ++it) {
    177     BufferingState::State stream_state = (*it)->GetState();
    178     if (stream_state == BufferingState::kLowLevel)
    179       return true;
    180   }
    181 
    182   return false;
    183 }
    184 
    185 void BufferingController::DumpState() const {
    186   CMALOG(kLogControl) << __FUNCTION__;
    187   for (StreamList::const_iterator it = stream_list_.begin();
    188        it != stream_list_.end(); ++it) {
    189     CMALOG(kLogControl) << (*it)->ToString();
    190   }
    191 }
    192 
    193 }  // namespace media
    194 }  // namespace chromecast
    195