*/
-#include "writer.h"
-#include "compose.hpp"
-#include "film.h"
-#include "ratio.h"
-#include "log.h"
-#include "dcpomatic_log.h"
-#include "dcp_video.h"
-#include "dcp_content_type.h"
+#include "audio_buffers.h"
#include "audio_mapping.h"
+#include "compose.hpp"
#include "config.h"
-#include "job.h"
+#include "constants.h"
#include "cross.h"
-#include "audio_buffers.h"
-#include "version.h"
-#include "font_data.h"
-#include "util.h"
+#include "dcp_content_type.h"
+#include "dcp_video.h"
+#include "dcpomatic_log.h"
+#include "film.h"
+#include "film_util.h"
+#include "job.h"
+#include "log.h"
+#include "ratio.h"
#include "reel_writer.h"
#include "text_content.h"
+#include "util.h"
+#include "version.h"
+#include "writer.h"
#include <dcp/cpl.h>
#include <dcp/locale_convert.h>
+#include <dcp/raw_convert.h>
+#include <dcp/reel_closed_caption_asset.h>
#include <dcp/reel_file_asset.h>
-#include <fstream>
+#include <dcp/reel_subtitle_asset.h>
#include <cerrno>
-#include <iostream>
#include <cfloat>
+#include <set>
#include "i18n.h"
using std::cout;
using std::dynamic_pointer_cast;
-using std::list;
-using std::make_pair;
using std::make_shared;
-using std::map;
using std::max;
using std::min;
-using std::pair;
using std::shared_ptr;
+using std::set;
using std::string;
using std::vector;
using std::weak_ptr;
using namespace dcpomatic;
-static
-void
-ignore_progress (float)
-{
-
-}
-
-
-/** @param j Job to report progress to, or 0.
+/** @param weak_job Job to report progress to, or 0.
* @param text_only true to enable only the text (subtitle/ccap) parts of the writer.
*/
-Writer::Writer (weak_ptr<const Film> weak_film, weak_ptr<Job> j, bool text_only)
+Writer::Writer(weak_ptr<const Film> weak_film, weak_ptr<Job> weak_job, bool text_only)
: WeakConstFilm (weak_film)
- , _job (j)
+ , _job(weak_job)
/* These will be reset to sensible values when J2KEncoder is created */
, _maximum_frames_in_memory (8)
, _maximum_queue_size (8)
qi.reel = video_reel (frame);
qi.frame = frame - _reels[qi.reel].start ();
- if (film()->three_d() && eyes == Eyes::BOTH) {
- /* 2D material in a 3D DCP; fake the 3D */
- qi.eyes = Eyes::LEFT;
- _queue.push_back (qi);
- ++_queued_full_in_memory;
- qi.eyes = Eyes::RIGHT;
- _queue.push_back (qi);
- ++_queued_full_in_memory;
- } else {
- qi.eyes = eyes;
- _queue.push_back (qi);
- ++_queued_full_in_memory;
- }
+ DCPOMATIC_ASSERT((film()->three_d() && eyes != Eyes::BOTH) || (!film()->three_d() && eyes == Eyes::BOTH));
+
+ qi.eyes = eyes;
+ _queue.push_back(qi);
+ ++_queued_full_in_memory;
/* Now there's something to do: wake anything wait()ing on _empty_condition */
_empty_condition.notify_all ();
qi.size = _reels[reel].read_frame_info(info_file, frame_in_reel, eyes).size;
}
+ DCPOMATIC_ASSERT((film()->three_d() && eyes != Eyes::BOTH) || (!film()->three_d() && eyes == Eyes::BOTH));
+
qi.reel = reel;
qi.frame = frame_in_reel;
- if (film()->three_d() && eyes == Eyes::BOTH) {
- qi.eyes = Eyes::LEFT;
- _queue.push_back (qi);
- qi.eyes = Eyes::RIGHT;
- _queue.push_back (qi);
- } else {
- qi.eyes = eyes;
- _queue.push_back (qi);
- }
+ qi.eyes = eyes;
+ _queue.push_back(qi);
/* Now there's something to do: wake anything wait()ing on _empty_condition */
_empty_condition.notify_all ();
DCPOMATIC_ASSERT ((part_frames[0] + part_frames[1]) <= audio->frames());
if (part_frames[0]) {
- shared_ptr<AudioBuffers> part (new AudioBuffers(audio, part_frames[0], 0));
+ auto part = make_shared<AudioBuffers>(audio, part_frames[0], 0);
_audio_reel->write (part);
}
if (part_frames[1]) {
- audio.reset (new AudioBuffers(audio, part_frames[1], part_frames[0]));
+ audio = make_shared<AudioBuffers>(audio, part_frames[1], part_frames[0]);
} else {
audio.reset ();
}
Writer::thread ()
try
{
+ start_of_thread ("Writer");
+
while (true)
{
boost::mutex::scoped_lock lock (_state_mutex);
/* Find one from the back of the queue */
_queue.sort ();
- auto i = _queue.rbegin ();
- while (i != _queue.rend() && (i->type != QueueItem::Type::FULL || !i->encoded)) {
- ++i;
+ auto item = _queue.rbegin();
+ while (item != _queue.rend() && (item->type != QueueItem::Type::FULL || !item->encoded)) {
+ ++item;
}
- DCPOMATIC_ASSERT (i != _queue.rend());
+ DCPOMATIC_ASSERT(item != _queue.rend());
++_pushed_to_disk;
/* For the log message below */
int const awaiting = _last_written[_queue.front().reel].frame() + 1;
thread could erase the last item in the list.
*/
- LOG_GENERAL ("Writer full; pushes %1 to disk while awaiting %2", i->frame, awaiting);
+ LOG_GENERAL("Writer full; pushes %1 to disk while awaiting %2", item->frame, awaiting);
- i->encoded->write_via_temp (
- film()->j2c_path(i->reel, i->frame, i->eyes, true),
- film()->j2c_path(i->reel, i->frame, i->eyes, false)
+ item->encoded->write_via_temp(
+ film()->j2c_path(item->reel, item->frame, item->eyes, true),
+ film()->j2c_path(item->reel, item->frame, item->eyes, false)
);
lock.lock ();
- i->encoded.reset ();
+ item->encoded.reset();
--_queued_full_in_memory;
_full_condition.notify_all ();
}
}
-/** @param output_dcp Path to DCP folder to write */
void
-Writer::finish (boost::filesystem::path output_dcp)
+Writer::calculate_digests ()
{
- if (_thread.joinable()) {
- LOG_GENERAL_NC ("Terminating writer thread");
- terminate_thread (true);
- }
-
- LOG_GENERAL_NC ("Finishing ReelWriters");
-
- for (auto& i: _reels) {
- write_hanging_text (i);
- i.finish (output_dcp);
- }
-
- LOG_GENERAL_NC ("Writing XML");
-
- dcp::DCP dcp (output_dcp);
-
- auto cpl = make_shared<dcp::CPL>(
- film()->dcp_name(),
- film()->dcp_content_type()->libdcp_kind()
- );
-
- dcp.add (cpl);
-
- /* Calculate digests for each reel in parallel */
-
auto job = _job.lock ();
if (job) {
job->sub (_("Computing digests"));
auto work = make_shared<boost::asio::io_service::work>(service);
- int const threads = max (1, Config::instance()->master_encoding_threads ());
+ 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::function<void (float)> set_progress;
+ std::function<void (int, int64_t, int64_t)> set_progress;
if (job) {
- set_progress = boost::bind (&Writer::set_digest_progress, this, job.get(), _1);
+ set_progress = boost::bind(&Writer::set_digest_progress, this, job.get(), _1, _2, _3);
} else {
- set_progress = &ignore_progress;
+ set_progress = [](int, int64_t, int64_t) {
+ boost::this_thread::interruption_point();
+ };
}
+ int index = 0;
+
for (auto& i: _reels) {
- service.post (boost::bind (&ReelWriter::calculate_digests, &i, set_progress));
+ service.post(
+ boost::bind(
+ &ReelWriter::calculate_digests,
+ &i,
+ std::function<void (int64_t, int64_t)>(boost::bind(set_progress, index, _1, _2))
+ ));
+ ++index;
}
- service.post (boost::bind (&Writer::calculate_referenced_digests, this, set_progress));
+ service.post(
+ boost::bind(
+ &Writer::calculate_referenced_digests,
+ this,
+ std::function<void (int64_t, int64_t)>(boost::bind(set_progress, index, _1, _2))
+ ));
work.reset ();
- pool.join_all ();
+
+ try {
+ pool.join_all ();
+ } catch (boost::thread_interrupted) {
+ /* join_all was interrupted, so we need to interrupt the threads
+ * in our pool then try again to join them.
+ */
+ pool.interrupt_all ();
+ pool.join_all ();
+ }
+
service.stop ();
+}
+
+
+/** @param output_dcp Path to DCP folder to write */
+void
+Writer::finish (boost::filesystem::path output_dcp)
+{
+ if (_thread.joinable()) {
+ LOG_GENERAL_NC ("Terminating writer thread");
+ terminate_thread (true);
+ }
+
+ LOG_GENERAL_NC ("Finishing ReelWriters");
+
+ for (auto& reel: _reels) {
+ write_hanging_text(reel);
+ reel.finish(output_dcp);
+ }
+
+ LOG_GENERAL_NC ("Writing XML");
+
+ dcp::DCP dcp (output_dcp);
+
+ auto cpl = make_shared<dcp::CPL>(
+ film()->dcp_name(),
+ film()->dcp_content_type()->libdcp_kind(),
+ film()->interop() ? dcp::Standard::INTEROP : dcp::Standard::SMPTE
+ );
+
+ dcp.add (cpl);
+
+ calculate_digests ();
/* Add reels */
for (auto& i: _reels) {
- cpl->add (i.create_reel(_reel_assets, _fonts, output_dcp, _have_subtitles, _have_closed_captions));
+ cpl->add(i.create_reel(_reel_assets, output_dcp, _have_subtitles, _have_closed_captions));
}
/* Add metadata */
issuer = String::compose("DCP-o-matic %1 %2", dcpomatic_version, dcpomatic_git_commit);
}
+ cpl->set_creator (creator);
+ cpl->set_issuer (issuer);
+
cpl->set_ratings (film()->ratings());
vector<dcp::ContentVersion> cv;
for (auto i: film()->content_versions()) {
- cv.push_back (dcp::ContentVersion(i));
+ /* Make sure we don't end up writing an empty <LabelText> node as some validators
+ * complain about that.
+ */
+ cv.push_back(!i.empty() ? dcp::ContentVersion(i) : dcp::ContentVersion("1"));
+ }
+ if (cv.empty()) {
+ cv = { dcp::ContentVersion("1") };
}
cpl->set_content_versions (cv);
cpl->set_full_content_title_text (film()->name());
cpl->set_full_content_title_text_language (film()->name_language());
- cpl->set_release_territory (film()->release_territory());
+ if (film()->release_territory()) {
+ cpl->set_release_territory (*film()->release_territory());
+ }
cpl->set_version_number (film()->version_number());
cpl->set_status (film()->status());
- cpl->set_chain (film()->chain());
- cpl->set_distributor (film()->distributor());
- cpl->set_facility (film()->facility());
- cpl->set_luminance (film()->luminance());
-
- auto ac = film()->mapped_audio_channels();
- dcp::MCASoundField field = (
- find(ac.begin(), ac.end(), static_cast<int>(dcp::Channel::BSL)) != ac.end() ||
- find(ac.begin(), ac.end(), static_cast<int>(dcp::Channel::BSR)) != ac.end()
- ) ? dcp::MCASoundField::SEVEN_POINT_ONE : dcp::MCASoundField::FIVE_POINT_ONE;
-
- dcp::MainSoundConfiguration msc (field, film()->audio_channels());
- for (auto i: ac) {
- if (static_cast<int>(i) < film()->audio_channels()) {
- msc.set_mapping (i, static_cast<dcp::Channel>(i));
+ if (film()->chain()) {
+ cpl->set_chain (*film()->chain());
+ }
+ if (film()->distributor()) {
+ cpl->set_distributor (*film()->distributor());
+ }
+ if (film()->facility()) {
+ cpl->set_facility (*film()->facility());
+ }
+ if (film()->luminance()) {
+ cpl->set_luminance (*film()->luminance());
+ }
+ if (film()->sign_language_video_language()) {
+ cpl->set_sign_language_video_language (*film()->sign_language_video_language());
+ }
+
+ dcp::MCASoundField field;
+ if (channel_is_mapped(film(), dcp::Channel::BSL) || channel_is_mapped(film(), dcp::Channel::BSR)) {
+ field = dcp::MCASoundField::SEVEN_POINT_ONE;
+ } else {
+ field = dcp::MCASoundField::FIVE_POINT_ONE;
+ }
+
+ auto const audio_channels = film()->audio_channels();
+ dcp::MainSoundConfiguration msc(field, audio_channels);
+ for (auto i: film()->mapped_audio_channels()) {
+ if (i < audio_channels) {
+ msc.set_mapping(i, static_cast<dcp::Channel>(i));
}
}
- cpl->set_main_sound_configuration (msc.to_string());
+ cpl->set_main_sound_configuration(msc);
cpl->set_main_sound_sample_rate (film()->audio_frame_rate());
cpl->set_main_picture_stored_area (film()->frame_size());
auto active_area = film()->active_area();
if (active_area.width > 0 && active_area.height > 0) {
- /* It's not allowed to have a zero active area width or height */
- cpl->set_main_picture_active_area (active_area);
+ /* It's not allowed to have a zero active area width or height, and the sizes must be multiples of 2 */
+ cpl->set_main_picture_active_area({ active_area.width & ~1, active_area.height & ~1});
}
- vector<dcp::LanguageTag> sl = film()->subtitle_languages();
- if (sl.size() > 1) {
- cpl->set_additional_subtitle_languages(std::vector<dcp::LanguageTag>(sl.begin() + 1, sl.end()));
+ auto sl = film()->subtitle_languages().second;
+ if (!sl.empty()) {
+ cpl->set_additional_subtitle_languages(sl);
}
auto signer = Config::instance()->signer_chain();
throw InvalidSignerError (reason);
}
- dcp.write_xml (
- film()->interop() ? dcp::Standard::INTEROP : dcp::Standard::SMPTE,
- issuer,
- creator,
- dcp::LocalTime().as_string(),
- film()->dcp_name(),
- signer,
- Config::instance()->dcp_metadata_filename_format()
- );
+ dcp.set_issuer(issuer);
+ dcp.set_creator(creator);
+ dcp.set_annotation_text(film()->dcp_name());
+
+ dcp.write_xml(signer, !film()->limit_to_smpte_bv20(), 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
Writer::write_cover_sheet (boost::filesystem::path output_dcp)
{
auto const cover = film()->file("COVER_SHEET.txt");
- auto f = fopen_boost (cover, "w");
- if (!f) {
+ dcp::File file(cover, "w");
+ if (!file) {
throw OpenFileError (cover, errno, OpenFileError::WRITE);
}
auto text = Config::instance()->cover_sheet ();
boost::algorithm::replace_all (text, "$CPL_NAME", film()->name());
+ auto cpls = film()->cpls();
+ if (!cpls.empty()) {
+ boost::algorithm::replace_all (text, "$CPL_FILENAME", cpls[0].cpl_file.filename().string());
+ }
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);
+
+ auto audio_language = film()->audio_language();
+ if (audio_language) {
+ boost::algorithm::replace_all (text, "$AUDIO_LANGUAGE", audio_language->description());
+ } else {
+ boost::algorithm::replace_all (text, "$AUDIO_LANGUAGE", _("None"));
+ }
auto subtitle_languages = film()->subtitle_languages();
- if (subtitle_languages.empty()) {
- boost::algorithm::replace_all (text, "$SUBTITLE_LANGUAGE", "None");
+ if (subtitle_languages.first) {
+ boost::algorithm::replace_all (text, "$SUBTITLE_LANGUAGE", subtitle_languages.first->description());
} else {
- boost::algorithm::replace_all (text, "$SUBTITLE_LANGUAGE", subtitle_languages.front().description());
+ boost::algorithm::replace_all (text, "$SUBTITLE_LANGUAGE", _("None"));
}
boost::uintmax_t size = 0;
for (
- auto i = boost::filesystem::recursive_directory_iterator(output_dcp);
- i != boost::filesystem::recursive_directory_iterator();
+ auto i = dcp::filesystem::recursive_directory_iterator(output_dcp);
+ i != dcp::filesystem::recursive_directory_iterator();
++i) {
- if (boost::filesystem::is_regular_file (i->path())) {
- size += boost::filesystem::file_size (i->path());
+ if (dcp::filesystem::is_regular_file(i->path())) {
+ size += dcp::filesystem::file_size(i->path());
}
}
boost::algorithm::replace_all (text, "$LENGTH", length);
- checked_fwrite (text.c_str(), text.length(), f, cover);
- fclose (f);
+ file.checked_write(text.c_str(), text.length());
}
/* Make frame relative to the start of the reel */
frame -= reel.start ();
- return (frame != 0 && frame < reel.first_nonexistant_frame());
+ return (frame != 0 && frame < reel.first_nonexistent_frame());
}
period = back_off(period);
}
- (*reel)->write (text, type, track, period);
+ (*reel)->write(text, type, track, period, _fonts, _chosen_interop_font);
}
void
-Writer::write (vector<FontData> fonts)
+Writer::write (vector<shared_ptr<Font>> fonts)
{
- /* Just keep a list of unique fonts and we'll deal with them in ::finish */
+ if (fonts.empty()) {
+ return;
+ }
- for (auto const& i: fonts) {
- bool got = false;
- for (auto& j: _fonts) {
- if (i == j) {
- got = true;
- }
- }
+ /* Fonts may come in with empty IDs but we don't want to put those in the DCP */
+ auto fix_id = [](string id) {
+ return id.empty() ? "font" : id;
+ };
- if (!got) {
- _fonts.push_back (i);
+ if (film()->interop()) {
+ /* Interop will ignore second and subsequent <LoadFont>s so we don't want to
+ * even write them as they upset some validators. Set up _fonts so that every
+ * font used by any subtitle will be written with the same ID.
+ */
+ for (size_t i = 0; i < fonts.size(); ++i) {
+ _fonts.put(fonts[i], fix_id(fonts[0]->id()));
+ }
+ _chosen_interop_font = fonts[0];
+ } else {
+ for (auto font: fonts) {
+ _fonts.put(font, fix_id(font->id()));
}
}
}
Writer::write (ReferencedReelAsset asset)
{
_reel_assets.push_back (asset);
+
+ if (dynamic_pointer_cast<dcp::ReelSubtitleAsset>(asset.asset)) {
+ _have_subtitles = true;
+ } else if (auto ccap = dynamic_pointer_cast<dcp::ReelClosedCaptionAsset>(asset.asset)) {
+ /* This feels quite fragile. We have a referenced reel and want to know if it's
+ * part of a given closed-caption track so that we can fill if it has any
+ * missing reels. I guess for that purpose almost any DCPTextTrack values are
+ * fine so long as they are consistent.
+ */
+ DCPTextTrack track;
+ track.name = ccap->annotation_text().get_value_or("");
+ track.language = dcp::LanguageTag(ccap->language().get_value_or("en-US"));
+ if (_have_closed_captions.find(track) == _have_closed_captions.end()) {
+ _have_closed_captions.insert(track);
+ }
+ }
}
Writer::video_reel (int frame) const
{
auto t = DCPTime::from_frames (frame, film()->video_frame_rate());
- size_t i = 0;
- while (i < _reels.size() && !_reels[i].period().contains (t)) {
- ++i;
+ size_t reel_index = 0;
+ while (reel_index < _reels.size() && !_reels[reel_index].period().contains(t)) {
+ ++reel_index;
}
- DCPOMATIC_ASSERT (i < _reels.size ());
- return i;
+ DCPOMATIC_ASSERT(reel_index < _reels.size ());
+ return reel_index;
}
+/** Update job progress with information about the progress of a single digest calculation
+ * thread.
+ * @param id Unique identifier for the thread whose progress has changed.
+ * @param done Number of bytes that this thread has processed.
+ * @param size Total number of bytes that this thread must process.
+ */
void
-Writer::set_digest_progress (Job* job, float progress)
+Writer::set_digest_progress(Job* job, int id, int64_t done, int64_t size)
{
boost::mutex::scoped_lock lm (_digest_progresses_mutex);
- _digest_progresses[boost::this_thread::get_id()] = progress;
- float min_progress = FLT_MAX;
+ /* Update the progress for this thread */
+ _digest_progresses[id] = std::make_pair(done, size);
+
+ /* Get the total progress across all threads and use it to set job progress */
+ int64_t total_done = 0;
+ int64_t total_size = 0;
for (auto const& i: _digest_progresses) {
- min_progress = min (min_progress, i.second);
+ total_done += i.second.first;
+ total_size += i.second.second;
}
- job->set_progress (min_progress);
+ job->set_progress(float(total_done) / total_size);
Waker waker;
waker.nudge ();
+
+ boost::this_thread::interruption_point();
}
/** Calculate hashes for any referenced MXF assets which do not already have one */
void
-Writer::calculate_referenced_digests (boost::function<void (float)> set_progress)
+Writer::calculate_referenced_digests(std::function<void (int64_t, int64_t)> set_progress)
+try
{
+ int64_t total_size = 0;
+ for (auto const& i: _reel_assets) {
+ auto file = dynamic_pointer_cast<dcp::ReelFileAsset>(i.asset);
+ if (file && !file->hash()) {
+ auto filename = file->asset_ref().asset()->file();
+ DCPOMATIC_ASSERT(filename);
+ total_size += boost::filesystem::file_size(*filename);
+ }
+ }
+
+ int64_t total_done = 0;
for (auto const& i: _reel_assets) {
auto file = dynamic_pointer_cast<dcp::ReelFileAsset>(i.asset);
if (file && !file->hash()) {
- file->asset_ref().asset()->hash (set_progress);
+ file->asset_ref().asset()->hash([&total_done, total_size, set_progress](int64_t done, int64_t) {
+ set_progress(total_done + done, total_size);
+ });
+ total_done += boost::filesystem::file_size(*file->asset_ref().asset()->file());
file->set_hash (file->asset_ref().asset()->hash());
}
}
+} catch (boost::thread_interrupted) {
+ /* set_progress contains an interruption_point, so any of these methods
+ * may throw thread_interrupted, at which point we just give up.
+ */
}
vector<HangingText> new_hanging_texts;
for (auto i: _hanging_texts) {
if (i.period.from == reel.period().from) {
- reel.write (i.text, i.type, i.track, i.period);
+ reel.write(i.text, i.type, i.track, i.period, _fonts, _chosen_interop_font);
} else {
new_hanging_texts.push_back (i);
}
projects / dcpomatic.git / blobdiff