+double calc_progress(const Clip &clip, int64_t pts)
+{
+ return double(pts - clip.pts_in) / (clip.pts_out - clip.pts_in);
+}
+
+void do_splice(const vector<ClipWithID> &new_list, size_t playing_index1, ssize_t playing_index2, vector<ClipWithID> *old_list)
+{
+ assert(playing_index2 == -1 || size_t(playing_index2) == playing_index1 + 1);
+
+ // First see if we can do the simple thing; find an element in the new
+ // list that we are already playing, which will serve as our splice point.
+ int splice_start_new_list = -1;
+ for (size_t clip_idx = 0; clip_idx < new_list.size(); ++clip_idx) {
+ if (new_list[clip_idx].id == (*old_list)[playing_index1].id) {
+ splice_start_new_list = clip_idx + 1;
+ } else if (playing_index2 != -1 && new_list[clip_idx].id == (*old_list)[playing_index2].id) {
+ splice_start_new_list = clip_idx + 1;
+ }
+ }
+ if (splice_start_new_list == -1) {
+ // OK, so the playing items are no longer in the new list. Most likely,
+ // that means we deleted some range that included them. But the ones
+ // before should stay put -- and we don't want to play them. So find
+ // the ones that we've already played, and ignore them. Hopefully,
+ // they're contiguous; the last one that's not seen will be our cut point.
+ //
+ // Keeping track of the playlist range explicitly in the UI would remove
+ // the need for these heuristics, but it would probably also mean we'd
+ // have to lock the playing clip, which sounds annoying.
+ unordered_map<uint64_t, size_t> played_ids;
+ for (size_t clip_idx = 0; clip_idx < playing_index1; ++old_list) {
+ played_ids.emplace((*old_list)[clip_idx].id, clip_idx);
+ }
+ for (size_t clip_idx = 0; clip_idx < new_list.size(); ++clip_idx) {
+ if (played_ids.count(new_list[clip_idx].id)) {
+ splice_start_new_list = clip_idx + 1;
+ }
+ }
+
+ if (splice_start_new_list == -1) {
+ // OK, we didn't find any matches; the lists are totally distinct.
+ // So probably the entire thing was deleted; leave it alone.
+ return;
+ }
+ }
+
+ size_t splice_start_old_list = ((playing_index2 == -1) ? playing_index1 : playing_index2) + 1;
+ old_list->erase(old_list->begin() + splice_start_old_list, old_list->end());
+ old_list->insert(old_list->end(), new_list.begin() + splice_start_new_list, new_list.end());
+}
+
+} // namespace
+
+void Player::play_playlist_once()
+{
+ vector<ClipWithID> clip_list;
+ bool clip_ready;
+ steady_clock::time_point before_sleep = steady_clock::now();
+ string pause_status;
+ float master_speed = start_master_speed;
+
+ // Wait until we're supposed to play something.
+ {
+ unique_lock<mutex> lock(queue_state_mu);
+ playing = false;
+ clip_ready = new_clip_changed.wait_for(lock, milliseconds(100), [this] {
+ return should_quit || new_clip_ready;
+ });
+ if (should_quit) {
+ return;
+ }
+ if (clip_ready) {