Fix some issues that happened if we tried to play while already playing.

[nageru] / player.cpp

diff --git a/player.cpp b/player.cpp
index b3cc76997e74b6e39f632088509315d31d64fdd9..fa4ea47d8615f72fcf48c7f863865f6760eba4f4 100644 (file)
--- a/player.cpp
+++ b/player.cpp
@@ -1,13 +1,4 @@
-#include <algorithm>
-#include <chrono>
-#include <condition_variable>
-#include <mutex>
-#include <thread>
-#include <vector>
-
-#include <stdio.h>
-
-#include <movit/util.h>
+#include "player.h"
 
 #include "clip_list.h"
 #include "context.h"
@@ -16,10 +7,18 @@
 #include "httpd.h"
 #include "jpeg_frame_view.h"
 #include "mux.h"
-#include "player.h"
 #include "timebase.h"
 #include "video_stream.h"
 
+#include <algorithm>
+#include <chrono>
+#include <condition_variable>
+#include <movit/util.h>
+#include <mutex>
+#include <stdio.h>
+#include <thread>
+#include <vector>
+
 using namespace std;
 using namespace std::chrono;
 
@@ -45,7 +44,7 @@ void Player::thread_func(bool also_output_to_stream)
                video_stream.reset(new VideoStream);
                video_stream->start();
        }
-       
+
        check_error();
 
        constexpr double output_framerate = 60000.0 / 1001.0;  // FIXME: make configurable
@@ -55,13 +54,14 @@ void Player::thread_func(bool also_output_to_stream)
        double next_clip_fade_time = -1.0;
 
        for ( ;; ) {
+wait_for_clip:
                bool clip_ready;
                steady_clock::time_point before_sleep = steady_clock::now();
 
                // Wait until we're supposed to play something.
                {
                        unique_lock<mutex> lock(queue_state_mu);
-                       clip_ready = new_clip_changed.wait_for(lock, milliseconds(100), [this]{
+                       clip_ready = new_clip_changed.wait_for(lock, milliseconds(100), [this] {
                                return new_clip_ready && current_clip.pts_in != -1;
                        });
                        new_clip_ready = false;
@@ -116,6 +116,10 @@ got_clip:
                        int64_t in_pts = lrint(in_pts_origin + TIMEBASE * frameno * speed / output_framerate);
                        pts = lrint(out_pts);
 
+                       if (in_pts >= clip.pts_out) {
+                               break;
+                       }
+
                        steady_clock::duration time_behind = steady_clock::now() - next_frame_start;
                        if (time_behind >= milliseconds(200)) {
                                fprintf(stderr, "WARNING: %ld ms behind, dropping a frame (no matter the type).\n",
@@ -138,22 +142,22 @@ got_clip:
 
                        int primary_stream_idx = stream_idx;
                        int secondary_stream_idx = -1;
+                       int64_t secondary_pts = -1;
+                       int64_t in_pts_secondary = -1;
                        float fade_alpha = 0.0f;
                        if (got_next_clip) {
                                secondary_stream_idx = next_clip.stream_idx;
+                               in_pts_secondary = lrint(next_clip.pts_in + (next_clip_fade_time - time_left_this_clip) * TIMEBASE * speed);
                                fade_alpha = 1.0f - time_left_this_clip / next_clip_fade_time;
 
                                // If more than half-way through the fade, interpolate the next clip
                                // instead of the current one, since it's more visible.
                                if (fade_alpha >= 0.5f) {
                                        swap(primary_stream_idx, secondary_stream_idx);
+                                       swap(in_pts, in_pts_secondary);
                                        fade_alpha = 1.0f - fade_alpha;
                                }
-                       }
 
-                       int64_t secondary_pts = -1;
-                       if (got_next_clip) {
-                               int64_t in_pts_secondary = lrint(next_clip.pts_in + TIMEBASE * frameno * speed / output_framerate);
                                int64_t in_pts_lower, in_pts_upper;
                                bool ok = find_surrounding_frames(in_pts_secondary, secondary_stream_idx, &in_pts_lower, &in_pts_upper);
                                if (ok) {
@@ -172,7 +176,7 @@ got_clip:
 
                        int64_t in_pts_lower, in_pts_upper;
                        bool ok = find_surrounding_frames(in_pts, primary_stream_idx, &in_pts_lower, &in_pts_upper);
-                       if (!ok || in_pts_upper >= clip.pts_out) {
+                       if (!ok) {
                                break;
                        }
 
@@ -182,7 +186,9 @@ got_clip:
                                new_clip_changed.wait_until(lock, next_frame_start, [this]{
                                        return new_clip_ready || override_stream_idx != -1;
                                });
-                               if (new_clip_ready) break;
+                               if (new_clip_ready) {
+                                       goto wait_for_clip;
+                               }
                                if (override_stream_idx != -1) {
                                        stream_idx = override_stream_idx;
                                        override_stream_idx = -1;
@@ -331,7 +337,7 @@ void Player::play_clip(const Clip &clip, unsigned stream_idx)
 
 void Player::override_angle(unsigned stream_idx)
 {
-       // Corner case: If a new clip is waiting to be played, change its stream and then we're done. 
+       // Corner case: If a new clip is waiting to be played, change its stream and then we're done.
        {
                unique_lock<mutex> lock(queue_state_mu);
                if (new_clip_ready) {
@@ -362,7 +368,7 @@ void Player::override_angle(unsigned stream_idx)
                }
                pts_out = current_clip.pts_out;
        }
-                       
+
        lock_guard<mutex> lock(frame_mu);
        auto it = upper_bound(frames[stream_idx].begin(), frames[stream_idx].end(), pts_out);
        if (it == frames[stream_idx].end()) {