// Copyright 2021 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chromecast/media/audio/rate_adjuster.h"
#include <algorithm>
#include <cmath>
#include <utility>
#include "base/check.h"
namespace chromecast {
namespace media {
namespace {
constexpr auto kMaxRateChangeInterval = base::Minutes(5);
} // namespace
RateAdjuster::RateAdjuster(const Config& config,
RateChangeCallback change_clock_rate,
double current_clock_rate)
: config_(config),
change_clock_rate_(std::move(change_clock_rate)),
linear_error_(config_.linear_regression_window.InMicroseconds()),
current_clock_rate_(current_clock_rate) {
DCHECK(change_clock_rate_);
}
RateAdjuster::~RateAdjuster() = default;
void RateAdjuster::Reserve(int count) {
linear_error_.Reserve(count);
}
void RateAdjuster::Reset() {
linear_error_.Reset();
initialized_ = false;
clock_rate_start_timestamp_ = 0;
initial_timestamp_ = 0;
clock_rate_error_base_ = 0.0;
}
void RateAdjuster::AddError(int64_t error, int64_t timestamp) {
if (!initialized_) {
clock_rate_start_timestamp_ = timestamp;
clock_rate_error_base_ = 0.0;
initial_timestamp_ = timestamp;
initialized_ = true;
}
int64_t x = timestamp - initial_timestamp_;
// Error is positive if actions are happening too late.
// We perform |current_clock_rate_| seconds of actions per second of actual
// time. We want to run a linear regression on how the error is changing over
// time, if we ignore the effects of any previous clock rate changes. To do
// this, we correct the error value to what it would have been if we had never
// adjusted the clock rate.
// In the last N seconds, if the clock rate was 1.0 we would have performed
// (1.0 - clock_rate) * N more seconds of actions, so the current action would
// have occurred that much sooner (reducing its error by that amount). We
// also need to take into account the previous "expected error" (due to clock
// rate changes) at the point when we last changed the clock rate. The
// expected error now is the previous expected error, plus the change due to
// the clock rate of (1.0 - clock_rate) * N seconds.
int64_t time_at_current_clock_rate = timestamp - clock_rate_start_timestamp_;
double correction = clock_rate_error_base_ +
(1.0 - current_clock_rate_) * time_at_current_clock_rate;
int64_t corrected_error = error - correction;
linear_error_.AddSample(x, corrected_error, 1.0);
if (time_at_current_clock_rate <
config_.rate_change_interval.InMicroseconds()) {
// Don't change clock rate too frequently.
return;
}
int64_t offset;
double slope;
double e;
if (!linear_error_.EstimateY(x, &offset, &e) ||
!linear_error_.EstimateSlope(&slope, &e)) {
return;
}
// Get the smoothed error (linear regression estimate) at the current time,
// translated back into actual error.
int64_t smoothed_error = offset + correction;
// If slope is positive, a clock rate of 1.0 is too slow (actions are
// occurring progressively later than desired). We wanted to do slope*N
// seconds actions during N seconds than would have been done at rate 1.0.
// Therefore the actual clock rate should be (1.0 + slope).
// However, we also want to correct for any existing offset. We correct so
// that the error should reduce to 0 by the next rate change interval;
// however the rate change is capped to prevent very fast slewing.
double offset_correction =
static_cast<double>(smoothed_error) /
(config_.rate_change_interval.InMicroseconds() * 2);
if (std::abs(smoothed_error) < config_.max_ignored_current_error) {
// Offset is small enough that we can ignore it, but still correct a little
// bit to avoid bouncing in and out of the ignored region.
offset_correction = offset_correction / 4;
}
offset_correction =
std::clamp(offset_correction, -config_.max_current_error_correction,
config_.max_current_error_correction);
double new_rate = (1.0 + slope) + offset_correction;
// Only change the clock rate if the difference between the desired rate and
// the current rate is larger than the minimum change.
if (std::fabs(new_rate - current_clock_rate_) > config_.min_rate_change ||
time_at_current_clock_rate > kMaxRateChangeInterval.InMicroseconds()) {
current_clock_rate_ =
change_clock_rate_.Run(new_rate, slope, smoothed_error);
clock_rate_start_timestamp_ = timestamp;
clock_rate_error_base_ = correction;
}
}
} // namespace media
} // namespace chromecast
Codebase Browser
chromium