+// Keeps track of the various timelines (wall clock time, output pts,
+// position in the clip we are playing). Generally we keep an origin
+// and assume we increase linearly from there; the intention is to
+// avoid getting compounded accuracy errors, although with double,
+// that is perhaps overkill. (Whenever we break the linear assumption,
+// we need to reset said origin.)
+class TimelineTracker
+{
+public:
+ struct Instant {
+ steady_clock::time_point wallclock_time;
+ int64_t in_pts;
+ int64_t out_pts;
+ int64_t frameno;
+ };
+
+ 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;
+ }
+
+ void new_clip(steady_clock::time_point wallclock_origin, const Clip *clip, int64_t start_pts_offset)
+ {
+ this->clip = clip;
+ origin.wallclock_time = wallclock_origin;
+ origin.in_pts = clip->pts_in + start_pts_offset;
+ origin.out_pts = last_out_pts;
+ origin.frameno = 0;
+ }
+
+ // Returns the current time for said frame.
+ Instant advance_to_frame(int64_t frameno);
+
+ int64_t get_in_pts_origin() const { return origin.in_pts; }
+ bool playing_at_normal_speed() const {
+ const double effective_speed = clip->speed * master_speed;
+ return effective_speed >= 0.999 && effective_speed <= 1.001;
+ }
+
+ void snap_by(int64_t offset) {
+ origin.in_pts += offset;
+ }
+
+ void change_master_speed(double new_master_speed, Instant now);
+
+private:
+ double master_speed;
+ const Clip *clip = nullptr;
+ Instant origin;
+ int64_t last_out_pts;
+};
+
+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;
+ 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;
+
+ return ret;
+}
+
+void TimelineTracker::change_master_speed(double new_master_speed, Instant now)
+{
+ master_speed = new_master_speed;
+
+ // Reset the origins, since the calculations depend on linear interpolation
+ // based on the master speed.
+ origin = now;
+}
+