X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=futatabi%2Fplayer.cpp;h=f342ac57bb60bf8acf682bcff86b02c86dc99314;hb=4a9e97065dade428e373a83618bc973cd93cbe52;hp=b2b7ac26764995faaffc0a04dd7052bf3c4a0f03;hpb=f1cddd2fcaf4d166b31c7d28e4ccd2201c5508f2;p=nageru diff --git a/futatabi/player.cpp b/futatabi/player.cpp index b2b7ac2..f342ac5 100644 --- a/futatabi/player.cpp +++ b/futatabi/player.cpp @@ -1,13 +1,13 @@ #include "player.h" #include "clip_list.h" -#include "shared/context.h" #include "defs.h" -#include "shared/ffmpeg_raii.h" #include "flags.h" #include "frame_on_disk.h" -#include "shared/httpd.h" #include "jpeg_frame_view.h" +#include "shared/context.h" +#include "shared/ffmpeg_raii.h" +#include "shared/httpd.h" #include "shared/metrics.h" #include "shared/mux.h" #include "shared/timebase.h" @@ -27,7 +27,7 @@ using namespace std::chrono; extern HTTPD *global_httpd; -void Player::thread_func(Player::StreamOutput stream_output, AVFormatContext *file_avctx) +void Player::thread_func(AVFormatContext *file_avctx) { pthread_setname_np(pthread_self(), "Player"); @@ -48,55 +48,72 @@ void Player::thread_func(Player::StreamOutput stream_output, AVFormatContext *fi check_error(); - int64_t pts = 0; - Clip next_clip; - size_t next_clip_idx = size_t(-1); - bool got_next_clip = false; - double next_clip_fade_time = -1.0; - while (!should_quit) { -wait_for_clip: - bool clip_ready; - steady_clock::time_point before_sleep = steady_clock::now(); + play_playlist_once(); + } +} - // Wait until we're supposed to play something. - { - unique_lock lock(queue_state_mu); - clip_ready = new_clip_changed.wait_for(lock, milliseconds(100), [this] { - return should_quit || (new_clip_ready && current_clip.pts_in != -1); - }); - if (should_quit) { - return; - } +namespace { + +double calc_progress(const Clip &clip, int64_t pts) +{ + return double(pts - clip.pts_in) / (clip.pts_out - clip.pts_in); +} + +} // namespace + +void Player::play_playlist_once() +{ + vector clip_list; + bool clip_ready; + steady_clock::time_point before_sleep = steady_clock::now(); + + // Wait until we're supposed to play something. + { + unique_lock 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) { new_clip_ready = false; playing = true; + clip_list = move(queued_clip_list); + queued_clip_list.clear(); + assert(!clip_list.empty()); } + } - steady_clock::duration time_slept = steady_clock::now() - before_sleep; - pts += duration_cast>(time_slept).count(); + steady_clock::duration time_slept = steady_clock::now() - before_sleep; + pts += duration_cast>(time_slept).count(); - if (!clip_ready) { - if (video_stream != nullptr) { - ++metric_refresh_frame; - video_stream->schedule_refresh_frame(steady_clock::now(), pts, /*display_func=*/nullptr, QueueSpotHolder()); - } - continue; + if (!clip_ready) { + if (video_stream != nullptr) { + ++metric_refresh_frame; + video_stream->schedule_refresh_frame(steady_clock::now(), pts, /*display_func=*/nullptr, QueueSpotHolder()); } + return; + } - Clip clip; - size_t clip_idx; - unsigned stream_idx; - { - lock_guard lock(mu); - clip = current_clip; - clip_idx = current_clip_idx; - stream_idx = current_stream_idx; - } - steady_clock::time_point origin = steady_clock::now(); // TODO: Add a 100 ms buffer for ramp-up? - int64_t in_pts_origin = clip.pts_in; -got_clip: + steady_clock::time_point origin = steady_clock::now(); // TODO: Add a 100 ms buffer for ramp-up? + int64_t in_pts_origin = clip_list[0].pts_in; + for (size_t clip_idx = 0; clip_idx < clip_list.size(); ++clip_idx) { + const Clip &clip = clip_list[clip_idx]; + const Clip *next_clip = (clip_idx + 1 < clip_list.size()) ? &clip_list[clip_idx + 1] : nullptr; int64_t out_pts_origin = pts; + double next_clip_fade_time = -1.0; + if (next_clip != nullptr) { + double duration_this_clip = double(clip.pts_out - in_pts_origin) / TIMEBASE / clip.speed; + double duration_next_clip = double(next_clip->pts_out - next_clip->pts_in) / TIMEBASE / clip.speed; + next_clip_fade_time = min(min(duration_this_clip, duration_next_clip), clip.fade_time_seconds); + } + + int stream_idx = clip.stream_idx; + // Start playing exactly at a frame. // TODO: Snap secondary (fade-to) clips in the same fashion // so that we don't get jank here). @@ -110,7 +127,6 @@ got_clip: } } - int64_t in_pts_start_next_clip = -1; steady_clock::time_point next_frame_start; for (int frameno = 0; !should_quit; ++frameno) { // Ends when the clip ends. double out_pts = out_pts_origin + TIMEBASE * frameno / global_flags.output_framerate; @@ -126,24 +142,11 @@ got_clip: steady_clock::duration time_behind = steady_clock::now() - next_frame_start; if (stream_output != FILE_STREAM_OUTPUT && time_behind >= milliseconds(200)) { fprintf(stderr, "WARNING: %ld ms behind, dropping a frame (no matter the type).\n", - lrint(1e3 * duration(time_behind).count())); + lrint(1e3 * duration(time_behind).count())); ++metric_dropped_unconditional_frame; continue; } - double time_left_this_clip = double(clip.pts_out - in_pts) / TIMEBASE / clip.speed; - if (!got_next_clip && next_clip_callback != nullptr && time_left_this_clip <= clip.fade_time_seconds) { - // Find the next clip so that we can begin a fade. - tie(next_clip, next_clip_idx) = next_clip_callback(); - if (next_clip.pts_in != -1) { - got_next_clip = true; - - double duration_next_clip = double(next_clip.pts_out - next_clip.pts_in) / TIMEBASE / clip.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 * clip.speed); - } - } - // pts not affected by the swapping below. int64_t in_pts_for_progress = in_pts, in_pts_secondary_for_progress = -1; @@ -151,9 +154,11 @@ got_clip: FrameOnDisk secondary_frame; int secondary_stream_idx = -1; float fade_alpha = 0.0f; - if (got_next_clip && time_left_this_clip <= next_clip_fade_time) { - secondary_stream_idx = next_clip.stream_idx; - int64_t in_pts_secondary = lrint(next_clip.pts_in + (next_clip_fade_time - time_left_this_clip) * TIMEBASE * clip.speed); + double time_left_this_clip = double(clip.pts_out - in_pts) / TIMEBASE / clip.speed; + if (next_clip != nullptr && time_left_this_clip <= next_clip_fade_time) { + // We're in a fade to the next clip. + secondary_stream_idx = next_clip->stream_idx; + int64_t in_pts_secondary = lrint(next_clip->pts_in + (next_clip_fade_time - time_left_this_clip) * TIMEBASE * clip.speed); in_pts_secondary_for_progress = in_pts_secondary; fade_alpha = 1.0f - time_left_this_clip / next_clip_fade_time; @@ -174,14 +179,9 @@ got_clip: if (progress_callback != nullptr) { // NOTE: None of this will take into account any snapping done below. - double played_this_clip = double(in_pts_for_progress - clip.pts_in) / TIMEBASE / clip.speed; - double total_length = double(clip.pts_out - clip.pts_in) / TIMEBASE / clip.speed; - map progress{{ clip_idx, played_this_clip / total_length }}; - - if (got_next_clip && time_left_this_clip <= next_clip_fade_time) { - double played_next_clip = double(in_pts_secondary_for_progress - next_clip.pts_in) / TIMEBASE / next_clip.speed; - double total_next_length = double(next_clip.pts_out - next_clip.pts_in) / TIMEBASE / next_clip.speed; - progress[next_clip_idx] = played_next_clip / total_next_length; + map progress{ { clip_idx, calc_progress(clip, in_pts_for_progress) } }; + if (next_clip != nullptr && time_left_this_clip <= next_clip_fade_time) { + progress[clip_idx + 1] = calc_progress(*next_clip, in_pts_secondary_for_progress); } progress_callback(progress); } @@ -192,16 +192,17 @@ got_clip: break; } + // Wait until we should, or (given buffering) can, output the frame. { unique_lock lock(queue_state_mu); if (video_stream == nullptr) { // No queue, just wait until the right time and then show the frame. - new_clip_changed.wait_until(lock, next_frame_start, [this]{ + new_clip_changed.wait_until(lock, next_frame_start, [this] { return should_quit || new_clip_ready || override_stream_idx != -1; }); - if (should_quit) { - return; - } + if (should_quit) { + return; + } } else { // If the queue is full (which is really the state we'd like to be in), // wait until there's room for one more frame (ie., one was output from @@ -209,7 +210,7 @@ got_clip: // // In this case, we don't sleep until next_frame_start; the displaying is // done by the queue. - new_clip_changed.wait(lock, [this]{ + new_clip_changed.wait(lock, [this] { if (num_queued_frames < max_queued_frames) { return true; } @@ -225,9 +226,9 @@ got_clip: video_stream->clear_queue(); lock.lock(); } - got_next_clip = false; - goto wait_for_clip; + return; } + // Honor if we got an override request for the camera. if (override_stream_idx != -1) { stream_idx = override_stream_idx; override_stream_idx = -1; @@ -235,28 +236,11 @@ got_clip: } } - if (frame_lower.pts == frame_upper.pts || global_flags.interpolation_quality == 0) { - auto display_func = [this, primary_stream_idx, frame_lower, secondary_frame, fade_alpha]{ - if (destination != nullptr) { - destination->setFrame(primary_stream_idx, frame_lower, secondary_frame, fade_alpha); - } - }; - if (video_stream == nullptr) { - display_func(); - } else { - if (secondary_stream_idx == -1) { - ++metric_original_frame; - video_stream->schedule_original_frame( - next_frame_start, pts, display_func, QueueSpotHolder(this), - frame_lower); - } else { - assert(secondary_frame.pts != -1); - ++metric_faded_frame; - video_stream->schedule_faded_frame(next_frame_start, pts, display_func, - QueueSpotHolder(this), frame_lower, - secondary_frame, fade_alpha); - } - } + // If there's nothing to interpolate between, or if interpolation is turned off, + // or we're a preview, then just display the frame. + if (frame_lower.pts == frame_upper.pts || global_flags.interpolation_quality == 0 || video_stream == nullptr) { + display_single_frame(primary_stream_idx, frame_lower, secondary_stream_idx, + secondary_frame, fade_alpha, next_frame_start, /*snapped=*/false); continue; } @@ -267,27 +251,8 @@ got_clip: bool snapped = false; for (FrameOnDisk snap_frame : { frame_lower, frame_upper }) { if (fabs(snap_frame.pts - in_pts) < pts_snap_tolerance) { - auto display_func = [this, primary_stream_idx, snap_frame, secondary_frame, fade_alpha]{ - if (destination != nullptr) { - destination->setFrame(primary_stream_idx, snap_frame, secondary_frame, fade_alpha); - } - }; - if (video_stream == nullptr) { - display_func(); - } else { - if (secondary_stream_idx == -1) { - ++metric_original_snapped_frame; - video_stream->schedule_original_frame( - next_frame_start, pts, display_func, - QueueSpotHolder(this), snap_frame); - } else { - assert(secondary_frame.pts != -1); - ++metric_faded_snapped_frame; - video_stream->schedule_faded_frame( - next_frame_start, pts, display_func, QueueSpotHolder(this), - snap_frame, secondary_frame, fade_alpha); - } - } + display_single_frame(primary_stream_idx, snap_frame, secondary_stream_idx, + secondary_frame, fade_alpha, next_frame_start, /*snapped=*/true); in_pts_origin += snap_frame.pts - in_pts; snapped = true; break; @@ -324,76 +289,83 @@ got_clip: if (stream_output != FILE_STREAM_OUTPUT && time_behind >= milliseconds(100)) { fprintf(stderr, "WARNING: %ld ms behind, dropping an interpolated frame.\n", - lrint(1e3 * duration(time_behind).count())); + lrint(1e3 * duration(time_behind).count())); ++metric_dropped_interpolated_frame; continue; } double alpha = double(in_pts - frame_lower.pts) / (frame_upper.pts - frame_lower.pts); - - if (video_stream == nullptr) { - // Previews don't do any interpolation. - assert(secondary_stream_idx == -1); + auto display_func = [this](shared_ptr frame) { if (destination != nullptr) { - destination->setFrame(primary_stream_idx, frame_lower); + destination->setFrame(frame); } + }; + if (secondary_stream_idx == -1) { + ++metric_interpolated_frame; } else { - auto display_func = [this](shared_ptr frame) { - if (destination != nullptr) { - destination->setFrame(frame); - } - }; - if (secondary_stream_idx == -1) { - ++metric_interpolated_frame; - } else { - ++metric_interpolated_faded_frame; - } - video_stream->schedule_interpolated_frame( - next_frame_start, pts, display_func, QueueSpotHolder(this), - frame_lower, frame_upper, alpha, - secondary_frame, fade_alpha); + ++metric_interpolated_faded_frame; } + video_stream->schedule_interpolated_frame( + next_frame_start, pts, display_func, QueueSpotHolder(this), + frame_lower, frame_upper, alpha, + secondary_frame, fade_alpha); + last_pts_played = in_pts; // Not really needed; only previews use last_pts_played. } + // The clip ended. if (should_quit) { return; } - - // The clip ended. - - // Last-ditch effort to get the next clip (if e.g. the fade time was zero seconds). - if (!got_next_clip && next_clip_callback != nullptr) { - tie(next_clip, next_clip_idx) = next_clip_callback(); - if (next_clip.pts_in != -1) { - got_next_clip = true; - in_pts_start_next_clip = next_clip.pts_in; - } + if (done_callback != nullptr) { + done_callback(); } - // Switch to next clip if we got it. - if (got_next_clip) { - clip = next_clip; - clip_idx = next_clip_idx; - stream_idx = next_clip.stream_idx; // Override is used for previews only, and next_clip is used for live ony. - if (done_callback != nullptr) { - done_callback(); - } - got_next_clip = false; - - // Start the next clip from the point where the fade went out. + // Start the next clip from the point where the fade went out. + if (next_clip != nullptr) { origin = next_frame_start; - in_pts_origin = in_pts_start_next_clip; - goto got_clip; + in_pts_origin = next_clip->pts_in + lrint(next_clip_fade_time * TIMEBASE * clip.speed); } + } - { - unique_lock lock(queue_state_mu); - playing = false; + if (done_callback != nullptr) { + done_callback(); + } +} + +void Player::display_single_frame(int primary_stream_idx, const FrameOnDisk &primary_frame, int secondary_stream_idx, const FrameOnDisk &secondary_frame, double fade_alpha, steady_clock::time_point frame_start, bool snapped) +{ + auto display_func = [this, primary_stream_idx, primary_frame, secondary_frame, fade_alpha] { + if (destination != nullptr) { + destination->setFrame(primary_stream_idx, primary_frame, secondary_frame, fade_alpha); } - if (done_callback != nullptr) { - done_callback(); + }; + if (video_stream == nullptr) { + display_func(); + } else { + if (secondary_stream_idx == -1) { + // NOTE: We could be increasing unused metrics for previews, but that's harmless. + if (snapped) { + ++metric_original_snapped_frame; + } else { + ++metric_original_frame; + } + video_stream->schedule_original_frame( + frame_start, pts, display_func, QueueSpotHolder(this), + primary_frame); + } else { + assert(secondary_frame.pts != -1); + // NOTE: We could be increasing unused metrics for previews, but that's harmless. + if (snapped) { + ++metric_faded_snapped_frame; + } else { + ++metric_faded_frame; + } + video_stream->schedule_faded_frame(frame_start, pts, display_func, + QueueSpotHolder(this), primary_frame, + secondary_frame, fade_alpha); } } + last_pts_played = primary_frame.pts; } // Find the frame immediately before and after this point. @@ -420,20 +392,20 @@ bool Player::find_surrounding_frames(int64_t pts, int stream_idx, FrameOnDisk *f } Player::Player(JPEGFrameView *destination, Player::StreamOutput stream_output, AVFormatContext *file_avctx) - : destination(destination) + : destination(destination), stream_output(stream_output) { - player_thread = thread(&Player::thread_func, this, stream_output, file_avctx); + player_thread = thread(&Player::thread_func, this, file_avctx); if (stream_output == HTTPD_STREAM_OUTPUT) { - global_metrics.add("http_output_frames", {{ "type", "original" }, { "reason", "edge_frame_or_no_interpolation" }}, &metric_original_frame); - global_metrics.add("http_output_frames", {{ "type", "faded" }, { "reason", "edge_frame_or_no_interpolation" }}, &metric_faded_frame); - global_metrics.add("http_output_frames", {{ "type", "original" }, { "reason", "snapped" }}, &metric_original_snapped_frame); - global_metrics.add("http_output_frames", {{ "type", "faded" }, { "reason", "snapped" }}, &metric_faded_snapped_frame); - global_metrics.add("http_output_frames", {{ "type", "interpolated" }}, &metric_interpolated_frame); - global_metrics.add("http_output_frames", {{ "type", "interpolated_faded" }}, &metric_interpolated_faded_frame); - global_metrics.add("http_output_frames", {{ "type", "refresh" }}, &metric_refresh_frame); - global_metrics.add("http_dropped_frames", {{ "type", "interpolated" }}, &metric_dropped_interpolated_frame); - global_metrics.add("http_dropped_frames", {{ "type", "unconditional" }}, &metric_dropped_unconditional_frame); + global_metrics.add("http_output_frames", { { "type", "original" }, { "reason", "edge_frame_or_no_interpolation" } }, &metric_original_frame); + global_metrics.add("http_output_frames", { { "type", "faded" }, { "reason", "edge_frame_or_no_interpolation" } }, &metric_faded_frame); + global_metrics.add("http_output_frames", { { "type", "original" }, { "reason", "snapped" } }, &metric_original_snapped_frame); + global_metrics.add("http_output_frames", { { "type", "faded" }, { "reason", "snapped" } }, &metric_faded_snapped_frame); + global_metrics.add("http_output_frames", { { "type", "interpolated" } }, &metric_interpolated_frame); + global_metrics.add("http_output_frames", { { "type", "interpolated_faded" } }, &metric_interpolated_faded_frame); + global_metrics.add("http_output_frames", { { "type", "refresh" } }, &metric_refresh_frame); + global_metrics.add("http_dropped_frames", { { "type", "interpolated" } }, &metric_dropped_interpolated_frame); + global_metrics.add("http_dropped_frames", { { "type", "unconditional" } }, &metric_dropped_unconditional_frame); } } @@ -447,59 +419,47 @@ Player::~Player() player_thread.join(); } -void Player::play_clip(const Clip &clip, size_t clip_idx, unsigned stream_idx) +void Player::play(const vector &clips) { - { - lock_guard lock(mu); - current_clip = clip; - current_stream_idx = stream_idx; - current_clip_idx = clip_idx; - } - - { - lock_guard lock(queue_state_mu); - new_clip_ready = true; - override_stream_idx = -1; - new_clip_changed.notify_all(); - } + lock_guard lock(queue_state_mu); + new_clip_ready = true; + queued_clip_list = clips; + override_stream_idx = -1; + new_clip_changed.notify_all(); } void Player::override_angle(unsigned stream_idx) { + int64_t last_pts; + // Corner case: If a new clip is waiting to be played, change its stream and then we're done. { - unique_lock lock(queue_state_mu); + lock_guard lock(queue_state_mu); if (new_clip_ready) { - lock_guard lock2(mu); - current_stream_idx = stream_idx; + assert(queued_clip_list.size() == 1); + queued_clip_list[0].stream_idx = stream_idx; return; } - } - // If we are playing a clip, set override_stream_idx, and the player thread will - // pick it up and change its internal index. - { - unique_lock lock(queue_state_mu); + // If we are playing a clip, set override_stream_idx, and the player thread will + // pick it up and change its internal index. if (playing) { override_stream_idx = stream_idx; new_clip_changed.notify_all(); + return; } - } - // OK, so we're standing still, presumably at the end of a clip. - // Look at the current pts_out (if it exists), and show the closest - // thing we've got. - int64_t pts_out; - { - lock_guard lock(mu); - if (current_clip.pts_out < 0) { + // OK, so we're standing still, presumably at the end of a clip. + // Look at the last frame played (if it exists), and show the closest + // thing we've got. + if (last_pts_played < 0) { return; } - pts_out = current_clip.pts_out; + last_pts = last_pts_played; } lock_guard lock(frame_mu); - auto it = find_first_frame_at_or_after(frames[stream_idx], pts_out); + auto it = find_first_frame_at_or_after(frames[stream_idx], last_pts); if (it == frames[stream_idx].end()) { return; } @@ -508,13 +468,13 @@ void Player::override_angle(unsigned stream_idx) void Player::take_queue_spot() { - unique_lock lock(queue_state_mu); + lock_guard lock(queue_state_mu); ++num_queued_frames; } void Player::release_queue_spot() { - unique_lock lock(queue_state_mu); + lock_guard lock(queue_state_mu); assert(num_queued_frames > 0); --num_queued_frames; new_clip_changed.notify_all();