Fire canplaythrough event at the proper time for audio/video

media/base/download_rate_monitor.cc

+// Copyright (c) 2011 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/base/download_rate_monitor.h"
+
+#include "base/bind.h"
+#include "base/time.h"
+
+namespace media {
+
+// Number of samples to use to collect and average for each measurement of
+// download rate.
+static const size_t kNumberOfSamples = 5;
+
+// Minimum number of seconds represented in a sample period.
+static const float kSamplePeriod = 1.0;
+
+DownloadRateMonitor::Sample::Sample() {
+  Reset();
+}
+
+DownloadRateMonitor::Sample::~Sample() { }
+
+DownloadRateMonitor::Sample::Sample(
+    const BufferingPoint& start, const BufferingPoint& end) {
+  Reset();
+  start_ = start;
+  set_end(end);
+}
+
+void DownloadRateMonitor::Sample::set_end(const BufferingPoint& new_end) {
+  DCHECK(!start_.timestamp.is_null());
+  DCHECK(new_end.buffered_bytes >= start_.buffered_bytes);
+  DCHECK(new_end.timestamp >= start_.timestamp);
+  end_ = new_end;
+}
+
+float DownloadRateMonitor::Sample::bytes_per_second() const {
+  if (seconds_elapsed() > 0.0 && bytes_downloaded() >= 0)
+    return bytes_downloaded() / seconds_elapsed();
+  return -1.0;
+}
+
+float DownloadRateMonitor::Sample::seconds_elapsed() const {
+  if (start_.timestamp.is_null() || end_.timestamp.is_null())
+    return -1.0;
+  return (end_.timestamp - start_.timestamp).InSecondsF();
+}
+
+int64 DownloadRateMonitor::Sample::bytes_downloaded() const {
+  if (start_.timestamp.is_null() || end_.timestamp.is_null())
+    return -1.0;
+  return end_.buffered_bytes - start_.buffered_bytes;
+}
+
+bool DownloadRateMonitor::Sample::is_null() const {
+  return start_.timestamp.is_null() && end_.timestamp.is_null();
+}
+
+void DownloadRateMonitor::Sample::Reset() {
+  start_ = BufferingPoint();
+  end_ = BufferingPoint();
+}
+
+void DownloadRateMonitor::Sample::RestartAtEndBufferingPoint() {
+  start_ = end_;
+  end_ = BufferingPoint();
+}
+
+DownloadRateMonitor::DownloadRateMonitor() {
+  Reset();
+}
+
+void DownloadRateMonitor::Start(
+    const base::Closure& canplaythrough_cb, int media_bitrate) {
+  DCHECK(stopped_);
+  canplaythrough_cb_ = canplaythrough_cb;
+  stopped_ = false;
+  bitrate_ = media_bitrate;
+  current_sample_.Reset();
+  buffered_bytes_ = 0;
+
+  NotifyCanPlayThroughIfNeeded();
+}
+
+void DownloadRateMonitor::SetBufferedBytes(
+    int64 buffered_bytes, const base::Time& timestamp) {
+  if (stopped_)
+    return;
+
+  is_downloading_data_ = true;
+
+  // Check monotonically nondecreasing constraint.
+  base::Time previous_time;
+  if (!current_sample_.is_null())
+    previous_time = current_sample_.end().timestamp;
+  else if (!sample_window_.empty())
+    previous_time = sample_window_.back().end().timestamp;
+
+  // If we go backward in time, dismiss the sample.
+  if (!previous_time.is_null() && timestamp < previous_time)
+    return;
+
+  // If the buffer level has dropped, invalidate current sample.
+  if (buffered_bytes < buffered_bytes_)
+    current_sample_.Reset();
+  buffered_bytes_ = buffered_bytes;
+
+  BufferingPoint latest_point = { buffered_bytes, timestamp };
+  if (current_sample_.is_null())
+    current_sample_ = Sample(latest_point, latest_point);
+  else
+    current_sample_.set_end(latest_point);
+
+  UpdateSampleWindow();
+  NotifyCanPlayThroughIfNeeded();
+}
+
+void DownloadRateMonitor::SetNetworkActivity(bool is_downloading_data) {
+  if (is_downloading_data == is_downloading_data_)
+    return;
+  // Invalidate the current sample if downloading is going from start to stopped
+  // or vice versa.
+  current_sample_.Reset();
+  is_downloading_data_ = is_downloading_data;
+}
+
+void DownloadRateMonitor::Stop() {
+  stopped_ = true;
+  current_sample_.Reset();
+  buffered_bytes_ = 0;
+}
+
+void DownloadRateMonitor::Reset() {
+  canplaythrough_cb_.Reset();
+  has_notified_can_play_through_ = false;
+  current_sample_.Reset();
+  sample_window_.clear();
+  is_downloading_data_ = false;
+  total_bytes_ = -1;
+  buffered_bytes_ = 0;
+  loaded_ = false;
+  bitrate_ = 0;
+  stopped_ = true;
+}
+
+DownloadRateMonitor::~DownloadRateMonitor() { }
+
+int64 DownloadRateMonitor::bytes_downloaded_in_window() const {
+  // There are max |kNumberOfSamples| so we might as well recompute each time.
+  int64 total = 0;
+  for (size_t i = 0; i < sample_window_.size(); ++i)
+    total += sample_window_[i].bytes_downloaded();
+  return total;
+}
+
+float DownloadRateMonitor::seconds_elapsed_in_window() const {
+  // There are max |kNumberOfSamples| so we might as well recompute each time.
+  float total = 0.0;
+  for (size_t i = 0; i < sample_window_.size(); ++i)
+    total += sample_window_[i].seconds_elapsed();
+  return total;
+}
+
+void DownloadRateMonitor::UpdateSampleWindow() {
+  if (current_sample_.seconds_elapsed() < kSamplePeriod)
+    return;
+
+  // Add latest sample and remove oldest sample.
+  sample_window_.push_back(current_sample_);
+  if (sample_window_.size() > kNumberOfSamples)
+    sample_window_.pop_front();
+
+  // Prepare for next measurement.
+  current_sample_.RestartAtEndBufferingPoint();
+}
+
+float DownloadRateMonitor::ApproximateDownloadByteRate() const {
+  // Compute and return the average download byte rate from within the sample
+  // window.
+  // NOTE: In the unlikely case where the data is arriving really bursty-ly,
+  // say getting a big chunk of data every 5 seconds, then with this
+  // implementation it will take 25 seconds until bitrate is calculated.
+  if (sample_window_.size() >= kNumberOfSamples &&
+      seconds_elapsed_in_window() > 0.0) {
+    return bytes_downloaded_in_window() / seconds_elapsed_in_window();
+  }
+
+  // Could not determine approximate download byte rate.
+  return -1.0;
+}
+
+bool DownloadRateMonitor::ShouldNotifyCanPlayThrough() {
+  if (stopped_)
+    return false;
+
+  // Only notify CanPlayThrough once for now.
+  if (has_notified_can_play_through_)
+    return false;
+
+  // If the media is from a local file (|loaded_|) or if all bytes are
+  // buffered, fire CanPlayThrough.
+  if (loaded_ || buffered_bytes_ == total_bytes_)
+    return true;
+
+  // Cannot approximate when the media can play through if bitrate is unknown.
+  if (bitrate_ <= 0)
+    return false;
+
+  float bytes_needed_per_second = bitrate_ / 8;
+  float download_rate = ApproximateDownloadByteRate();
+
+  // If we are downloading at or faster than the media's bitrate, then we can
+  // play through to the end of the media without stopping to buffer.
+  if (download_rate > 0)
+    return download_rate >= bytes_needed_per_second;
+
+  // If download rate is unknown, it may be because the media is being
+  // downloaded so fast that it cannot collect an adequate number of samples
+  // before the download gets deferred.
+  //
+  // To catch this case, we also look at how much data is being downloaded
+  // immediately after the download begins.
+  if (sample_window_.size() < kNumberOfSamples) {
+    int64 bytes_downloaded_since_start =
+        bytes_downloaded_in_window() + current_sample_.bytes_downloaded();
+    float seconds_elapsed_since_start =
+        seconds_elapsed_in_window() + current_sample_.seconds_elapsed();
+
+    // If we download 4 seconds of data in less than 2 seconds of time, we're
+    // probably downloading at a fast enough rate that we can play through.
+    // This is an arbitrary metric that will likely need tweaking.
+    if (seconds_elapsed_since_start < 2.0 &&
+        bytes_downloaded_since_start > 4.0 * bytes_needed_per_second) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+void DownloadRateMonitor::NotifyCanPlayThroughIfNeeded() {
+  if (ShouldNotifyCanPlayThrough() && !canplaythrough_cb_.is_null()) {
+    canplaythrough_cb_.Run();
+    has_notified_can_play_through_ = true;
+  }
+}
+
+}  // namespace media