TimelineTracker(double master_speed, int64_t out_pts_origin)
: master_speed(master_speed), last_out_pts(out_pts_origin) {
origin.out_pts = out_pts_origin;
+ master_speed_ease_target = master_speed; // Keeps GCC happy.
}
void new_clip(steady_clock::time_point wallclock_origin, const Clip *clip, int64_t start_pts_offset)
int64_t get_in_pts_origin() const { return origin.in_pts; }
bool playing_at_normal_speed() const {
+ if (in_easing) return false;
+
const double effective_speed = clip->speed * master_speed;
return effective_speed >= 0.999 && effective_speed <= 1.001;
}
void change_master_speed(double new_master_speed, Instant now);
+ // Instead of changing the speed instantly, change it over the course of
+ // about 200 ms. This is a simple linear ramp; I tried various forms of
+ // Bézier curves for more elegant/dramatic changing, but it seemed linear
+ // looked just as good in practical video.
+ void start_easing(double new_master_speed, Instant now);
+
private:
+ // Find out how far we are into the easing curve (0..1).
+ // We use this to adjust the input pts.
+ double find_ease_t(double out_pts) const;
+ double easing_out_pts_adjustment(double out_pts) const;
+
double master_speed;
const Clip *clip = nullptr;
Instant origin;
int64_t last_out_pts;
+
+ // If easing between new and old master speeds.
+ bool in_easing = false;
+ int64_t ease_started_pts = 0;
+ double master_speed_ease_target;
+ static constexpr int64_t ease_length_out_pts = TIMEBASE / 5; // 200 ms.
};
TimelineTracker::Instant TimelineTracker::advance_to_frame(int64_t frameno)
{
Instant ret;
double in_pts_double = origin.in_pts + TIMEBASE * clip->speed * (frameno - origin.frameno) * master_speed / global_flags.output_framerate;
- ret.in_pts = lrint(in_pts_double);
double out_pts_double = origin.out_pts + TIMEBASE * (frameno - origin.frameno) / global_flags.output_framerate;
+
+ if (in_easing) {
+ double in_pts_adjustment = easing_out_pts_adjustment(out_pts_double) * clip->speed;
+ in_pts_double += in_pts_adjustment;
+ }
+
+ ret.in_pts = lrint(in_pts_double);
ret.out_pts = lrint(out_pts_double);
ret.wallclock_time = origin.wallclock_time + microseconds(lrint((out_pts_double - origin.out_pts) * 1e6 / TIMEBASE));
ret.frameno = frameno;
last_out_pts = ret.out_pts;
+ if (in_easing && ret.out_pts >= ease_started_pts + ease_length_out_pts) {
+ // We have ended easing. Add what we need for the entire easing period,
+ // then _actually_ change the speed as we go back into normal mode.
+ origin.out_pts += easing_out_pts_adjustment(out_pts_double);
+ change_master_speed(master_speed_ease_target, ret);
+ in_easing = false;
+ }
+
return ret;
}
origin = now;
}
+void TimelineTracker::start_easing(double new_master_speed, Instant now)
+{
+ if (in_easing) {
+ // Apply whatever we managed to complete of the previous easing.
+ origin.out_pts += easing_out_pts_adjustment(now.out_pts);
+ double reached_speed = master_speed + (master_speed_ease_target - master_speed) * find_ease_t(now.out_pts);
+ change_master_speed(reached_speed, now);
+ }
+ in_easing = true;
+ ease_started_pts = now.out_pts;
+ master_speed_ease_target = new_master_speed;
+}
+
+double TimelineTracker::find_ease_t(double out_pts) const
+{
+ return (out_pts - ease_started_pts) / double(ease_length_out_pts);
+}
+
+double TimelineTracker::easing_out_pts_adjustment(double out_pts) const
+{
+ double t = find_ease_t(out_pts);
+ double area_factor = (master_speed_ease_target - master_speed) * ease_length_out_pts;
+ double val = 0.5 * min(t, 1.0) * min(t, 1.0) * area_factor;
+ if (t > 1.0) {
+ val += area_factor * (t - 1.0);
+ }
+ return val;
+}
+
} // namespace
void Player::play_playlist_once()
float new_master_speed = change_master_speed.exchange(0.0f / 0.0f);
if (!std::isnan(new_master_speed)) {
- timeline.change_master_speed(new_master_speed, instant);
+ timeline.start_easing(new_master_speed, instant);
}
if (should_skip_to_next.exchange(false)) { // Test and clear.