X-Git-Url: https://git.carlh.net/gitweb/?a=blobdiff_plain;ds=sidebyside;f=src%2Flib%2Fplayer.h;h=22701cb2ca452c486746f643063c7bb7affa1250;hb=182b9d2e2feb6545592868606aaf0f0146095481;hp=c6e657d162cf0558b7191bd2a3a5d728d5fe25d9;hpb=c9a97108df1d609bd13df8a21bee11d7ca55feea;p=dcpomatic.git diff --git a/src/lib/player.h b/src/lib/player.h index c6e657d16..22701cb2c 100644 --- a/src/lib/player.h +++ b/src/lib/player.h @@ -1,5 +1,5 @@ /* - Copyright (C) 2013-2018 Carl Hetherington + Copyright (C) 2013-2020 Carl Hetherington This file is part of DCP-o-matic. @@ -18,35 +18,40 @@ */ + #ifndef DCPOMATIC_PLAYER_H #define DCPOMATIC_PLAYER_H -#include "player_text.h" + #include "active_text.h" +#include "atmos_metadata.h" +#include "audio_merger.h" +#include "audio_stream.h" +#include "content_atmos.h" +#include "content_audio.h" #include "content_text.h" -#include "film.h" -#include "content.h" -#include "position_image.h" -#include "piece.h" #include "content_video.h" -#include "content_audio.h" -#include "audio_stream.h" -#include "audio_merger.h" #include "empty.h" -#include -#include +#include "film.h" +#include "image.h" +#include "player_text.h" +#include "position_image.h" +#include "shuffler.h" +#include #include + namespace dcp { class ReelAsset; } +class AtmosContent; +class AudioBuffers; +class Content; class PlayerVideo; class Playlist; -class Font; -class AudioBuffers; class ReferencedReelAsset; -class Shuffler; + class PlayerProperty { @@ -56,27 +61,28 @@ public: static int const FILM_CONTAINER; static int const FILM_VIDEO_FRAME_RATE; static int const DCP_DECODE_REDUCTION; - static int const IGNORE_COMPONENTS; - static int const FAST; - static int const PLAY_REFERENCED; + static int const PLAYBACK_LENGTH; }; + /** @class Player * @brief A class which can play a Playlist. */ -class Player : public boost::enable_shared_from_this, public boost::noncopyable +class Player : public std::enable_shared_from_this { public: - Player (boost::shared_ptr, boost::shared_ptr playlist); - ~Player (); + Player (std::shared_ptr, Image::Alignment subtitle_alignment); + Player (std::shared_ptr, std::shared_ptr playlist); + + Player (Player const& Player) = delete; + Player& operator= (Player const& Player) = delete; bool pass (); - void seek (DCPTime time, bool accurate); + void seek (dcpomatic::DCPTime time, bool accurate); + + std::vector> get_subtitle_fonts (); - std::list > get_subtitle_fonts (); - std::list get_reel_assets (); dcp::Size video_container_size () const { - boost::mutex::scoped_lock lm (_mutex); return _video_container_size; } @@ -89,24 +95,22 @@ public: void set_play_referenced (); void set_dcp_decode_reduction (boost::optional reduction); - DCPTime content_time_to_dcp (boost::shared_ptr content, ContentTime t); + boost::optional content_time_to_dcp (std::shared_ptr content, dcpomatic::ContentTime t) const; + boost::optional dcp_to_content_time (std::shared_ptr content, dcpomatic::DCPTime t) const; - /** Emitted when something has changed such that if we went back and emitted - * the last frame again it would look different. This is not emitted after - * a seek. - * - * The first parameter is what changed. - * The second parameter is true if these signals are currently likely to be frequent. - */ - boost::signals2::signal Changed; + boost::signals2::signal Change; /** Emitted when a video frame is ready. These emissions happen in the correct order. */ - boost::signals2::signal, DCPTime)> Video; - boost::signals2::signal, DCPTime)> Audio; + boost::signals2::signal, dcpomatic::DCPTime)> Video; + /** Emitted when audio data is ready. First parameter is the audio data, second its time, + * third the frame rate. + */ + boost::signals2::signal, dcpomatic::DCPTime, int)> Audio; /** Emitted when a text is ready. This signal may be emitted considerably * after the corresponding Video. */ - boost::signals2::signal Text; + boost::signals2::signal, dcpomatic::DCPTimePeriod)> Text; + boost::signals2::signal, dcpomatic::DCPTime, AtmosMetadata)> Atmos; private: friend class PlayerWrapper; @@ -115,102 +119,123 @@ private: friend struct player_time_calculation_test2; friend struct player_time_calculation_test3; friend struct player_subframe_test; + friend struct empty_test1; + friend struct empty_test2; + friend struct check_reuse_old_data_test; + friend struct overlap_video_test1; + void construct (); void setup_pieces (); - void flush (); - void film_changed (Film::Property); - void playlist_changed (); - void playlist_content_changed (boost::weak_ptr, int, bool); - std::list transform_bitmap_texts (std::list) const; - Frame dcp_to_content_video (boost::shared_ptr piece, DCPTime t) const; - DCPTime content_video_to_dcp (boost::shared_ptr piece, Frame f) const; - Frame dcp_to_resampled_audio (boost::shared_ptr piece, DCPTime t) const; - DCPTime resampled_audio_to_dcp (boost::shared_ptr piece, Frame f) const; - ContentTime dcp_to_content_time (boost::shared_ptr piece, DCPTime t) const; - DCPTime content_time_to_dcp (boost::shared_ptr piece, ContentTime t) const; - boost::shared_ptr black_player_video_frame (Eyes eyes) const; - void video (boost::weak_ptr, ContentVideo); - void audio (boost::weak_ptr, AudioStreamPtr, ContentAudio); - void bitmap_text_start (boost::weak_ptr, boost::weak_ptr, ContentBitmapText); - void plain_text_start (boost::weak_ptr, boost::weak_ptr, ContentStringText); - void subtitle_stop (boost::weak_ptr, boost::weak_ptr, ContentTime, TextType); - DCPTime one_video_frame () const; - void fill_audio (DCPTimePeriod period); - std::pair, DCPTime> discard_audio ( - boost::shared_ptr audio, DCPTime time, DCPTime discard_to + void film_change (ChangeType, Film::Property); + void playlist_change (ChangeType); + void playlist_content_change (ChangeType, int, bool); + Frame dcp_to_content_video (std::shared_ptr piece, dcpomatic::DCPTime t) const; + dcpomatic::DCPTime content_video_to_dcp (std::shared_ptr piece, Frame f) const; + Frame dcp_to_resampled_audio (std::shared_ptr piece, dcpomatic::DCPTime t) const; + dcpomatic::DCPTime resampled_audio_to_dcp (std::shared_ptr piece, Frame f) const; + dcpomatic::ContentTime dcp_to_content_time (std::shared_ptr piece, dcpomatic::DCPTime t) const; + dcpomatic::DCPTime content_time_to_dcp (std::shared_ptr piece, dcpomatic::ContentTime t) const; + std::shared_ptr black_player_video_frame (Eyes eyes) const; + + void video (std::weak_ptr, ContentVideo); + void audio (std::weak_ptr, AudioStreamPtr, ContentAudio); + void bitmap_text_start (std::weak_ptr, std::weak_ptr, ContentBitmapText); + void plain_text_start (std::weak_ptr, std::weak_ptr, ContentStringText); + void subtitle_stop (std::weak_ptr, std::weak_ptr, dcpomatic::ContentTime); + void atmos (std::weak_ptr, ContentAtmos); + + dcpomatic::DCPTime one_video_frame () const; + void fill_audio (dcpomatic::DCPTimePeriod period); + std::pair, dcpomatic::DCPTime> discard_audio ( + std::shared_ptr audio, dcpomatic::DCPTime time, dcpomatic::DCPTime discard_to ) const; - boost::optional open_subtitles_for_frame (DCPTime time) const; - void emit_video (boost::shared_ptr pv, DCPTime time); - void do_emit_video (boost::shared_ptr pv, DCPTime time); - void emit_audio (boost::shared_ptr data, DCPTime time); + boost::optional open_subtitles_for_frame (dcpomatic::DCPTime time) const; + void emit_video (std::shared_ptr pv, dcpomatic::DCPTime time); + void do_emit_video (std::shared_ptr pv, dcpomatic::DCPTime time); + void emit_audio (std::shared_ptr data, dcpomatic::DCPTime time); + std::shared_ptr playlist () const; - /** Mutex to protect the whole Player state. When it's used for the preview we have + /** Mutex to protect the most of the Player state. When it's used for the preview we have seek() and pass() called from the Butler thread and lots of other stuff called from the GUI thread. */ mutable boost::mutex _mutex; - boost::shared_ptr _film; - boost::shared_ptr _playlist; + std::shared_ptr const _film; + /** Playlist, or 0 if we are using the one from the _film */ + std::shared_ptr const _playlist; - /** Our pieces are ready to go; if this is false the pieces must be (re-)created before they are used */ - bool _have_valid_pieces; - std::list > _pieces; + /** > 0 if we are suspended (i.e. pass() and seek() do nothing) */ + boost::atomic _suspended; + std::list> _pieces; + + /** Size of the image we are rendering to; this may be the DCP frame size, or + * the size of preview in a window. + */ + boost::atomic _video_container_size; - /** Size of the image in the DCP (e.g. 1990x1080 for flat) */ - dcp::Size _video_container_size; - boost::shared_ptr _black_image; + mutable boost::mutex _black_image_mutex; + std::shared_ptr _black_image; /** true if the player should ignore all video; i.e. never produce any */ - bool _ignore_video; - bool _ignore_audio; + boost::atomic _ignore_video; + boost::atomic _ignore_audio; /** true if the player should ignore all text; i.e. never produce any */ - bool _ignore_text; - bool _always_burn_open_subtitles; + boost::atomic _ignore_text; + boost::atomic _always_burn_open_subtitles; /** true if we should try to be fast rather than high quality */ - bool _fast; + boost::atomic _fast; + /** true if we should keep going in the face of `survivable' errors */ + bool const _tolerant; /** true if we should `play' (i.e output) referenced DCP data (e.g. for preview) */ - bool _play_referenced; + boost::atomic _play_referenced; - /** Time just after the last video frame we emitted, or the time of the last accurate seek */ - boost::optional _last_video_time; - boost::optional _last_video_eyes; - /** Time just after the last audio frame we emitted, or the time of the last accurate seek */ - boost::optional _last_audio_time; + /** Time of the next video that we will emit, or the time of the last accurate seek */ + boost::optional _next_video_time; + /** Eyes of the next video that we will emit */ + boost::optional _next_video_eyes; + /** Time of the next audio that we will emit, or the time of the last accurate seek */ + boost::optional _next_audio_time; - boost::optional _dcp_decode_reduction; + boost::atomic> _dcp_decode_reduction; - typedef std::map, boost::shared_ptr > LastVideoMap; + typedef std::map, std::shared_ptr, std::owner_less>> LastVideoMap; LastVideoMap _last_video; AudioMerger _audio_merger; - Shuffler* _shuffler; - std::list, DCPTime> > _delay; + std::unique_ptr _shuffler; + std::list, dcpomatic::DCPTime>> _delay; class StreamState { public: StreamState () {} - StreamState (boost::shared_ptr p, DCPTime l) + StreamState (std::shared_ptr p, dcpomatic::DCPTime l) : piece(p) , last_push_end(l) {} - boost::shared_ptr piece; - DCPTime last_push_end; + std::shared_ptr piece; + dcpomatic::DCPTime last_push_end; }; std::map _stream_states; Empty _black; Empty _silent; - ActiveText _active_texts[TEXT_COUNT]; - boost::shared_ptr _audio_processor; + ActiveText _active_texts[static_cast(TextType::COUNT)]; + std::shared_ptr _audio_processor; + + boost::atomic _playback_length; + + /** Alignment for subtitle images that we create */ + Image::Alignment const _subtitle_alignment = Image::Alignment::PADDED; boost::signals2::scoped_connection _film_changed_connection; - boost::signals2::scoped_connection _playlist_changed_connection; - boost::signals2::scoped_connection _playlist_content_changed_connection; + boost::signals2::scoped_connection _playlist_change_connection; + boost::signals2::scoped_connection _playlist_content_change_connection; }; + #endif