Cast: Reshuffle files under media/cast

media/cast/congestion_control/congestion_control.cc

-// Copyright 2013 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.
-
-// The purpose of this file is determine what bitrate to use for mirroring.
-// Ideally this should be as much as possible, without causing any frames to
-// arrive late.
-
-// The current algorithm is to measure how much bandwidth we've been using
-// recently. We also keep track of how much data has been queued up for sending
-// in a virtual "buffer" (this virtual buffer represents all the buffers between
-// the sender and the receiver, including retransmissions and so forth.)
-// If we estimate that our virtual buffer is mostly empty, we try to use
-// more bandwidth than our recent usage, otherwise we use less.
-
-#include "media/cast/congestion_control/congestion_control.h"
-
-#include "base/logging.h"
-#include "media/cast/cast_config.h"
-#include "media/cast/cast_defines.h"
-
-namespace media {
-namespace cast {
-
-// This means that we *try* to keep our buffer 90% empty.
-// If it is less full, we increase the bandwidth, if it is more
-// we decrease the bandwidth. Making this smaller makes the
-// congestion control more aggressive.
-static const double kTargetEmptyBufferFraction = 0.9;
-
-// This is the size of our history in frames. Larger values makes the
-// congestion control adapt slower.
-static const size_t kHistorySize = 100;
-
-CongestionControl::FrameStats::FrameStats() : frame_size(0) {
-}
-
-CongestionControl::CongestionControl(base::TickClock* clock,
-                                     uint32 max_bitrate_configured,
-                                     uint32 min_bitrate_configured,
-                                     size_t max_unacked_frames)
-    : clock_(clock),
-      max_bitrate_configured_(max_bitrate_configured),
-      min_bitrate_configured_(min_bitrate_configured),
-      last_frame_stats_(static_cast<uint32>(-1)),
-      last_acked_frame_(static_cast<uint32>(-1)),
-      last_encoded_frame_(static_cast<uint32>(-1)),
-      history_size_(max_unacked_frames + kHistorySize),
-      acked_bits_in_history_(0) {
-  DCHECK_GE(max_bitrate_configured, min_bitrate_configured) << "Invalid config";
-  frame_stats_.resize(2);
-  base::TimeTicks now = clock->NowTicks();
-  frame_stats_[0].ack_time = now;
-  frame_stats_[0].sent_time = now;
-  frame_stats_[1].ack_time = now;
-  DCHECK(!frame_stats_[0].ack_time.is_null());
-}
-
-CongestionControl::~CongestionControl() {}
-
-void CongestionControl::UpdateRtt(base::TimeDelta rtt) {
-  rtt_ = (7 * rtt_ + rtt) / 8;
-}
-
-// Calculate how much "dead air" there is between two frames.
-base::TimeDelta CongestionControl::DeadTime(const FrameStats& a,
-                                            const FrameStats& b) {
-  if (b.sent_time > a.ack_time) {
-    return b.sent_time - a.ack_time;
-  } else {
-    return base::TimeDelta();
-  }
-}
-
-double CongestionControl::CalculateSafeBitrate() {
-  double transmit_time =
-      (GetFrameStats(last_acked_frame_)->ack_time -
-       frame_stats_.front().sent_time - dead_time_in_history_).InSecondsF();
-
-  if (acked_bits_in_history_ == 0 || transmit_time <= 0.0) {
-    return min_bitrate_configured_;
-  }
-  return acked_bits_in_history_ / std::max(transmit_time, 1E-3);
-}
-
-CongestionControl::FrameStats* CongestionControl::GetFrameStats(
-    uint32 frame_id) {
-  int32 offset = static_cast<int32>(frame_id - last_frame_stats_);
-  DCHECK_LT(offset, static_cast<int32>(kHistorySize));
-  if (offset > 0) {
-    frame_stats_.resize(frame_stats_.size() + offset);
-    last_frame_stats_ += offset;
-    offset = 0;
-  }
-  while (frame_stats_.size() > history_size_) {
-    DCHECK_GT(frame_stats_.size(), 1UL);
-    DCHECK(!frame_stats_[0].ack_time.is_null());
-    acked_bits_in_history_ -= frame_stats_[0].frame_size;
-    dead_time_in_history_ -= DeadTime(frame_stats_[0], frame_stats_[1]);
-    DCHECK_GE(acked_bits_in_history_, 0UL);
-    VLOG(2) << "DT: " << dead_time_in_history_.InSecondsF();
-    DCHECK_GE(dead_time_in_history_.InSecondsF(), 0.0);
-    frame_stats_.pop_front();
-  }
-  offset += frame_stats_.size() - 1;
-  if (offset < 0 || offset >= static_cast<int32>(frame_stats_.size())) {
-    return NULL;
-  }
-  return &frame_stats_[offset];
-}
-
-void CongestionControl::AckFrame(uint32 frame_id, base::TimeTicks when) {
-  FrameStats* frame_stats = GetFrameStats(last_acked_frame_);
-  while (IsNewerFrameId(frame_id, last_acked_frame_)) {
-    FrameStats* last_frame_stats = frame_stats;
-    last_acked_frame_++;
-    frame_stats = GetFrameStats(last_acked_frame_);
-    DCHECK(frame_stats);
-    frame_stats->ack_time = when;
-    acked_bits_in_history_ += frame_stats->frame_size;
-    dead_time_in_history_ += DeadTime(*last_frame_stats, *frame_stats);
-  }
-}
-
-void CongestionControl::SendFrameToTransport(uint32 frame_id,
-                                             size_t frame_size,
-                                             base::TimeTicks when) {
-  last_encoded_frame_ = frame_id;
-  FrameStats* frame_stats = GetFrameStats(frame_id);
-  DCHECK(frame_stats);
-  frame_stats->frame_size = frame_size;
-  frame_stats->sent_time = when;
-}
-
-base::TimeTicks CongestionControl::EstimatedAckTime(uint32 frame_id,
-                                                    double bitrate) {
-  FrameStats* frame_stats = GetFrameStats(frame_id);
-  DCHECK(frame_stats);
-  if (frame_stats->ack_time.is_null()) {
-    DCHECK(frame_stats->frame_size) << "frame_id: " << frame_id;
-    base::TimeTicks ret = EstimatedSendingTime(frame_id, bitrate);
-    ret += base::TimeDelta::FromSecondsD(frame_stats->frame_size / bitrate);
-    ret += rtt_;
-    base::TimeTicks now = clock_->NowTicks();
-    if (ret < now) {
-      // This is a little counter-intuitive, but it seems to work.
-      // Basically, when we estimate that the ACK should have already happened,
-      // we figure out how long ago it should have happened and guess that the
-      // ACK will happen half of that time in the future. This will cause some
-      // over-estimation when acks are late, which is actually what we want.
-      return now + (now - ret) / 2;
-    } else {
-      return ret;
-    }
-  } else {
-    return frame_stats->ack_time;
-  }
-}
-
-base::TimeTicks CongestionControl::EstimatedSendingTime(uint32 frame_id,
-                                                        double bitrate) {
-  FrameStats* frame_stats = GetFrameStats(frame_id);
-  DCHECK(frame_stats);
-  base::TimeTicks ret = EstimatedAckTime(frame_id - 1, bitrate) - rtt_;
-  if (frame_stats->sent_time.is_null()) {
-    // Not sent yet, but we can't start sending it in the past.
-    return std::max(ret, clock_->NowTicks());
-  } else {
-    return std::max(ret, frame_stats->sent_time);
-  }
-}
-
-uint32 CongestionControl::GetBitrate(base::TimeTicks playout_time,
-                                     base::TimeDelta playout_delay) {
-  double safe_bitrate = CalculateSafeBitrate();
-  // Estimate when we might start sending the next frame.
-  base::TimeDelta time_to_catch_up =
-      playout_time -
-      EstimatedSendingTime(last_encoded_frame_ + 1, safe_bitrate);
-
-  double empty_buffer_fraction =
-      time_to_catch_up.InSecondsF() / playout_delay.InSecondsF();
-  empty_buffer_fraction = std::min(empty_buffer_fraction, 1.0);
-  empty_buffer_fraction = std::max(empty_buffer_fraction, 0.0);
-
-  uint32 bits_per_second = static_cast<uint32>(
-      safe_bitrate * empty_buffer_fraction / kTargetEmptyBufferFraction);
-  VLOG(3) << " FBR:" << (bits_per_second / 1E6)
-          << " EBF:" << empty_buffer_fraction
-          << " SBR:" << (safe_bitrate / 1E6);
-  bits_per_second = std::max(bits_per_second, min_bitrate_configured_);
-  bits_per_second = std::min(bits_per_second, max_bitrate_configured_);
-  return bits_per_second;
-}
-
-}  // namespace cast
-}  // namespace media