X-Git-Url: https://main.carlh.net/gitweb/?p=dcpomatic.git;a=blobdiff_plain;f=src%2Flib%2Freel_writer.cc;h=071cab12a3facd9f6f4fcf15b13a356d02eaf881;hp=bc0013ff130ec7230f324f80563114f7f131f8f5;hb=2998afa8238fc826f696a856f272e1f16d166f3c;hpb=ddad6389ba1971603a3dbf975b1e5fae95ce6bd6 diff --git a/src/lib/reel_writer.cc b/src/lib/reel_writer.cc index bc0013ff1..071cab12a 100644 --- a/src/lib/reel_writer.cc +++ b/src/lib/reel_writer.cc @@ -1,5 +1,5 @@ /* - Copyright (C) 2012-2015 Carl Hetherington + Copyright (C) 2012-2019 Carl Hetherington This file is part of DCP-o-matic. @@ -23,10 +23,12 @@ #include "cross.h" #include "job.h" #include "log.h" -#include "md5_digester.h" +#include "dcpomatic_log.h" +#include "digester.h" #include "font.h" #include "compose.hpp" #include "audio_buffers.h" +#include "image.h" #include #include #include @@ -36,83 +38,91 @@ #include #include #include +#include #include #include #include #include #include +#include +#include #include #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; int const ReelWriter::_info_size = 48; -ReelWriter::ReelWriter (shared_ptr film, DCPTimePeriod period, shared_ptr job) +/** @param job Related job, or 0 */ +ReelWriter::ReelWriter ( + shared_ptr film, DCPTimePeriod period, shared_ptr job, int reel_index, int reel_count, optional content_summary + ) : _film (film) , _period (period) - , _first_nonexistant_frame (0) , _last_written_video_frame (-1) , _last_written_eyes (EYES_RIGHT) - , _total_written_audio_frames (0) + , _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. */ + 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))); + _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))); + _picture_asset.reset (new dcp::MonoPictureAsset (dcp::Fraction (_film->video_frame_rate(), 1), standard)); } _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 ( _film->internal_video_asset_dir() / _film->internal_video_asset_filename(_period) ); - job->sub (_("Checking existing image data")); - check_existing_picture_asset (); + _first_nonexistant_frame = check_existing_picture_asset (); _picture_asset_writer = _picture_asset->start_write ( _film->internal_video_asset_dir() / _film->internal_video_asset_filename(_period), - _film->interop() ? dcp::INTEROP : dcp::SMPTE, _first_nonexistant_frame > 0 ); if (_film->audio_channels ()) { _sound_asset.reset ( - new dcp::SoundAsset (dcp::Fraction (_film->video_frame_rate(), 1), _film->audio_frame_rate (), _film->audio_channels ()) + new dcp::SoundAsset (dcp::Fraction (_film->video_frame_rate(), 1), _film->audio_frame_rate (), _film->audio_channels (), standard) ); if (_film->encrypted ()) { _sound_asset->set_key (_film->key ()); } + DCPOMATIC_ASSERT (_film->directory()); + /* 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() / audio_asset_filename (_sound_asset), - _film->interop() ? dcp::INTEROP : dcp::SMPTE + _film->directory().get() / audio_asset_filename (_sound_asset, _reel_index, _reel_count, _content_summary) ); } } @@ -121,37 +131,27 @@ ReelWriter::ReelWriter (shared_ptr film, DCPTimePeriod period, share 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); - if (boost::filesystem::exists (info_file)) { - file = fopen_boost (info_file, "r+b"); - } else { - file = fopen_boost (info_file, "wb"); - } - if (!file) { - throw OpenFileError (info_file); - } - 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 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 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 @@ -171,51 +171,80 @@ ReelWriter::frame_info_position (Frame frame, Eyes eyes) const DCPOMATIC_ASSERT (false); } -void +Frame ReelWriter::check_existing_picture_asset () { + DCPOMATIC_ASSERT (_picture_asset->file()); + boost::filesystem::path asset = _picture_asset->file().get(); + + shared_ptr job = _job.lock (); + + /* 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); + } + + if (job) { + job->sub (_("Checking existing image data")); + } + /* Try to open the existing asset */ - FILE* asset_file = fopen_boost (_picture_asset->file(), "rb"); + FILE* asset_file = fopen_boost (asset, "rb"); if (!asset_file) { - LOG_GENERAL ("Could not open existing asset at %1 (errno=%2)", _picture_asset->file().string(), errno); - return; + LOG_GENERAL ("Could not open existing asset at %1 (errno=%2)", asset.string(), errno); + return 0; } else { - LOG_GENERAL ("Opened existing asset at %1", _picture_asset->file().string()); + 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 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; + 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 */ - _first_nonexistant_frame = n / 2; + first_nonexistant_frame = n / 2; } else { - _first_nonexistant_frame = n; + first_nonexistant_frame = n; } - while (!existing_picture_frame_ok(asset_file, info_file) && _first_nonexistant_frame > 0) { - --_first_nonexistant_frame; + while (!existing_picture_frame_ok(asset_file, info_file, first_nonexistant_frame) && first_nonexistant_frame > 0) { + --first_nonexistant_frame; } - if (!_film->three_d() && _first_nonexistant_frame > 0) { + if (!_film->three_d() && first_nonexistant_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_nonexistant_frame; } - LOG_GENERAL ("Proceeding with first nonexistant frame %1", _first_nonexistant_frame); + LOG_GENERAL ("Proceeding with first nonexistant frame %1", first_nonexistant_frame); fclose (asset_file); - fclose (info_file); + + return first_nonexistant_frame; } void @@ -253,6 +282,7 @@ ReelWriter::finish () { if (!_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 (); } @@ -263,19 +293,35 @@ ReelWriter::finish () /* Hard-link any video asset file into the DCP */ if (_picture_asset) { - boost::filesystem::path video_from = _picture_asset->file (); + DCPOMATIC_ASSERT (_picture_asset->file()); + boost::filesystem::path video_from = _picture_asset->file().get(); boost::filesystem::path video_to; video_to /= _film->dir (_film->dcp_name()); - video_to /= video_asset_filename (_picture_asset); + video_to /= video_asset_filename (_picture_asset, _reel_index, _reel_count, _content_summary); + + LOG_GENERAL ("Must put %1 into DCP at %2", video_from.string(), video_to.string()); + LOG_GENERAL ("%1: %2", video_from.string(), boost::filesystem::is_regular_file(video_from) ? "yes" : "no"); + LOG_GENERAL ("%1: %2", video_to.string(), boost::filesystem::is_regular_file(video_to) ? "yes" : "no"); boost::system::error_code 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); + LOG_WARNING ("Hard-link failed (%1); copying instead", ec.message()); + shared_ptr 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); + } } } @@ -286,13 +332,14 @@ ReelWriter::finish () if (_sound_asset) { boost::filesystem::path audio_to; audio_to /= _film->dir (_film->dcp_name ()); - audio_to /= audio_asset_filename (_sound_asset); + string const aaf = audio_asset_filename (_sound_asset, _reel_index, _reel_count, _content_summary); + audio_to /= aaf; boost::system::error_code ec; - boost::filesystem::rename (_film->file (audio_asset_filename (_sound_asset)), audio_to, ec); + boost::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 ()), audio_asset_filename (_sound_asset) + String::compose (_("could not move audio asset into the DCP (%1)"), ec.value ()), aaf ); } @@ -300,13 +347,106 @@ ReelWriter::finish () } } +template +shared_ptr +maybe_add_text ( + shared_ptr asset, + int64_t picture_duration, + shared_ptr reel, + list const & refs, + list > const & fonts, + shared_ptr film, + DCPTimePeriod period + ) +{ + Frame const period_duration = period.duration().frames_round(film->video_frame_rate()); + + shared_ptr reel_asset; + + if (asset) { + boost::filesystem::path liberation_normal; + try { + liberation_normal = shared_path() / "LiberationSans-Regular.ttf"; + if (!boost::filesystem::exists (liberation_normal)) { + /* Hack for unit tests */ + liberation_normal = shared_path() / "fonts" / "LiberationSans-Regular.ttf"; + } + } catch (boost::filesystem::filesystem_error& e) { + + } + + if (!boost::filesystem::exists(liberation_normal)) { + liberation_normal = "/usr/share/fonts/truetype/liberation/LiberationSans-Regular.ttf"; + } + + /* Add the font to the subtitle content */ + BOOST_FOREACH (shared_ptr j, fonts) { + asset->add_font (j->id(), j->file().get_value_or(liberation_normal)); + } + + if (dynamic_pointer_cast (asset)) { + boost::filesystem::path directory = film->dir (film->dcp_name ()) / asset->id (); + 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 + just interested in its presentation length. + */ + dynamic_pointer_cast(asset)->set_intrinsic_duration (picture_duration); + + asset->write ( + film->dir(film->dcp_name()) / ("sub_" + asset->id() + ".mxf") + ); + } + + reel_asset.reset ( + new T ( + asset, + dcp::Fraction (film->video_frame_rate(), 1), + picture_duration, + 0 + ) + ); + } else { + /* We don't have a subtitle asset of our own; hopefully we have one to reference */ + BOOST_FOREACH (ReferencedReelAsset j, refs) { + shared_ptr k = dynamic_pointer_cast (j.asset); + if (k && j.period == period) { + reel_asset = k; + /* If we have a hash for this asset in the CPL, assume that it is correct */ + if (k->hash()) { + k->asset_ref()->set_hash (k->hash().get()); + } + } + } + } + + if (reel_asset) { + if (reel_asset->duration() != period_duration) { + throw ProgrammingError ( + __FILE__, __LINE__, + String::compose ("%1 vs %2", reel_asset->duration(), period_duration) + ); + } + reel->add (reel_asset); + } + + return reel_asset; +} + shared_ptr ReelWriter::create_reel (list const & refs, list > const & fonts) { + LOG_GENERAL ("create_reel for %1-%2; %3 of %4", _period.from.get(), _period.to.get(), _reel_index, _reel_count); + shared_ptr reel (new dcp::Reel ()); shared_ptr 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 mono = dynamic_pointer_cast (_picture_asset); @@ -319,30 +459,50 @@ ReelWriter::create_reel (list const & refs, list k = dynamic_pointer_cast (j.asset); + if (k) { + LOG_GENERAL ("candidate picture asset period is %1-%2", j.period.from.get(), j.period.to.get()); + } if (k && j.period == _period) { reel_picture_asset = k; } } } + 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) + ); + } reel->add (reel_picture_asset); + /* If we have a hash for this asset in the CPL, assume that it is correct */ if (reel_picture_asset->hash()) { reel_picture_asset->asset_ref()->set_hash (reel_picture_asset->hash().get()); } + shared_ptr reel_sound_asset; + if (_sound_asset) { /* We have made a sound asset of our own. Put it into the reel */ - reel->add (shared_ptr (new dcp::ReelSoundAsset (_sound_asset, 0))); + 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 k = dynamic_pointer_cast (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->add (k); + reel_sound_asset = k; /* If we have a hash for this asset in the CPL, assume that it is correct */ if (k->hash()) { k->asset_ref()->set_hash (k->hash().get()); @@ -351,82 +511,44 @@ ReelWriter::create_reel (list const & refs, list j, fonts) { - _subtitle_asset->add_font (j->id(), j->file(FontFiles::NORMAL).get_value_or(liberation_normal)); - } - - if (dynamic_pointer_cast (_subtitle_asset)) { - boost::filesystem::path directory = _film->dir (_film->dcp_name ()) / _subtitle_asset->id (); - boost::filesystem::create_directories (directory); - _subtitle_asset->write (directory / ("sub_" + _subtitle_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. - */ - dynamic_pointer_cast(_subtitle_asset)->set_intrinsic_duration ( - reel_picture_asset->intrinsic_duration () - ); - - _subtitle_asset->write ( - _film->dir (_film->dcp_name ()) / ("sub_" + _subtitle_asset->id() + ".mxf") + DCPOMATIC_ASSERT (reel_sound_asset); + if (reel_sound_asset->duration() != period_duration) { + LOG_ERROR ( + "Reel sound asset has length %1 but reel period is %2", + reel_sound_asset->duration(), + period_duration + ); + if (reel_sound_asset->duration() != period_duration) { + throw ProgrammingError ( + __FILE__, __LINE__, + String::compose ("%1 vs %2", reel_sound_asset->duration(), period_duration) ); } - reel->add (shared_ptr ( - new dcp::ReelSubtitleAsset ( - _subtitle_asset, - dcp::Fraction (_film->video_frame_rate(), 1), - reel_picture_asset->intrinsic_duration (), - 0 - ) - )); - } else { - /* We don't have a subtitle asset of our own; hopefully we have one to reference */ - BOOST_FOREACH (ReferencedReelAsset j, refs) { - shared_ptr k = dynamic_pointer_cast (j.asset); - if (k && j.period == _period) { - reel->add (k); - /* If we have a hash for this asset in the CPL, assume that it is correct */ - if (k->hash()) { - k->asset_ref()->set_hash (k->hash().get()); - } - } - } + } + reel->add (reel_sound_asset); + + maybe_add_text (_subtitle_asset, reel_picture_asset->duration(), reel, refs, fonts, _film, _period); + for (map >::const_iterator i = _closed_caption_assets.begin(); i != _closed_caption_assets.end(); ++i) { + shared_ptr a = maybe_add_text ( + i->second, reel_picture_asset->duration(), reel, refs, fonts, _film, _period + ); + a->set_annotation_text (i->first.name); + a->set_language (i->first.language); } return reel; } void -ReelWriter::calculate_digests (shared_ptr job) +ReelWriter::calculate_digests (boost::function set_progress) { - job->sub (_("Computing image digest")); if (_picture_asset) { - _picture_asset->hash (boost::bind (&Job::set_progress, job.get(), _1, false)); + _picture_asset->hash (set_progress); } if (_sound_asset) { - job->sub (_("Computing audio digest")); - _sound_asset->hash (boost::bind (&Job::set_progress, job.get(), _1, false)); + _sound_asset->hash (set_progress); } } @@ -444,55 +566,101 @@ ReelWriter::write (shared_ptr audio) return; } - if (audio) { - _sound_asset_writer->write (audio->data(), audio->frames()); - } - - ++_total_written_audio_frames; + DCPOMATIC_ASSERT (audio); + _sound_asset_writer->write (audio->data(), audio->frames()); } void -ReelWriter::write (PlayerSubtitles subs) +ReelWriter::write (PlayerText subs, TextType type, optional track, DCPTimePeriod period) { - if (!_subtitle_asset) { + shared_ptr 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 s (new dcp::InteropSubtitleAsset ()); s->set_movie_title (_film->name ()); - s->set_language (lang); - s->set_reel_number ("1"); - _subtitle_asset = s; + if (type == TEXT_OPEN_SUBTITLE) { + s->set_language (lang.empty() ? "Unknown" : lang); + } else { + s->set_language (track->language); + } + s->set_reel_number (raw_convert (_reel_index + 1)); + asset = s; } else { shared_ptr 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 (1); + s->set_reel_number (_reel_index + 1); s->set_time_code_rate (_film->video_frame_rate ()); s->set_start_time (dcp::Time ()); - _subtitle_asset = s; + if (_film->encrypted ()) { + s->set_key (_film->key ()); + } + asset = s; } } - BOOST_FOREACH (dcp::SubtitleString i, subs.text) { + 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)); - _subtitle_asset->add (i); + asset->add (shared_ptr(new dcp::SubtitleString(i))); + } + + BOOST_FOREACH (BitmapText i, subs.bitmap) { + asset->add ( + shared_ptr( + new dcp::SubtitleImage( + i.image->as_png(), + 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) const +ReelWriter::existing_picture_frame_ok (FILE* asset_file, shared_ptr info_file, Frame frame) const { - LOG_GENERAL ("Checking existing picture frame %1", _first_nonexistant_frame); + LOG_GENERAL ("Checking existing picture frame %1", frame); /* Read the data from the info file; for 3D we just check the left frames until we find a good one. */ - dcp::FrameInfo const info = read_frame_info (info_file, _first_nonexistant_frame, _film->three_d () ? EYES_LEFT : EYES_BOTH); + dcp::FrameInfo const info = read_frame_info (info_file, frame, _film->three_d () ? EYES_LEFT : EYES_BOTH); bool ok = true; @@ -502,14 +670,14 @@ ReelWriter::existing_picture_frame_ok (FILE* asset_file, FILE* info_file) const size_t const read = fread (data.data().get(), 1, data.size(), asset_file); LOG_GENERAL ("Read %1 bytes of asset data; wanted %2", read, info.size); if (read != static_cast (data.size ())) { - LOG_GENERAL ("Existing frame %1 is incomplete", _first_nonexistant_frame); + LOG_GENERAL ("Existing frame %1 is incomplete", frame); ok = false; } else { - MD5Digester digester; + Digester digester; digester.add (data.data().get(), data.size()); LOG_GENERAL ("Hash %1 vs %2", digester.get(), info.hash); if (digester.get() != info.hash) { - LOG_GENERAL ("Existing frame %1 failed hash check", _first_nonexistant_frame); + LOG_GENERAL ("Existing frame %1 failed hash check", frame); ok = false; } }