Assorted clang-format fixes (not complete).

[nageru] / player.cpp

diff --git a/player.cpp b/player.cpp
index 2261ee43dff929f482aa0b2a6d52ec46dafbdb14..dc619f43b6df0fc7d2a154b4d780d986b4f1b073 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
@@ -61,7 +60,7 @@ void Player::thread_func(bool also_output_to_stream)
                // 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;
@@ -85,12 +84,14 @@ void Player::thread_func(bool also_output_to_stream)
                        clip = current_clip;
                        stream_idx = current_stream_idx;
                }
-got_clip:
                steady_clock::time_point origin = steady_clock::now();
                int64_t in_pts_origin = clip.pts_in;
+got_clip:
                int64_t out_pts_origin = pts;
 
                // Start playing exactly at a frame.
+               // TODO: Snap secondary (fade-to) clips in the same fashion
+               // so that we don't get jank here).
                {
                        lock_guard<mutex> lock(frame_mu);
 
@@ -106,6 +107,7 @@ got_clip:
                // TODO: Lock to a rational multiple of the frame rate if possible.
                double speed = 0.5;
 
+               int64_t in_pts_start_next_clip = -1;
                for (int frameno = 0; ; ++frameno) {  // Ends when the clip ends.
                        double out_pts = out_pts_origin + TIMEBASE * frameno / output_framerate;
                        steady_clock::time_point next_frame_start =
@@ -129,6 +131,7 @@ got_clip:
 
                                        double duration_next_clip = (next_clip.pts_out - next_clip.pts_in) / TIMEBASE / speed;
                                        next_clip_fade_time = std::min(time_left_this_clip, duration_next_clip);
+                                       in_pts_start_next_clip = next_clip.pts_in + lrint(next_clip_fade_time * TIMEBASE * speed);
                                }
                        }
 
@@ -149,8 +152,9 @@ got_clip:
 
                        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_stream_idx, &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) {
                                        secondary_pts = in_pts_lower;
                                } else {
@@ -199,6 +203,7 @@ got_clip:
 
                        // Snap to input frame: If we can do so with less than 1% jitter
                        // (ie., move less than 1% of an _output_ frame), do so.
+                       // TODO: Snap secondary (fade-to) clips in the same fashion.
                        bool snapped = false;
                        for (int64_t snap_pts : { in_pts_lower, in_pts_upper }) {
                                double snap_pts_as_frameno = (snap_pts - in_pts_origin) * output_framerate / TIMEBASE / speed;
@@ -231,7 +236,7 @@ got_clip:
                        if (video_stream == nullptr) {
                                // Previews don't do any interpolation.
                                assert(secondary_stream_idx == -1);
-                               destination->setFrame(primary_stream_idx, in_pts_lower, /*interpolated=*/false, fade_alpha);
+                               destination->setFrame(primary_stream_idx, in_pts_lower, /*interpolated=*/false);
                        } else {
                                // Calculate the interpolated frame. When it's done, the destination
                                // will be unblocked.
@@ -247,6 +252,7 @@ got_clip:
                        next_clip = next_clip_callback();
                        if (next_clip.pts_in != -1) {
                                got_next_clip = true;
+                               in_pts_start_next_clip = next_clip.pts_in;
                        }
                }
 
@@ -258,6 +264,10 @@ got_clip:
                                done_callback();
                        }
                        got_next_clip = false;
+
+                       // Start the next clip from the point where the fade went out.
+                       origin = steady_clock::now();
+                       in_pts_origin = in_pts_start_next_clip;
                        goto got_clip;
                }
 
@@ -320,7 +330,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) {
@@ -351,7 +361,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()) {