#include "audio_buffers.h"
#include "compose.hpp"
#include "config.h"
+#include "constants.h"
#include "cross.h"
#include "dcpomatic_log.h"
#include "digester.h"
#include "film.h"
-#include "font_data.h"
+#include "film_util.h"
#include "image.h"
#include "image_png.h"
#include "job.h"
#include <dcp/certificate_chain.h>
#include <dcp/cpl.h>
#include <dcp/dcp.h>
+#include <dcp/filesystem.h>
#include <dcp/interop_subtitle_asset.h>
#include <dcp/mono_picture_asset.h>
#include <dcp/raw_convert.h>
, _content_summary (film()->content_summary(period))
, _job (job)
, _text_only (text_only)
+ , _font_metrics(film()->frame_size().height)
{
/* Create or find our picture asset in a subdirectory, named
according to those film's parameters which affect the video
boost::filesystem::path const asset =
film()->internal_video_asset_dir() / film()->internal_video_asset_filename(_period);
- _first_nonexistant_frame = check_existing_picture_asset (asset);
+ _first_nonexistent_frame = check_existing_picture_asset (asset);
- if (_first_nonexistant_frame < period.duration().frames_round(film()->video_frame_rate())) {
+ if (_first_nonexistent_frame < period.duration().frames_round(film()->video_frame_rate())) {
/* We do not have a complete picture asset. If there is an
existing asset, break any hard links to it as we are about
to change its contents (if only by changing the IDs); see
#1126.
*/
- if (boost::filesystem::exists(asset) && boost::filesystem::hard_link_count(asset) > 1) {
+ if (dcp::filesystem::exists(asset) && dcp::filesystem::hard_link_count(asset) > 1) {
if (job) {
job->sub (_("Copying old video file"));
copy_in_bits (asset, asset.string() + ".tmp", bind(&Job::set_progress, job.get(), _1, false));
} else {
- boost::filesystem::copy_file (asset, asset.string() + ".tmp");
+ dcp::filesystem::copy_file(asset, asset.string() + ".tmp");
}
- boost::filesystem::remove (asset);
- boost::filesystem::rename (asset.string() + ".tmp", asset);
+ dcp::filesystem::remove(asset);
+ dcp::filesystem::rename(asset.string() + ".tmp", asset);
}
}
_picture_asset->set_file (asset);
- _picture_asset_writer = _picture_asset->start_write (asset, _first_nonexistant_frame > 0);
+ _picture_asset_writer = _picture_asset->start_write(asset, _first_nonexistent_frame > 0 ? dcp::PictureAsset::Behaviour::OVERWRITE_EXISTING : dcp::PictureAsset::Behaviour::MAKE_NEW);
} else if (!text_only) {
/* We already have a complete picture asset that we can just re-use */
/* XXX: what about if the encryption key changes? */
DCPOMATIC_ASSERT (film()->directory());
+ std::vector<dcp::Channel> extra_active_channels;
+ for (auto channel: std::vector<dcp::Channel>{dcp::Channel::HI, dcp::Channel::VI, dcp::Channel::BSL, dcp::Channel::BSR}) {
+ if (channel_is_mapped(film(), channel)) {
+ extra_active_channels.push_back(channel);
+ }
+ }
+
/* Write the sound asset into the film directory so that we leave the creation
of the DCP directory until the last minute.
*/
_sound_asset_writer = _sound_asset->start_write (
film()->directory().get() / audio_asset_filename (_sound_asset, _reel_index, _reel_count, _content_summary),
- film()->contains_atmos_content()
+ extra_active_channels,
+ film()->contains_atmos_content() ? dcp::SoundAsset::AtmosSync::ENABLED : dcp::SoundAsset::AtmosSync::DISABLED,
+ film()->limit_to_smpte_bv20() ? dcp::SoundAsset::MCASubDescriptors::DISABLED : dcp::SoundAsset::MCASubDescriptors::ENABLED
);
}
}
/* Offset of the last dcp::FrameInfo in the info file */
- int const n = (boost::filesystem::file_size(info_file->get().path()) / _info_size) - 1;
- LOG_GENERAL ("The last FI is %1; info file is %2, info size %3", n, boost::filesystem::file_size(info_file->get().path()), _info_size);
+ int const n = (dcp::filesystem::file_size(info_file->get().path()) / _info_size) - 1;
+ LOG_GENERAL ("The last FI is %1; info file is %2, info size %3", n, dcp::filesystem::file_size(info_file->get().path()), _info_size);
- Frame first_nonexistant_frame;
+ Frame first_nonexistent_frame;
if (film()->three_d()) {
/* Start looking at the last left frame */
- first_nonexistant_frame = n / 2;
+ first_nonexistent_frame = n / 2;
} else {
- first_nonexistant_frame = n;
+ first_nonexistent_frame = n;
}
- while (!existing_picture_frame_ok(asset_file, info_file, first_nonexistant_frame) && first_nonexistant_frame > 0) {
- --first_nonexistant_frame;
+ while (!existing_picture_frame_ok(asset_file, info_file, first_nonexistent_frame) && first_nonexistent_frame > 0) {
+ --first_nonexistent_frame;
}
- if (!film()->three_d() && first_nonexistant_frame > 0) {
+ if (!film()->three_d() && first_nonexistent_frame > 0) {
/* If we are doing 3D we might have found a good L frame with no R, so only
do this if we're in 2D and we've just found a good B(oth) frame.
*/
- ++first_nonexistant_frame;
+ ++first_nonexistent_frame;
}
- LOG_GENERAL ("Proceeding with first nonexistant frame %1", first_nonexistant_frame);
+ LOG_GENERAL ("Proceeding with first nonexistent frame %1", first_nonexistent_frame);
- return first_nonexistant_frame;
+ return first_nonexistent_frame;
}
auto fin = _picture_asset_writer->write (encoded->data(), encoded->size());
write_frame_info (frame, eyes, fin);
- _last_written[static_cast<int>(eyes)] = encoded;
+ _last_written[eyes] = encoded;
}
return;
}
- auto fin = _picture_asset_writer->write (
- _last_written[static_cast<int>(eyes)]->data(),
- _last_written[static_cast<int>(eyes)]->size()
- );
+ auto fin = _picture_asset_writer->write(_last_written[eyes]->data(), _last_written[eyes]->size());
write_frame_info (frame, eyes, fin);
}
changing any video.
*/
boost::system::error_code ec;
- boost::filesystem::remove (video_to, ec);
+ dcp::filesystem::remove(video_to, ec);
- boost::filesystem::create_hard_link (video_from, video_to, ec);
+ dcp::filesystem::create_hard_link(video_from, video_to, ec);
if (ec) {
- LOG_WARNING_NC ("Hard-link failed; copying instead");
+ LOG_WARNING("Hard-link failed (%1); copying instead", error_details(ec));
auto job = _job.lock ();
if (job) {
job->sub (_("Copying video file into DCP"));
throw FileError (e.what(), video_from);
}
} else {
- boost::filesystem::copy_file (video_from, video_to, ec);
+ dcp::filesystem::copy_file(video_from, video_to, ec);
if (ec) {
- LOG_ERROR ("Failed to copy video file from %1 to %2 (%3)", video_from.string(), video_to.string(), ec.message());
+ LOG_ERROR("Failed to copy video file from %1 to %2 (%3)", video_from.string(), video_to.string(), error_details(ec));
throw FileError (ec.message(), video_from);
}
}
audio_to /= aaf;
boost::system::error_code ec;
- boost::filesystem::rename (film()->file(aaf), audio_to, ec);
+ dcp::filesystem::rename(film()->file(aaf), audio_to, ec);
if (ec) {
throw FileError (
- String::compose (_("could not move audio asset into the DCP (%1)"), ec.value ()), aaf
+ String::compose(_("could not move audio asset into the DCP (%1)"), error_details(ec)), aaf
);
}
atmos_to /= aaf;
boost::system::error_code ec;
- boost::filesystem::rename (film()->file(aaf), atmos_to, ec);
+ dcp::filesystem::rename(film()->file(aaf), atmos_to, ec);
if (ec) {
throw FileError (
- String::compose (_("could not move atmos asset into the DCP (%1)"), ec.value ()), aaf
+ String::compose(_("could not move atmos asset into the DCP (%1)"), error_details(ec)), aaf
);
}
int reel_count,
optional<string> content_summary,
list<ReferencedReelAsset> const & refs,
- vector<FontData> const & fonts,
- dcp::ArrayData default_font,
shared_ptr<const Film> film,
DCPTimePeriod period,
boost::filesystem::path output_dcp,
shared_ptr<Result> reel_asset;
if (asset) {
- /* Add the font to the subtitle content */
- for (auto const& j: fonts) {
- asset->add_font (j.id, j.data.get_value_or(default_font));
- }
-
if (auto interop = dynamic_pointer_cast<dcp::InteropSubtitleAsset>(asset)) {
auto directory = output_dcp / interop->id ();
- boost::filesystem::create_directories (directory);
- interop->write (directory / subtitle_asset_filename(asset, reel_index, reel_count, content_summary));
+ dcp::filesystem::create_directories(directory);
+ interop->write (directory / subtitle_asset_filename(asset, reel_index, reel_count, content_summary, ".xml"));
reel_asset = make_shared<Interop> (
interop,
dcp::Fraction(film->video_frame_rate(), 1),
*/
smpte->set_intrinsic_duration(picture_duration);
smpte->write (
- output_dcp / subtitle_asset_filename(asset, reel_index, reel_count, content_summary)
+ output_dcp / subtitle_asset_filename(asset, reel_index, reel_count, content_summary, ".mxf")
);
reel_asset = make_shared<SMPTE> (
smpte,
ReelWriter::create_reel_text (
shared_ptr<dcp::Reel> reel,
list<ReferencedReelAsset> const & refs,
- vector<FontData> const& fonts,
int64_t duration,
boost::filesystem::path output_dcp,
bool ensure_subtitles,
) const
{
auto subtitle = maybe_add_text<dcp::ReelInteropSubtitleAsset, dcp::ReelSMPTESubtitleAsset, dcp::ReelSubtitleAsset> (
- _subtitle_asset, duration, reel, _reel_index, _reel_count, _content_summary, refs, fonts, _default_font, film(), _period, output_dcp, _text_only
+ _subtitle_asset, duration, reel, _reel_index, _reel_count, _content_summary, refs, film(), _period, output_dcp, _text_only
);
- if (subtitle) {
- /* We have a subtitle asset that we either made or are referencing */
- if (auto main_language = film()->subtitle_languages().first) {
- subtitle->set_language (*main_language);
- }
- } else if (ensure_subtitles) {
+ if (!subtitle && ensure_subtitles) {
/* We had no subtitle asset, but we've been asked to make sure there is one */
subtitle = maybe_add_text<dcp::ReelInteropSubtitleAsset, dcp::ReelSMPTESubtitleAsset, dcp::ReelSubtitleAsset> (
empty_text_asset(TextType::OPEN_SUBTITLE, optional<DCPTextTrack>(), true),
_reel_count,
_content_summary,
refs,
- fonts,
- _default_font,
film(),
_period,
output_dcp,
);
}
+ if (subtitle) {
+ /* We have a subtitle asset that we either made or are referencing */
+ if (auto main_language = film()->subtitle_languages().first) {
+ subtitle->set_language (*main_language);
+ }
+ }
+
for (auto const& i: _closed_caption_assets) {
auto a = maybe_add_text<dcp::ReelInteropClosedCaptionAsset, dcp::ReelSMPTEClosedCaptionAsset, dcp::ReelClosedCaptionAsset> (
- i.second, duration, reel, _reel_index, _reel_count, _content_summary, refs, fonts, _default_font, film(), _period, output_dcp, _text_only
+ i.second, duration, reel, _reel_index, _reel_count, _content_summary, refs, film(), _period, output_dcp, _text_only
);
DCPOMATIC_ASSERT (a);
a->set_annotation_text (i.first.name);
_reel_count,
_content_summary,
refs,
- fonts,
- _default_font,
film(),
_period,
output_dcp,
shared_ptr<dcp::Reel>
ReelWriter::create_reel (
list<ReferencedReelAsset> const & refs,
- vector<FontData> const & fonts,
boost::filesystem::path output_dcp,
bool ensure_subtitles,
set<DCPTextTrack> ensure_closed_captions
auto reel_picture_asset = create_reel_picture (reel, refs);
duration = reel_picture_asset->actual_duration ();
create_reel_sound (reel, refs);
- create_reel_markers (reel);
+ if (!film()->interop()) {
+ create_reel_markers(reel);
+ }
}
- create_reel_text (reel, refs, fonts, duration, output_dcp, ensure_subtitles, ensure_closed_captions);
+ create_reel_text(reel, refs, duration, output_dcp, ensure_subtitles, ensure_closed_captions);
if (_atmos_asset) {
reel->add (make_shared<dcp::ReelAtmosAsset>(_atmos_asset, 0));
return reel;
}
+
+/** @param set_progress Method to call with progress; first parameter is the number of bytes
+ * done, second parameter is the number of bytes in total.
+ */
void
-ReelWriter::calculate_digests (std::function<void (float)> set_progress)
+ReelWriter::calculate_digests(std::function<void (int64_t, int64_t)> set_progress)
try
{
+ vector<shared_ptr<const dcp::Asset>> assets;
+
if (_picture_asset) {
- _picture_asset->hash (set_progress);
+ assets.push_back(_picture_asset);
}
-
if (_sound_asset) {
- _sound_asset->hash (set_progress);
+ assets.push_back(_sound_asset);
}
-
if (_atmos_asset) {
- _atmos_asset->hash (set_progress);
+ assets.push_back(_atmos_asset);
}
+
+ int64_t total_size = 0;
+ for (auto asset: assets) {
+ total_size += asset->file() ? boost::filesystem::file_size(*asset->file()) : 0;
+ }
+
+ int64_t total_done = 0;
+ for (auto asset: assets) {
+ asset->hash([&total_done, total_size, set_progress](int64_t done, int64_t) {
+ set_progress(total_done + done, total_size);
+ });
+ total_done += asset->file() ? boost::filesystem::file_size(*asset->file()) : 0;
+ }
+
} 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.
}
DCPOMATIC_ASSERT (audio);
- _sound_asset_writer->write (audio->data(), audio->frames());
+ _sound_asset_writer->write(audio->data(), audio->channels(), audio->frames());
}
ReelWriter::empty_text_asset (TextType type, optional<DCPTextTrack> track, bool with_dummy) const
{
shared_ptr<dcp::SubtitleAsset> asset;
+ optional<string> font;
auto lang = film()->subtitle_languages();
if (film()->interop()) {
if (film()->encrypted()) {
s->set_key (film()->key());
}
- if (with_dummy) {
- s->add (
- std::make_shared<dcp::SubtitleString>(
- optional<std::string>(),
- false,
- false,
- false,
- dcp::Colour(),
- 42,
- 1.0,
- dcp::Time(0, 0, 0, 0, 24),
- dcp::Time(0, 0, 1, 0, 24),
- 0.5,
- dcp::HAlign::CENTER,
- 0.5,
- dcp::VAlign::CENTER,
- dcp::Direction::LTR,
- " ",
- dcp::Effect::NONE,
- dcp::Colour(),
- dcp::Time(),
- dcp::Time(),
- 0
- )
- );
- }
asset = s;
}
+ if (with_dummy) {
+ asset->add(
+ std::make_shared<dcp::SubtitleString>(
+ font,
+ false,
+ false,
+ false,
+ dcp::Colour(),
+ 42,
+ 1.0,
+ dcp::Time(0, 0, 0, 0, 24),
+ dcp::Time(0, 0, 1, 0, 24),
+ 0.5,
+ dcp::HAlign::CENTER,
+ 0.5,
+ dcp::VAlign::CENTER,
+ 0,
+ dcp::Direction::LTR,
+ " ",
+ dcp::Effect::NONE,
+ dcp::Colour(),
+ dcp::Time(),
+ dcp::Time(),
+ 0,
+ std::vector<dcp::Ruby>()
+ )
+ );
+
+ if (!film()->interop()) {
+ /* We must have a LoadFont since we have a Text */
+ font = "font";
+ asset->ensure_font(*font, _default_font);
+ }
+ }
+
return asset;
}
+float
+ReelWriter::convert_vertical_position(StringText const& subtitle, dcp::SubtitleStandard to) const
+{
+ if (dcp::uses_baseline(subtitle.valign_standard) == dcp::uses_baseline(to)) {
+ /* The from and to standards use the same alignment reference */
+ return subtitle.v_position();
+ }
+
+ auto const baseline_to_bottom = _font_metrics.baseline_to_bottom(subtitle);
+ auto const height = _font_metrics.height(subtitle);
+
+ float correction = 0;
+ switch (subtitle.v_align()) {
+ case dcp::VAlign::TOP:
+ correction = height - baseline_to_bottom;
+ break;
+ case dcp::VAlign::CENTER:
+ correction = (height / 2) - baseline_to_bottom;
+ break;
+ case dcp::VAlign::BOTTOM:
+ correction = baseline_to_bottom;
+ break;
+ }
+
+ return subtitle.v_position() + (dcp::uses_bounding_box(subtitle.valign_standard) ? correction : -correction);
+}
+
+
void
-ReelWriter::write (PlayerText subs, TextType type, optional<DCPTextTrack> track, DCPTimePeriod period)
+ReelWriter::write(PlayerText subs, TextType type, optional<DCPTextTrack> track, DCPTimePeriod period, FontIdMap const& fonts, shared_ptr<dcpomatic::Font> chosen_interop_font)
{
shared_ptr<dcp::SubtitleAsset> asset;
for (auto i: subs.string) {
i.set_in (dcp::Time(period.from.seconds() - _period.from.seconds(), tcr));
i.set_out (dcp::Time(period.to.seconds() - _period.from.seconds(), tcr));
- asset->add (make_shared<dcp::SubtitleString>(i));
+ i.set_v_position(convert_vertical_position(i, film()->interop() ? dcp::SubtitleStandard::INTEROP : dcp::SubtitleStandard::SMPTE_2014));
+ auto sub = make_shared<dcp::SubtitleString>(i);
+ /* i.font is a shared_ptr<Font> which uniquely identifies the font we want,
+ * though if we are Interop we can only have one font, so we'll use the chosen
+ * one instead.
+ */
+ auto font = film()->interop() ? chosen_interop_font : i.font;
+ /* We can get the corresponding ID from fonts */
+ auto const font_id_to_use = fonts.get(font);
+ /* Give this subtitle the correct font ID */
+ sub->set_font(font_id_to_use);
+ asset->add(sub);
+ /* Make sure the asset LoadFonts the font we just asked for */
+ asset->ensure_font(font_id_to_use, font->data().get_value_or(_default_font));
}
for (auto i: subs.bitmap) {
image_as_png(i.image),
dcp::Time(period.from.seconds() - _period.from.seconds(), tcr),
dcp::Time(period.to.seconds() - _period.from.seconds(), tcr),
- i.rectangle.x, dcp::HAlign::LEFT, i.rectangle.y, dcp::VAlign::TOP,
+ i.rectangle.x, dcp::HAlign::LEFT, i.rectangle.y, dcp::VAlign::TOP, 0,
dcp::Time(), dcp::Time()
)
);
projects / dcpomatic.git / blobdiff