X-Git-Url: https://main.carlh.net/gitweb/?p=dcpomatic.git;a=blobdiff_plain;f=src%2Flib%2Fwriter.cc;h=227de6277731d4ff31a81649ef8eb24ed114bd1d;hp=8c01afe7c03f91a686dbb20682c1a2d0c2da9b25;hb=8e4a2e5ea578ac4f0f41edb6145d5c0040e33ec2;hpb=3828baf56467224f5d44049bf1e7a7ed11f43a05 diff --git a/src/lib/writer.cc b/src/lib/writer.cc index 8c01afe7c..227de6277 100644 --- a/src/lib/writer.cc +++ b/src/lib/writer.cc @@ -1,5 +1,5 @@ /* - Copyright (C) 2012-2015 Carl Hetherington + Copyright (C) 2012-2017 Carl Hetherington This file is part of DCP-o-matic. @@ -30,16 +30,17 @@ #include "job.h" #include "cross.h" #include "audio_buffers.h" -#include "md5_digester.h" #include "version.h" #include "font.h" #include "util.h" #include "reel_writer.h" #include +#include #include #include #include #include +#include #include "i18n.h" @@ -59,6 +60,9 @@ using std::pair; using std::string; using std::list; using std::cout; +using std::map; +using std::min; +using std::max; using boost::shared_ptr; using boost::weak_ptr; using boost::dynamic_pointer_cast; @@ -76,14 +80,13 @@ Writer::Writer (shared_ptr film, weak_ptr j) , _repeat_written (0) , _pushed_to_disk (0) { - /* Remove any old DCP */ - boost::filesystem::remove_all (_film->dir (_film->dcp_name ())); - shared_ptr job = _job.lock (); DCPOMATIC_ASSERT (job); - BOOST_FOREACH (DCPTimePeriod p, _film->reels ()) { - _reels.push_back (ReelWriter (film, p, job)); + int reel_index = 0; + list const reels = _film->reels (); + BOOST_FOREACH (DCPTimePeriod p, reels) { + _reels.push_back (ReelWriter (film, p, job, reel_index++, reels.size(), _film->content_summary(p))); } /* We can keep track of the current audio and subtitle reels easily because audio @@ -93,17 +96,19 @@ Writer::Writer (shared_ptr film, weak_ptr j) _subtitle_reel = _reels.begin (); /* Check that the signer is OK if we need one */ - if (_film->is_signed() && !Config::instance()->signer_chain()->valid ()) { - throw InvalidSignerError (); + string reason; + if (_film->is_signed() && !Config::instance()->signer_chain()->valid(&reason)) { + throw InvalidSignerError (reason); } - - job->sub (_("Encoding image data")); } void Writer::start () { _thread = new boost::thread (boost::bind (&Writer::thread, this)); +#ifdef DCPOMATIC_LINUX + pthread_setname_np (_thread->native_handle(), "writer"); +#endif } Writer::~Writer () @@ -228,23 +233,63 @@ Writer::fake_write (Frame frame, Eyes eyes) _empty_condition.notify_all (); } -/** Write one video frame's worth of audio frames to the DCP. - * @param audio Audio data or 0 if there is no audio to be written here (i.e. it is referenced). +/** Write some audio frames to the DCP. + * @param audio Audio data. + * @param time Time of this data within the DCP. * This method is not thread safe. */ void -Writer::write (shared_ptr audio) +Writer::write (shared_ptr audio, DCPTime const time) { - if (_audio_reel == _reels.end ()) { - /* This audio is off the end of the last reel; ignore it */ - return; - } + DCPOMATIC_ASSERT (audio); + + int const afr = _film->audio_frame_rate(); + + DCPTime const end = time + DCPTime::from_frames(audio->frames(), afr); + + /* The audio we get might span a reel boundary, and if so we have to write it in bits */ - _audio_reel->write (audio); + DCPTime t = time; + while (t < end) { + + if (_audio_reel == _reels.end ()) { + /* This audio is off the end of the last reel; ignore it */ + return; + } + + if (end <= _audio_reel->period().to) { + /* Easy case: we can write all the audio to this reel */ + _audio_reel->write (audio); + t = end; + } else { + /* Split the audio into two and write the first part */ + DCPTime part_lengths[2] = { + _audio_reel->period().to - t, + end - _audio_reel->period().to + }; + + Frame part_frames[2] = { + part_lengths[0].frames_ceil(afr), + part_lengths[1].frames_ceil(afr) + }; + + if (part_frames[0]) { + shared_ptr part (new AudioBuffers (audio->channels(), part_frames[0])); + part->copy_from (audio.get(), part_frames[0], 0, 0); + _audio_reel->write (part); + } + + if (part_frames[1]) { + shared_ptr part (new AudioBuffers (audio->channels(), part_frames[1])); + part->copy_from (audio.get(), part_frames[1], part_frames[0], 0); + audio = part; + } else { + audio.reset (); + } - /* written is in video frames, not audio frames */ - if (_audio_reel->total_written_audio_frames() >= _audio_reel->period().duration().frames_floor (_film->video_frame_rate())) { - ++_audio_reel; + ++_audio_reel; + t += part_lengths[0]; + } } } @@ -317,9 +362,9 @@ try LOG_WARNING (N_("Finishing writer with a left-over queue of %1:"), _queue.size()); for (list::const_iterator i = _queue.begin(); i != _queue.end(); ++i) { if (i->type == QueueItem::FULL) { - LOG_WARNING (N_("- type FULL, frame %1, eyes %2"), i->frame, i->eyes); + LOG_WARNING (N_("- type FULL, frame %1, eyes %2"), i->frame, (int) i->eyes); } else { - LOG_WARNING (N_("- type FAKE, size %1, frame %2, eyes %3"), i->size, i->frame, i->eyes); + LOG_WARNING (N_("- type FAKE, size %1, frame %2, eyes %3"), i->size, i->frame, (int) i->eyes); } } } @@ -340,7 +385,7 @@ try switch (qi.type) { case QueueItem::FULL: - LOG_DEBUG_ENCODE (N_("Writer FULL-writes %1 (%2)"), qi.frame, qi.eyes); + LOG_DEBUG_ENCODE (N_("Writer FULL-writes %1 (%2)"), qi.frame, (int) qi.eyes); if (!qi.encoded) { qi.encoded = Data (_film->j2c_path (qi.reel, qi.frame, qi.eyes, false)); } @@ -360,19 +405,6 @@ try } lock.lock (); - - shared_ptr job = _job.lock (); - DCPOMATIC_ASSERT (job); - int64_t total = _film->length().frames_round (_film->video_frame_rate ()); - if (_film->three_d ()) { - /* _full_written and so on are incremented for each eye, so we need to double the total - frames to get the correct progress. - */ - total *= 2; - } - if (total) { - job->set_progress (float (_full_written + _fake_written + _repeat_written) / total); - } } while (_queued_full_in_memory > _maximum_frames_in_memory) { @@ -389,6 +421,8 @@ try DCPOMATIC_ASSERT (i != _queue.rend()); ++_pushed_to_disk; + /* For the log message below */ + int const awaiting = _reels[_queue.front().reel].last_written_video_frame(); lock.unlock (); /* i is valid here, even though we don't hold a lock on the mutex, @@ -396,7 +430,7 @@ try thread could erase the last item in the list. */ - LOG_GENERAL ("Writer full; pushes %1 to disk", i->frame); + LOG_GENERAL ("Writer full; pushes %1 to disk while awaiting %2", i->frame, awaiting); i->encoded->write_via_temp ( _film->j2c_path (i->reel, i->frame, i->eyes, true), @@ -472,16 +506,39 @@ Writer::finish () dcp.add (cpl); + /* Calculate digests for each reel in parallel */ + + shared_ptr job = _job.lock (); + job->sub (_("Computing digests")); + + boost::asio::io_service service; + boost::thread_group pool; + + shared_ptr work (new boost::asio::io_service::work (service)); + + int const threads = max (1, Config::instance()->master_encoding_threads ()); + + for (int i = 0; i < threads; ++i) { + pool.create_thread (boost::bind (&boost::asio::io_service::run, &service)); + } + BOOST_FOREACH (ReelWriter& i, _reels) { + boost::function set_progress = boost::bind (&Writer::set_digest_progress, this, job.get(), _1); + service.post (boost::bind (&ReelWriter::calculate_digests, &i, set_progress)); + } + + work.reset (); + pool.join_all (); + service.stop (); - shared_ptr job = _job.lock (); - DCPOMATIC_ASSERT (job); - i.calculate_digests (job); + /* Add reels to CPL */ + BOOST_FOREACH (ReelWriter& i, _reels) { cpl->add (i.create_reel (_reel_assets, _fonts)); } dcp::XMLMetadata meta; + meta.annotation_text = cpl->annotation_text (); meta.creator = Config::instance()->dcp_creator (); if (meta.creator.empty ()) { meta.creator = String::compose ("DCP-o-matic %1 %2", dcpomatic_version, dcpomatic_git_commit); @@ -498,16 +555,80 @@ Writer::finish () if (_film->is_signed ()) { signer = Config::instance()->signer_chain (); /* We did check earlier, but check again here to be on the safe side */ - if (!signer->valid ()) { - throw InvalidSignerError (); + string reason; + if (!signer->valid (&reason)) { + throw InvalidSignerError (reason); } } - dcp.write_xml (_film->interop () ? dcp::INTEROP : dcp::SMPTE, meta, signer); + dcp.write_xml (_film->interop () ? dcp::INTEROP : dcp::SMPTE, meta, signer, Config::instance()->dcp_metadata_filename_format()); LOG_GENERAL ( N_("Wrote %1 FULL, %2 FAKE, %3 REPEAT, %4 pushed to disk"), _full_written, _fake_written, _repeat_written, _pushed_to_disk ); + + write_cover_sheet (); +} + +void +Writer::write_cover_sheet () +{ + boost::filesystem::path const cover = _film->file ("COVER_SHEET.txt"); + FILE* f = fopen_boost (cover, "w"); + if (!f) { + throw OpenFileError (cover, errno, false); + } + + string text = Config::instance()->cover_sheet (); + boost::algorithm::replace_all (text, "$CPL_NAME", _film->name()); + boost::algorithm::replace_all (text, "$TYPE", _film->dcp_content_type()->pretty_name()); + boost::algorithm::replace_all (text, "$CONTAINER", _film->container()->container_nickname()); + boost::algorithm::replace_all (text, "$AUDIO_LANGUAGE", _film->isdcf_metadata().audio_language); + boost::algorithm::replace_all (text, "$SUBTITLE_LANGUAGE", _film->isdcf_metadata().subtitle_language); + + boost::uintmax_t size = 0; + for ( + boost::filesystem::recursive_directory_iterator i = boost::filesystem::recursive_directory_iterator(_film->dir(_film->dcp_name())); + i != boost::filesystem::recursive_directory_iterator(); + ++i) { + if (boost::filesystem::is_regular_file (i->path ())) { + size += boost::filesystem::file_size (i->path ()); + } + } + + if (size > (1000000000L)) { + boost::algorithm::replace_all (text, "$SIZE", String::compose ("%1GB", dcp::locale_convert (size / 1000000000.0, 1, true))); + } else { + boost::algorithm::replace_all (text, "$SIZE", String::compose ("%1MB", dcp::locale_convert (size / 1000000.0, 1, true))); + } + + pair ch = audio_channel_types (_film->mapped_audio_channels(), _film->audio_channels()); + string description = String::compose("%1.%2", ch.first, ch.second); + + if (description == "0.0") { + description = _("None"); + } else if (description == "1.0") { + description = _("Mono"); + } else if (description == "2.0") { + description = _("Stereo"); + } + boost::algorithm::replace_all (text, "$AUDIO", description); + + int h, m, s, fr; + _film->length().split (_film->video_frame_rate(), h, m, s, fr); + string length; + if (h == 0 && m == 0) { + length = String::compose("%1s", s); + } else if (h == 0 && m > 0) { + length = String::compose("%1m%2s", m, s); + } else if (h > 0 && m > 0) { + length = String::compose("%1h%2m%3s", h, m, s); + } + + boost::algorithm::replace_all (text, "$LENGTH", length); + + fwrite (text.c_str(), 1, text.length(), f); + fclose (f); } /** @param frame Frame index within the whole DCP. @@ -528,13 +649,13 @@ Writer::can_fake_write (Frame frame) const } void -Writer::write (PlayerSubtitles subs) +Writer::write (PlayerSubtitles subs, DCPTimePeriod period) { if (subs.text.empty ()) { return; } - if (_subtitle_reel->period().to <= subs.from) { + if (_subtitle_reel->period().to <= period.from) { ++_subtitle_reel; } @@ -583,16 +704,7 @@ operator== (QueueItem const & a, QueueItem const & b) void Writer::set_encoder_threads (int threads) { - /* I think the scaling factor here should be the ratio of the longest frame - encode time to the shortest; if the thread count is T, longest time is L - and the shortest time S we could encode L/S frames per thread whilst waiting - for the L frame to encode so we might have to store LT/S frames. - - However we don't want to use too much memory, so keep it a bit lower than we'd - perhaps like. A J2K frame is typically about 1Mb so 3 here will mean we could - use about 240Mb with 72 encoding threads. - */ - _maximum_frames_in_memory = lrint (threads * 3); + _maximum_frames_in_memory = lrint (threads * Config::instance()->frames_in_memory_multiplier()); } void @@ -613,3 +725,18 @@ Writer::video_reel (int frame) const DCPOMATIC_ASSERT (i < _reels.size ()); return i; } + +void +Writer::set_digest_progress (Job* job, float progress) +{ + /* I believe this is thread-safe */ + _digest_progresses[boost::this_thread::get_id()] = progress; + + boost::mutex::scoped_lock lm (_digest_progresses_mutex); + float min_progress = FLT_MAX; + for (map::const_iterator i = _digest_progresses.begin(); i != _digest_progresses.end(); ++i) { + min_progress = min (min_progress, i->second); + } + + job->set_progress (min_progress); +}