/*
- Copyright (C) 2012-2019 Carl Hetherington <cth@carlh.net>
+ Copyright (C) 2012-2021 Carl Hetherington <cth@carlh.net>
This file is part of DCP-o-matic.
*/
+
#include "writer.h"
#include "compose.hpp"
#include "film.h"
#include "i18n.h"
+
/* OS X strikes again */
#undef set_key
-using std::make_pair;
-using std::pair;
-using std::string;
-using std::list;
+
using std::cout;
+using std::dynamic_pointer_cast;
+using std::list;
+using std::make_pair;
+using std::make_shared;
using std::map;
-using std::min;
using std::max;
-using std::vector;
+using std::min;
+using std::pair;
using std::shared_ptr;
+using std::string;
+using std::vector;
using std::weak_ptr;
-using std::dynamic_pointer_cast;
using boost::optional;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
Writer::Writer (weak_ptr<const Film> weak_film, weak_ptr<Job> j, bool text_only)
: WeakConstFilm (weak_film)
, _job (j)
- , _finish (false)
- , _queued_full_in_memory (0)
/* These will be reset to sensible values when J2KEncoder is created */
, _maximum_frames_in_memory (8)
, _maximum_queue_size (8)
- , _full_written (0)
- , _fake_written (0)
- , _repeat_written (0)
- , _pushed_to_disk (0)
, _text_only (text_only)
- , _have_subtitles (false)
{
- shared_ptr<Job> job = _job.lock ();
+ auto job = _job.lock ();
int reel_index = 0;
auto const reels = film()->reels();
}
}
+
void
Writer::start ()
{
}
}
+
Writer::~Writer ()
{
if (!_text_only) {
}
}
+
/** Pass a video frame to the writer for writing to disk at some point.
* This method can be called with frames out of order.
* @param encoded JPEG2000-encoded data.
}
QueueItem qi;
- qi.type = QueueItem::FULL;
+ qi.type = QueueItem::Type::FULL;
qi.encoded = encoded;
qi.reel = video_reel (frame);
qi.frame = frame - _reels[qi.reel].start ();
- if (film()->three_d() && eyes == EYES_BOTH) {
+ if (film()->three_d() && eyes == Eyes::BOTH) {
/* 2D material in a 3D DCP; fake the 3D */
- qi.eyes = EYES_LEFT;
+ qi.eyes = Eyes::LEFT;
_queue.push_back (qi);
++_queued_full_in_memory;
- qi.eyes = EYES_RIGHT;
+ qi.eyes = Eyes::RIGHT;
_queue.push_back (qi);
++_queued_full_in_memory;
} else {
_empty_condition.notify_all ();
}
+
bool
Writer::can_repeat (Frame frame) const
{
return frame > _reels[video_reel(frame)].start();
}
+
/** Repeat the last frame that was written to a reel as a new frame.
* @param frame Frame index within the DCP of the new (repeated) frame.
* @param eyes Eyes that this repeated frame image is for.
}
QueueItem qi;
- qi.type = QueueItem::REPEAT;
+ qi.type = QueueItem::Type::REPEAT;
qi.reel = video_reel (frame);
qi.frame = frame - _reels[qi.reel].start ();
- if (film()->three_d() && eyes == EYES_BOTH) {
- qi.eyes = EYES_LEFT;
+ if (film()->three_d() && eyes == Eyes::BOTH) {
+ qi.eyes = Eyes::LEFT;
_queue.push_back (qi);
- qi.eyes = EYES_RIGHT;
+ qi.eyes = Eyes::RIGHT;
_queue.push_back (qi);
} else {
qi.eyes = eyes;
_empty_condition.notify_all ();
}
+
void
Writer::fake_write (Frame frame, Eyes eyes)
{
Frame const frame_in_reel = frame - _reels[reel].start ();
QueueItem qi;
- qi.type = QueueItem::FAKE;
+ qi.type = QueueItem::Type::FAKE;
{
shared_ptr<InfoFileHandle> info_file = film()->info_file_handle(_reels[reel].period(), true);
qi.reel = reel;
qi.frame = frame_in_reel;
- if (film()->three_d() && eyes == EYES_BOTH) {
- qi.eyes = EYES_LEFT;
+ if (film()->three_d() && eyes == Eyes::BOTH) {
+ qi.eyes = Eyes::LEFT;
_queue.push_back (qi);
- qi.eyes = EYES_RIGHT;
+ qi.eyes = Eyes::RIGHT;
_queue.push_back (qi);
} else {
qi.eyes = eyes;
_empty_condition.notify_all ();
}
+
/** Write some audio frames to the DCP.
* @param audio Audio data.
* @param time Time of this data within the DCP.
end - _audio_reel->period().to
};
+ /* Be careful that part_lengths[0] + part_lengths[1] can't be bigger than audio->frames() */
Frame part_frames[2] = {
part_lengths[0].frames_ceil(afr),
- part_lengths[1].frames_ceil(afr)
+ part_lengths[1].frames_floor(afr)
};
+ 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));
_audio_reel->write (part);
}
_queue.sort ();
- QueueItem const & f = _queue.front();
+ auto const & f = _queue.front();
return _last_written[f.reel].next(f);
}
bool
Writer::LastWritten::next (QueueItem qi) const
{
- if (qi.eyes == EYES_BOTH) {
+ if (qi.eyes == Eyes::BOTH) {
/* 2D */
return qi.frame == (_frame + 1);
}
/* 3D */
- if (_eyes == EYES_LEFT && qi.frame == _frame && qi.eyes == EYES_RIGHT) {
+ if (_eyes == Eyes::LEFT && qi.frame == _frame && qi.eyes == Eyes::RIGHT) {
return true;
}
- if (_eyes == EYES_RIGHT && qi.frame == (_frame + 1) && qi.eyes == EYES_LEFT) {
+ if (_eyes == Eyes::RIGHT && qi.frame == (_frame + 1) && qi.eyes == Eyes::LEFT) {
return true;
}
if (!_queue.empty() && !have_sequenced_image_at_queue_head()) {
LOG_WARNING (N_("Finishing writer with a left-over queue of %1:"), _queue.size());
for (auto const& i: _queue) {
- if (i.type == QueueItem::FULL) {
+ if (i.type == QueueItem::Type::FULL) {
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, (int) i.eyes);
/* Write any frames that we can write; i.e. those that are in sequence. */
while (have_sequenced_image_at_queue_head ()) {
- QueueItem qi = _queue.front ();
+ auto qi = _queue.front ();
_last_written[qi.reel].update (qi);
_queue.pop_front ();
- if (qi.type == QueueItem::FULL && qi.encoded) {
+ if (qi.type == QueueItem::Type::FULL && qi.encoded) {
--_queued_full_in_memory;
}
lock.unlock ();
- ReelWriter& reel = _reels[qi.reel];
+ auto& reel = _reels[qi.reel];
switch (qi.type) {
- case QueueItem::FULL:
+ case QueueItem::Type::FULL:
LOG_DEBUG_ENCODE (N_("Writer FULL-writes %1 (%2)"), qi.frame, (int) qi.eyes);
if (!qi.encoded) {
qi.encoded.reset (new ArrayData(film()->j2c_path(qi.reel, qi.frame, qi.eyes, false)));
reel.write (qi.encoded, qi.frame, qi.eyes);
++_full_written;
break;
- case QueueItem::FAKE:
+ case QueueItem::Type::FAKE:
LOG_DEBUG_ENCODE (N_("Writer FAKE-writes %1"), qi.frame);
reel.fake_write (qi.size);
++_fake_written;
break;
- case QueueItem::REPEAT:
+ case QueueItem::Type::REPEAT:
LOG_DEBUG_ENCODE (N_("Writer REPEAT-writes %1"), qi.frame);
reel.repeat_write (qi.frame, qi.eyes);
++_repeat_written;
/* Find one from the back of the queue */
_queue.sort ();
- list<QueueItem>::reverse_iterator i = _queue.rbegin ();
- while (i != _queue.rend() && (i->type != QueueItem::FULL || !i->encoded)) {
+ auto i = _queue.rbegin ();
+ while (i != _queue.rend() && (i->type != QueueItem::Type::FULL || !i->encoded)) {
++i;
}
store_current ();
}
+
void
Writer::terminate_thread (bool can_throw)
{
LOG_GENERAL_NC ("Finishing ReelWriters");
for (auto& i: _reels) {
+ write_hanging_text (i);
i.finish (output_dcp);
}
dcp::DCP dcp (output_dcp);
- shared_ptr<dcp::CPL> cpl (
- new dcp::CPL (
- film()->dcp_name(),
- film()->dcp_content_type()->libdcp_kind ()
- )
+ 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 */
- shared_ptr<Job> job = _job.lock ();
+ auto job = _job.lock ();
if (job) {
job->sub (_("Computing digests"));
}
boost::asio::io_service service;
boost::thread_group pool;
- shared_ptr<boost::asio::io_service::work> work (new boost::asio::io_service::work (service));
+ auto work = make_shared<boost::asio::io_service::work>(service);
int const threads = max (1, Config::instance()->master_encoding_threads ());
/* Add metadata */
- string creator = Config::instance()->dcp_creator();
+ auto creator = Config::instance()->dcp_creator();
if (creator.empty()) {
creator = String::compose("DCP-o-matic %1 %2", dcpomatic_version, dcpomatic_git_commit);
}
- string issuer = Config::instance()->dcp_issuer();
+ auto issuer = Config::instance()->dcp_issuer();
if (issuer.empty()) {
issuer = String::compose("DCP-o-matic %1 %2", dcpomatic_version, dcpomatic_git_commit);
}
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());
+ 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());
+ }
auto ac = film()->mapped_audio_channels();
dcp::MCASoundField field = (
cpl->set_main_sound_configuration (msc.to_string());
cpl->set_main_sound_sample_rate (film()->audio_frame_rate());
cpl->set_main_picture_stored_area (film()->frame_size());
- cpl->set_main_picture_active_area (film()->active_area());
+
+ 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);
+ }
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()));
}
- shared_ptr<const dcp::CertificateChain> signer;
- signer = Config::instance()->signer_chain ();
+ auto signer = Config::instance()->signer_chain();
/* We did check earlier, but check again here to be on the safe side */
string reason;
if (!signer->valid (&reason)) {
write_cover_sheet (output_dcp);
}
+
void
Writer::write_cover_sheet (boost::filesystem::path output_dcp)
{
- boost::filesystem::path const cover = film()->file("COVER_SHEET.txt");
- FILE* f = fopen_boost (cover, "w");
+ auto const cover = film()->file("COVER_SHEET.txt");
+ auto f = fopen_boost (cover, "w");
if (!f) {
throw OpenFileError (cover, errno, OpenFileError::WRITE);
}
- string text = Config::instance()->cover_sheet ();
+ auto 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);
- vector<dcp::LanguageTag> subtitle_languages = film()->subtitle_languages();
+ auto subtitle_languages = film()->subtitle_languages();
if (subtitle_languages.empty()) {
boost::algorithm::replace_all (text, "$SUBTITLE_LANGUAGE", "None");
} else {
boost::uintmax_t size = 0;
for (
- boost::filesystem::recursive_directory_iterator i = boost::filesystem::recursive_directory_iterator(output_dcp);
+ auto i = boost::filesystem::recursive_directory_iterator(output_dcp);
i != boost::filesystem::recursive_directory_iterator();
++i) {
- if (boost::filesystem::is_regular_file (i->path ())) {
- size += boost::filesystem::file_size (i->path ());
+ 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<string> (size / 1000000000.0, 1, true)));
+ boost::algorithm::replace_all (text, "$SIZE", String::compose("%1GB", dcp::locale_convert<string>(size / 1000000000.0, 1, true)));
} else {
- boost::algorithm::replace_all (text, "$SIZE", String::compose ("%1MB", dcp::locale_convert<string> (size / 1000000.0, 1, true)));
+ boost::algorithm::replace_all (text, "$SIZE", String::compose("%1MB", dcp::locale_convert<string>(size / 1000000.0, 1, true)));
}
- pair<int, int> ch = audio_channel_types (film()->mapped_audio_channels(), film()->audio_channels());
- string description = String::compose("%1.%2", ch.first, ch.second);
+ auto ch = audio_channel_types (film()->mapped_audio_channels(), film()->audio_channels());
+ auto description = String::compose("%1.%2", ch.first, ch.second);
if (description == "0.0") {
description = _("None");
}
boost::algorithm::replace_all (text, "$AUDIO", description);
- int h, m, s, fr;
- film()->length().split(film()->video_frame_rate(), h, m, s, fr);
+ auto const hmsf = film()->length().split(film()->video_frame_rate());
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);
+ if (hmsf.h == 0 && hmsf.m == 0) {
+ length = String::compose("%1s", hmsf.s);
+ } else if (hmsf.h == 0 && hmsf.m > 0) {
+ length = String::compose("%1m%2s", hmsf.m, hmsf.s);
+ } else if (hmsf.h > 0 && hmsf.m > 0) {
+ length = String::compose("%1h%2m%3s", hmsf.h, hmsf.m, hmsf.s);
}
boost::algorithm::replace_all (text, "$LENGTH", length);
fclose (f);
}
+
/** @param frame Frame index within the whole DCP.
* @return true if we can fake-write this frame.
*/
parameters in the asset writer.
*/
- ReelWriter const & reel = _reels[video_reel(frame)];
+ auto const & reel = _reels[video_reel(frame)];
/* Make frame relative to the start of the reel */
frame -= reel.start ();
return (frame != 0 && frame < reel.first_nonexistant_frame());
}
-/** @param track Closed caption track if type == TEXT_CLOSED_CAPTION */
+
+/** @param track Closed caption track if type == TextType::CLOSED_CAPTION */
void
Writer::write (PlayerText text, TextType type, optional<DCPTextTrack> track, DCPTimePeriod period)
{
- vector<ReelWriter>::iterator* reel = 0;
+ vector<ReelWriter>::iterator* reel = nullptr;
switch (type) {
- case TEXT_OPEN_SUBTITLE:
+ case TextType::OPEN_SUBTITLE:
reel = &_subtitle_reel;
_have_subtitles = true;
break;
- case TEXT_CLOSED_CAPTION:
+ case TextType::CLOSED_CAPTION:
DCPOMATIC_ASSERT (track);
DCPOMATIC_ASSERT (_caption_reels.find(*track) != _caption_reels.end());
reel = &_caption_reels[*track];
while ((*reel)->period().to <= period.from) {
++(*reel);
DCPOMATIC_ASSERT (*reel != _reels.end());
+ write_hanging_text (**reel);
+ }
+
+ auto back_off = [this](DCPTimePeriod period) {
+ period.to -= DCPTime::from_frames(2, film()->video_frame_rate());
+ return period;
+ };
+
+ if (period.to > (*reel)->period().to) {
+ /* This text goes off the end of the reel. Store parts of it that should go into
+ * other reels.
+ */
+ for (auto i = std::next(*reel); i != _reels.end(); ++i) {
+ auto overlap = i->period().overlap(period);
+ if (overlap) {
+ _hanging_texts.push_back (HangingText{text, type, track, back_off(*overlap)});
+ }
+ }
+ /* Back off from the reel boundary by a couple of frames to avoid tripping checks
+ * for subtitles being too close together.
+ */
+ period.to = (*reel)->period().to;
+ period = back_off(period);
}
(*reel)->write (text, type, track, period);
}
+
void
Writer::write (vector<FontData> fonts)
{
}
}
+
bool
operator< (QueueItem const & a, QueueItem const & b)
{
return static_cast<int> (a.eyes) < static_cast<int> (b.eyes);
}
+
bool
operator== (QueueItem const & a, QueueItem const & b)
{
return a.reel == b.reel && a.frame == b.frame && a.eyes == b.eyes;
}
+
void
Writer::set_encoder_threads (int threads)
{
_maximum_queue_size = threads * 16;
}
+
void
Writer::write (ReferencedReelAsset asset)
{
_reel_assets.push_back (asset);
}
+
size_t
Writer::video_reel (int frame) const
{
- DCPTime t = DCPTime::from_frames (frame, film()->video_frame_rate());
+ auto t = DCPTime::from_frames (frame, film()->video_frame_rate());
size_t i = 0;
while (i < _reels.size() && !_reels[i].period().contains (t)) {
++i;
return i;
}
+
void
Writer::set_digest_progress (Job* job, float progress)
{
_digest_progresses[boost::this_thread::get_id()] = progress;
float min_progress = FLT_MAX;
- for (map<boost::thread::id, float>::const_iterator i = _digest_progresses.begin(); i != _digest_progresses.end(); ++i) {
- min_progress = min (min_progress, i->second);
+ for (auto const& i: _digest_progresses) {
+ min_progress = min (min_progress, i.second);
}
job->set_progress (min_progress);
}
}
+
+void
+Writer::write_hanging_text (ReelWriter& reel)
+{
+ 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);
+ } else {
+ new_hanging_texts.push_back (i);
+ }
+ }
+ _hanging_texts = new_hanging_texts;
+}