X-Git-Url: https://git.sesse.net/?p=nageru;a=blobdiff_plain;f=futatabi%2Fplayer.cpp;fp=futatabi%2Fplayer.cpp;h=982091d88595f32ee20c512f561c624c95bcac35;hp=d168a9dfc051b76339fccbabc7c38dc2acf0ac12;hb=10343a951dc058a6706c0c2158bbc06544ee1cd9;hpb=8919e39eca6caa673bb7cde70dbd34fd1e484010

diff --git a/futatabi/player.cpp b/futatabi/player.cpp
index d168a9d..982091d 100644
--- a/futatabi/player.cpp
+++ b/futatabi/player.cpp
@@ -125,6 +125,7 @@ public:
 	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)
@@ -141,6 +142,8 @@ public:
 
 	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;
 	}
@@ -151,25 +154,56 @@ public:
 
 	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;
 }
 
@@ -182,6 +216,35 @@ void TimelineTracker::change_master_speed(double new_master_speed, Instant now)
 	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()
@@ -272,7 +335,7 @@ 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.