X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;ds=sidebyside;f=futatabi%2Fplayer.cpp;h=da63f10647ab58f67f5c49ec194860a5d35b6580;hb=5ec5103f6c772770d0d2ebf1b7be758fe538a65b;hp=b2b7ac26764995faaffc0a04dd7052bf3c4a0f03;hpb=f1cddd2fcaf4d166b31c7d28e4ccd2201c5508f2;p=nageru diff --git a/futatabi/player.cpp b/futatabi/player.cpp index b2b7ac2..da63f10 100644 --- a/futatabi/player.cpp +++ b/futatabi/player.cpp @@ -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,63 @@ 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; - } +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 +118,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; @@ -131,18 +138,6 @@ got_clip: 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 +146,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; @@ -178,10 +175,10 @@ got_clip: 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; + if (next_clip != nullptr && 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[clip_idx + 1] = played_next_clip / total_next_length; } progress_callback(progress); } @@ -192,6 +189,7 @@ got_clip: break; } + // Wait until we should, or (given buffering) can, output the frame. { unique_lock lock(queue_state_mu); if (video_stream == nullptr) { @@ -199,9 +197,9 @@ got_clip: 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 @@ -225,9 +223,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; @@ -257,6 +255,7 @@ got_clip: secondary_frame, fade_alpha); } } + last_pts_played = frame_lower.pts; continue; } @@ -290,6 +289,7 @@ got_clip: } in_pts_origin += snap_frame.pts - in_pts; snapped = true; + last_pts_played = snap_frame.pts; break; } } @@ -313,7 +313,7 @@ got_clip: // decorrelated with no common factor, of course (e.g. 12.345 → 34.567, which we should // really never see in practice). for (double fraction : { 1.0 / 2.0, 1.0 / 3.0, 2.0 / 3.0, 1.0 / 4.0, 3.0 / 4.0, - 1.0 / 5.0, 2.0 / 5.0, 3.0 / 5.0, 4.0 / 5.0 }) { + 1.0 / 5.0, 2.0 / 5.0, 3.0 / 5.0, 4.0 / 5.0 }) { double subsnap_pts = frame_lower.pts + fraction * (frame_upper.pts - frame_lower.pts); if (fabs(subsnap_pts - in_pts) < pts_snap_tolerance) { in_pts_origin += lrint(subsnap_pts) - in_pts; @@ -337,6 +337,7 @@ got_clip: if (destination != nullptr) { destination->setFrame(primary_stream_idx, frame_lower); } + last_pts_played = frame_lower.pts; } else { auto display_func = [this](shared_ptr frame) { if (destination != nullptr) { @@ -352,47 +353,27 @@ got_clip: 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(); - } + if (done_callback != nullptr) { + done_callback(); } } @@ -420,9 +401,9 @@ 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); @@ -447,59 +428,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 +477,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();