X-Git-Url: https://git.carlh.net/gitweb/?a=blobdiff_plain;f=src%2Flib%2Fwriter.h;h=1ae761dea83656073d4d03abb45c1ef6b8a9e5f7;hb=8b38c3523b061883c3d320bd2e38afffe7424f4d;hp=8156308a6b9c86e9849703c28aef22c9ce9df584;hpb=479b67ec506289a4763b2dd4f07e72d1dd676483;p=dcpomatic.git diff --git a/src/lib/writer.h b/src/lib/writer.h index 8156308a6..1ae761dea 100644 --- a/src/lib/writer.h +++ b/src/lib/writer.h @@ -1,60 +1,227 @@ /* - Copyright (C) 2012 Carl Hetherington + Copyright (C) 2012-2021 Carl Hetherington - This program is free software; you can redistribute it and/or modify + This file is part of DCP-o-matic. + + DCP-o-matic is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. - This program is distributed in the hope that it will be useful, + DCP-o-matic is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + along with DCP-o-matic. If not, see . */ -#include -#include + +/** @file src/lib/writer.h + * @brief Writer class. + */ + + +#include "atmos_metadata.h" +#include "dcp_text_track.h" +#include "dcpomatic_time.h" +#include "exception_store.h" +#include "font_id_map.h" +#include "player_text.h" +#include "types.h" +#include "weak_film.h" +#include #include #include +#include -class Film; -class EncodedData; -namespace libdcp { - class MonoPictureAsset; - class MonoPictureAssetWriter; +namespace dcp { + class Data; } -class Writer +class AudioBuffers; +class Film; +class Job; +class ReelWriter; +class ReferencedReelAsset; +struct writer_disambiguate_font_ids1; +struct writer_disambiguate_font_ids2; +struct writer_disambiguate_font_ids3; + + +struct QueueItem { public: - Writer (boost::shared_ptr); - - void write (boost::shared_ptr, int); - void repeat (int f); - void finish (); + QueueItem () {} + + enum class Type { + /** a normal frame with some JPEG200 data */ + FULL, + /** a frame whose data already exists in the MXF, + and we fake-write it; i.e. we update the writer's + state but we use the data that is already on disk. + */ + FAKE, + REPEAT, + } type; + + /** encoded data for FULL */ + std::shared_ptr encoded; + /** size of data for FAKE */ + int size = 0; + /** reel index */ + size_t reel = 0; + /** frame index within the reel */ + int frame = 0; + /** eyes for FULL, FAKE and REPEAT */ + Eyes eyes = Eyes::BOTH; +}; + + +bool operator< (QueueItem const & a, QueueItem const & b); +bool operator== (QueueItem const & a, QueueItem const & b); + + +/** @class Writer + * @brief Class to manage writing JPEG2000 and audio data to assets on disk. + * + * This class creates sound and picture assets, then takes Data + * or AudioBuffers objects (containing image or sound data respectively) + * and writes them to the assets. + * + * write() for Data (picture) can be called out of order, and the Writer + * will sort it out. write() for AudioBuffers must be called in order. + */ + +class Writer : public ExceptionStore, public WeakConstFilm +{ +public: + Writer (std::weak_ptr, std::weak_ptr, bool text_only = false); + ~Writer (); + + Writer (Writer const &) = delete; + Writer& operator= (Writer const &) = delete; + + void start (); + + bool can_fake_write (Frame) const; + + void write (std::shared_ptr, Frame, Eyes); + void fake_write (Frame, Eyes); + bool can_repeat (Frame) const; + void repeat (Frame, Eyes); + void write (std::shared_ptr, dcpomatic::DCPTime time); + void write (PlayerText text, TextType type, boost::optional, dcpomatic::DCPTimePeriod period); + void write (std::vector> fonts); + void write (ReferencedReelAsset asset); + void write (std::shared_ptr atmos, dcpomatic::DCPTime time, AtmosMetadata metadata); + void finish (boost::filesystem::path output_dcp); + + void set_encoder_threads (int threads); private: + friend struct ::writer_disambiguate_font_ids1; + friend struct ::writer_disambiguate_font_ids2; + friend struct ::writer_disambiguate_font_ids3; void thread (); + void terminate_thread (bool); + bool have_sequenced_image_at_queue_head (); + size_t video_reel (int frame) const; + void set_digest_progress (Job* job, float progress); + void write_cover_sheet (boost::filesystem::path output_dcp); + void calculate_referenced_digests (std::function set_progress); + void write_hanging_text (ReelWriter& reel); + void calculate_digests (); + + std::weak_ptr _job; + std::vector _reels; + std::vector::iterator _audio_reel; + std::vector::iterator _subtitle_reel; + std::map::iterator> _caption_reels; + std::vector::iterator _atmos_reel; + + /** our thread */ + boost::thread _thread; + /** true if our thread should finish */ + bool _finish = false; + /** queue of things to write to disk */ + std::list _queue; + /** number of FULL frames whose JPEG200 data is currently held in RAM */ + int _queued_full_in_memory = 0; + /** mutex for thread state */ + mutable boost::mutex _state_mutex; + /** condition to manage thread wakeups when we have nothing to do */ + boost::condition _empty_condition; + /** condition to manage thread wakeups when we have too much to do */ + boost::condition _full_condition; + /** maximum number of frames to hold in memory, for when we are managing + * ordering + */ + int _maximum_frames_in_memory; + unsigned int _maximum_queue_size; + + class LastWritten + { + public: + LastWritten() + : _frame(-1) + , _eyes(Eyes::RIGHT) + {} + + /** @return true if qi is the next item after this one */ + bool next (QueueItem qi) const; + void update (QueueItem qi); + + int frame () const { + return _frame; + } + + private: + int _frame; + Eyes _eyes; + }; + + /** The last frame written to each reel */ + std::vector _last_written; + + /** number of FULL written frames */ + int _full_written = 0; + /** number of FAKE written frames */ + int _fake_written = 0; + int _repeat_written = 0; + /** number of frames pushed to disk and then recovered + due to the limit of frames to be held in memory. + */ + int _pushed_to_disk = 0; + + bool _text_only; + + boost::mutex _digest_progresses_mutex; + std::map _digest_progresses; + + std::list _reel_assets; + + FontIdMap _fonts; + /** If we are given many fonts, but we're making an Interop DCP, we'll choose a single + * one that we'll use everywher. This is that chosen font. + */ + std::shared_ptr _chosen_interop_font; - boost::shared_ptr _film; + /** true if any reel has any subtitles */ + bool _have_subtitles = false; + /** all closed caption tracks that we have on any reel */ + std::set _have_closed_captions; - boost::thread* _thread; - bool _finish; - std::list, int> > _queue; - mutable boost::mutex _mutex; - boost::condition _condition; - boost::shared_ptr _last_written; - std::list _pending; - int _last_written_frame; - static const unsigned int _maximum_frames_in_memory; + struct HangingText { + PlayerText text; + TextType type; + boost::optional track; + dcpomatic::DCPTimePeriod period; + }; - boost::shared_ptr _picture_asset; - boost::shared_ptr _picture_asset_writer; + std::vector _hanging_texts; };