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         FontIdMap const& fonts,
 481         shared_ptr<dcpomatic::Font> chosen_interop_font,
 482         dcp::ArrayData default_font,
 483         shared_ptr<const Film> film,
 484         DCPTimePeriod period,
 485         boost::filesystem::path output_dcp,
 486         bool text_only
 487         )
 488 {
 489         Frame const period_duration = period.duration().frames_round(film->video_frame_rate());
 490
 491         shared_ptr<Result> reel_asset;
 492
 493         if (asset) {
 494                 if (film->interop()) {
 495                         if (chosen_interop_font) {
 496                                 /* We only add one font, as Interop will ignore subsequent ones (and some validators will
 497                                  * complain if they are even present)
 498                                  */
 499                                 asset->add_font(fonts.get(chosen_interop_font), chosen_interop_font->data().get_value_or(default_font));
 500                         }
 501                 } else {
 502                         for (auto const& font: fonts.map()) {
 503                                 asset->add_font(font.second, font.first->data().get_value_or(default_font));
 504                         }
 505                 }
 506
 507                 if (auto interop = dynamic_pointer_cast<dcp::InteropSubtitleAsset>(asset)) {
 508                         auto directory = output_dcp / interop->id ();
 509                         boost::filesystem::create_directories (directory);
 510                         interop->write (directory / subtitle_asset_filename(asset, reel_index, reel_count, content_summary, ".xml"));
 511                         reel_asset = make_shared<Interop> (
 512                                 interop,
 513                                 dcp::Fraction(film->video_frame_rate(), 1),
 514                                 picture_duration,
 515                                 0
 516                                 );
 517                 } else if (auto smpte = dynamic_pointer_cast<dcp::SMPTESubtitleAsset>(asset)) {
 518                         /* All our assets should be the same length; use the picture asset length here
 519                            as a reference to set the subtitle one.  We'll use the duration rather than
 520                            the intrinsic duration; we don't care if the picture asset has been trimmed, we're
 521                            just interested in its presentation length.
 522                         */
 523                         smpte->set_intrinsic_duration(picture_duration);
 524                         smpte->write (
 525                                 output_dcp / subtitle_asset_filename(asset, reel_index, reel_count, content_summary, ".mxf")
 526                                 );
 527                         reel_asset = make_shared<SMPTE> (
 528                                 smpte,
 529                                 dcp::Fraction(film->video_frame_rate(), 1),
 530                                 picture_duration,
 531                                 0
 532                                 );
 533                 }
 534
 535         } else {
 536                 /* We don't have a subtitle asset of our own; hopefully we have one to reference */
 537                 for (auto j: refs) {
 538                         auto k = dynamic_pointer_cast<Result> (j.asset);
 539                         if (k && j.period == period) {
 540                                 reel_asset = k;
 541                                 /* If we have a hash for this asset in the CPL, assume that it is correct */
 542                                 if (k->hash()) {
 543                                         k->asset_ref()->set_hash (k->hash().get());
 544                                 }
 545                         }
 546                 }
 547         }
 548
 549         if (reel_asset) {
 550                 if (!text_only && reel_asset->actual_duration() != period_duration) {
 551                         throw ProgrammingError (
 552                                 __FILE__, __LINE__,
 553                                 String::compose ("%1 vs %2", reel_asset->actual_duration(), period_duration)
 554                                 );
 555                 }
 556                 reel->add (reel_asset);
 557         }
 558
 559         return reel_asset;
 560 }
 561
 562
 563 shared_ptr<dcp::ReelPictureAsset>
 564 ReelWriter::create_reel_picture (shared_ptr<dcp::Reel> reel, list<ReferencedReelAsset> const & refs) const
 565 {
 566         shared_ptr<dcp::ReelPictureAsset> reel_asset;
 567
 568         if (_picture_asset) {
 569                 /* We have made a picture asset of our own.  Put it into the reel */
 570                 auto mono = dynamic_pointer_cast<dcp::MonoPictureAsset> (_picture_asset);
 571                 if (mono) {
 572                         reel_asset = make_shared<dcp::ReelMonoPictureAsset>(mono, 0);
 573                 }
 574
 575                 auto stereo = dynamic_pointer_cast<dcp::StereoPictureAsset> (_picture_asset);
 576                 if (stereo) {
 577                         reel_asset = make_shared<dcp::ReelStereoPictureAsset>(stereo, 0);
 578                 }
 579         } else {
 580                 LOG_GENERAL ("no picture asset of our own; look through %1", refs.size());
 581                 /* We don't have a picture asset of our own; hopefully we have one to reference */
 582                 for (auto j: refs) {
 583                         auto k = dynamic_pointer_cast<dcp::ReelPictureAsset> (j.asset);
 584                         if (k) {
 585                                 LOG_GENERAL ("candidate picture asset period is %1-%2", j.period.from.get(), j.period.to.get());
 586                         }
 587                         if (k && j.period == _period) {
 588                                 reel_asset = k;
 589                         }
 590                 }
 591         }
 592
 593         Frame const period_duration = _period.duration().frames_round(film()->video_frame_rate());
 594
 595         DCPOMATIC_ASSERT (reel_asset);
 596         if (reel_asset->duration() != period_duration) {
 597                 throw ProgrammingError (
 598                         __FILE__, __LINE__,
 599                         String::compose ("%1 vs %2", reel_asset->actual_duration(), period_duration)
 600                         );
 601         }
 602         reel->add (reel_asset);
 603
 604         /* If we have a hash for this asset in the CPL, assume that it is correct */
 605         if (reel_asset->hash()) {
 606                 reel_asset->asset_ref()->set_hash (reel_asset->hash().get());
 607         }
 608
 609         return reel_asset;
 610 }
 611
 612
 613 void
 614 ReelWriter::create_reel_sound (shared_ptr<dcp::Reel> reel, list<ReferencedReelAsset> const & refs) const
 615 {
 616         shared_ptr<dcp::ReelSoundAsset> reel_asset;
 617
 618         if (_sound_asset) {
 619                 /* We have made a sound asset of our own.  Put it into the reel */
 620                 reel_asset = make_shared<dcp::ReelSoundAsset>(_sound_asset, 0);
 621         } else {
 622                 LOG_GENERAL ("no sound asset of our own; look through %1", refs.size());
 623                 /* We don't have a sound asset of our own; hopefully we have one to reference */
 624                 for (auto j: refs) {
 625                         auto k = dynamic_pointer_cast<dcp::ReelSoundAsset> (j.asset);
 626                         if (k) {
 627                                 LOG_GENERAL ("candidate sound asset period is %1-%2", j.period.from.get(), j.period.to.get());
 628                         }
 629                         if (k && j.period == _period) {
 630                                 reel_asset = k;
 631                                 /* If we have a hash for this asset in the CPL, assume that it is correct */
 632                                 if (k->hash()) {
 633                                         k->asset_ref()->set_hash (k->hash().get());
 634                                 }
 635                         }
 636                 }
 637         }
 638
 639         auto const period_duration = _period.duration().frames_round(film()->video_frame_rate());
 640
 641         DCPOMATIC_ASSERT (reel_asset);
 642         if (reel_asset->actual_duration() != period_duration) {
 643                 LOG_ERROR (
 644                         "Reel sound asset has length %1 but reel period is %2",
 645                         reel_asset->actual_duration(),
 646                         period_duration
 647                         );
 648                 if (reel_asset->actual_duration() != period_duration) {
 649                         throw ProgrammingError (
 650                                 __FILE__, __LINE__,
 651                                 String::compose ("%1 vs %2", reel_asset->actual_duration(), period_duration)
 652                                 );
 653                 }
 654
 655         }
 656         reel->add (reel_asset);
 657 }
 658
 659
 660 void
 661 ReelWriter::create_reel_text (
 662         shared_ptr<dcp::Reel> reel,
 663         list<ReferencedReelAsset> const & refs,
 664         FontIdMap const& fonts,
 665         shared_ptr<dcpomatic::Font> chosen_interop_font,
 666         int64_t duration,
 667         boost::filesystem::path output_dcp,
 668         bool ensure_subtitles,
 669         set<DCPTextTrack> ensure_closed_captions
 670         ) const
 671 {
 672         auto subtitle = maybe_add_text<dcp::ReelInteropSubtitleAsset, dcp::ReelSMPTESubtitleAsset, dcp::ReelSubtitleAsset> (
 673                 _subtitle_asset, duration, reel, _reel_index, _reel_count, _content_summary, refs, fonts, chosen_interop_font, _default_font, film(), _period, output_dcp, _text_only
 674                 );
 675
 676         if (subtitle) {
 677                 /* We have a subtitle asset that we either made or are referencing */
 678                 if (auto main_language = film()->subtitle_languages().first) {
 679                         subtitle->set_language (*main_language);
 680                 }
 681         } else if (ensure_subtitles) {
 682                 /* We had no subtitle asset, but we've been asked to make sure there is one */
 683                 subtitle = maybe_add_text<dcp::ReelInteropSubtitleAsset, dcp::ReelSMPTESubtitleAsset, dcp::ReelSubtitleAsset> (
 684                         empty_text_asset(TextType::OPEN_SUBTITLE, optional<DCPTextTrack>(), true),
 685                         duration,
 686                         reel,
 687                         _reel_index,
 688                         _reel_count,
 689                         _content_summary,
 690                         refs,
 691                         fonts,
 692                         chosen_interop_font,
 693                         _default_font,
 694                         film(),
 695                         _period,
 696                         output_dcp,
 697                         _text_only
 698                         );
 699         }
 700
 701         for (auto const& i: _closed_caption_assets) {
 702                 auto a = maybe_add_text<dcp::ReelInteropClosedCaptionAsset, dcp::ReelSMPTEClosedCaptionAsset, dcp::ReelClosedCaptionAsset> (
 703                         i.second, duration, reel, _reel_index, _reel_count, _content_summary, refs, fonts, chosen_interop_font, _default_font, film(), _period, output_dcp, _text_only
 704                         );
 705                 DCPOMATIC_ASSERT (a);
 706                 a->set_annotation_text (i.first.name);
 707                 if (i.first.language) {
 708                         a->set_language (i.first.language.get());
 709                 }
 710
 711                 ensure_closed_captions.erase (i.first);
 712         }
 713
 714         /* Make empty tracks for anything we've been asked to ensure but that we haven't added */
 715         for (auto i: ensure_closed_captions) {
 716                 auto a = maybe_add_text<dcp::ReelInteropClosedCaptionAsset, dcp::ReelSMPTEClosedCaptionAsset, dcp::ReelClosedCaptionAsset> (
 717                         empty_text_asset(TextType::CLOSED_CAPTION, i, true),
 718                         duration,
 719                         reel,
 720                         _reel_index,
 721                         _reel_count,
 722                         _content_summary,
 723                         refs,
 724                         fonts,
 725                         chosen_interop_font,
 726                         _default_font,
 727                         film(),
 728                         _period,
 729                         output_dcp,
 730                         _text_only
 731                         );
 732                 DCPOMATIC_ASSERT (a);
 733                 a->set_annotation_text (i.name);
 734                 if (i.language) {
 735                         a->set_language (i.language.get());
 736                 }
 737         }
 738 }
 739
 740
 741 void
 742 ReelWriter::create_reel_markers (shared_ptr<dcp::Reel> reel) const
 743 {
 744         auto markers = film()->markers();
 745         film()->add_ffoc_lfoc(markers);
 746         Film::Markers reel_markers;
 747         for (auto const& i: markers) {
 748                 if (_period.contains(i.second)) {
 749                         reel_markers[i.first] = i.second;
 750                 }
 751         }
 752
 753         if (!reel_markers.empty ()) {
 754                 auto ma = make_shared<dcp::ReelMarkersAsset>(dcp::Fraction(film()->video_frame_rate(), 1), reel->duration());
 755                 for (auto const& i: reel_markers) {
 756                         DCPTime relative = i.second - _period.from;
 757                         auto hmsf = relative.split (film()->video_frame_rate());
 758                         ma->set (i.first, dcp::Time(hmsf.h, hmsf.m, hmsf.s, hmsf.f, film()->video_frame_rate()));
 759                 }
 760                 reel->add (ma);
 761         }
 762 }
 763
 764
 765 /** @param ensure_subtitles true to make sure the reel has a subtitle asset.
 766  *  @param ensure_closed_captions make sure the reel has these closed caption tracks.
 767  */
 768 shared_ptr<dcp::Reel>
 769 ReelWriter::create_reel (
 770         list<ReferencedReelAsset> const & refs,
 771         FontIdMap const & fonts,
 772         shared_ptr<dcpomatic::Font> chosen_interop_font,
 773         boost::filesystem::path output_dcp,
 774         bool ensure_subtitles,
 775         set<DCPTextTrack> ensure_closed_captions
 776         )
 777 {
 778         LOG_GENERAL ("create_reel for %1-%2; %3 of %4", _period.from.get(), _period.to.get(), _reel_index, _reel_count);
 779
 780         auto reel = make_shared<dcp::Reel>();
 781
 782         /* This is a bit of a hack; in the strange `_text_only' mode we have no picture, so we don't know
 783          * how long the subtitle / CCAP assets should be.  However, since we're only writing them to see
 784          * how big they are, we don't care about that.
 785          */
 786         int64_t duration = 0;
 787         if (!_text_only) {
 788                 auto reel_picture_asset = create_reel_picture (reel, refs);
 789                 duration = reel_picture_asset->actual_duration ();
 790                 create_reel_sound (reel, refs);
 791                 create_reel_markers (reel);
 792         }
 793
 794         create_reel_text (reel, refs, fonts, chosen_interop_font, duration, output_dcp, ensure_subtitles, ensure_closed_captions);
 795
 796         if (_atmos_asset) {
 797                 reel->add (make_shared<dcp::ReelAtmosAsset>(_atmos_asset, 0));
 798         }
 799
 800         return reel;
 801 }
 802
 803 void
 804 ReelWriter::calculate_digests (std::function<void (float)> set_progress)
 805 try
 806 {
 807         if (_picture_asset) {
 808                 _picture_asset->hash (set_progress);
 809         }
 810
 811         if (_sound_asset) {
 812                 _sound_asset->hash (set_progress);
 813         }
 814
 815         if (_atmos_asset) {
 816                 _atmos_asset->hash (set_progress);
 817         }
 818 } catch (boost::thread_interrupted) {
 819         /* set_progress contains an interruption_point, so any of these methods
 820          * may throw thread_interrupted, at which point we just give up.
 821          */
 822 }
 823
 824
 825 Frame
 826 ReelWriter::start () const
 827 {
 828         return _period.from.frames_floor (film()->video_frame_rate());
 829 }
 830
 831
 832 void
 833 ReelWriter::write (shared_ptr<const AudioBuffers> audio)
 834 {
 835         if (!_sound_asset_writer) {
 836                 return;
 837         }
 838
 839         DCPOMATIC_ASSERT (audio);
 840         _sound_asset_writer->write(audio->data(), audio->channels(), audio->frames());
 841 }
 842
 843
 844 shared_ptr<dcp::SubtitleAsset>
 845 ReelWriter::empty_text_asset (TextType type, optional<DCPTextTrack> track, bool with_dummy) const
 846 {
 847         shared_ptr<dcp::SubtitleAsset> asset;
 848
 849         auto lang = film()->subtitle_languages();
 850         if (film()->interop()) {
 851                 auto s = make_shared<dcp::InteropSubtitleAsset>();
 852                 s->set_movie_title (film()->name());
 853                 if (type == TextType::OPEN_SUBTITLE) {
 854                         s->set_language (lang.first ? lang.first->to_string() : "Unknown");
 855                 } else if (track->language) {
 856                         s->set_language (track->language->to_string());
 857                 }
 858                 s->set_reel_number (raw_convert<string> (_reel_index + 1));
 859                 asset = s;
 860         } else {
 861                 auto s = make_shared<dcp::SMPTESubtitleAsset>();
 862                 s->set_content_title_text (film()->name());
 863                 s->set_metadata (mxf_metadata());
 864                 if (type == TextType::OPEN_SUBTITLE && lang.first) {
 865                         s->set_language (*lang.first);
 866                 } else if (track && track->language) {
 867                         s->set_language (dcp::LanguageTag(track->language->to_string()));
 868                 }
 869                 s->set_edit_rate (dcp::Fraction (film()->video_frame_rate(), 1));
 870                 s->set_reel_number (_reel_index + 1);
 871                 s->set_time_code_rate (film()->video_frame_rate());
 872                 s->set_start_time (dcp::Time ());
 873                 if (film()->encrypted()) {
 874                         s->set_key (film()->key());
 875                 }
 876                 asset = s;
 877         }
 878
 879         if (with_dummy) {
 880                 asset->add(
 881                         std::make_shared<dcp::SubtitleString>(
 882                                 optional<std::string>(),
 883                                 false,
 884                                 false,
 885                                 false,
 886                                 dcp::Colour(),
 887                                 42,
 888                                 1.0,
 889                                 dcp::Time(0, 0, 0, 0, 24),
 890                                 dcp::Time(0, 0, 1, 0, 24),
 891                                 0.5,
 892                                 dcp::HAlign::CENTER,
 893                                 0.5,
 894                                 dcp::VAlign::CENTER,
 895                                 0,
 896                                 dcp::Direction::LTR,
 897                                 " ",
 898                                 dcp::Effect::NONE,
 899                                 dcp::Colour(),
 900                                 dcp::Time(),
 901                                 dcp::Time(),
 902                                 0
 903                                 )
 904                        );
 905         }
 906
 907         return asset;
 908 }
 909
 910
 911 float
 912 ReelWriter::convert_vertical_position(StringText const& subtitle, dcp::SubtitleStandard to) const
 913 {
 914         if (dcp::uses_baseline(subtitle.valign_standard) == dcp::uses_baseline(to)) {
 915                 /* The from and to standards use the same alignment reference */
 916                 return subtitle.v_position();
 917         }
 918
 919         auto const baseline_to_bottom = _font_metrics.baseline_to_bottom(subtitle);
 920         auto const height = _font_metrics.height(subtitle);
 921
 922         float correction = 0;
 923         switch (subtitle.v_align()) {
 924         case dcp::VAlign::TOP:
 925                 correction = height - baseline_to_bottom;
 926                 break;
 927         case dcp::VAlign::CENTER:
 928                 correction = (height / 2) - baseline_to_bottom;
 929                 break;
 930         case dcp::VAlign::BOTTOM:
 931                 correction = baseline_to_bottom;
 932                 break;
 933         }
 934
 935         return subtitle.v_position() + (dcp::uses_bounding_box(subtitle.valign_standard) ? correction : -correction);
 936 }
 937
 938
 939 void
 940 ReelWriter::write (PlayerText subs, TextType type, optional<DCPTextTrack> track, DCPTimePeriod period, FontIdMap const& fonts)
 941 {
 942         shared_ptr<dcp::SubtitleAsset> asset;
 943
 944         switch (type) {
 945         case TextType::OPEN_SUBTITLE:
 946                 asset = _subtitle_asset;
 947                 break;
 948         case TextType::CLOSED_CAPTION:
 949                 DCPOMATIC_ASSERT (track);
 950                 asset = _closed_caption_assets[*track];
 951                 break;
 952         default:
 953                 DCPOMATIC_ASSERT (false);
 954         }
 955
 956         if (!asset) {
 957                 asset = empty_text_asset (type, track, false);
 958         }
 959
 960         switch (type) {
 961         case TextType::OPEN_SUBTITLE:
 962                 _subtitle_asset = asset;
 963                 break;
 964         case TextType::CLOSED_CAPTION:
 965                 DCPOMATIC_ASSERT (track);
 966                 _closed_caption_assets[*track] = asset;
 967                 break;
 968         default:
 969                 DCPOMATIC_ASSERT (false);
 970         }
 971
 972         /* timecode rate for subtitles we emit; we might as well stick to ms accuracy here, I think */
 973         auto const tcr = 1000;
 974
 975         for (auto i: subs.string) {
 976                 i.set_in  (dcp::Time(period.from.seconds() - _period.from.seconds(), tcr));
 977                 i.set_out (dcp::Time(period.to.seconds() - _period.from.seconds(), tcr));
 978                 i.set_v_position(convert_vertical_position(i, film()->interop() ? dcp::SubtitleStandard::INTEROP : dcp::SubtitleStandard::SMPTE_2014));
 979                 auto sub = make_shared<dcp::SubtitleString>(i);
 980                 if (type == TextType::OPEN_SUBTITLE) {
 981                         sub->set_font(fonts.get(i.font));
 982                 }
 983                 asset->add(sub);
 984         }
 985
 986         for (auto i: subs.bitmap) {
 987                 asset->add (
 988                         make_shared<dcp::SubtitleImage>(
 989                                 image_as_png(i.image),
 990                                 dcp::Time(period.from.seconds() - _period.from.seconds(), tcr),
 991                                 dcp::Time(period.to.seconds() - _period.from.seconds(), tcr),
 992                                 i.rectangle.x, dcp::HAlign::LEFT, i.rectangle.y, dcp::VAlign::TOP, 0,
 993                                 dcp::Time(), dcp::Time()
 994                                 )
 995                         );
 996         }
 997 }
 998
 999
