X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=futatabi%2Fplayer.h;h=77fb9e29b485a58ffbfbfc37273c9c9ce8e22a52;hb=refs%2Fheads%2Fmaster;hp=92b6eea5e257136e27cb700c533867460e91a7d3;hpb=5ec5103f6c772770d0d2ebf1b7be758fe538a65b;p=nageru diff --git a/futatabi/player.h b/futatabi/player.h index 92b6eea..77fb9e2 100644 --- a/futatabi/player.h +++ b/futatabi/player.h @@ -4,6 +4,7 @@ #include "clip_list.h" #include "frame_on_disk.h" #include "queue_spot_holder.h" +#include "shared/metrics.h" extern "C" { #include @@ -20,7 +21,10 @@ class VideoStream; class QSurface; class QSurfaceFormat; -double compute_time_left(const std::vector &clips, const std::map &progress); +struct TimeRemaining { + size_t num_infinite; + double t; +}; class Player : public QueueInterface { public: @@ -32,9 +36,48 @@ public: Player(JPEGFrameView *destination, StreamOutput stream_output, AVFormatContext *file_avctx = nullptr); ~Player(); - void play(const std::vector &clips); + void play(const Clip &clip) + { + play({ ClipWithID{ clip, 0 } }); + } + void play(const std::vector &clips); void override_angle(unsigned stream_idx); // Assumes one-clip playlist only. + // Replace the part of the playlist that we haven't started playing yet + // (ie., from the point immediately after the last current playing clip + // and to the end) with the given one. + // + // E.g., if we have the playlist A, B, C, D, E, F, we're currently in a fade + // from B to C and run splice_play() with the list G, C, H, I, the resulting + // list will be A, B, C, H, I. (If the new list doesn't contain B nor C, + // there will be some heuristics.) Note that we always compare on ID only; + // changes will be ignored for the purposes of setting the split point, + // although the newly-spliced entries will of course get the new in/out points + // etc., which is the main reason for going through this exercise in the first + // place. + // + // If nothing is playing, the call will be ignored. + void splice_play(const std::vector &clips); + + // Set the status string that will be used for the video stream's status subtitles + // whenever we are not playing anything. + void set_pause_status(const std::string &status) + { + std::lock_guard lock(queue_state_mu); + pause_status = status; + } + + void skip_to_next() + { + should_skip_to_next = true; + } + + void set_master_speed(float speed) + { + start_master_speed = speed; + change_master_speed = speed; + } + // Not thread-safe to set concurrently with playing. // Will be called back from the player thread. using done_callback_func = std::function; @@ -42,8 +85,8 @@ public: // Not thread-safe to set concurrently with playing. // Will be called back from the player thread. - // The keys in the given map are indexes in the vector given to play(). - using progress_callback_func = std::function &progress)>; + // The keys in the given map are row members in the vector given to play(). + using progress_callback_func = std::function &progress, TimeRemaining time_remaining)>; void set_progress_callback(progress_callback_func cb) { progress_callback = cb; } // QueueInterface. @@ -53,6 +96,7 @@ public: private: void thread_func(AVFormatContext *file_avctx); void play_playlist_once(); + void display_single_frame(int primary_stream_idx, const FrameOnDisk &primary_frame, int secondary_stream_idx, const FrameOnDisk &secondary_frame, double fade_alpha, std::chrono::steady_clock::time_point frame_start, bool snapped, const std::string &subtitle, bool play_audio); void open_output_stream(); static int write_packet2_thunk(void *opaque, uint8_t *buf, int buf_size, AVIODataMarkerType type, int64_t time); int write_packet2(uint8_t *buf, int buf_size, AVIODataMarkerType type, int64_t time); @@ -62,7 +106,10 @@ private: bool find_surrounding_frames(int64_t pts, int stream_idx, FrameOnDisk *frame_lower, FrameOnDisk *frame_upper); std::thread player_thread; - std::atomic should_quit{false}; + std::atomic should_quit{ false }; + std::atomic should_skip_to_next{ false }; + std::atomic start_master_speed{ 1.0f }; + std::atomic change_master_speed{ 0.0f / 0.0f }; JPEGFrameView *destination; done_callback_func done_callback; @@ -70,23 +117,28 @@ private: std::mutex queue_state_mu; std::condition_variable new_clip_changed; - std::vector queued_clip_list; // Under queue_state_mu. + std::vector queued_clip_list; // Under queue_state_mu. bool new_clip_ready = false; // Under queue_state_mu. bool playing = false; // Under queue_state_mu. int override_stream_idx = -1; // Under queue_state_mu. int64_t last_pts_played = -1; // Under queue_state_mu. Used by previews only. + bool splice_ready = false; // Under queue_state_mu. + std::vector to_splice_clip_list; // Under queue_state_mu. + std::string pause_status = "paused"; // Under queue_state_mu. + std::unique_ptr video_stream; // Can be nullptr. - std::atomic metric_dropped_interpolated_frame{0}; - std::atomic metric_dropped_unconditional_frame{0}; - std::atomic metric_faded_frame{0}; - std::atomic metric_faded_snapped_frame{0}; - std::atomic metric_original_frame{0}; - std::atomic metric_original_snapped_frame{0}; - std::atomic metric_refresh_frame{0}; - std::atomic metric_interpolated_frame{0}; - std::atomic metric_interpolated_faded_frame{0}; + std::atomic metric_dropped_interpolated_frame{ 0 }; + std::atomic metric_dropped_unconditional_frame{ 0 }; + std::atomic metric_faded_frame{ 0 }; + std::atomic metric_faded_snapped_frame{ 0 }; + std::atomic metric_original_frame{ 0 }; + std::atomic metric_original_snapped_frame{ 0 }; + std::atomic metric_refresh_frame{ 0 }; + std::atomic metric_interpolated_frame{ 0 }; + std::atomic metric_interpolated_faded_frame{ 0 }; + Summary metric_player_ahead_seconds; // under queue_state_mu. Part of this instead of VideoStream so that we own // its lock and can sleep on it. @@ -98,4 +150,13 @@ private: const StreamOutput stream_output; }; +TimeRemaining compute_time_left(const std::vector &clips, size_t currently_playing_idx, double progress_currently_playing); + +static inline TimeRemaining compute_total_time(const std::vector &clips) +{ + return compute_time_left(clips, 0, 0.0); +} + +std::string format_duration(TimeRemaining t); + #endif // !defined(_PLAYER_H)