/*
- Copyright (C) 2012-2018 Carl Hetherington <cth@carlh.net>
+ Copyright (C) 2012-2019 Carl Hetherington <cth@carlh.net>
This file is part of DCP-o-matic.
#include "cross.h"
#include "job.h"
#include "log.h"
+#include "dcpomatic_log.h"
#include "digester.h"
#include "font.h"
#include "compose.hpp"
#include <dcp/reel_sound_asset.h>
#include <dcp/reel_subtitle_asset.h>
#include <dcp/reel_closed_caption_asset.h>
+#include <dcp/reel_markers_asset.h>
#include <dcp/dcp.h>
#include <dcp/cpl.h>
#include <dcp/certificate_chain.h>
#include "i18n.h"
-#define LOG_GENERAL(...) _film->log()->log (String::compose (__VA_ARGS__), LogEntry::TYPE_GENERAL);
-#define LOG_GENERAL_NC(...) _film->log()->log (__VA_ARGS__, LogEntry::TYPE_GENERAL);
-#define LOG_WARNING_NC(...) _film->log()->log (__VA_ARGS__, LogEntry::TYPE_WARNING);
-#define LOG_ERROR(...) _film->log()->log (String::compose (__VA_ARGS__), LogEntry::TYPE_ERROR);
-
using std::list;
using std::string;
using std::cout;
+using std::exception;
+using std::map;
using boost::shared_ptr;
using boost::optional;
using boost::dynamic_pointer_cast;
using dcp::Data;
using dcp::raw_convert;
+using namespace dcpomatic;
int const ReelWriter::_info_size = 48;
+/** @param job Related job, or 0 */
ReelWriter::ReelWriter (
shared_ptr<const Film> film, DCPTimePeriod period, shared_ptr<Job> job, int reel_index, int reel_count, optional<string> content_summary
)
, _reel_index (reel_index)
, _reel_count (reel_count)
, _content_summary (content_summary)
+ , _job (job)
{
- /* Create our picture asset in a subdirectory, named according to those
- film's parameters which affect the video output. We will hard-link
- it into the DCP later.
+ /* Create or find our picture asset in a subdirectory, named
+ according to those film's parameters which affect the video
+ output. We will hard-link it into the DCP later.
*/
dcp::Standard const standard = _film->interop() ? dcp::INTEROP : dcp::SMPTE;
- if (_film->three_d ()) {
- _picture_asset.reset (new dcp::StereoPictureAsset (dcp::Fraction (_film->video_frame_rate(), 1), standard));
- } else {
- _picture_asset.reset (new dcp::MonoPictureAsset (dcp::Fraction (_film->video_frame_rate(), 1), standard));
- }
+ boost::filesystem::path const asset =
+ _film->internal_video_asset_dir() / _film->internal_video_asset_filename(_period);
- _picture_asset->set_size (_film->frame_size ());
+ _first_nonexistant_frame = check_existing_picture_asset (asset);
- if (_film->encrypted ()) {
- _picture_asset->set_key (_film->key ());
- _picture_asset->set_context_id (_film->context_id ());
- }
+ if (_first_nonexistant_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 (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");
+ }
+ boost::filesystem::remove (asset);
+ boost::filesystem::rename (asset.string() + ".tmp", asset);
+ }
- _picture_asset->set_file (
- _film->internal_video_asset_dir() / _film->internal_video_asset_filename(_period)
- );
- job->sub (_("Checking existing image data"));
- _first_nonexistant_frame = check_existing_picture_asset ();
+ if (_film->three_d ()) {
+ _picture_asset.reset (new dcp::StereoPictureAsset(dcp::Fraction(_film->video_frame_rate(), 1), standard));
+ } else {
+ _picture_asset.reset (new dcp::MonoPictureAsset(dcp::Fraction(_film->video_frame_rate(), 1), standard));
+ }
- _picture_asset_writer = _picture_asset->start_write (
- _film->internal_video_asset_dir() / _film->internal_video_asset_filename(_period),
- _first_nonexistant_frame > 0
- );
+ _picture_asset->set_size (_film->frame_size());
+
+ if (_film->encrypted ()) {
+ _picture_asset->set_key (_film->key());
+ _picture_asset->set_context_id (_film->context_id());
+ }
+
+ _picture_asset->set_file (asset);
+ _picture_asset_writer = _picture_asset->start_write (asset, _first_nonexistant_frame > 0);
+ } else {
+ /* We already have a complete picture asset that we can just re-use */
+ /* XXX: what about if the encryption key changes? */
+ if (_film->three_d ()) {
+ _picture_asset.reset (new dcp::StereoPictureAsset(asset));
+ } else {
+ _picture_asset.reset (new dcp::MonoPictureAsset(asset));
+ }
+ }
if (_film->audio_channels ()) {
_sound_asset.reset (
void
ReelWriter::write_frame_info (Frame frame, Eyes eyes, dcp::FrameInfo info) const
{
- FILE* file = 0;
- boost::filesystem::path info_file = _film->info_file (_period);
-
- bool const read = boost::filesystem::exists (info_file);
-
- if (read) {
- file = fopen_boost (info_file, "r+b");
- } else {
- file = fopen_boost (info_file, "wb");
- }
- if (!file) {
- throw OpenFileError (info_file, errno, read);
- }
- dcpomatic_fseek (file, frame_info_position (frame, eyes), SEEK_SET);
- fwrite (&info.offset, sizeof (info.offset), 1, file);
- fwrite (&info.size, sizeof (info.size), 1, file);
- fwrite (info.hash.c_str(), 1, info.hash.size(), file);
- fclose (file);
+ shared_ptr<InfoFileHandle> handle = _film->info_file_handle(_period, false);
+ dcpomatic_fseek (handle->get(), frame_info_position(frame, eyes), SEEK_SET);
+ checked_fwrite (&info.offset, sizeof(info.offset), handle->get(), handle->file());
+ checked_fwrite (&info.size, sizeof (info.size), handle->get(), handle->file());
+ checked_fwrite (info.hash.c_str(), info.hash.size(), handle->get(), handle->file());
}
dcp::FrameInfo
-ReelWriter::read_frame_info (FILE* file, Frame frame, Eyes eyes) const
+ReelWriter::read_frame_info (shared_ptr<InfoFileHandle> info, Frame frame, Eyes eyes) const
{
- dcp::FrameInfo info;
- dcpomatic_fseek (file, frame_info_position (frame, eyes), SEEK_SET);
- fread (&info.offset, sizeof (info.offset), 1, file);
- fread (&info.size, sizeof (info.size), 1, file);
+ dcp::FrameInfo frame_info;
+ dcpomatic_fseek (info->get(), frame_info_position(frame, eyes), SEEK_SET);
+ checked_fread (&frame_info.offset, sizeof(frame_info.offset), info->get(), info->file());
+ checked_fread (&frame_info.size, sizeof(frame_info.size), info->get(), info->file());
char hash_buffer[33];
- fread (hash_buffer, 1, 32, file);
+ checked_fread (hash_buffer, 32, info->get(), info->file());
hash_buffer[32] = '\0';
- info.hash = hash_buffer;
+ frame_info.hash = hash_buffer;
- return info;
+ return frame_info;
}
long
}
Frame
-ReelWriter::check_existing_picture_asset ()
+ReelWriter::check_existing_picture_asset (boost::filesystem::path asset)
{
- DCPOMATIC_ASSERT (_picture_asset->file());
- boost::filesystem::path asset = _picture_asset->file().get();
-
- /* 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.
- */
+ shared_ptr<Job> job = _job.lock ();
- if (boost::filesystem::exists(asset) && boost::filesystem::hard_link_count(asset) > 1) {
- boost::filesystem::copy_file (asset, asset.string() + ".tmp");
- boost::filesystem::remove (asset);
- boost::filesystem::rename (asset.string() + ".tmp", asset);
+ if (job) {
+ job->sub (_("Checking existing image data"));
}
/* Try to open the existing asset */
LOG_GENERAL ("Opened existing asset at %1", asset.string());
}
- /* Offset of the last dcp::FrameInfo in the info file */
- int const n = (boost::filesystem::file_size (_film->info_file(_period)) / _info_size) - 1;
- LOG_GENERAL ("The last FI is %1; info file is %2, info size %3", n, boost::filesystem::file_size (_film->info_file(_period)), _info_size);
+ shared_ptr<InfoFileHandle> info_file;
- FILE* info_file = fopen_boost (_film->info_file(_period), "rb");
- if (!info_file) {
+ try {
+ info_file = _film->info_file_handle (_period, true);
+ } catch (OpenFileError) {
LOG_GENERAL_NC ("Could not open film info file");
fclose (asset_file);
return 0;
}
+ /* Offset of the last dcp::FrameInfo in the info file */
+ int const n = (boost::filesystem::file_size(info_file->file()) / _info_size) - 1;
+ LOG_GENERAL ("The last FI is %1; info file is %2, info size %3", n, boost::filesystem::file_size(info_file->file()), _info_size);
+
Frame first_nonexistant_frame;
if (_film->three_d ()) {
/* Start looking at the last left frame */
LOG_GENERAL ("Proceeding with first nonexistant frame %1", first_nonexistant_frame);
fclose (asset_file);
- fclose (info_file);
return first_nonexistant_frame;
}
void
ReelWriter::write (optional<Data> encoded, Frame frame, Eyes eyes)
{
+ if (!_picture_asset_writer) {
+ /* We're not writing any data */
+ return;
+ }
+
dcp::FrameInfo fin = _picture_asset_writer->write (encoded->data().get (), encoded->size());
write_frame_info (frame, eyes, fin);
_last_written[eyes] = encoded;
void
ReelWriter::fake_write (Frame frame, Eyes eyes, int size)
{
+ if (!_picture_asset_writer) {
+ /* We're not writing any data */
+ return;
+ }
+
_picture_asset_writer->fake_write (size);
_last_written_video_frame = frame;
_last_written_eyes = eyes;
void
ReelWriter::repeat_write (Frame frame, Eyes eyes)
{
+ if (!_picture_asset_writer) {
+ /* We're not writing any data */
+ return;
+ }
+
dcp::FrameInfo fin = _picture_asset_writer->write (
_last_written[eyes]->data().get(),
_last_written[eyes]->size()
void
ReelWriter::finish ()
{
- if (!_picture_asset_writer->finalize ()) {
+ if (_picture_asset_writer && !_picture_asset_writer->finalize ()) {
/* Nothing was written to the picture asset */
LOG_GENERAL ("Nothing was written to reel %1 of %2", _reel_index, _reel_count);
_picture_asset.reset ();
boost::filesystem::path video_to;
video_to /= _film->dir (_film->dcp_name());
video_to /= video_asset_filename (_picture_asset, _reel_index, _reel_count, _content_summary);
-
+ /* There may be an existing "to" file if we are recreating a DCP in the same place without
+ changing any video.
+ */
boost::system::error_code ec;
+ boost::filesystem::remove (video_to, ec);
+
boost::filesystem::create_hard_link (video_from, video_to, ec);
if (ec) {
LOG_WARNING_NC ("Hard-link failed; copying instead");
- boost::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 ());
- throw FileError (ec.message(), video_from);
+ shared_ptr<Job> job = _job.lock ();
+ if (job) {
+ job->sub (_("Copying video file into DCP"));
+ try {
+ copy_in_bits (video_from, video_to, bind(&Job::set_progress, job.get(), _1, false));
+ } catch (exception& e) {
+ LOG_ERROR ("Failed to copy video file from %1 to %2 (%3)", video_from.string(), video_to.string(), e.what());
+ throw FileError (e.what(), video_from);
+ }
+ } else {
+ boost::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());
+ throw FileError (ec.message(), video_from);
+ }
}
}
}
template <class T>
-void
-maybe_add_captions (
+shared_ptr<T>
+maybe_add_text (
shared_ptr<dcp::SubtitleAsset> asset,
int64_t picture_duration,
shared_ptr<dcp::Reel> reel,
shared_ptr<T> reel_asset;
if (asset) {
-
boost::filesystem::path liberation_normal;
try {
liberation_normal = shared_path() / "LiberationSans-Regular.ttf";
liberation_normal = "/usr/share/fonts/truetype/liberation/LiberationSans-Regular.ttf";
}
- /* Add all the fonts to the subtitle content */
+ /* Add the font to the subtitle content */
BOOST_FOREACH (shared_ptr<Font> j, fonts) {
- asset->add_font (j->id(), j->file(FontFiles::NORMAL).get_value_or(liberation_normal));
+ asset->add_font (j->id(), j->file().get_value_or(liberation_normal));
}
if (dynamic_pointer_cast<dcp::InteropSubtitleAsset> (asset)) {
boost::filesystem::create_directories (directory);
asset->write (directory / ("sub_" + asset->id() + ".xml"));
} else {
-
/* All our assets should be the same length; use the picture asset length here
as a reference to set the subtitle one. We'll use the duration rather than
the intrinsic duration; we don't care if the picture asset has been trimmed, we're
}
if (reel_asset) {
- if (reel_asset->duration() != period_duration) {
+ if (reel_asset->actual_duration() != period_duration) {
throw ProgrammingError (
__FILE__, __LINE__,
- String::compose ("%1 vs %2", reel_asset->duration(), period_duration)
+ String::compose ("%1 vs %2", reel_asset->actual_duration(), period_duration)
);
}
reel->add (reel_asset);
}
+
+ return reel_asset;
}
shared_ptr<dcp::Reel>
ReelWriter::create_reel (list<ReferencedReelAsset> const & refs, list<shared_ptr<Font> > const & fonts)
{
+ LOG_GENERAL ("create_reel for %1-%2; %3 of %4", _period.from.get(), _period.to.get(), _reel_index, _reel_count);
+
shared_ptr<dcp::Reel> reel (new dcp::Reel ());
shared_ptr<dcp::ReelPictureAsset> reel_picture_asset;
+ LOG_GENERAL ("create_reel for %1-%2; %3 of %4", _period.from.get(), _period.to.get(), _reel_index, _reel_count);
+
if (_picture_asset) {
/* We have made a picture asset of our own. Put it into the reel */
shared_ptr<dcp::MonoPictureAsset> mono = dynamic_pointer_cast<dcp::MonoPictureAsset> (_picture_asset);
}
}
- LOG_GENERAL ("create_reel for %1-%2; %3 of %4", _period.from.get(), _period.to.get(), _reel_index, _reel_count);
-
Frame const period_duration = _period.duration().frames_round(_film->video_frame_rate());
DCPOMATIC_ASSERT (reel_picture_asset);
if (reel_picture_asset->duration() != period_duration) {
throw ProgrammingError (
__FILE__, __LINE__,
- String::compose ("%1 vs %2", reel_picture_asset->duration(), period_duration)
+ String::compose ("%1 vs %2", reel_picture_asset->actual_duration(), period_duration)
);
}
reel->add (reel_picture_asset);
/* We have made a sound asset of our own. Put it into the reel */
reel_sound_asset.reset (new dcp::ReelSoundAsset (_sound_asset, 0));
} else {
+ LOG_GENERAL ("no sound asset of our own; look through %1", refs.size());
/* We don't have a sound asset of our own; hopefully we have one to reference */
BOOST_FOREACH (ReferencedReelAsset j, refs) {
shared_ptr<dcp::ReelSoundAsset> k = dynamic_pointer_cast<dcp::ReelSoundAsset> (j.asset);
+ if (k) {
+ LOG_GENERAL ("candidate sound asset period is %1-%2", j.period.from.get(), j.period.to.get());
+ }
if (k && j.period == _period) {
reel_sound_asset = k;
/* If we have a hash for this asset in the CPL, assume that it is correct */
}
DCPOMATIC_ASSERT (reel_sound_asset);
- if (reel_sound_asset->duration() != period_duration) {
+ if (reel_sound_asset->actual_duration() != period_duration) {
LOG_ERROR (
"Reel sound asset has length %1 but reel period is %2",
- reel_sound_asset->duration(),
+ reel_sound_asset->actual_duration(),
period_duration
);
- if (reel_sound_asset->duration() != period_duration) {
+ if (reel_sound_asset->actual_duration() != period_duration) {
throw ProgrammingError (
__FILE__, __LINE__,
- String::compose ("%1 vs %2", reel_sound_asset->duration(), period_duration)
+ String::compose ("%1 vs %2", reel_sound_asset->actual_duration(), period_duration)
);
}
}
reel->add (reel_sound_asset);
- maybe_add_captions<dcp::ReelSubtitleAsset> (_caption_asset[TEXT_OPEN_SUBTITLE], reel_picture_asset->duration(), reel, refs, fonts, _film, _period);
- maybe_add_captions<dcp::ReelClosedCaptionAsset> (_caption_asset[TEXT_CLOSED_CAPTION], reel_picture_asset->duration(), reel, refs, fonts, _film, _period);
+ maybe_add_text<dcp::ReelSubtitleAsset> (_subtitle_asset, reel_picture_asset->actual_duration(), reel, refs, fonts, _film, _period);
+ for (map<DCPTextTrack, shared_ptr<dcp::SubtitleAsset> >::const_iterator i = _closed_caption_assets.begin(); i != _closed_caption_assets.end(); ++i) {
+ shared_ptr<dcp::ReelClosedCaptionAsset> a = maybe_add_text<dcp::ReelClosedCaptionAsset> (
+ i->second, reel_picture_asset->actual_duration(), reel, refs, fonts, _film, _period
+ );
+ a->set_annotation_text (i->first.name);
+ a->set_language (i->first.language);
+ }
+
+ map<dcp::Marker, DCPTime> markers = _film->markers ();
+ map<dcp::Marker, DCPTime> reel_markers;
+ for (map<dcp::Marker, DCPTime>::const_iterator i = markers.begin(); i != markers.end(); ++i) {
+ if (_period.contains(i->second)) {
+ reel_markers[i->first] = i->second;
+ }
+ }
+
+ if (!reel_markers.empty ()) {
+ shared_ptr<dcp::ReelMarkersAsset> ma (new dcp::ReelMarkersAsset(dcp::Fraction(_film->video_frame_rate(), 1), 0));
+ for (map<dcp::Marker, DCPTime>::const_iterator i = reel_markers.begin(); i != reel_markers.end(); ++i) {
+ int h, m, s, f;
+ DCPTime relative = i->second - _period.from;
+ relative.split (_film->video_frame_rate(), h, m, s, f);
+ ma->set (i->first, dcp::Time(h, m, s, f, _film->video_frame_rate()));
+ }
+ reel->add (ma);
+ }
return reel;
}
}
void
-ReelWriter::write (PlayerText subs, TextType type, DCPTimePeriod period)
+ReelWriter::write (PlayerText subs, TextType type, optional<DCPTextTrack> track, DCPTimePeriod period)
{
- if (!_caption_asset[type]) {
+ shared_ptr<dcp::SubtitleAsset> asset;
+
+ switch (type) {
+ case TEXT_OPEN_SUBTITLE:
+ asset = _subtitle_asset;
+ break;
+ case TEXT_CLOSED_CAPTION:
+ DCPOMATIC_ASSERT (track);
+ asset = _closed_caption_assets[*track];
+ break;
+ default:
+ DCPOMATIC_ASSERT (false);
+ }
+
+ if (!asset) {
string lang = _film->subtitle_language ();
- if (lang.empty ()) {
- lang = "Unknown";
- }
if (_film->interop ()) {
shared_ptr<dcp::InteropSubtitleAsset> s (new dcp::InteropSubtitleAsset ());
s->set_movie_title (_film->name ());
- s->set_language (lang);
+ if (type == TEXT_OPEN_SUBTITLE) {
+ s->set_language (lang.empty() ? "Unknown" : lang);
+ } else {
+ s->set_language (track->language);
+ }
s->set_reel_number (raw_convert<string> (_reel_index + 1));
- _caption_asset[type] = s;
+ asset = s;
} else {
shared_ptr<dcp::SMPTESubtitleAsset> s (new dcp::SMPTESubtitleAsset ());
s->set_content_title_text (_film->name ());
- s->set_language (lang);
+ if (type == TEXT_OPEN_SUBTITLE && !lang.empty()) {
+ s->set_language (lang);
+ } else {
+ s->set_language (track->language);
+ }
s->set_edit_rate (dcp::Fraction (_film->video_frame_rate (), 1));
s->set_reel_number (_reel_index + 1);
s->set_time_code_rate (_film->video_frame_rate ());
if (_film->encrypted ()) {
s->set_key (_film->key ());
}
- _caption_asset[type] = s;
+ asset = s;
}
}
+ switch (type) {
+ case TEXT_OPEN_SUBTITLE:
+ _subtitle_asset = asset;
+ break;
+ case TEXT_CLOSED_CAPTION:
+ DCPOMATIC_ASSERT (track);
+ _closed_caption_assets[*track] = asset;
+ break;
+ default:
+ DCPOMATIC_ASSERT (false);
+ }
+
BOOST_FOREACH (StringText i, subs.string) {
/* XXX: couldn't / shouldn't we use period here rather than getting time from the subtitle? */
i.set_in (i.in() - dcp::Time (_period.from.seconds(), i.in().tcr));
i.set_out (i.out() - dcp::Time (_period.from.seconds(), i.out().tcr));
- _caption_asset[type]->add (shared_ptr<dcp::Subtitle>(new dcp::SubtitleString(i)));
+ asset->add (shared_ptr<dcp::Subtitle>(new dcp::SubtitleString(i)));
}
BOOST_FOREACH (BitmapText i, subs.bitmap) {
- _caption_asset[type]->add (
+ asset->add (
shared_ptr<dcp::Subtitle>(
new dcp::SubtitleImage(
i.image->as_png(),
- dcp::Time(period.from.seconds(), _film->video_frame_rate()),
- dcp::Time(period.to.seconds(), _film->video_frame_rate()),
+ dcp::Time(period.from.seconds() - _period.from.seconds(), _film->video_frame_rate()),
+ dcp::Time(period.to.seconds() - _period.from.seconds(), _film->video_frame_rate()),
i.rectangle.x, dcp::HALIGN_LEFT, i.rectangle.y, dcp::VALIGN_TOP,
dcp::Time(), dcp::Time()
)
}
bool
-ReelWriter::existing_picture_frame_ok (FILE* asset_file, FILE* info_file, Frame frame) const
+ReelWriter::existing_picture_frame_ok (FILE* asset_file, shared_ptr<InfoFileHandle> info_file, Frame frame) const
{
LOG_GENERAL ("Checking existing picture frame %1", frame);