1000 bool
1001 ReelWriter::existing_picture_frame_ok (dcp::File& asset_file, shared_ptr<InfoFileHandle> info_file, Frame frame) const
1002 {
1003         LOG_GENERAL ("Checking existing picture frame %1", frame);
1004
1005         /* Read the data from the info file; for 3D we just check the left
1006            frames until we find a good one.
1007         */
1008         auto const info = read_frame_info (info_file, frame, film()->three_d() ? Eyes::LEFT : Eyes::BOTH);
1009
1010         bool ok = true;
1011
1012         /* Read the data from the asset and hash it */
1013         asset_file.seek(info.offset, SEEK_SET);
1014         ArrayData data (info.size);
1015         size_t const read = asset_file.read(data.data(), 1, data.size());
1016         LOG_GENERAL ("Read %1 bytes of asset data; wanted %2", read, info.size);
1017         if (read != static_cast<size_t> (data.size ())) {
1018                 LOG_GENERAL ("Existing frame %1 is incomplete", frame);
1019                 ok = false;
1020         } else {
1021                 Digester digester;
1022                 digester.add (data.data(), data.size());
1023                 LOG_GENERAL ("Hash %1 vs %2", digester.get(), info.hash);
1024                 if (digester.get() != info.hash) {
1025                         LOG_GENERAL ("Existing frame %1 failed hash check", frame);
1026                         ok = false;
1027                 }
1028         }
1029
1030         return ok;
1031 }