src/lib/reel_writer.cc

   1 /*
   2     Copyright (C) 2012-2020 Carl Hetherington <cth@carlh.net>
   3
   4     This file is part of DCP-o-matic.
   5
   6     DCP-o-matic is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     DCP-o-matic is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with DCP-o-matic.  If not, see <http://www.gnu.org/licenses/>.
  18
  19 */
  20
  21
  22 #include "audio_buffers.h"
  23 #include "compose.hpp"
  24 #include "config.h"
  25 #include "constants.h"
  26 #include "cross.h"
  27 #include "dcpomatic_log.h"
  28 #include "digester.h"
  29 #include "film.h"
  30 #include "image.h"
  31 #include "image_png.h"
  32 #include "job.h"
  33 #include "log.h"
  34 #include "reel_writer.h"
  35 #include <dcp/atmos_asset.h>
  36 #include <dcp/atmos_asset_writer.h>
  37 #include <dcp/certificate_chain.h>
  38 #include <dcp/cpl.h>
  39 #include <dcp/dcp.h>
  40 #include <dcp/interop_subtitle_asset.h>
  41 #include <dcp/mono_picture_asset.h>
  42 #include <dcp/raw_convert.h>
  43 #include <dcp/reel.h>
  44 #include <dcp/reel_atmos_asset.h>
  45 #include <dcp/reel_interop_closed_caption_asset.h>
  46 #include <dcp/reel_interop_subtitle_asset.h>
  47 #include <dcp/reel_markers_asset.h>
  48 #include <dcp/reel_mono_picture_asset.h>
  49 #include <dcp/reel_smpte_closed_caption_asset.h>
  50 #include <dcp/reel_smpte_subtitle_asset.h>
  51 #include <dcp/reel_sound_asset.h>
  52 #include <dcp/reel_stereo_picture_asset.h>
  53 #include <dcp/smpte_subtitle_asset.h>
  54 #include <dcp/sound_asset.h>
  55 #include <dcp/sound_asset_writer.h>
  56 #include <dcp/stereo_picture_asset.h>
  57 #include <dcp/subtitle_image.h>
  58
  59 #include "i18n.h"
  60
  61
  62 using std::dynamic_pointer_cast;
  63 using std::exception;
  64 using std::list;
  65 using std::make_shared;
  66 using std::map;
  67 using std::set;
  68 using std::shared_ptr;
  69 using std::string;
  70 using std::vector;
  71 using std::weak_ptr;
  72 using boost::optional;
  73 #if BOOST_VERSION >= 106100
  74 using namespace boost::placeholders;
  75 #endif
  76 using dcp::ArrayData;
  77 using dcp::Data;
  78 using dcp::raw_convert;
  79 using namespace dcpomatic;
  80
  81
  82 int const ReelWriter::_info_size = 48;
  83
  84
  85 static dcp::MXFMetadata
  86 mxf_metadata ()
  87 {
  88         dcp::MXFMetadata meta;
  89         auto config = Config::instance();
  90         if (!config->dcp_company_name().empty()) {
  91                 meta.company_name = config->dcp_company_name ();
  92         }
  93         if (!config->dcp_product_name().empty()) {
  94                 meta.product_name = config->dcp_product_name ();
  95         }
  96         if (!config->dcp_product_version().empty()) {
  97                 meta.product_version = config->dcp_product_version ();
  98         }
  99         return meta;
 100 }
 101
 102
 103 /** @param job Related job, or 0.
 104  *  @param text_only true to enable a special mode where the writer will expect only subtitles and closed captions to be written
 105  *  (no picture nor sound) and not give errors in that case.  This is used by the hints system to check the potential sizes of
 106  *  subtitle / closed caption files.
 107  */
 108 ReelWriter::ReelWriter (
 109         weak_ptr<const Film> weak_film, DCPTimePeriod period, shared_ptr<Job> job, int reel_index, int reel_count, bool text_only
 110         )
 111         : WeakConstFilm (weak_film)
 112         , _period (period)
 113         , _reel_index (reel_index)
 114         , _reel_count (reel_count)
 115         , _content_summary (film()->content_summary(period))
 116         , _job (job)
 117         , _text_only (text_only)
 118         , _font_metrics(film()->frame_size().height)
 119 {
 120         /* Create or find our picture asset in a subdirectory, named
 121            according to those film's parameters which affect the video
 122            output.  We will hard-link it into the DCP later.
 123         */
 124
 125         auto const standard = film()->interop() ? dcp::Standard::INTEROP : dcp::Standard::SMPTE;
 126
 127         boost::filesystem::path const asset =
 128                 film()->internal_video_asset_dir() / film()->internal_video_asset_filename(_period);
 129
 130         _first_nonexistent_frame = check_existing_picture_asset (asset);
 131
 132         if (_first_nonexistent_frame < period.duration().frames_round(film()->video_frame_rate())) {
 133                 /* We do not have a complete picture asset.  If there is an
 134                    existing asset, break any hard links to it as we are about
 135                    to change its contents (if only by changing the IDs); see
 136                    #1126.
 137                 */
 138                 if (boost::filesystem::exists(asset) && boost::filesystem::hard_link_count(asset) > 1) {
 139                         if (job) {
 140                                 job->sub (_("Copying old video file"));
 141                                 copy_in_bits (asset, asset.string() + ".tmp", bind(&Job::set_progress, job.get(), _1, false));
 142                         } else {
 143                                 boost::filesystem::copy_file (asset, asset.string() + ".tmp");
 144                         }
 145                         boost::filesystem::remove (asset);
 146                         boost::filesystem::rename (asset.string() + ".tmp", asset);
 147                 }
 148
 149
 150                 if (film()->three_d()) {
 151                         _picture_asset.reset (new dcp::StereoPictureAsset(dcp::Fraction(film()->video_frame_rate(), 1), standard));
 152                 } else {
 153                         _picture_asset.reset (new dcp::MonoPictureAsset(dcp::Fraction(film()->video_frame_rate(), 1), standard));
 154                 }
 155
 156                 _picture_asset->set_size (film()->frame_size());
 157                 _picture_asset->set_metadata (mxf_metadata());
 158
 159                 if (film()->encrypted()) {
 160                         _picture_asset->set_key (film()->key());
 161                         _picture_asset->set_context_id (film()->context_id());
 162                 }
 163
 164                 _picture_asset->set_file (asset);
 165                 _picture_asset_writer = _picture_asset->start_write(asset, _first_nonexistent_frame > 0 ? dcp::PictureAsset::Behaviour::OVERWRITE_EXISTING : dcp::PictureAsset::Behaviour::MAKE_NEW);
 166         } else if (!text_only) {
 167                 /* We already have a complete picture asset that we can just re-use */
 168                 /* XXX: what about if the encryption key changes? */
 169                 if (film()->three_d()) {
 170                         _picture_asset = make_shared<dcp::StereoPictureAsset>(asset);
 171                 } else {
 172                         _picture_asset = make_shared<dcp::MonoPictureAsset>(asset);
 173                 }
 174         }
 175
 176         if (film()->audio_channels()) {
 177                 auto lang = film()->audio_language();
 178                 _sound_asset = make_shared<dcp::SoundAsset> (
 179                         dcp::Fraction(film()->video_frame_rate(), 1),
 180                         film()->audio_frame_rate(),
 181                         /* Always make 16-channel sound assets for SMPTE; libdcp will pad unused channels for us */
 182                         standard == dcp::Standard::SMPTE ? MAX_DCP_AUDIO_CHANNELS : film()->audio_channels(),
 183                         lang ? *lang : dcp::LanguageTag("en-US"),
 184                         standard
 185                         );
 186
 187                 _sound_asset->set_metadata (mxf_metadata());
 188
 189                 if (film()->encrypted()) {
 190                         _sound_asset->set_key (film()->key());
 191                 }
 192
 193                 DCPOMATIC_ASSERT (film()->directory());
 194
 195                 auto mapped = film()->mapped_audio_channels();
 196                 std::vector<dcp::Channel> extra_active_channels;
 197                 auto add_if_mapped = [mapped, &extra_active_channels](dcp::Channel channel) {
 198                         if (std::find(mapped.begin(), mapped.end(), static_cast<int>(channel)) != mapped.end()) {
 199                                 extra_active_channels.push_back(channel);
 200                         }
 201                 };
 202
 203                 add_if_mapped(dcp::Channel::HI);
 204                 add_if_mapped(dcp::Channel::VI);
 205                 add_if_mapped(dcp::Channel::BSL);
 206                 add_if_mapped(dcp::Channel::BSR);
 207
 208                 /* Write the sound asset into the film directory so that we leave the creation
 209                    of the DCP directory until the last minute.
 210                 */
 211                 _sound_asset_writer = _sound_asset->start_write (
 212                         film()->directory().get() / audio_asset_filename (_sound_asset, _reel_index, _reel_count, _content_summary),
 213                         extra_active_channels,
 214                         film()->contains_atmos_content() ? dcp::SoundAsset::AtmosSync::ENABLED : dcp::SoundAsset::AtmosSync::DISABLED,
 215                         film()->limit_to_smpte_bv20() ? dcp::SoundAsset::MCASubDescriptors::DISABLED : dcp::SoundAsset::MCASubDescriptors::ENABLED
 216                         );
 217         }
 218
 219         _default_font = dcp::ArrayData(default_font_file());
 220 }
 221
 222
 223 /** @param frame reel-relative frame */
 224 void
 225 ReelWriter::write_frame_info (Frame frame, Eyes eyes, dcp::FrameInfo info) const
 226 {
 227         auto handle = film()->info_file_handle(_period, false);
 228         handle->get().seek(frame_info_position(frame, eyes), SEEK_SET);
 229         handle->get().checked_write(&info.offset, sizeof(info.offset));
 230         handle->get().checked_write(&info.size, sizeof(info.size));
 231         handle->get().checked_write(info.hash.c_str(), info.hash.size());
 232 }
 233
 234
 235 dcp::FrameInfo
 236 ReelWriter::read_frame_info (shared_ptr<InfoFileHandle> info, Frame frame, Eyes eyes) const
 237 {
 238         dcp::FrameInfo frame_info;
 239         info->get().seek(frame_info_position(frame, eyes), SEEK_SET);
 240         info->get().checked_read(&frame_info.offset, sizeof(frame_info.offset));
 241         info->get().checked_read(&frame_info.size, sizeof(frame_info.size));
 242
 243         char hash_buffer[33];
 244         info->get().checked_read(hash_buffer, 32);
 245         hash_buffer[32] = '\0';
 246         frame_info.hash = hash_buffer;
 247
 248         return frame_info;
 249 }
 250
 251
 252 long
 253 ReelWriter::frame_info_position (Frame frame, Eyes eyes) const
 254 {
 255         switch (eyes) {
 256         case Eyes::BOTH:
 257                 return frame * _info_size;
 258         case Eyes::LEFT:
 259                 return frame * _info_size * 2;
 260         case Eyes::RIGHT:
 261                 return frame * _info_size * 2 + _info_size;
 262         default:
 263                 DCPOMATIC_ASSERT (false);
 264         }
 265
 266         DCPOMATIC_ASSERT (false);
 267 }
 268
 269
 270 Frame
 271 ReelWriter::check_existing_picture_asset (boost::filesystem::path asset)
 272 {
 273         auto job = _job.lock ();
 274
 275         if (job) {
 276                 job->sub (_("Checking existing image data"));
 277         }
 278
 279         /* Try to open the existing asset */
 280         dcp::File asset_file(asset, "rb");
 281         if (!asset_file) {
 282                 LOG_GENERAL ("Could not open existing asset at %1 (errno=%2)", asset.string(), errno);
 283                 return 0;
 284         } else {
 285                 LOG_GENERAL ("Opened existing asset at %1", asset.string());
 286         }
 287
 288         shared_ptr<InfoFileHandle> info_file;
 289
 290         try {
 291                 info_file = film()->info_file_handle (_period, true);
 292         } catch (OpenFileError &) {
 293                 LOG_GENERAL_NC ("Could not open film info file");
 294                 return 0;
 295         }
 296
 297         /* Offset of the last dcp::FrameInfo in the info file */
 298         int const n = (boost::filesystem::file_size(info_file->get().path()) / _info_size) - 1;
 299         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);
 300
 301         Frame first_nonexistent_frame;
 302         if (film()->three_d()) {
 303                 /* Start looking at the last left frame */
 304                 first_nonexistent_frame = n / 2;
 305         } else {
 306                 first_nonexistent_frame = n;
 307         }
 308
 309         while (!existing_picture_frame_ok(asset_file, info_file, first_nonexistent_frame) && first_nonexistent_frame > 0) {
 310                 --first_nonexistent_frame;
 311         }
 312
 313         if (!film()->three_d() && first_nonexistent_frame > 0) {
 314                 /* If we are doing 3D we might have found a good L frame with no R, so only
 315                    do this if we're in 2D and we've just found a good B(oth) frame.
 316                 */
 317                 ++first_nonexistent_frame;
 318         }
 319
 320         LOG_GENERAL ("Proceeding with first nonexistent frame %1", first_nonexistent_frame);
 321
 322         return first_nonexistent_frame;
 323 }
 324
 325
 326 void
 327 ReelWriter::write (shared_ptr<const Data> encoded, Frame frame, Eyes eyes)
 328 {
 329         if (!_picture_asset_writer) {
 330                 /* We're not writing any data */
 331                 return;
 332         }
 333
 334         auto fin = _picture_asset_writer->write (encoded->data(), encoded->size());
 335         write_frame_info (frame, eyes, fin);
 336         _last_written[eyes] = encoded;
 337 }
 338
 339
 340 void
 341 ReelWriter::write (shared_ptr<const dcp::AtmosFrame> atmos, AtmosMetadata metadata)
 342 {
 343         if (!_atmos_asset) {
 344                 _atmos_asset = metadata.create (dcp::Fraction(film()->video_frame_rate(), 1));
 345                 if (film()->encrypted()) {
 346                         _atmos_asset->set_key(film()->key());
 347                 }
 348                 _atmos_asset_writer = _atmos_asset->start_write (
 349                         film()->directory().get() / atmos_asset_filename (_atmos_asset, _reel_index, _reel_count, _content_summary)
 350                         );
 351         }
 352         _atmos_asset_writer->write (atmos);
 353 }
 354
 355
 356 void
 357 ReelWriter::fake_write (int size)
 358 {
 359         if (!_picture_asset_writer) {
 360                 /* We're not writing any data */
 361                 return;
 362         }
 363
 364         _picture_asset_writer->fake_write (size);
 365 }
 366
 367
 368 void
 369 ReelWriter::repeat_write (Frame frame, Eyes eyes)
 370 {
 371         if (!_picture_asset_writer) {
 372                 /* We're not writing any data */
 373                 return;
 374         }
 375
 376         auto fin = _picture_asset_writer->write(_last_written[eyes]->data(), _last_written[eyes]->size());
 377         write_frame_info (frame, eyes, fin);
 378 }
 379
 380
 381 void
 382 ReelWriter::finish (boost::filesystem::path output_dcp)
 383 {
 384         if (_picture_asset_writer && !_picture_asset_writer->finalize ()) {
 385                 /* Nothing was written to the picture asset */
 386                 LOG_GENERAL ("Nothing was written to reel %1 of %2", _reel_index, _reel_count);
 387                 _picture_asset.reset ();
 388         }
 389
 390         if (_sound_asset_writer && !_sound_asset_writer->finalize ()) {
 391                 /* Nothing was written to the sound asset */
 392                 _sound_asset.reset ();
 393         }
 394
 395         /* Hard-link any video asset file into the DCP */
 396         if (_picture_asset) {
 397                 DCPOMATIC_ASSERT (_picture_asset->file());
 398                 boost::filesystem::path video_from = _picture_asset->file().get();
 399                 boost::filesystem::path video_to = output_dcp;
 400                 video_to /= video_asset_filename (_picture_asset, _reel_index, _reel_count, _content_summary);
 401                 /* There may be an existing "to" file if we are recreating a DCP in the same place without
 402                    changing any video.
 403                 */
 404                 boost::system::error_code ec;
 405                 boost::filesystem::remove (video_to, ec);
 406
 407                 boost::filesystem::create_hard_link (video_from, video_to, ec);
 408                 if (ec) {
 409                         LOG_WARNING("Hard-link failed (%1); copying instead", error_details(ec));
 410                         auto job = _job.lock ();
 411                         if (job) {
 412                                 job->sub (_("Copying video file into DCP"));
 413                                 try {
 414                                         copy_in_bits (video_from, video_to, bind(&Job::set_progress, job.get(), _1, false));
 415                                 } catch (exception& e) {
 416                                         LOG_ERROR ("Failed to copy video file from %1 to %2 (%3)", video_from.string(), video_to.string(), e.what());
 417                                         throw FileError (e.what(), video_from);
 418                                 }
 419                         } else {
 420                                 boost::filesystem::copy_file (video_from, video_to, ec);
 421                                 if (ec) {
 422                                         LOG_ERROR("Failed to copy video file from %1 to %2 (%3)", video_from.string(), video_to.string(), error_details(ec));
 423                                         throw FileError (ec.message(), video_from);
 424                                 }
 425                         }
 426                 }
 427
 428                 _picture_asset->set_file (video_to);
 429         }
 430
 431         /* Move the audio asset into the DCP */
 432         if (_sound_asset) {
 433                 boost::filesystem::path audio_to = output_dcp;
 434                 auto const aaf = audio_asset_filename (_sound_asset, _reel_index, _reel_count, _content_summary);
 435                 audio_to /= aaf;
 436
 437                 boost::system::error_code ec;
 438                 boost::filesystem::rename (film()->file(aaf), audio_to, ec);
 439                 if (ec) {
 440                         throw FileError (
 441                                 String::compose(_("could not move audio asset into the DCP (%1)"), error_details(ec)), aaf
 442                                 );
 443                 }
 444
 445                 _sound_asset->set_file (audio_to);
 446         }
 447
 448         if (_atmos_asset) {
 449                 _atmos_asset_writer->finalize ();
 450                 boost::filesystem::path atmos_to = output_dcp;
 451                 auto const aaf = atmos_asset_filename (_atmos_asset, _reel_index, _reel_count, _content_summary);
 452                 atmos_to /= aaf;
 453
 454                 boost::system::error_code ec;
 455                 boost::filesystem::rename (film()->file(aaf), atmos_to, ec);
 456                 if (ec) {
 457                         throw FileError (
 458                                 String::compose(_("could not move atmos asset into the DCP (%1)"), error_details(ec)), aaf
 459                                 );
 460                 }
 461
 462                 _atmos_asset->set_file (atmos_to);
 463         }
 464 }
 465
 466
 467 /** Try to make a ReelAsset for a subtitles or closed captions in a given period in the DCP.
 468  *  A SubtitleAsset can be provided, or we will use one from @ref refs if not.
 469  */
 470 template <class Interop, class SMPTE, class Result>
 471 shared_ptr<Result>
 472 maybe_add_text (
 473         shared_ptr<dcp::SubtitleAsset> asset,
 474         int64_t picture_duration,
 475         shared_ptr<dcp::Reel> reel,
 476         int reel_index,
 477         int reel_count,
 478         optional<string> content_summary,
 479         list<ReferencedReelAsset> const & refs,
 480         shared_ptr<const Film> film,
 481         DCPTimePeriod period,
 482         boost::filesystem::path output_dcp,
 483         bool text_only
 484         )
 485 {
 486         Frame const period_duration = period.duration().frames_round(film->video_frame_rate());
 487
 488         shared_ptr<Result> reel_asset;
 489
 490         if (asset) {
 491                 if (auto interop = dynamic_pointer_cast<dcp::InteropSubtitleAsset>(asset)) {
 492                         auto directory = output_dcp / interop->id ();
 493                         boost::filesystem::create_directories (directory);
 494                         interop->write (directory / subtitle_asset_filename(asset, reel_index, reel_count, content_summary, ".xml"));
 495                         reel_asset = make_shared<Interop> (
 496                                 interop,
 497                                 dcp::Fraction(film->video_frame_rate(), 1),
 498                                 picture_duration,
 499                                 0
 500                                 );
 501                 } else if (auto smpte = dynamic_pointer_cast<dcp::SMPTESubtitleAsset>(asset)) {
 502                         /* All our assets should be the same length; use the picture asset length here
 503                            as a reference to set the subtitle one.  We'll use the duration rather than
 504                            the intrinsic duration; we don't care if the picture asset has been trimmed, we're
 505                            just interested in its presentation length.
 506                         */
 507                         smpte->set_intrinsic_duration(picture_duration);
 508                         smpte->write (
 509                                 output_dcp / subtitle_asset_filename(asset, reel_index, reel_count, content_summary, ".mxf")
 510                                 );
 511                         reel_asset = make_shared<SMPTE> (
 512                                 smpte,
 513                                 dcp::Fraction(film->video_frame_rate(), 1),
 514                                 picture_duration,
 515                                 0
 516                                 );
 517                 }
 518
 519         } else {
 520                 /* We don't have a subtitle asset of our own; hopefully we have one to reference */
 521                 for (auto j: refs) {
 522                         auto k = dynamic_pointer_cast<Result> (j.asset);
 523                         if (k && j.period == period) {
 524                                 reel_asset = k;
 525                                 /* If we have a hash for this asset in the CPL, assume that it is correct */
 526                                 if (k->hash()) {
 527                                         k->asset_ref()->set_hash (k->hash().get());
 528                                 }
 529                         }
 530                 }
 531         }
 532
 533         if (reel_asset) {
 534                 if (!text_only && reel_asset->actual_duration() != period_duration) {
 535                         throw ProgrammingError (
 536                                 __FILE__, __LINE__,
 537                                 String::compose ("%1 vs %2", reel_asset->actual_duration(), period_duration)
 538                                 );
 539                 }
 540                 reel->add (reel_asset);
 541         }
 542
 543         return reel_asset;
 544 }
 545
 546
 547 shared_ptr<dcp::ReelPictureAsset>
 548 ReelWriter::create_reel_picture (shared_ptr<dcp::Reel> reel, list<ReferencedReelAsset> const & refs) const
 549 {
 550         shared_ptr<dcp::ReelPictureAsset> reel_asset;
 551
 552         if (_picture_asset) {
 553                 /* We have made a picture asset of our own.  Put it into the reel */
 554                 auto mono = dynamic_pointer_cast<dcp::MonoPictureAsset> (_picture_asset);
 555                 if (mono) {
 556                         reel_asset = make_shared<dcp::ReelMonoPictureAsset>(mono, 0);
 557                 }
 558
 559                 auto stereo = dynamic_pointer_cast<dcp::StereoPictureAsset> (_picture_asset);
 560                 if (stereo) {
 561                         reel_asset = make_shared<dcp::ReelStereoPictureAsset>(stereo, 0);
 562                 }
 563         } else {
 564                 LOG_GENERAL ("no picture asset of our own; look through %1", refs.size());
 565                 /* We don't have a picture asset of our own; hopefully we have one to reference */
 566                 for (auto j: refs) {
 567                         auto k = dynamic_pointer_cast<dcp::ReelPictureAsset> (j.asset);
 568                         if (k) {
 569                                 LOG_GENERAL ("candidate picture asset period is %1-%2", j.period.from.get(), j.period.to.get());
 570                         }
 571                         if (k && j.period == _period) {
 572                                 reel_asset = k;
 573                         }
 574                 }
 575         }
 576
 577         Frame const period_duration = _period.duration().frames_round(film()->video_frame_rate());
 578
 579         DCPOMATIC_ASSERT (reel_asset);
 580         if (reel_asset->duration() != period_duration) {
 581                 throw ProgrammingError (
 582                         __FILE__, __LINE__,
 583                         String::compose ("%1 vs %2", reel_asset->actual_duration(), period_duration)
 584                         );
 585         }
 586         reel->add (reel_asset);
 587
 588         /* If we have a hash for this asset in the CPL, assume that it is correct */
 589         if (reel_asset->hash()) {
 590                 reel_asset->asset_ref()->set_hash (reel_asset->hash().get());
 591         }
 592
 593         return reel_asset;
 594 }
 595
 596
 597 void
 598 ReelWriter::create_reel_sound (shared_ptr<dcp::Reel> reel, list<ReferencedReelAsset> const & refs) const
 599 {
 600         shared_ptr<dcp::ReelSoundAsset> reel_asset;
 601
 602         if (_sound_asset) {
 603                 /* We have made a sound asset of our own.  Put it into the reel */
 604                 reel_asset = make_shared<dcp::ReelSoundAsset>(_sound_asset, 0);
 605         } else {
 606                 LOG_GENERAL ("no sound asset of our own; look through %1", refs.size());
 607                 /* We don't have a sound asset of our own; hopefully we have one to reference */
 608                 for (auto j: refs) {
 609                         auto k = dynamic_pointer_cast<dcp::ReelSoundAsset> (j.asset);
 610                         if (k) {
 611                                 LOG_GENERAL ("candidate sound asset period is %1-%2", j.period.from.get(), j.period.to.get());
 612                         }
 613                         if (k && j.period == _period) {
 614                                 reel_asset = k;
 615                                 /* If we have a hash for this asset in the CPL, assume that it is correct */
 616                                 if (k->hash()) {
 617                                         k->asset_ref()->set_hash (k->hash().get());
 618                                 }
 619                         }
 620                 }
 621         }
 622
 623         auto const period_duration = _period.duration().frames_round(film()->video_frame_rate());
 624
 625         DCPOMATIC_ASSERT (reel_asset);
 626         if (reel_asset->actual_duration() != period_duration) {
 627                 LOG_ERROR (
 628                         "Reel sound asset has length %1 but reel period is %2",
 629                         reel_asset->actual_duration(),
 630                         period_duration
 631                         );
 632                 if (reel_asset->actual_duration() != period_duration) {
 633                         throw ProgrammingError (
 634                                 __FILE__, __LINE__,
 635                                 String::compose ("%1 vs %2", reel_asset->actual_duration(), period_duration)
 636                                 );
 637                 }
 638
 639         }
 640         reel->add (reel_asset);
 641 }
 642
 643
 644 void
 645 ReelWriter::create_reel_text (
 646         shared_ptr<dcp::Reel> reel,
 647         list<ReferencedReelAsset> const & refs,
 648         int64_t duration,
 649         boost::filesystem::path output_dcp,
 650         bool ensure_subtitles,
 651         set<DCPTextTrack> ensure_closed_captions
 652         ) const
 653 {
 654         auto subtitle = maybe_add_text<dcp::ReelInteropSubtitleAsset, dcp::ReelSMPTESubtitleAsset, dcp::ReelSubtitleAsset> (
 655                 _subtitle_asset, duration, reel, _reel_index, _reel_count, _content_summary, refs, film(), _period, output_dcp, _text_only
 656                 );
 657
 658         if (!subtitle && ensure_subtitles) {
 659                 /* We had no subtitle asset, but we've been asked to make sure there is one */
 660                 subtitle = maybe_add_text<dcp::ReelInteropSubtitleAsset, dcp::ReelSMPTESubtitleAsset, dcp::ReelSubtitleAsset> (
 661                         empty_text_asset(TextType::OPEN_SUBTITLE, optional<DCPTextTrack>(), true),
 662                         duration,
 663                         reel,
 664                         _reel_index,
 665                         _reel_count,
 666                         _content_summary,
 667                         refs,
 668                         film(),
 669                         _period,
 670                         output_dcp,
 671                         _text_only
 672                         );
 673         }
 674
 675         if (subtitle) {
 676                 /* We have a subtitle asset that we either made or are referencing */
 677                 if (auto main_language = film()->subtitle_languages().first) {
 678                         subtitle->set_language (*main_language);
 679                 }
 680         }
 681
 682         for (auto const& i: _closed_caption_assets) {
 683                 auto a = maybe_add_text<dcp::ReelInteropClosedCaptionAsset, dcp::ReelSMPTEClosedCaptionAsset, dcp::ReelClosedCaptionAsset> (
 684                         i.second, duration, reel, _reel_index, _reel_count, _content_summary, refs, film(), _period, output_dcp, _text_only
 685                         );
 686                 DCPOMATIC_ASSERT (a);
 687                 a->set_annotation_text (i.first.name);
 688                 if (i.first.language) {
 689                         a->set_language (i.first.language.get());
 690                 }
 691
 692                 ensure_closed_captions.erase (i.first);
 693         }
 694
 695         /* Make empty tracks for anything we've been asked to ensure but that we haven't added */
 696         for (auto i: ensure_closed_captions) {
 697                 auto a = maybe_add_text<dcp::ReelInteropClosedCaptionAsset, dcp::ReelSMPTEClosedCaptionAsset, dcp::ReelClosedCaptionAsset> (
 698                         empty_text_asset(TextType::CLOSED_CAPTION, i, true),
 699                         duration,
 700                         reel,
 701                         _reel_index,
 702                         _reel_count,
 703                         _content_summary,
 704                         refs,
 705                         film(),
 706                         _period,
 707                         output_dcp,
 708                         _text_only
 709                         );
 710                 DCPOMATIC_ASSERT (a);
 711                 a->set_annotation_text (i.name);
 712                 if (i.language) {
 713                         a->set_language (i.language.get());
 714                 }
 715         }
 716 }
 717
 718
 719 void
 720 ReelWriter::create_reel_markers (shared_ptr<dcp::Reel> reel) const
 721 {
 722         auto markers = film()->markers();
 723         film()->add_ffoc_lfoc(markers);
 724         Film::Markers reel_markers;
 725         for (auto const& i: markers) {
 726                 if (_period.contains(i.second)) {
 727                         reel_markers[i.first] = i.second;
 728                 }
 729         }
 730
 731         if (!reel_markers.empty ()) {
 732                 auto ma = make_shared<dcp::ReelMarkersAsset>(dcp::Fraction(film()->video_frame_rate(), 1), reel->duration());
 733                 for (auto const& i: reel_markers) {
 734                         DCPTime relative = i.second - _period.from;
 735                         auto hmsf = relative.split (film()->video_frame_rate());
 736                         ma->set (i.first, dcp::Time(hmsf.h, hmsf.m, hmsf.s, hmsf.f, film()->video_frame_rate()));
 737                 }
 738                 reel->add (ma);
 739         }
 740 }
 741
 742
 743 /** @param ensure_subtitles true to make sure the reel has a subtitle asset.
 744  *  @param ensure_closed_captions make sure the reel has these closed caption tracks.
 745  */
 746 shared_ptr<dcp::Reel>
 747 ReelWriter::create_reel (
 748         list<ReferencedReelAsset> const & refs,
 749         boost::filesystem::path output_dcp,
 750         bool ensure_subtitles,
 751         set<DCPTextTrack> ensure_closed_captions
 752         )
 753 {
 754         LOG_GENERAL ("create_reel for %1-%2; %3 of %4", _period.from.get(), _period.to.get(), _reel_index, _reel_count);
 755
 756         auto reel = make_shared<dcp::Reel>();
 757
 758         /* This is a bit of a hack; in the strange `_text_only' mode we have no picture, so we don't know
 759          * how long the subtitle / CCAP assets should be.  However, since we're only writing them to see
 760          * how big they are, we don't care about that.
 761          */
 762         int64_t duration = 0;
 763         if (!_text_only) {
 764                 auto reel_picture_asset = create_reel_picture (reel, refs);
 765                 duration = reel_picture_asset->actual_duration ();
 766                 create_reel_sound (reel, refs);
 767                 if (!film()->interop()) {
 768                         create_reel_markers(reel);
 769                 }
 770         }
 771
 772         create_reel_text(reel, refs, duration, output_dcp, ensure_subtitles, ensure_closed_captions);
 773
 774         if (_atmos_asset) {
 775                 reel->add (make_shared<dcp::ReelAtmosAsset>(_atmos_asset, 0));
 776         }
 777
 778         return reel;
 779 }
 780
 781 void
 782 ReelWriter::calculate_digests (std::function<void (float)> set_progress)
 783 try
 784 {
 785         if (_picture_asset) {
 786                 _picture_asset->hash (set_progress);
 787         }
 788
 789         if (_sound_asset) {
 790                 _sound_asset->hash (set_progress);
 791         }
 792
 793         if (_atmos_asset) {
 794                 _atmos_asset->hash (set_progress);
 795         }
 796 } catch (boost::thread_interrupted) {
 797         /* set_progress contains an interruption_point, so any of these methods
 798          * may throw thread_interrupted, at which point we just give up.
 799          */
 800 }
 801
 802
 803 Frame
 804 ReelWriter::start () const
 805 {
 806         return _period.from.frames_floor (film()->video_frame_rate());
 807 }
 808
 809
 810 void
 811 ReelWriter::write (shared_ptr<const AudioBuffers> audio)
 812 {
 813         if (!_sound_asset_writer) {
 814                 return;
 815         }
 816
 817         DCPOMATIC_ASSERT (audio);
 818         _sound_asset_writer->write(audio->data(), audio->channels(), audio->frames());
 819 }
 820
 821
 822 shared_ptr<dcp::SubtitleAsset>
 823 ReelWriter::empty_text_asset (TextType type, optional<DCPTextTrack> track, bool with_dummy) const
 824 {
 825         shared_ptr<dcp::SubtitleAsset> asset;
 826
 827         auto lang = film()->subtitle_languages();
 828         if (film()->interop()) {
 829                 auto s = make_shared<dcp::InteropSubtitleAsset>();
 830                 s->set_movie_title (film()->name());
 831                 if (type == TextType::OPEN_SUBTITLE) {
 832                         s->set_language (lang.first ? lang.first->to_string() : "Unknown");
 833                 } else if (track->language) {
 834                         s->set_language (track->language->to_string());
 835                 }
 836                 s->set_reel_number (raw_convert<string> (_reel_index + 1));
 837                 asset = s;
 838         } else {
 839                 auto s = make_shared<dcp::SMPTESubtitleAsset>();
 840                 s->set_content_title_text (film()->name());
 841                 s->set_metadata (mxf_metadata());
 842                 if (type == TextType::OPEN_SUBTITLE && lang.first) {
 843                         s->set_language (*lang.first);
 844                 } else if (track && track->language) {
 845                         s->set_language (dcp::LanguageTag(track->language->to_string()));
 846                 }
 847                 s->set_edit_rate (dcp::Fraction (film()->video_frame_rate(), 1));
 848                 s->set_reel_number (_reel_index + 1);
 849                 s->set_time_code_rate (film()->video_frame_rate());
 850                 s->set_start_time (dcp::Time ());
 851                 if (film()->encrypted()) {
 852                         s->set_key (film()->key());
 853                 }
 854                 asset = s;
 855         }
 856
 857         if (with_dummy) {
 858                 asset->add(
 859                         std::make_shared<dcp::SubtitleString>(
 860                                 optional<std::string>(),
 861                                 false,
 862                                 false,
 863                                 false,
 864                                 dcp::Colour(),
 865                                 42,
 866                                 1.0,
 867                                 dcp::Time(0, 0, 0, 0, 24),
 868                                 dcp::Time(0, 0, 1, 0, 24),
 869                                 0.5,
 870                                 dcp::HAlign::CENTER,
 871                                 0.5,
 872                                 dcp::VAlign::CENTER,
 873                                 0,
 874                                 dcp::Direction::LTR,
 875                                 " ",
 876                                 dcp::Effect::NONE,
 877                                 dcp::Colour(),
 878                                 dcp::Time(),
 879                                 dcp::Time(),
 880                                 0
 881                                 )
 882                        );
 883         }
 884
 885         return asset;
 886 }
 887
 888
 889 float
 890 ReelWriter::convert_vertical_position(StringText const& subtitle, dcp::SubtitleStandard to) const
 891 {
 892         if (dcp::uses_baseline(subtitle.valign_standard) == dcp::uses_baseline(to)) {
 893                 /* The from and to standards use the same alignment reference */
 894                 return subtitle.v_position();
 895         }
 896
 897         auto const baseline_to_bottom = _font_metrics.baseline_to_bottom(subtitle);
 898         auto const height = _font_metrics.height(subtitle);
 899
 900         float correction = 0;
 901         switch (subtitle.v_align()) {
 902         case dcp::VAlign::TOP:
 903                 correction = height - baseline_to_bottom;
 904                 break;
 905         case dcp::VAlign::CENTER:
 906                 correction = (height / 2) - baseline_to_bottom;
 907                 break;
 908         case dcp::VAlign::BOTTOM:
 909                 correction = baseline_to_bottom;
 910                 break;
 911         }
 912
 913         return subtitle.v_position() + (dcp::uses_bounding_box(subtitle.valign_standard) ? correction : -correction);
 914 }
 915
 916
 917 void
 918 ReelWriter::write(PlayerText subs, TextType type, optional<DCPTextTrack> track, DCPTimePeriod period, FontIdMap const& fonts, shared_ptr<dcpomatic::Font> chosen_interop_font)
 919 {
 920         shared_ptr<dcp::SubtitleAsset> asset;
 921
 922         switch (type) {
 923         case TextType::OPEN_SUBTITLE:
 924                 asset = _subtitle_asset;
 925                 break;
 926         case TextType::CLOSED_CAPTION:
 927                 DCPOMATIC_ASSERT (track);
 928                 asset = _closed_caption_assets[*track];
 929                 break;
 930         default:
 931                 DCPOMATIC_ASSERT (false);
 932         }
 933
 934         if (!asset) {
 935                 asset = empty_text_asset (type, track, false);
 936         }
 937
 938         switch (type) {
 939         case TextType::OPEN_SUBTITLE:
 940                 _subtitle_asset = asset;
 941                 break;
 942         case TextType::CLOSED_CAPTION:
 943                 DCPOMATIC_ASSERT (track);
 944                 _closed_caption_assets[*track] = asset;
 945                 break;
 946         default:
 947                 DCPOMATIC_ASSERT (false);
 948         }
 949
 950         /* timecode rate for subtitles we emit; we might as well stick to ms accuracy here, I think */
 951         auto const tcr = 1000;
 952
 953         for (auto i: subs.string) {
 954                 i.set_in  (dcp::Time(period.from.seconds() - _period.from.seconds(), tcr));
 955                 i.set_out (dcp::Time(period.to.seconds() - _period.from.seconds(), tcr));
 956                 i.set_v_position(convert_vertical_position(i, film()->interop() ? dcp::SubtitleStandard::INTEROP : dcp::SubtitleStandard::SMPTE_2014));
 957                 auto sub = make_shared<dcp::SubtitleString>(i);
 958                 /* i.font is a shared_ptr<Font> which uniquely identifies the font we want,
 959                  * though if we are Interop we can only have one font, so we'll use the chosen
 960                  * one instead.
 961                  */
 962                 auto font = film()->interop() ? chosen_interop_font : i.font;
 963                 /* We can get the corresponding ID from fonts */
 964                 auto const font_id_to_use = fonts.get(font);
 965                 /* Give this subtitle the correct font ID */
 966                 sub->set_font(font_id_to_use);
 967                 asset->add(sub);
 968                 /* Make sure the asset LoadFonts the font we just asked for */
 969                 asset->ensure_font(font_id_to_use, font->data().get_value_or(_default_font));
 970         }
 971
 972         for (auto i: subs.bitmap) {
 973                 asset->add (
 974                         make_shared<dcp::SubtitleImage>(
 975                                 image_as_png(i.image),
 976                                 dcp::Time(period.from.seconds() - _period.from.seconds(), tcr),
 977                                 dcp::Time(period.to.seconds() - _period.from.seconds(), tcr),
 978                                 i.rectangle.x, dcp::HAlign::LEFT, i.rectangle.y, dcp::VAlign::TOP, 0,
 979                                 dcp::Time(), dcp::Time()
 980                                 )
 981                         );
 982         }
 983 }
 984
 985
 986 bool
 987 ReelWriter::existing_picture_frame_ok (dcp::File& asset_file, shared_ptr<InfoFileHandle> info_file, Frame frame) const
 988 {
 989         LOG_GENERAL ("Checking existing picture frame %1", frame);
 990
 991         /* Read the data from the info file; for 3D we just check the left
 992            frames until we find a good one.
 993         */
 994         auto const info = read_frame_info (info_file, frame, film()->three_d() ? Eyes::LEFT : Eyes::BOTH);
 995
 996         bool ok = true;
 997
 998         /* Read the data from the asset and hash it */
 999         asset_file.seek(info.offset, SEEK_SET);
1000         ArrayData data (info.size);
1001         size_t const read = asset_file.read(data.data(), 1, data.size());
1002         LOG_GENERAL ("Read %1 bytes of asset data; wanted %2", read, info.size);
1003         if (read != static_cast<size_t> (data.size ())) {
1004                 LOG_GENERAL ("Existing frame %1 is incomplete", frame);
1005                 ok = false;
1006         } else {
1007                 Digester digester;
1008                 digester.add (data.data(), data.size());
1009                 LOG_GENERAL ("Hash %1 vs %2", digester.get(), info.hash);
1010                 if (digester.get() != info.hash) {
1011                         LOG_GENERAL ("Existing frame %1 failed hash check", frame);
1012                         ok = false;
1013                 }
1014         }
1015
1016         return ok;
1017 }