X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=futatabi%2Fplayer.h;h=77fb9e29b485a58ffbfbfc37273c9c9ce8e22a52;hb=refs%2Fheads%2Fmaster;hp=c8ed083fd544899124f749926c9598a0b0f9d235;hpb=4d7015171fbd6c36c480d1d7992b76bbb45410c5;p=nageru diff --git a/futatabi/player.h b/futatabi/player.h index c8ed083..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,6 +21,11 @@ class VideoStream; class QSurface; class QSurfaceFormat; +struct TimeRemaining { + size_t num_infinite; + double t; +}; + class Player : public QueueInterface { public: enum StreamOutput { @@ -30,17 +36,48 @@ public: Player(JPEGFrameView *destination, StreamOutput stream_output, AVFormatContext *file_avctx = nullptr); ~Player(); - struct ClipWithRow { - Clip clip; - size_t row; // Used for progress callback only. - }; void play(const Clip &clip) { - play({ ClipWithRow{ clip, 0 } }); + play({ ClipWithID{ clip, 0 } }); } - void play(const std::vector &clips); + 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; @@ -49,7 +86,7 @@ public: // Not thread-safe to set concurrently with playing. // Will be called back from the player thread. // The keys in the given map are row members in the vector given to play(). - using progress_callback_func = std::function &progress, double time_remaining)>; + using progress_callback_func = std::function &progress, TimeRemaining time_remaining)>; void set_progress_callback(progress_callback_func cb) { progress_callback = cb; } // QueueInterface. @@ -59,7 +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); + 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); @@ -70,6 +107,9 @@ private: std::thread player_thread; 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; @@ -77,12 +117,16 @@ 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 }; @@ -94,6 +138,7 @@ private: 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. @@ -105,11 +150,13 @@ private: const StreamOutput stream_output; }; -double compute_time_left(const std::vector &clips, size_t currently_playing_idx, double progress_currently_playing); +TimeRemaining compute_time_left(const std::vector &clips, size_t currently_playing_idx, double progress_currently_playing); -static inline double compute_total_time(const std::vector &clips) +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)